SO3Engine/SCOLPack/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/



#include "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 = (SScene*) MMfetch(m, MTOP(s), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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 = (SNode*) MMfetch(m, MTOP(ps), 0);
  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;       
}


#define NBPARTICLEPKG 9

char* PARTICLEname[NBPARTICLEPKG]= 
{
  "SO3ParticleSystemCreateFromTemplate",
  "SO3ParticleSystemGetTemplate",
  "SO3ParticleSystemSetEnable",
  "SO3ParticleSystemGetEnable",
  "SO3ParticleSystemSetPause",
  "SO3ParticleSystemGetPause",
  "SO3ParticleSystemSetSpeedFactor",
  "SO3ParticleSystemGetSpeedFactor",
  "SO3ParticleSystemClear"
};


int (*PARTICLEFunc[NBPARTICLEPKG])(mmachine m)=
{

  SO3ParticleSystemCreateFromTemplate,
  SO3ParticleSystemGetTemplate,
  SO3ParticleSystemSetEnable,
  SO3ParticleSystemGetEnable,
  SO3ParticleSystemSetPause,
  SO3ParticleSystemGetPause,
  SO3ParticleSystemSetSpeedFactor,
  SO3ParticleSystemGetSpeedFactor,
  SO3ParticleSystemClear
};


int PARTICLEnarg[NBPARTICLEPKG]= 
{
  3,                                                                                        //SO3ParticleSystemCreateFromTemplate
  1,                                                                                        //SO3ParticleSystemGetTemplate
  2,                                                                                        //SO3ParticleSystemSetEnable
  1,                                                                                        //SO3ParticleSystemGetEnable
  2,                                                                                        //SO3ParticleSystemSetPause
  1,                                                                                        //SO3ParticleSystemGetPause
  2,                                                                                        //SO3ParticleSystemSetSpeedFactor
  1,                                                                                        //SO3ParticleSystemGetSpeedFactor
  1                                                                                                 //SO3ParticleSystemClear
};


char* PARTICLEType[NBPARTICLEPKG]=
{
  "fun [SO3_SCENE S S] SO3_OBJECT",     //SO3ParticleSystemCreateFromTemplate
  "fun [SO3_OBJECT] S",                               //SO3ParticleSystemGetTemplate
  "fun [SO3_OBJECT I] I",                             //SO3ParticleSystemSetEnable
  "fun [SO3_OBJECT] I",                               //SO3ParticleSystemGetEnable
  "fun [SO3_OBJECT I] I",                             //SO3ParticleSystemSetPause
  "fun [SO3_OBJECT] I",                               //SO3ParticleSystemGetPause
  "fun [SO3_OBJECT F] I",                             //SO3ParticleSystemSetSpeedFactor
  "fun [SO3_OBJECT] F",                               //SO3ParticleSystemGetSpeedFactor
  "fun [SO3_OBJECT] I"                    //SO3ParticleSystemClear
};


int SCOLloadParticle(mmachine m,cbmachine w)
{       
        return PKhardpak(m, "Particle", NBPARTICLEPKG, PARTICLEname, PARTICLEFunc, PARTICLEnarg, PARTICLEType);
}


int SCOLfreeParticle()
{
        return 0;
}

---