### Particle Services Availability LightWave® 6.0 Component Layout Header lwprtcl.h The particles global returns functions that allow you to create particle systems and to read and write particle data. Particles are typically used by volumetric renderers to define the extent and local density of a volume. LightWave®'s Hypervoxels, for example, uses them this way. The host side of the particles global manages a database of particle systems. The global supplies methods for adding, deleting and reading particle data in the database. Having such a database allows one plug-in to create particle systems that others can later use. Global Call
       LWPSysFuncs *psysf;
       psysf = global( LWPSYSFUNCS_GLOBAL, GFUSE_TRANSIENT );
The global function returns a pointer to an LWPSysFuncs.
       typedef struct st_LWPSysFuncs {
          LWPSysID   (*create)      (int flags, int type);
          int        (*destroy)     (LWPSysID);
          int        (*init)        (LWPSysID, int np);
          void       (*cleanup)     (LWPSysID);
          void       (*load)        (LWPSysID, LWLoadState *);
          void       (*save)        (LWPSysID, LWSaveState *);
          int        (*getPCount)   (LWPSysID);
          void       (*attach)      (LWPSysID, LWItemID);
          void       (*detach)      (LWPSysID, LWItemID);
          LWPSysID * (*getPSys)     (LWItemID);
          LWPSBufID  (*addBuf)      (LWPSysID, LWPSBufDesc);
          LWPSBufID  (*getBufID)    (LWPSysID, int bufFlag);
          void       (*setBufData)  (LWPSBufID, void *data);
          void       (*getBufData)  (LWPSBufID, void *data);
          int        (*addParticle) (LWPSysID);
          void       (*setParticle) (LWPSBufID, int index, void *data);
          void       (*getParticle) (LWPSBufID, int index, void *data);
          void       (*remParticle) (LWPSysID, int index);
       } LWPSysFuncs;
  You can allocate, initialize and read particle data either individually (one particle at a time) or all at once. Which approach you take will depend primarily on where the data comes from and how you use it. `psys = create( flags, type )` Create a particle system. The flags indicate which buffers should be allocated for the particles and can be any of the following, combined using bitwise-or.
  `LWPSB_POS` | position | `float[3]`
  `LWPSB_SIZ` | size | `float`
  `LWPSB_SCL` | scale | `float[3]`
  `LWPSB_ROT` | rotation | `float[3]`
  `LWPSB_VEL` | velocity | `float[3]`
  `LWPSB_AGE` | age | `float`
  `LWPSB_FCE` | force | `float`
  `LWPSB_PRS` | pressure | `float`
  `LWPSB_TMP` | temperature | `float`
  `LWPSB_MAS` | mass | `float`
  `LWPSB_LNK` | link to particle (for trails) | `int`
  `LWPSB_ID` | ID (unique index for the particle) | `int`
  `LWPSB_ENB` | enable state (dead/alive/limbo) | `char`
  `LWPSB_RGBA` | display color and alpha | `char[4]`
  `LWPSB_CAGE` | time since last collision | `float`
The particle type can be either `LWPST_PRTCL` (single points) or `LWPST_TRAIL` (line segments). `LWPST_TRAIL` particle systems should include an `LWPSB_LNK` buffer for the second point in each trail. `result = destroy( psys )` Free the particle system. `error = init( psys, nparticles )` Allocate memory for the particles. This is equivalent to calling the `addParticle` function `nparticles` times. `cleanup( psys )` Frees the memory allocated by `init` and `addParticle`. `load( psys, loadstate )` Read the particle system data from a file. This will typically be used by handler load callbacks. `save( psys, savestate )` Write the particle system data to a file. This will typically be used by handler save callbacks. `count = getPCount( psys )` Returns the number of particles. `attach( psys, item )` Associate a particle system with an item in the scene, usually an object. More than one particle system can be attached to an item, and more than one item can share the same particle system. Attaching a particle system to an item makes it possible for others, Hypervoxels in particular, to use the `getPSys` function to find it. `detach( psys, item )` Remove the association between a particle system and an item. `psys_array = getPSys( item )` Returns a NULL-terminated array of particle system IDs that have been associated with the item by the `attach` function. `psbuf = addBuf( psys, bufdesc )` Add a custom per-particle buffer. Call this before any calls to `init` or `addParticle`. (The predefined buffer types should be added when `create` is called.) The structure used to define the buffer is described below. The buffer ID returned by this function can be used with the functions that get and set buffer data. `psbuf = getBufID( psys, bufbit )` Returns a buffer ID for one of the predefined buffers. This is used with the functions that get and set buffer data. The second argument is one of the buffer flags passed to `create`. `setBufData( psbuf, data )` Set the buffer values for all particles. The data is an array of the appropriate type for the buffer, with a number of entries equal to the number of particles. Use `setParticle` to set the buffer data for one particle at a time. `getBufData( psbuf, data )` Get the buffer values for all particles. Use `getParticle` to get the buffer data for one particle at a time. `index = addParticle( psys )` Add a particle. `setParticle( psbuf, index, data )` Set the buffer value for a particle. Particles are numbered from 0 to `getPCount` - 1 in the order in which they're added. `getParticle( psbuf, index, data )` Get the buffer value for a particle. `remParticle( psys, index )` Remove a particle. Particle Buffers The `addBuf` function uses a buffer descriptor to define the buffer to be added.
       typedef struct st_LWPSBufDesc {
          const char *name;
          int         dataType;
          int         dataSize;
       } LWPSBufDesc;
  `name` A string that names the buffer. In the future, this may allow users or plug-ins to refer to the buffer by name. `dataType` The data type of the data in the buffer.
      LWPSBT_FLOAT
      LWPSBT_INT
      LWPSBT_CHAR
`dataSize` The number of values per particle in the buffer (and not the number of bytes). Example The particle sample is a displacement handler that demonstrates the use of the particle system global. Its operation is similar to that of the HVParticle displacement handler Hypervoxels adds to objects that lack particle systems.