particle_services.h

Go to the documentation of this file.

#ifndef PARTICLE_SERVICES_H
#define PARTICLE_SERVICES_H

#include <lwpp/global.h>

#include <lwpp/point3d.h>
#include <lwpp/vector3d.h>

#include <lwprtcl.h>

namespace lwpp
{

  class ParticleServices : protected GlobalBase<LWPSysFuncs>
  {
  
  private:
    LWPSysID prtsv_id;
    
    LWPSBufID posbf_id;
    LWPSBufID sizbf_id;
    LWPSBufID sclbf_id;
    LWPSBufID rotbf_id;
    LWPSBufID velbf_id;
    LWPSBufID agebf_id;
    LWPSBufID frcbf_id;
    LWPSBufID prsbf_id;
    LWPSBufID tmpbf_id;
    LWPSBufID masbf_id;
    LWPSBufID lnkbf_id;
    LWPSBufID pidbf_id;
    LWPSBufID enbbf_id;
    LWPSBufID rgbabf_id;
    LWPSBufID cagebf_id;
    LWPSBufID ragebf_id;
    LWPSBufID sposbf_id;
    LWPSBufID ssclbf_id;
    LWPSBufID srotbf_id;  

  public:
    ParticleServices( LWPSysID _prtsv_id = 0) : prtsv_id(_prtsv_id) {;}

    LWPSysID getID() const { return prtsv_id; }

    LWPSysID create (int flags, int type = LWPST_PRTCL)
    {
      prtsv_id = globPtr->create(flags, type);
      
      // Get and store all the buffers created
      // to avoid later calls to getBufferID.
      // Position
      if (flags & LWPSB_POS)  { posbf_id  = getBufferID(LWPSB_POS); }
      // Size
      if (flags & LWPSB_SIZ)  { sizbf_id  = getBufferID(LWPSB_SIZ); }
      // Scale
      if (flags & LWPSB_SCL)  { sclbf_id  = getBufferID(LWPSB_SCL); }
      // Rotation
      if (flags & LWPSB_ROT)  { rotbf_id  = getBufferID(LWPSB_ROT); }
      // Velocity
      if (flags & LWPSB_VEL)  { velbf_id  = getBufferID(LWPSB_VEL); }
      // Age
      if (flags & LWPSB_AGE)  { agebf_id  = getBufferID(LWPSB_AGE); }
      // Force
      if (flags & LWPSB_FCE)  { frcbf_id  = getBufferID(LWPSB_FCE); }
      // Pressure
      if (flags & LWPSB_PRS)  { prsbf_id  = getBufferID(LWPSB_PRS); }
      // Temperature
      if (flags & LWPSB_TMP)  { tmpbf_id  = getBufferID(LWPSB_TMP); }
      // Mass
      if (flags & LWPSB_MAS)  { masbf_id  = getBufferID(LWPSB_MAS); }
      // Linked Particle
      // This buffer is created as well if the type is a trail particle system
      if (flags & LWPSB_TMP || type == LWPST_TRAIL ) { lnkbf_id  = getBufferID(LWPSB_TMP); }
      // Particle ID 
      if (flags & LWPSB_ID) { pidbf_id  = getBufferID(LWPSB_ID); }
      // Enable
      if (flags & LWPSB_ENB) { enbbf_id  = getBufferID(LWPSB_ENB); }
      // RGBA
      if (flags & LWPSB_RGBA) { rgbabf_id = getBufferID(LWPSB_RGBA); }
      // Colision Age
      if (flags & LWPSB_CAGE) { cagebf_id = getBufferID(LWPSB_CAGE); }
      // Relative Age
      if (flags & LWPSB_RAGE) { ragebf_id = getBufferID(LWPSB_RAGE); }
      // Start Position
      if (flags & LWPSB_POS0) { sposbf_id = getBufferID(LWPSB_POS0); }
      // Start Scale
      if (flags & LWPSB_SCL0) { ssclbf_id = getBufferID(LWPSB_SCL0); }
      // Start Rotation
      if (flags & LWPSB_ROT0) { ssclbf_id = srotbf_id = getBufferID(LWPSB_ROT0); }

      return prtsv_id;
    }
    
    int destroy ()  { return globPtr->destroy(prtsv_id); }

    int init (int num_particles) { return globPtr->init(prtsv_id, num_particles); }

    void cleanup () { globPtr->cleanup(prtsv_id); }
    
    void load ( LWLoadState *loadstate ) { globPtr->load(prtsv_id, loadstate); }

    void save ( LWSaveState *savestate ) { globPtr->save(prtsv_id, savestate); }
    
    int getParticleCount () { return globPtr->getPCount(prtsv_id); }
    
    void attach (LWItemID lwitid) { globPtr->attach(prtsv_id, lwitid); }

    void detach (LWItemID lwitid) { globPtr->detach(prtsv_id, lwitid); }

    LWPSysID * getParticleSystems (LWItemID lwitid) { return globPtr->getPSys(lwitid); }
    
    LWPSBufID addBuffer (LWPSBufDesc lwbufdesc) { return globPtr->addBuf(prtsv_id, lwbufdesc); }
    
    LWPSBufID getBufferID ( int bufferFlag) { return globPtr->getBufID( prtsv_id, bufferFlag ); }
    
    template <typename T>
    void setBufferData (LWPSBufID buffer_id, T data) { globPtr->setBufData( buffer_id, &data ); }
    
    template <typename T>
    void getBufferData (LWPSBufID buffer_id, T &data) { globPtr->getBufData( buffer_id, &data ); }
    
    int addParticle () { return globPtr->addParticle(prtsv_id); }
    
