more work on CPhysical

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 */
+
+