Public API Reference

imesh/particles.h

Go to the documentation of this file.

/*
  Copyright (C) 2006 by Marten Svanfeldt

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library 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
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_IMESH_PARTICLES_H__
#define __CS_IMESH_PARTICLES_H__

#include "csutil/scf_interface.h"

#include "csgeom/obb.h"
#include "csgeom/vector2.h"
#include "csgeom/vector3.h"
#include "csgeom/quaternion.h"
#include "csutil/array.h"
#include "csutil/cscolor.h"
#include "csutil/ref.h"

struct iParticleSystemBase;

enum csParticleSortMode
{
  CS_PARTICLE_SORT_NONE,
  CS_PARTICLE_SORT_DISTANCE,
  CS_PARTICLE_SORT_DOT
};

enum csParticleRenderOrientation
{
  CS_PARTICLE_CAMERAFACE,
  CS_PARTICLE_CAMERAFACE_APPROX,
  CS_PARTICLE_ORIENT_COMMON,
  CS_PARTICLE_ORIENT_COMMON_APPROX,
  CS_PARTICLE_ORIENT_VELOCITY,
   CS_PARTICLE_ORIENT_SELF,
    CS_PARTICLE_ORIENT_SELF_FORWARD
};

enum csParticleRotationMode
{
  CS_PARTICLE_ROTATE_NONE,
  CS_PARTICLE_ROTATE_TEXCOORD,
  CS_PARTICLE_ROTATE_VERTICES
};

enum csParticleIntegrationMode
{
  CS_PARTICLE_INTEGRATE_NONE,
  CS_PARTICLE_INTEGRATE_LINEAR,
  CS_PARTICLE_INTEGRATE_BOTH
};

enum csParticleTransformMode
{
  CS_PARTICLE_LOCAL_MODE,
  CS_PARTICLE_LOCAL_EMITTER,
  CS_PARTICLE_WORLD_MODE
};

struct csParticle
{
  csVector3 position;

  float mass;

  csQuaternion orientation;
  
  csVector3 linearVelocity;

  float timeToLive;

  csVector3 angularVelocity;

  // Pad to make this struct 64 bytes
  float pad;
};

struct csParticleAux
{
  csColor4 color;

  csVector2 particleSize;

  // Pad to make this 32 bytes
  float pad[2];
};

struct csParticleBuffer
{
  csParticle* particleData;
  
  csParticleAux* particleAuxData;

  size_t particleCount;
};

struct iParticleEmitter : public virtual iBase
{
  SCF_INTERFACE(iParticleEmitter,1,0,0);

  virtual void SetEnabled (bool enabled) = 0;

  virtual bool GetEnabled () const = 0;

  virtual void SetStartTime (float time) = 0;

  virtual float GetStartTime () const = 0;

  virtual void SetDuration (float time) = 0;

  virtual float GetDuration () const = 0;

  virtual void SetEmissionRate (float particlesPerSecond) = 0;

  virtual float GetEmissionRate () const = 0;

  virtual void SetInitialTTL (float min, float max) = 0;

  virtual void GetInitialTTL (float& min, float& max) const= 0;

  virtual void SetInitialMass (float min, float max) = 0;

  virtual void GetInitialMass (float& min, float& max) const = 0;

  virtual csPtr<iParticleEmitter> Clone () const = 0;

  virtual size_t ParticlesToEmit (iParticleSystemBase* system,
    float dt, float totalTime) = 0;

  virtual void EmitParticles (iParticleSystemBase* system,
    const csParticleBuffer& particleBuffer, float dt, float totalTime,
    const csReversibleTransform* const emitterToParticle = 0) = 0;

};

struct iParticleEffector : public virtual iBase
{
  SCF_INTERFACE(iParticleEffector,1,0,0);

  virtual csPtr<iParticleEffector> Clone () const = 0;

  virtual void EffectParticles (iParticleSystemBase* system,
    const csParticleBuffer& particleBuffer, float dt, float totalTime) = 0;
};


struct iParticleSystemBase : public virtual iBase
{
  SCF_INTERFACE(iParticleSystemBase, 1,0,0);

  virtual void SetParticleRenderOrientation (csParticleRenderOrientation o) = 0;

  virtual csParticleRenderOrientation GetParticleRenderOrientation () const = 0;

  virtual void SetRotationMode (csParticleRotationMode mode) = 0;

  virtual csParticleRotationMode GetRotationMode () const = 0;

  virtual void SetSortMode (csParticleSortMode mode) = 0;

  virtual csParticleSortMode GetSortMode () const = 0;

  virtual void SetIntegrationMode (csParticleIntegrationMode mode) = 0;

  virtual csParticleIntegrationMode GetIntegrationMode () = 0;

  virtual void SetCommonDirection (const csVector3& direction) = 0;

  virtual const csVector3& GetCommonDirection () const = 0;

  virtual void SetTransformMode (csParticleTransformMode mode) = 0;

  virtual csParticleTransformMode GetTransformMode () const = 0;

  virtual void SetUseIndividualSize (bool individual) = 0;

  virtual bool GetUseIndividualSize () const = 0;

  virtual void SetParticleSize (const csVector2& size) = 0;

  virtual const csVector2& GetParticleSize () const = 0;

  virtual void SetMinBoundingBox (const csBox3& box) = 0;
  
  virtual const csBox3& GetMinBoundingBox () const = 0;

  virtual void AddEmitter (iParticleEmitter* emitter) = 0;

  virtual iParticleEmitter* GetEmitter (size_t index) const = 0;

  virtual void RemoveEmitter (size_t index) = 0;

  virtual size_t GetEmitterCount () const = 0;

  virtual void AddEffector (iParticleEffector* effector) = 0;

  virtual iParticleEffector* GetEffector (size_t index) const = 0;

  virtual void RemoveEffector (size_t index) = 0;

  virtual size_t GetEffectorCount () const = 0;

};


struct iParticleSystemFactory : public iParticleSystemBase
{
  SCF_INTERFACE(iParticleSystemFactory,1,0,0);

  virtual void SetDeepCreation (bool deep) = 0;

  virtual bool GetDeepCreation () const = 0;
};


struct iParticleSystem : public iParticleSystemBase
{
  SCF_INTERFACE(iParticleSystem,1,0,1);

  virtual size_t GetParticleCount () const = 0;

  virtual csParticle* GetParticle (size_t index) = 0;

  virtual csParticleAux* GetParticleAux (size_t index) = 0;

  virtual csParticleBuffer* LockForExternalControl (size_t maxParticles) = 0;
  
  virtual void Advance (csTicks time) = 0;
};



enum csParticleBuiltinEmitterPlacement
{
  CS_PARTICLE_BUILTIN_CENTER,
  CS_PARTICLE_BUILTIN_VOLUME,
  CS_PARTICLE_BUILTIN_SURFACE
};

struct iParticleBuiltinEmitterBase : public iParticleEmitter
{
  SCF_INTERFACE(iParticleBuiltinEmitterBase,1,0,0);

  virtual void SetPosition (const csVector3& position) = 0;

  virtual const csVector3& GetPosition () const = 0;

  virtual void SetParticlePlacement (csParticleBuiltinEmitterPlacement place) = 0;

  virtual csParticleBuiltinEmitterPlacement GetParticlePlacement () const = 0;

  virtual void SetUniformVelocity (bool uniform) = 0;

  virtual bool GetUniformVelocity () const = 0;

  virtual void SetInitialVelocity (const csVector3& linear, 
    const csVector3& angular) = 0;

  virtual void GetInitialVelocity (csVector3& linear, 
    csVector3& angular) const = 0;
};

struct iParticleBuiltinEmitterSphere : public iParticleBuiltinEmitterBase
{
  SCF_INTERFACE(iParticleBuiltinEmitterSphere,1,0,0);

  virtual void SetRadius (float radius) = 0;

  virtual float GetRadius () const = 0;
};

struct iParticleBuiltinEmitterCone : public iParticleBuiltinEmitterBase
{
  SCF_INTERFACE(iParticleBuiltinEmitterCone,1,0,0);

  virtual void SetExtent (const csVector3& extent) = 0;

  virtual const csVector3& GetExtent () const = 0;

  virtual void SetConeAngle (float angle) = 0;

  virtual float GetConeAngle () const = 0;
};

struct iParticleBuiltinEmitterBox : public iParticleBuiltinEmitterBase
{
  SCF_INTERFACE(iParticleBuiltinEmitterBox,1,0,0);

  virtual void SetBox (const csOBB& box) = 0;

  virtual const csOBB& GetBox () const = 0;
};

struct iParticleBuiltinEmitterCylinder : public iParticleBuiltinEmitterBase
{
  SCF_INTERFACE(iParticleBuiltinEmitterCylinder,1,0,0);

  virtual void SetRadius (float radius) = 0;

  virtual float GetRadius () const = 0;

  virtual void SetExtent (const csVector3& extent) = 0;

  virtual const csVector3& GetExtent () const = 0;
};

struct iParticleBuiltinEmitterFactory : public virtual iBase
{
  SCF_INTERFACE(iParticleBuiltinEmitterFactory,1,0,0);

  virtual csPtr<iParticleBuiltinEmitterSphere> CreateSphere () const = 0;
  virtual csPtr<iParticleBuiltinEmitterCone> CreateCone () const = 0;
  virtual csPtr<iParticleBuiltinEmitterBox> CreateBox () const = 0;
  virtual csPtr<iParticleBuiltinEmitterCylinder> CreateCylinder () const = 0;
};

struct iParticleBuiltinEffectorForce : public iParticleEffector
{
  SCF_INTERFACE(iParticleBuiltinEffectorForce,2,0,0);
  
  virtual void SetAcceleration (const csVector3& acceleration) = 0;

  virtual const csVector3& GetAcceleration () const = 0;

  virtual void SetForce (const csVector3& force) = 0;

  virtual const csVector3& GetForce () const = 0;

  virtual void SetRandomAcceleration (const csVector3& magnitude) = 0;

  virtual const csVector3& GetRandomAcceleration () const = 0;
};

struct iParticleBuiltinEffectorLinColor : public iParticleEffector
{
  SCF_INTERFACE(iParticleBuiltinEffectorLinColor,1,0,0);

  virtual size_t AddColor (const csColor4& color, float endTTL) = 0;

  virtual void SetColor (size_t index, const csColor4& color) = 0;

  virtual void GetColor (size_t index, csColor4& color, float& endTTL) const = 0;

  virtual size_t GetColorCount () const = 0;
};

enum csParticleBuiltinEffectorVFType
{
  CS_PARTICLE_BUILTIN_SPIRAL,

  CS_PARTICLE_BUILTIN_RADIALPOINT
};

struct iParticleBuiltinEffectorVelocityField : public iParticleEffector
{
  SCF_INTERFACE(iParticleBuiltinEffectorVelocityField,1,0,0);

  virtual void SetType (csParticleBuiltinEffectorVFType type) = 0;

  virtual csParticleBuiltinEffectorVFType GetType () const = 0;

  virtual void SetFParameter (size_t parameterNumber, float value) = 0;
  
  virtual float GetFParameter (size_t parameterNumber) const = 0;

  virtual size_t GetFParameterCount () const = 0;

  virtual void SetVParameter (size_t parameterNumber, const csVector3& value) = 0;
  
  virtual csVector3 GetVParameter (size_t parameterNumber) const = 0;

  virtual size_t GetVParameterCount () const = 0;
};

struct iParticleBuiltinEffectorFactory : public virtual iBase
{
  SCF_INTERFACE(iParticleBuiltinEffectorFactory,1,0,0);

  virtual csPtr<iParticleBuiltinEffectorForce> CreateForce () const = 0;
  virtual csPtr<iParticleBuiltinEffectorLinColor> CreateLinColor () const = 0;
  virtual csPtr<iParticleBuiltinEffectorVelocityField> CreateVelocityField () const = 0;
};

#endif // __CS_IMESH_PARTICLES_H__

---