summaryrefslogtreecommitdiffstats
path: root/rwsdk/include/d3d8/rpprtstd.h
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--rwsdk/include/d3d8/rpprtstd.h1026
1 files changed, 1026 insertions, 0 deletions
diff --git a/rwsdk/include/d3d8/rpprtstd.h b/rwsdk/include/d3d8/rpprtstd.h
new file mode 100644
index 00000000..ad1b87f7
--- /dev/null
+++ b/rwsdk/include/d3d8/rpprtstd.h
@@ -0,0 +1,1026 @@
+
+#ifndef RPPRTSTD_H
+#define RPPRTSTD_H
+
+/*===========================================================================*
+ *--- Include files ---------------------------------------------------------*
+ *===========================================================================*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+
+
+/*---- start: ./prtstd.h----*/
+
+#include "rwcore.h"
+#include "rpworld.h"
+#include "rpptank.h"
+
+#include "rpprtstd.rpe"
+
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+/**
+ * \defgroup rpprtstd RpPrtStd
+ * \ingroup rpplugin
+ *
+ * Particle Animation Plugin for RenderWare Graphics.
+ */
+
+/*
+ * Current version stamp
+ */
+#define rpPRTSTDVERSIONSTAMP 2
+
+/*
+ * Random Number Generation Macros
+ */
+#define PRTSTD_SRAND_MAX 0xFFFFFFFF
+#define PRTSTD_SRAND_IMAX ((RwReal) 1.0 / (RwReal) PRTSTD_SRAND_MAX)
+
+#define PRTSTD_SRAND(_seed) ((_seed) = ((_seed) * 196314165 + 907633515))
+
+/* Real rand -1.0 .. + 1.0 */
+#define PRTSTD_RSRAND(_seed) (((RwReal)((RwUInt32) (_seed) * PRTSTD_SRAND_IMAX) * \
+ (RwReal) 2.0) - (RwReal) 1.0)
+
+
+
+#define PRTSTD_RSRAND2(_seed) (((RwReal)((RwReal) (_seed) * PRTSTD_SRAND_IMAX) * \
+ (RwReal)1.0))
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdParticleFlags, this type represents the different properties of
+ * a particle.
+ */
+enum RpPrtStdParticleFlags
+{
+ rpPRTSTDPARTICLEFLAGEMITTER = 0x00000001, /**<Particle is an emitter. */
+
+ rpPRTSTDPARTICLEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdParticleFlags RpPrtStdParticleFlags;
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdEmitterFlags, this type represents the different properties of
+ * an emitter.
+ */
+enum RpPrtStdEmitterFlags
+{
+ rpPRTSTDEMITTERFLAGALIVE = 0x00000001, /**< The emitter is alive and should not be removed */
+ rpPRTSTDEMITTERFLAGACTIVE = 0x00000002, /**< This indicates the emitter is active or idle */
+ rpPRTSTDEMITTERFLAGPTANK = 0x00000004, /**< The emitter uses the \ref rpptank */
+ rpPRTSTDEMITTERFLAGEMIT = 0x00000008, /**< This indicates the emitter can emit new particles */
+ rpPRTSTDEMITTERFLAGUPDATE = 0x00000010, /**< This indicates if the emitter is to be updated. */
+ rpPRTSTDEMITTERFLAGUPDATEPARTICLE = 0x00000020, /**< This indicated if the emitter's particles are updated. */
+ rpPRTSTDEMITTERFLAGRENDER = 0x00000040, /**< This indicates if the emitter is rendered. */
+ rpPRTSTDEMITTERFLAGRENDERPARTICLE = 0x00000080, /**< This indicates if the emitter's particles are rendered. */
+ rpPRTSTDEMITTERFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdEmitterFlags RpPrtStdEmitterFlags;
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#define rpPRTSTDPARTICLECALLBACKMAX 7
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdParticleCallBackCode, this type represents the different callbacks for
+ * processing a \ref RpPrtStdParticleBatch. These callbacks will be called at various point for
+ * processing the particle's custom data.
+ */
+enum RpPrtStdParticleCallBackCode
+{
+ rpPRTSTDPARTICLECALLBACKUPDATE = 0, /**< Particle update callback */
+ rpPRTSTDPARTICLECALLBACKRENDER, /**< Particle render callback */
+ rpPRTSTDPARTICLECALLBACKCREATE, /**< Particle create callback */
+ rpPRTSTDPARTICLECALLBACKDESTROY, /**< Particle destroy callback */
+ rpPRTSTDPARTICLECALLBACKSTREAMREAD, /**< Particle stream input callback */
+ rpPRTSTDPARTICLECALLBACKSTREAMWRITE, /**< Particle stream outout callback */
+ rpPRTSTDPARTICLECALLBACKSTREAMGETSIZE, /**< Particle stream get size callback */
+ rpPRTSTDPARTICLECALLBACKFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdParticleCallBackCode RpPrtStdParticleCallBackCode;
+
+#define rpPRTSTDEMITTERCALLBACKMAX 10
+
+/**
+ * \ingroup rpprtstd
+ * \ref RpPrtStdEmitterCallBackCode, this type represents the different callbacks for
+ * processing a \ref RpPrtStdEmitter. These callbacks will be called at various point for
+ * processing the emitter's custom data.
+ */
+enum RpPrtStdEmitterCallBackCode
+{
+ rpPRTSTDEMITTERCALLBACKEMIT = 0, /**< Emitter particle emission callback */
+ rpPRTSTDEMITTERCALLBACKBEGINUPDATE, /**< Emitter begin update call back */
+ rpPRTSTDEMITTERCALLBACKENDUPDATE, /**< Emitter end update callback */
+ rpPRTSTDEMITTERCALLBACKBEGINRENDER, /**< Emitter begin render callback */
+ rpPRTSTDEMITTERCALLBACKENDRENDER, /**< Emitter end render callback */
+ rpPRTSTDEMITTERCALLBACKCREATE, /**< Emitter create callback */
+ rpPRTSTDEMITTERCALLBACKDESTROY, /**< Emitter destroy callback */
+ rpPRTSTDEMITTERCALLBACKSTREAMREAD, /**< Emitter stream input callback */
+ rpPRTSTDEMITTERCALLBACKSTREAMWRITE, /**< Emitter stream output callback */
+ rpPRTSTDEMITTERCALLBACKSTREAMGETSIZE, /**< Emitter stream get size callback */
+ rpPRTSTDEMITTERCALLBACKFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdEmitterCallBackCode RpPrtStdEmitterCallBackCode;
+
+typedef RwInt32 RpPrtStdPropertyCode;
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+typedef struct RpPrtStdEmitter RWALIGN(RpPrtStdEmitter, rwMATRIXALIGNMENT);
+
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdEmitterCallBack
+ * \ref RpPrtStdEmitterCallBack represents the function called for processing
+ * a \ref RpPrtStdEmitter. There can several types of the functions, each performing a
+ * specific task defined by \ref RpPrtStdEmitterCallBackCode.
+ *
+ * \param atomic A pointer to the emitter's parent atomic.
+ * \param emt A pointer to the emitter.
+ * \param data A pointer to user data.
+ *
+ * \return A pointer to the emitter on success. NULL otherwise.
+ */
+typedef RpPrtStdEmitter *
+ (*RpPrtStdEmitterCallBack)
+ (RpAtomic *atomic, RpPrtStdEmitter *emt, void *data);
+
+typedef struct RpPrtStdParticleBatch RWALIGN(RpPrtStdParticleBatch, rwMATRIXALIGNMENT);
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdParticleCallBack
+ * \ref RpPrtStdParticleCallBack represents the function called for processing
+ * a \ref RpPrtStdParticleBatch. There can be several types of the functions, each
+ * performing a specific task defined by \ref RpPrtStdParticleCallBackCode.
+ *
+ * \param emt A pointer to the particle batch's parent emitter.
+ * \param prtBatch A pointer to the particle batch.
+ * \param data A pointer to user data.
+ *
+ * \return A pointer to the particle batch on success. NULL otherwise.
+ */
+typedef RpPrtStdParticleBatch *
+ (*RpPrtStdParticleCallBack)
+ (RpPrtStdEmitter *emt, RpPrtStdParticleBatch *prtBatch, void *data);
+
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdEmitterCallBackArray
+ * \ref RpPrtStdEmitterCallBackArray represents a set of callback functions for
+ * processing a \ref RpPrtStdEmitter. All the functions are of the type \ref
+ * RpPrtStdEmitterCallBack.
+ *
+ * \see RpPrtStdEmitterCallBackCode
+ */
+typedef RpPrtStdEmitterCallBack
+ RpPrtStdEmitterCallBackArray[rpPRTSTDEMITTERCALLBACKMAX];
+
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdParticleCallBackArray
+ * \ref RpPrtStdParticleCallBackArray represents a set of callback functions for
+ * processing a \ref RpPrtStdParticleBatch. All the functions are of the type \ref
+ * RpPrtStdParticleCallBack.
+ *
+ * \see RpPrtStdParticleCallBackCode
+ */
+typedef RpPrtStdParticleCallBack
+ RpPrtStdParticleCallBackArray[rpPRTSTDPARTICLECALLBACKMAX];
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+typedef struct RpPrtStdEmitterClass RpPrtStdEmitterClass;
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdEClassSetupCallBack
+ * \ref RpPrtStdEClassSetupCallBack represents the function called for setting up an
+ * emitter class's set of callback function. The callback function is called
+ * after an emitter class is streamed in.
+ *
+ * \param eClass A pointer to an emitter class.
+ *
+ * \return A pointer to the emitter class on success. NULL otherwise.
+ */
+typedef RpPrtStdEmitterClass *
+ (*RpPrtStdEClassSetupCallBack)
+ (RpPrtStdEmitterClass *eClass);
+
+typedef struct RpPrtStdParticleClass RpPrtStdParticleClass;
+/**
+ * \ingroup rpprtstd
+ * \typedef RpPrtStdPClassSetupCallBack
+ * \ref RpPrtStdPClassSetupCallBack represents the function called for setting up an
+ * emitter class's set of callback function. The callback function is called
+ * after an emitter class is streamed in.
+ *
+ * \param pClass A pointer to a particle class.
+ *
+ * \return A pointer to the particle class on success. NULL otherwise.
+ */
+typedef RpPrtStdParticleClass *
+ (*RpPrtStdPClassSetupCallBack)
+ (RpPrtStdParticleClass *pClass);
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+typedef struct RpPrtStdPropertyTable RpPrtStdPropertyTable;
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdPropertyTable
+ * A structure representing properties's data present in an emitter or
+ * particle.
+ * An emitter, or particle, are treated as a single block of memory. The
+ * property table is used to describe the data presents in the memory block.
+ * It stores the property's id, offset entry from the start of the memory
+ * block and size in bytes.
+ */
+struct RpPrtStdPropertyTable
+{
+ RwUInt32 *propPtr; /**< Internal usage */
+ RpPrtStdPropertyTable *next; /**< Internal usage */
+
+ RwInt32 id; /**< Property table's id */
+
+ RwInt32 numProp; /**< Number of properties in the table */
+ RwInt32 maxProp; /**< Internal usage */
+ RwInt32 *propID; /**< Array of properties's id */
+ RwInt32 *propOffset; /**< Array of properties's offset */
+ RwInt32 *propSize; /**< Array of properties's size */
+ RwInt32 *propSizeUA; /**< Internal usage */
+};
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterClass
+ * A structure representing the collection of data and callbacks for an emitter. An emitter
+ * class is used to create emitters that share the same properties and callback functions.
+ * Once created, an emitter class cannot be altered. An emitter class should also not be
+ * destroyed if emitters of the class are still in use.
+ */
+struct RpPrtStdEmitterClass
+{
+ RpPrtStdEmitterClass *next; /**< Internal usage */
+
+ RwInt32 id; /**< Emitter class's id */
+
+ RwInt32 objSize; /**< Size of the emitter */
+ RpPrtStdPropertyTable *propTab; /**< Reference to a table of emitter properties */
+
+ RwInt32 numCallback; /**< Number of callback arrays */
+ RpPrtStdEmitterCallBackArray *callback; /**< Array of emitter callback functions */
+};
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleClass
+ * A structure representing the collection of data and callbacks for a particle. A particle
+ * class is used to create particle that share the same properties and callback functions.
+ * Once created, a particle class cannot be altered. A particle class should also not be
+ * destroyed if particles of the class are still in use.
+ */
+struct RpPrtStdParticleClass
+{
+ RpPrtStdParticleClass *next; /**< Internal usage */
+
+ RwInt32 id; /**< Particle class's id */
+
+ RwInt32 objSize; /**< Size of a particle */
+ RpPrtStdPropertyTable *propTab; /**< Reference to a table of particle properties */
+
+ RwInt32 numCallback; /**< Number of callback sets */
+ RpPrtStdParticleCallBackArray *callback; /**< Array of particle batch callback functions */
+};
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleBatch
+ * A structure repsenting a group of particles. For efficient, particles are stored
+ * in batches rather than individually. All live particles are stored at the head
+ * of batch with no gaps of dead particles. A counter is used to record the number of
+ * live particles in the batch. Once a batch has 0 live particles, it will removed
+ * from the emitter's active particle list to the inactive list.
+ * The first particle of the batch is given by an offset from the start of the
+ * particle batch.
+ */
+struct RpPrtStdParticleBatch
+{
+ RpPrtStdParticleBatch *next; /**< Pointer to the next particle batch */
+
+ RpPrtStdParticleClass *prtClass; /**< Pointer to the particle's class */
+
+ RwInt32 numPrt; /**< Number of particles in the batch */
+ RwInt32 maxPrt; /**< Maxium number of particles in batch */
+ RwInt32 newPrt; /**< Start of newly emitted particles in the batch */
+
+ RwInt32 offset; /**< Offset to the first particle, from the start of the
+ * particle batch */
+};
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitter
+ * A structure repsenting the mandatory data set for any emitter. Each emitter contains information of
+ * itself and its particles, via the emitter class and particle class respectively. It also contains the
+ * list of particles, in batches, it had emitted.
+ * Optional data are stored immediately after the mandatory set. The contents of the optional data are
+ * described in the emitter class's property table. The offset from the property table are from the start
+ * of the emitter.
+ *
+ * The type of particles emitted are given by the particle class. Each emitter may have only emitter class
+ * and particle class and these should not be changed during the lifetime of the emitter and its particles.
+ * The emitter maintains two lists of particle batches, an acitive list, contain still active particles,
+ * and an inactive list. The maximum number of particles in each batch is given by the prtBatchMaxPrt field.
+ */
+struct RpPrtStdEmitter
+{
+ RpPrtStdEmitter *next; /**< Pointer to the next emitter */
+
+ RwUInt32 flag; /**< Emitter's property flag */
+
+ RpAtomic *atomic; /**< Pointer to emitter's parent atomic */
+
+ RpPrtStdEmitterClass *emtClass; /**< Pointer the emitter's class */
+
+ RwInt32 prtActive; /**< Number of particles emitted */
+ RwInt32 prtBatchMaxPrt; /**< Maximum number of particles per batch */
+ RpPrtStdParticleClass *prtClass; /**< Pointer to the particle's class */
+
+ RpPrtStdParticleBatch *inactiveBatch, /**< Circular linked list of inactive particle batches */
+ *activeBatch; /**< Circular linked list of active particle batches */
+
+ RwReal boundingSphere; /**< Emitter's bounding sphere. */
+};
+
+
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#define rpPRTSTDPROPERTYCODEEMITTER 0
+#define rpPRTSTDPROPERTYCODEEMITTERSTANDARD 1
+#define rpPRTSTDPROPERTYCODEEMITTERPRTCOLOR 2
+#define rpPRTSTDPROPERTYCODEEMITTERPRTTEXCOORDS 3
+#define rpPRTSTDPROPERTYCODEEMITTERPRTANIMFRAME 4
+#define rpPRTSTDPROPERTYCODEEMITTERPRTSIZE 5
+#define rpPRTSTDPROPERTYCODEEMITTERPTANK 6
+#define rpPRTSTDPROPERTYCODEEMITTERPRTVELOCITY 7
+#define rpPRTSTDPROPERTYCODEEMITTERPRTMATRIX 8
+
+#define rpPRTSTDEMITTERPROPERTYCOUNT 9
+
+#define rpPRTSTDEMITTERDATAFLAGSTANDARD 0x00000001
+#define rpPRTSTDEMITTERDATAFLAGPRTCOLOR 0x00000002
+#define rpPRTSTDEMITTERDATAFLAGPRTTEXCOORDS 0x00000004
+#define rpPRTSTDEMITTERDATAFLAGPRTANIMFRAME 0x00000008
+#define rpPRTSTDEMITTERDATAFLAGPRTSIZE 0x00000010
+#define rpPRTSTDEMITTERDATAFLAGPTANK 0x00000020
+#define rpPRTSTDEMITTERDATAFLAGPRTMATRIX 0x00000040
+
+
+typedef struct RpPrtStdEmitterStandard RpPrtStdEmitterStandard;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterStandard
+ * A structure represent the set of properties for a basic emitter. The structure is stored as
+ * a single optional data in the emitter property table.
+ *
+ * The basic emitter uses a 'time' variable to control particle emissions. A large time gap between
+ * emission can give pulse effects where as a small time gap produces a streaming effects. Particles
+ * can be emitted from a single point, line, area or a volume.
+ *
+ * Particles emitted from an emitter are of the same type. An emitter cannot emit different types of
+ * particles. Once an emitter has reached its maximum number of particles, no further particles are
+ * emitted until some of the existing particles have died.
+ *
+ * Most properties have a bias value to vary the property value. This uses the seed field
+ * to give a degreee of randomness.
+ */
+struct RpPrtStdEmitterStandard
+{
+ RwInt32 seed; /**< Seed for random number generator */
+
+ RwInt32 maxPrt; /**< Maximum number of active particles */
+
+ RwReal currTime, /**< Current timestamp for emitter */
+ prevTime; /**< Previous timestamp for emitter */
+ RwV3d force; /**< External force applied to particles */
+
+ RwV3d emtPos, /**< Emitter position */
+ emtSize; /**< Emitter size. This is the volume where new particles
+ * are emitted */
+ RwReal emtEmitGap, /**< Time gap between emission */
+ emtEmitGapBias, /**< Time gap bias */
+ emtPrevEmitTime, /**< Previous particle emission time */
+ emtEmitTime; /**< Next particle emission time */
+ RwInt32 emtPrtEmit, /**< Number of particle emit per emission */
+ emtPrtEmitBias; /**< Particle emission bias */
+
+ RwReal prtInitVel, /**< Particle's initial speed */
+ prtInitVelBias; /**< Particle's initial speed bias */
+ RwReal prtLife, /**< Particle's duration */
+ prtLifeBias; /**< Particle's duration bias */
+
+ RwV3d prtInitDir, /**< Particle's initial direction */
+ prtInitDirBias; /**< particle's initial direction bias */
+
+ RwV2d prtSize; /**< Particle's size */
+
+ RwRGBA prtColor; /**< Particle's color */
+
+ RwTexCoords prtUV[4]; /**< Particle's texture coordindates */
+ RwTexture *texture; /**< Particle's texture */
+
+ RwMatrix *ltm; /**< LTM to transform particle coordinates from local space
+ * to world space */
+};
+
+typedef struct RpPrtStdEmitterPrtColor RpPrtStdEmitterPrtColor;
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterPrtColor
+ * An optional structure to represent the change in color of a particle from birth to death.
+ * The particles will start with the prtStartCol and ends with endPrtColor. The particle's
+ * life is used to interpolate the colors.
+ *
+ * If this structure is not present, then the particles will have a constant color.
+ */
+struct RpPrtStdEmitterPrtColor
+{
+ RwRGBAReal prtStartCol, /**< Particle start color */
+ prtStartColBias; /**< Particle start color bias */
+ RwRGBAReal prtEndCol, /**< Particle end color */
+ prtEndColBias; /**< Particle end color bias */
+};
+
+typedef struct RpPrtStdEmitterPrtTexCoords RpPrtStdEmitterPrtTexCoords;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterPrtTexCoords
+ * An optional structure to represent the change in texcoords of a particle from birth to death.
+ * The particles will start with prtStartUV0 and prtStartUV1 and ends with endPrtEndUV0 and endPrtEndUV1.
+ * The particle's life is used to interpolate the texcoords.
+ *
+ * A particle can have two texcoords representing the top left and bottom right respectively. By varying
+ * the texcoords can give an animated texture effect on a particle.
+ *
+ * If this structure is not present, then the particles will have a constant texcoords.
+ */
+struct RpPrtStdEmitterPrtTexCoords
+{
+ RwTexCoords prtStartUV0, /**< Particle start top left texcoords */
+ prtStartUV0Bias; /**< Particle start top left texcoords bias */
+ RwTexCoords prtEndUV0, /**< Particle end top left texcoords */
+ prtEndUV0Bias; /**< Particle end top left texcoords bias */
+ RwTexCoords prtStartUV1, /**< Particle start bottom right texcoords */
+ prtStartUV1Bias; /**< Particle start botton right texcoords bias */
+ RwTexCoords prtEndUV1, /**< Particle end bottom right texcoords */
+ prtEndUV1Bias; /**< Particle end bottom right texcoords bias */
+};
+
+typedef struct RpPrtStdEmitterPrtAnimFrame RpPrtStdEmitterPrtAnimFrame;
+
+struct RpPrtStdEmitterPrtAnimFrame
+{
+ RwInt32 prtNumFrames;
+
+ RwTexCoords *prtAnimFrameTexCoords;
+};
+
+typedef struct RpPrtStdEmitterPrtSize RpPrtStdEmitterPrtSize;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdEmitterPrtSize
+ * An optional structure to represent the change in size of a particle from birth to death.
+ * The particles will start with prtStartSize and ends with prtEndSize. The particle's life
+ * is used to interpolate the size.
+ *
+ * If this structure is not present, then the particles will have a constant size.
+ */
+struct RpPrtStdEmitterPrtSize
+{
+ RwV2d prtStartSize, /**< Particle start size */
+ prtStartSizeBias; /**< Particle start size bias */
+ RwV2d prtEndSize, /**< Particle end size */
+ prtEndSizeBias; /**< Particle end size bias */
+};
+
+typedef struct RpPrtStdEmitterPrtMatrix RWALIGN(RpPrtStdEmitterPrtMatrix, rwMATRIXALIGNMENT);
+
+struct RpPrtStdEmitterPrtMatrix
+{
+ RwMatrix prtCnsMtx;
+
+ RwV3d prtPosMtxAt,
+ prtPosMtxAtBias;
+ RwV3d prtPosMtxUp,
+ prtPosMtxUpBias;
+
+ RwInt32 flags;
+};
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+
+
+enum RpPrtStdPTankPropertyCode
+{
+ rpPRTSTDPTANKPROPPARTICLESMAX = 0,
+ rpPRTSTDPTANKPROPDATAFLAGS,
+ rpPRTSTDPTANKPROPPLATFORMFLAGS,
+ rpPRTSTDPTANKPROPPTANK,
+ rpPRTSTDPTANKPROPFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+typedef enum RpPrtStdPTankPropertyCode RpPrtStdPTankPropertyCode;
+
+typedef struct RpPrtStdEmitterPTank RpPrtStdEmitterPTank;
+struct RpPrtStdEmitterPTank
+{
+ RwUInt32 dataFlags,
+ platFlags,
+ numPrt,
+ maxPrt,
+ updateFlags,
+ emitFlags;
+ RpAtomic *pTank;
+ RwChar **dataInPtrs,
+ **dataOutPtrs;
+ RwInt32 *dataStride;
+};
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#define rpPRTSTDPROPERTYCODEPARTICLESTANDARD 0
+#define rpPRTSTDPROPERTYCODEPARTICLEPOSITION 1
+#define rpPRTSTDPROPERTYCODEPARTICLECOLOR 2
+#define rpPRTSTDPROPERTYCODEPARTICLETEXCOORDS 3
+#define rpPRTSTDPROPERTYCODEPARTICLEANIMFRAME 4
+#define rpPRTSTDPROPERTYCODEPARTICLESIZE 5
+#define rpPRTSTDPROPERTYCODEPARTICLEVELOCITY 6
+#define rpPRTSTDPROPERTYCODEPARTICLEMATRIX 7
+
+#define rpPRTSTDPARTICLEPROPERTYCOUNT 8
+
+#define rpPRTSTDPARTICLEDATAFLAGSTANDARD 0x00000001
+#define rpPRTSTDPARTICLEDATAFLAGPOSITION 0x00000002
+#define rpPRTSTDPARTICLEDATAFLAGCOLOR 0x00000004
+#define rpPRTSTDPARTICLEDATAFLAGTEXCOORDS 0x00000008
+#define rpPRTSTDPARTICLEDATAFLAGANIMFRAME 0x00000010
+#define rpPRTSTDPARTICLEDATAFLAGSIZE 0x00000020
+#define rpPRTSTDPARTICLEDATAFLAGVELOCITY 0x00000040
+#define rpPRTSTDPARTICLEDATAFLAGMATRIX 0x00000080
+
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleStandard
+ * A structure represent the set of properties for a basic particle. This structure is mandatory
+ * for all particles.
+ * The structure contain the life duration of the particle. The particle will be removed when the current
+ * time is greater than the end time. The particle timer always starts at zero.
+ *
+ * The inverted end time is for interpolating optional particle properties.
+ */
+typedef struct RpPrtStdParticleStandard RpPrtStdParticleStandard;
+struct RpPrtStdParticleStandard
+{
+ RwInt32 flag; /**< Particle's property flag */
+ RwReal currTime, /**< Particle's curr time */
+ endTime, /**< Particle's end time */
+ invEndTime; /**< Particle's inv end for interpolation */
+};
+
+
+typedef struct RpPrtStdParticleColor RpPrtStdParticleColor;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleColor
+ * A structure representing the change in a particle's color during its life time. The structure is optional
+ * and should not be used if particles have a constant color.
+ */
+struct RpPrtStdParticleColor
+{
+ RwRGBAReal startCol, /**< Particle's end size bias */
+ deltaCol; /**< Particle's color rate of change */
+};
+
+typedef struct RpPrtStdParticleTexCoords RpPrtStdParticleTexCoords;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleTexCoords
+ * A structure representing the change in a particle's texcoords during its life time. The structure is optional
+ * and should not be used if particles have a constant texcoords.
+ */
+struct RpPrtStdParticleTexCoords
+{
+ RwTexCoords startUV0, /**< Particle's starting top left texcoords */
+ startUV1; /**< Particle's starting bottom right texcoords */
+ RwTexCoords deltaUV0, /**< Particle's top left texcoords rate of change */
+ deltaUV1; /**< Particle's bottom right texcoords rate of change */
+};
+
+typedef struct RpPrtStdParticleAnimFrame RpPrtStdParticleAnimFrame;
+
+struct RpPrtStdParticleAnimFrame
+{
+ RwInt32 frame;
+
+ RwReal delta;
+};
+
+typedef struct RpPrtStdParticleSize RpPrtStdParticleSize;
+
+/**
+ * \ingroup rpprtstd
+ * \struct RpPrtStdParticleSize
+ * A structure representing the change in a particle's size during its life time. The structure is optional
+ * and should not be used if particles have a constant size.
+ */
+struct RpPrtStdParticleSize
+{
+ RwV2d startSize, /**< Particle's starting size */
+ deltaSize; /**< Particle's size rate of change */
+ RwV2d currSize, /**< Particle's current size. Internal use only */
+ invCurrSize; /**< Particle's inverse current size. Internal use only */
+};
+
+/************************************************************************
+ *
+ *
+ *
+ ************************************************************************/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/************************************************************************/
+
+extern RwBool
+RpParticleStandardPluginAttach( void );
+
+/************************************************************************/
+
+extern RpAtomic *
+RpPrtStdAtomicCreate(RpPrtStdEmitterClass *eClass, void *data);
+
+extern RpAtomic *
+RpPrtStdAtomicUpdate(RpAtomic *atomic, void *data);
+
+extern RpAtomic *
+RpPrtStdAtomicSetEmitter(RpAtomic *atomic, RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdAtomicGetEmitter(RpAtomic *atomic);
+
+extern RpAtomic *
+RpPrtStdAtomicForAllEmitter(RpAtomic *atomic,
+ RpPrtStdEmitterCallBack callback,
+ void *data);
+
+extern RpAtomic *
+RpPrtStdAtomicAddEmitter(RpAtomic *,
+ RpPrtStdEmitter *emt);
+
+
+/************************************************************************/
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterCreate(RpPrtStdEmitterClass *eClass);
+
+extern RwBool
+RpPrtStdEmitterDestroy(RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterForAllParticleBatch(RpPrtStdEmitter *emt,
+ RpPrtStdParticleCallBack callback,
+ void * data);
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterAddEmitter(RpPrtStdEmitter *emtHead,
+ RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterLinkPTank(RpPrtStdEmitter *emt,RpAtomic *ptank);
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterDestroyParticleBatch(RpPrtStdEmitter *emt);
+
+extern RpPrtStdParticleBatch *
+RpPrtStdEmitterNewParticleBatch(RpPrtStdEmitter *emt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterAddParticleBatch(RpPrtStdEmitter *emt,
+ RpPrtStdParticleBatch *prtBatch);
+
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterSetPClass(RpPrtStdEmitter *emt,
+ RpPrtStdParticleClass *pClass,
+ RwInt32 maxPrt);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterGetPClass(RpPrtStdEmitter *emt,
+ RpPrtStdParticleClass **pClass,
+ RwInt32 *maxPrt);
+
+
+/************************************************************************/
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleBatchCreate(RpPrtStdParticleClass *pClass, RwInt32 maxPrt);
+
+extern RwBool
+RpPrtStdParticleBatchDestroy(RpPrtStdParticleBatch *prtBatch);
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleBatchAddBatch(RpPrtStdParticleBatch *prtBatchHead,
+ RpPrtStdParticleBatch *prtBatch);
+
+/************************************************************************/
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabCreate(RwInt32 numProp,
+ RwInt32 *propID, RwInt32 *propStride);
+
+extern RwBool
+RpPrtStdPropTabDestroy(RpPrtStdPropertyTable *propTab);
+
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabGetProperties(RpPrtStdPropertyTable *propTab,
+ RwInt32 *numProp,
+ RwInt32 **propID,
+ RwInt32 **propOffset,
+ RwInt32 **propSize);
+
+extern RwInt32
+RpPrtStdPropTabGetPropOffset(RpPrtStdPropertyTable *propTab,
+ RwInt32 propID);
+
+extern RwInt32
+RpPrtStdPropTabGetPropIndex(RpPrtStdPropertyTable *propTab,
+ RwInt32 propID);
+
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabGet(RwInt32 id);
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabStreamRead(RwStream *stream);
+
+extern RpPrtStdPropertyTable *
+RpPrtStdPropTabStreamWrite(RpPrtStdPropertyTable *eClass,
+ RwStream *stream);
+
+extern RwInt32
+RpPrtStdPropTabStreamGetSize(RpPrtStdPropertyTable *eClass);
+
+/************************************************************************/
+
+extern RwBool
+RpPrtStdEClassDestroy(RpPrtStdEmitterClass *eClass);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassCreate( void );
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassSetCallBack(RpPrtStdEmitterClass *eClass,
+ RwInt32 numCallback,
+ RpPrtStdEmitterCallBackArray *emtCB);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassGetCallBack(RpPrtStdEmitterClass *eClass,
+ RwInt32 *numCallback,
+ RpPrtStdEmitterCallBackArray **emtCB);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassSetPropTab(RpPrtStdEmitterClass *eClass,
+ RpPrtStdPropertyTable *propTab);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassGetPropTab(RpPrtStdEmitterClass *eClass,
+ RpPrtStdPropertyTable **propTab);
+
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassGet(RwInt32 id);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStreamRead(RwStream *stream);
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStreamWrite(RpPrtStdEmitterClass *eClass,
+ RwStream *stream);
+
+extern RwInt32
+RpPrtStdEClassStreamGetSize(RpPrtStdEmitterClass *eClass);
+
+/************************************************************************/
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassCreate( void );
+
+extern RwBool
+RpPrtStdPClassDestroy(RpPrtStdParticleClass *pClass);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassSetCallBack(RpPrtStdParticleClass *pClass,
+ RwInt32 numCallback,
+ RpPrtStdParticleCallBackArray *prtCB);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassGetCallBack(RpPrtStdParticleClass *pClass,
+ RwInt32 *numCallback,
+ RpPrtStdParticleCallBackArray **prtCB);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassSetPropTab(RpPrtStdParticleClass *pClass,
+ RpPrtStdPropertyTable *propTab);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassGetPropTab(RpPrtStdParticleClass *pClass,
+ RpPrtStdPropertyTable **propTab);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassGet(RwInt32 id);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStreamRead(RwStream *stream);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStreamWrite(RpPrtStdParticleClass *pClass,
+ RwStream *stream);
+
+extern RwInt32
+RpPrtStdPClassStreamGetSize(RpPrtStdParticleClass *pClass);
+
+/************************************************************************/
+
+extern RwBool
+RpPrtStdSetEClassSetupCallBack(RpPrtStdEClassSetupCallBack emtCB);
+
+extern RwBool
+RpPrtStdGetEClassSetupCallBack(RpPrtStdEClassSetupCallBack *emtCB);
+
+extern RwBool
+RpPrtStdSetPClassSetupCallBack(RpPrtStdPClassSetupCallBack prtCB);
+
+extern RwBool
+RpPrtStdGetPClassSetupCallBack(RpPrtStdPClassSetupCallBack *prtCB);
+
+/************************************************************************/
+
+
+extern RwStream *
+RpPrtStdGlobalDataStreamRead(RwStream *stream);
+
+extern RwStream *
+RpPrtStdGlobalDataStreamWrite(RwStream *stream);
+
+extern RwInt32
+RpPrtStdGlobalDataStreamGetSize( void );
+
+
+/************************************************************************/
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterDefaultCB(RpAtomic * atomic,
+ RpPrtStdEmitter *prtEmt, void * data);
+
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleDefaultCB(RpPrtStdEmitter * prtEmt,
+ RpPrtStdParticleBatch *prtBatch, void * data);
+
+/************************************************************************/
+
+extern RpPrtStdParticleBatch *
+RpPrtStdParticleStdUpdateCB(RpPrtStdEmitter *emt,
+ RpPrtStdParticleBatch *prtBatch, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdEmitCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdCreateCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdBeginUpdateCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdEndUpdateCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdRenderCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdStreamReadCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdStreamWriteCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+extern RpPrtStdEmitter *
+RpPrtStdEmitterStdStreamGetSizeCB(RpAtomic *atomic,
+ RpPrtStdEmitter *emt, void *data);
+
+
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStdCreate( RwInt32 dataFlag );
+
+extern RwInt32
+RpPrtStdEClassStdCreateID( RwInt32 dataFlag );
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStdCreate( RwInt32 dataFlag );
+
+extern RwInt32
+RpPrtStdPClassStdCreateID( RwInt32 dataFlag );
+
+extern RpPrtStdEmitterClass *
+RpPrtStdEClassStdSetupCB(RpPrtStdEmitterClass *eClass);
+
+extern RpPrtStdParticleClass *
+RpPrtStdPClassStdSetupCB(RpPrtStdParticleClass *pClass);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+/*---- end: ./prtstd.h----*/
+
+/*---- start: c:/daily/rwsdk/plugin/prtstd/d3d8/prtstdplatform.h----*/
+/*---- end: c:/daily/rwsdk/plugin/prtstd/d3d8/prtstdplatform.h----*/
+
+#endif /* RPPRTSTD_H */
+
+