    void setParticle (LWPSBufID buffer_id, int index, void *data) { globPtr->setParticle(buffer_id, index, data); }
    
    void getParticle (LWPSBufID buffer_id, int index, void *data) { globPtr->getParticle(buffer_id, index, data); }
    
    void removeParticle (int index) { globPtr->remParticle(prtsv_id, index); }

    /*  Auxiliary Functions from the wrapper to help to the writing of plugins
    * This ARE NOT part originally of the LWSDK but make use of it
    */

    void getPosition(int index, float *position) { getParticle(posbf_id, index, position); }
    
    Point3f getPosition(int index)
    {
      float position[3] = { 0, 0, 0 };
      getPosition(index, position);
      return Point3f(position);
    }

    void setPosition(int index, float *position) { setParticle(posbf_id, index, position); }

    void setPosition(int index, Point3d &position)
    {
      float fposition[3] = { (float) position.x, (float) position.y, (float) position.z };
      setParticle(posbf_id, index, fposition);
    }

    void getSize(int index, float *size) { getParticle(sizbf_id, index, size); }

    void setSize(int index, float size) { setParticle(sizbf_id, index, &size); }

    void getScale(int index, float *scale) { getParticle(sclbf_id, index, scale); }

    void setScale(int index, float scale) { setParticle(sclbf_id, index, &scale); }

    void getRotation(int index, float *rotation) { getParticle(rotbf_id, index, rotation); }

    void setRotation(int index, float rotation) { setParticle(rotbf_id, index, &rotation); }

    void getVelocity(int index, float *velocity) { getParticle(velbf_id, index, velocity); }

    void setVelocity(int index, float velocity) { setParticle(velbf_id, index, &velocity); }

    void * getAge(int index)
    {
      void *age;
      getParticle(agebf_id, index, age);
      return age;
    }

    void setAge(int index, float *age) { setParticle(agebf_id, index, age); }

    void * getForce(int index)
    {
      void *force;
      getParticle(frcbf_id, index, force);
      return force;
    }

    void setForce(int index, float force) { setParticle(frcbf_id, index, &force); }

    void * getPressure(int index)
    {
      void *pressure;
      getParticle(prsbf_id, index, pressure);
      return pressure;
    }

    void setPressure(int index, float pressure) { setParticle(prsbf_id, index, &pressure); }
    
    void * getTemperature(int index)
    {
      void *temperature;
      getParticle(tmpbf_id, index, temperature);
      return temperature;
    }

    void setTemperature(int index, float temperature) { setParticle(tmpbf_id, index, &temperature); }

    void * getMass(int index)
    {
      void *mass;
      getParticle(masbf_id, index, mass);
      return mass;
    }

    void setMass(int index, float mass) { setParticle(masbf_id, index, &mass); }

    void * getLink(int index)
    {
      void *link;
      getParticle(lnkbf_id, index, link);
      return link;
    }

    void setLink(int index, int link) { setParticle(lnkbf_id, index, &link); }

    void * getParticleID(int index)
    {
      void *PID;
      getParticle(pidbf_id, index, PID);
      return PID;
    }

    void setParticleID(int index, int PID) { setParticle(pidbf_id, index, &PID); }

    char getParticleState(int index)
    {
      char state = '0';
      getParticle(enbbf_id, index, &state);
      return state;
    }

    void setParticleState(int index, char state) { setParticle(enbbf_id, index, &state); }

    void setParticleDead(int index)
    {
      char state = (char) LWPST_DEAD;
      setParticleState(index, state);
    }

    void setParticleAlive(int index)
    {
      char state = (char) LWPST_ALIVE; 
      setParticleState(index, state);
    }

    void setParticleLimbo(int index)
    {
      char state = (char) LWPST_LIMBO; 
      setParticleState(index, state);
    }

    bool isDead(int index)
    {
      char isdead = getParticleState(index);
      return ( isdead == LWPST_DEAD) ? true : false ;
    }

    bool isAlive(int index)
    {
      int isalive = getParticleState(index);
      return ( isalive == LWPST_ALIVE) ? true : false ;
    }

    bool isLimbo(int index)
    {
      int islimbo = getParticleState(index);
      return ( islimbo == LWPST_LIMBO) ? true : false ;
    }

    void getRGBA(int index, unsigned char *RGBA)
    {
      getParticle(rgbabf_id, index, RGBA);
    }

    void setRGBA(int index, unsigned char *RGBA)
    {
      setParticle(rgbabf_id, index, RGBA);
    }

    void * getCollisionAge(int index)
    {
      void *cage;
      getParticle(cagebf_id, index, cage);
      return cage;
    }

    void setCollisionAge(int index, float cage) { setParticle(cagebf_id, index, &cage); }

    void * getRelativeAge(int index) 
    {
      void *rage;
      getParticle(ragebf_id, index, rage);
      return rage;
    }

    void setRelativeAge(int index, float rage) { setParticle(ragebf_id, index, &rage); }

    void * getStartPosition(int index, float *sposition) { getParticle(sposbf_id, index, sposition); }

    void setStartPosition(int index, float sposition) { setParticle(sposbf_id, index, &sposition); }

    void getStartScale(int index, float *sscale) { getParticle(ssclbf_id, index, sscale); }

    void setStartScale(int index, float sscale) { setParticle(ssclbf_id, index, &sscale); }

    void getStartRotation(int index, float *srotation) { getParticle(srotbf_id, index, srotation); }

    void setStartRotation(int index, float srotation) { setParticle(srotbf_id, index, &srotation); }
    
  };
} // namespace lwpp
#endif // PARTICLE_SERVICES_H