Public API Reference

csplugincommon/particlesys/partgen.h

Go to the documentation of this file.

/*
    Copyright (C) 2000-2001 by Jorrit Tyberghein
    Copyright (C) 2000 by W.C.A. Wijngaards

    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_CSPLUGINCOMMON_PARTICLESYS_PARTGEN_H__
#define __CS_CSPLUGINCOMMON_PARTICLESYS_PARTGEN_H__

#include "csextern.h"
#include "csgeom/box.h"
#include "cstool/objmodel.h"
#include "csgeom/vector3.h"
#include "csgfx/shadervarcontext.h"
#include "cstool/rendermeshholder.h"
#include "csutil/cscolor.h"
#include "csutil/flags.h"
#include "csutil/floatrand.h"
#include "csutil/refarr.h"
#include "iengine/lightmgr.h"
#include "iengine/material.h"
#include "imesh/object.h"
#include "imesh/particle.h"
#include "imesh/partsys.h"
#include "imesh/sprite2d.h"
#include "ivideo/graph3d.h"

struct iMeshObjectFactory;
struct iMaterialWrapper;
struct iMovable;
struct iRenderView;
struct iObjectRegistry;
struct iEngine;
struct iMeshWrapper;

#include "csutil/win32/msvc_deprecated_warn_off.h"

class CS_CRYSTALSPACE_EXPORT csParticleSystem :
  public scfImplementationExt2<csParticleSystem,
    csObjectModel, iMeshObject, iParticleState>
{
protected:
  iObjectRegistry* object_reg;
  iMeshObjectFactory* factory;
  iMeshWrapper* logparent;
  iEngine* engine;
  csRef<iLightManager> light_mgr;
  float radius;
  csRefArray<iMeshObject> partmeshes;
  csRefArray<iSprite2DState> sprite2ds;
  csRefArray<iParticle> particles;
  bool self_destruct;
  csTicks time_to_live; // msec
  csColor color;
  csRef<iMaterialWrapper> mat;
  uint MixMode;
  bool change_color; csColor colorpersecond;
  bool change_size; float scalepersecond;
  bool change_alpha; float alphapersecond; float alpha_now;
  bool change_rotation; float anglepersecond;
  csBox3 bbox;
  iMeshObjectDrawCallback* vis_cb;

  csRef<iMeshObjectFactory> spr_factory;
  csTicks prev_time;
  float current_lod;
  uint32 current_features;

  csFlags flags;

  // Number of particles.
  size_t number;
  csVector3 *part_pos;

  csRenderMeshHolder rmHolder;

  size_t VertexCount;
  size_t TriangleCount;
  struct PerFrameData
  {
    csRef<csRenderBufferHolder> bufferHolder;
    csRef<iRenderBuffer> vertex_buffer;
    csRef<iRenderBuffer> texel_buffer;
    csRef<iRenderBuffer> color_buffer;
  };
  csFrameDataHolder<PerFrameData> perFrameHolder;
  csRef<iRenderBuffer> index_buffer;

  csRef<iGraphics3D> g3d;

  void SetupBuffers (size_t part_sides);
  size_t part_sides;    // Number of vertices per particle (for buffers).

  bool initialized;
  virtual void SetupObject ();

  // Call if object needs changing.
  void ChangeObject ()
  {
    initialized = false;
    ShapeChanged ();
  }

private:
  csRandomFloatGen randgen;
protected:
  csVector3 GetRandomDirection();
  csVector3 GetRandomDirection(csVector3 const& magnitude,
    csVector3 const& offset);
  csVector3 GetRandomPosition(csBox3 const& box);

public:
  csParticleSystem (iObjectRegistry* object_reg, iMeshObjectFactory* factory);

  virtual ~csParticleSystem ();

  virtual void SetParticleCount (size_t num)
  {
    number = num;
    ChangeObject ();
  }
  size_t GetParticleCount () const { return number; }

  void UpdateLighting (const csArray<iLightSectorInfluence*>& lights,
      iMovable* movable);

  inline size_t GetNumParticles () const { return particles.Length();}
  inline iParticle* GetParticle (size_t idx) const
  { return particles[idx]; }
  void RemoveParticles ();

  inline void AppendParticle (iMeshObject* mesh,
        iParticle *part, iSprite2DState* spr2d)
  {
    partmeshes.Push (mesh);
    sprite2ds.Push (spr2d);
    particles.Push (part);
  }

  void AppendRectSprite (float width, float height, iMaterialWrapper* mat,
    bool lighted);

  void AppendRegularSprite (int n, float radius, iMaterialWrapper* mat,
    bool lighted);

  inline void SetSelfDestruct (csTicks t)
  { self_destruct=true; time_to_live = t; };
  inline void UnSetSelfDestruct () { self_destruct=false; }
  inline bool GetSelfDestruct () const { return self_destruct; }
  inline csTicks GetTimeToLive () const { return time_to_live; }

  inline void SetChangeColor(const csColor& col)
  {change_color = true; colorpersecond = col;}
  inline void UnsetChangeColor() {change_color=false;}
  inline bool GetChangeColor (csColor& col) const
  { if(!change_color) return false; col = colorpersecond; return true; }

  inline void SetChangeSize(float factor)
  {change_size = true; scalepersecond = factor;}
  inline void UnsetChangeSize() {change_size=false;}
  inline bool GetChangeSize (float& factor) const
  { if(!change_size) return false; factor = scalepersecond; return true; }

  inline void SetAlpha(float alpha)
  {alpha_now = alpha; MixMode = CS_FX_SETALPHA (alpha); SetupMixMode (); }
  inline float GetAlpha() const {return alpha_now;}
  inline void SetChangeAlpha(float factor)
  {change_alpha = true; alphapersecond = factor;}
  inline void UnsetChangeAlpha() {change_alpha=false;}
  inline bool GetChangeAlpha (float& factor) const
  { if(!change_alpha) return false; factor = alphapersecond; return true; }

  inline void SetChangeRotation(float angle)
  {change_rotation = true; anglepersecond = angle;}
  inline void UnsetChangeRotation() {change_rotation=false;}
  inline bool GetChangeRotation (float& angle) const
  { if(!change_rotation) return false; angle = anglepersecond; return true; }

  inline const csBox3& GetBoundingBox() const {return bbox;}

  virtual void SetupColor ();
  virtual void AddColor (const csColor& col);
  virtual void ScaleBy(float factor);
  virtual void SetupMixMode ();
  virtual void Rotate(float angle);

  virtual void Update (csTicks elapsed_time);

  virtual void GetObjectBoundingBox (csBox3& bbox)
  {
    SetupObject ();
    bbox = csParticleSystem::bbox;
  }
  virtual const csBox3& GetObjectBoundingBox ()
  {
    SetupObject ();
    return bbox;
  }
  virtual void SetObjectBoundingBox (const csBox3& bbox)
  {
    csParticleSystem::bbox = bbox;
    ShapeChanged ();
  }
  virtual void GetRadius (float& rad, csVector3& cent)
  {
    SetupObject ();
    rad = radius;
    cent = bbox.GetCenter();
  }

  //----------------------- iMeshObject implementation ------------------------
  virtual iMeshObjectFactory* GetFactory () const { return factory; }
  virtual csFlags& GetFlags () { return flags; }
  virtual csPtr<iMeshObject> Clone () { return 0; }
  virtual bool PreGetRenderMeshes (iRenderView* rview, iMovable* movable,
        uint32 frustum_mask);
  virtual csRenderMesh** GetRenderMeshes (int& n, iRenderView* rview,
    iMovable* movable, uint32 frustum_mask);
  virtual void SetVisibleCallback (iMeshObjectDrawCallback* cb)
  {
    if (cb) cb->IncRef ();
    if (vis_cb) vis_cb->DecRef ();
    vis_cb = cb;
  }
  virtual iMeshObjectDrawCallback* GetVisibleCallback () const
  {
    return vis_cb;
  }
  virtual void NextFrame (csTicks current_time, const csVector3& /*pos*/, 
    uint /*currentFrame*/)
  {
    csTicks elaps = 0;
    if (prev_time != 0) elaps = current_time-prev_time;
    if (elaps > 200) elaps = 200;
    prev_time = current_time;
    Update (elaps);
  }
  virtual int HitBeamBBox (const csVector3&, const csVector3&,
        csVector3&, float*)
  { return -1; }
  virtual bool HitBeamOutline (const csVector3&, const csVector3&,
        csVector3&, float*)
  { return false; }
  virtual bool HitBeamObject (const csVector3& start, const csVector3& end,
    csVector3& isect, float* pr, int* polygon_idx = 0, 
    iMaterialWrapper** material = 0) 
  { 
    (void)start; (void)end; (void)isect; (void)pr; (void)polygon_idx;
    (void)material;
    return false; 
  }
  virtual void SetMeshWrapper (iMeshWrapper* lp) { logparent = lp; }
  virtual iMeshWrapper* GetMeshWrapper () const { return logparent; }

  //------------------------- iObjectModel implementation ----------------
  virtual iObjectModel* GetObjectModel () { return this; }
  virtual bool SetColor (const csColor& col)
  {
    color = col;
    SetupColor ();
    return true;
  }
  virtual bool GetColor (csColor& col) const
  {
    col = color;
    return true;
  }
  virtual bool SetMaterialWrapper (iMaterialWrapper* mat)
  {
    initialized = false;
    csParticleSystem::mat = mat;
    return true;
  }
  virtual iMaterialWrapper* GetMaterialWrapper () const { return mat; }
  virtual iTerraFormer* GetTerraFormerColldet () { return 0; }
  //------------------------- iParticleState implementation ----------------
  virtual void SetMixMode (uint mode)
  {
    MixMode = mode;
    SetupMixMode ();
  }
  virtual uint GetMixMode () const { return MixMode; }
  virtual void InvalidateMaterialHandles () { }
  virtual void PositionChild (iMeshObject* /*child*/,csTicks /*current_time*/) { }
};

class CS_CRYSTALSPACE_EXPORT csNewtonianParticleSystem :
  public scfImplementationExt0<csNewtonianParticleSystem, csParticleSystem>
{
protected:
  csVector3 *part_speed;
  csVector3 *part_accel;

public:
  csNewtonianParticleSystem (iObjectRegistry* object_reg,
        iMeshObjectFactory* factory);
  virtual ~csNewtonianParticleSystem ();

  void SetCount (int max);

  virtual void Update (csTicks elapsed_time);

  csVector3& GetSpeed (int idx) const { return part_speed[idx]; }
  void SetSpeed (int idx, const csVector3& spd)
  { part_speed[idx] = spd; }

  csVector3& GetAccel (int idx) const { return part_accel[idx]; }
  void SetAccel (int idx, const csVector3& acl)
  { part_accel[idx] = acl; }
};

#include "csutil/win32/msvc_deprecated_warn_on.h"

#endif // __CS_CSPLUGINCOMMON_PARTICLESYS_PARTGEN_H__

---