SCOLParticle.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
 
#include "SCOLPack/SO3SCOL.h"
 
// particles includes
#include "SO3SceneGraph/SO3ParticleSystem.h"
 
// Scene Graph includes
#include "SO3SceneGraph/SO3Scene.h"
 
int SO3ParticleSystemCreateFromTemplate(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemCreateFromTemplate\n");
#endif
 
  int temp = MMpull(m);
  int name = MMpull(m);
  int s = MMget(m, 0);
  if ((s == NIL) || (temp == NIL) || (name == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SScene* scene = MMgetPointer<SScene*>(m, MTOP(s));
  if (scene == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  std::string tmpParticleSystemName(MMstartstr(m, MTOP(name)));
  std::string tmpParticleSystemtTemplate(MMstartstr(m, MTOP(temp)));
  SParticleSystem* particlesystem = 0;
 
  try
  {
    particlesystem = scene->CreateParticleSystem(tmpParticleSystemName, tmpParticleSystemtTemplate);
  }
  catch (Ogre::Exception& e)
  {
    MMechostr(MSKDEBUG, "An exception has occurred: %s\n", e.what());
    MMset(m, 0, NIL);
    return 0;
  }
 
  // remove last param
  MMpull(m);
  return createObject(m, particlesystem, scene);
}
 
 
int SO3ParticleSystemGetTemplate(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemGetTemplate\n");
#endif
 
  int ps = MMpull(m);
  if (ps == NIL)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
  if (particlesystem == 0)
  {
    MMpush(m, NIL);
    return 0;
  }
 
  return Mpushstrbloc(m, (char*)(particlesystem->GetParticleTemplateName().c_str()));
}
 
 
int SO3ParticleSystemSetEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemSetEnable\n");
#endif
 
  int b = MTOI(MMpull(m));
  int ps = MMget(m, 0);
  if ((ps == NIL) || (b == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  if (b == 0)
    particlesystem->SetEnable(false);
  else
    particlesystem->SetEnable(true);
 
  MMset(m, 0, ITOM(1));
  return 0;
 
}
 
 
int SO3ParticleSystemGetEnable(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemGetEnable\n");
#endif
 
  int ps = MMget(m, 0);
  if (ps == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  int val = 0;
  if (particlesystem->GetEnable())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3ParticleSystemSetPause(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemSetPause\n");
#endif
 
  int b = MTOI(MMpull(m));
  int ps = MMget(m, 0);
  if ((ps == NIL) || (b == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  if (b == 0)
    particlesystem->SetPaused(false);
  else
    particlesystem->SetPaused(true);
 
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3ParticleSystemGetPause(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemGetPause\n");
#endif
 
  int ps = MMget(m, 0);
  if (ps == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  int val = 0;
  if (particlesystem->GetPaused())
    val = 1;
 
  MMset(m, 0, ITOM(val));
  return 0;
}
 
 
int SO3ParticleSystemSetSpeedFactor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemSetSpeedFactor\n");
#endif
 
  int sf = MMpull(m);
  int ps = MMget(m, 0);
  if ((ps == NIL) || (sf == NIL))
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  particlesystem->SetSpeed(MTOF(sf));
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
int SO3ParticleSystemGetSpeedFactor(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemGetSpeedFactor\n");
#endif
 
  int ps = MMget(m, 0);
  if (ps == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  MMset(m, 0, FTOM(particlesystem->GetSpeed()));
  return 0;
}
 
 
int SO3ParticleSystemClear(mmachine m)
{
#ifdef SO3_DEBUG
  MMechostr(MSKDEBUG, "SO3ParticleSystemClear\n");
#endif
 
  int ps = MMget(m, 0);
  if (ps == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  SNode* node = MMgetPointer<SNode*>(m, MTOP(ps));
  if (node == 0)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  if (node->GetNodeType() != SNode::PARTICLE_SYSTEM_TYPE_ID)
  {
    MMset(m, 0, NIL);
    return 0;
  }
  SParticleSystem* particlesystem = static_cast<SParticleSystem*> (node);
 
  particlesystem->ClearParticles();
  MMset(m, 0, ITOM(1));
  return 0;
}
 
 
NativeDefinition natSO3Particle[] = {
  { "SO3ParticleSystemCreateFromTemplate", 3,  "fun [SO3_SCENE S S] SO3_OBJECT", SO3ParticleSystemCreateFromTemplate },
  { "SO3ParticleSystemGetTemplate",        1,  "fun [SO3_OBJECT] S",                                 SO3ParticleSystemGetTemplate        },
  { "SO3ParticleSystemSetEnable",          2,  "fun [SO3_OBJECT I] I",                       SO3ParticleSystemSetEnable          },
  { "SO3ParticleSystemGetEnable",          1,  "fun [SO3_OBJECT] I",                                 SO3ParticleSystemGetEnable          },
  { "SO3ParticleSystemSetPause",           2,  "fun [SO3_OBJECT I] I",                       SO3ParticleSystemSetPause           },
  { "SO3ParticleSystemGetPause",           1,  "fun [SO3_OBJECT] I",                                 SO3ParticleSystemGetPause           },
  { "SO3ParticleSystemSetSpeedFactor",     2,  "fun [SO3_OBJECT F] I",                       SO3ParticleSystemSetSpeedFactor     },
  { "SO3ParticleSystemGetSpeedFactor",     1,  "fun [SO3_OBJECT] F",                                 SO3ParticleSystemGetSpeedFactor     },
  { "SO3ParticleSystemClear",              1,    "fun [SO3_OBJECT] I",                   SO3ParticleSystemClear              }
};
 
 
int SCOLloadParticle(mmachine m, cbmachine w)
{
  return PKhardpak2(m, "SO3Particle.pkg", sizeof(natSO3Particle) / sizeof(natSO3Particle[0]), natSO3Particle);
}
 
 
int SCOLfreeParticle()
{
  return 0;
}