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



sdk/rwsdk/include/d3d8/rpprtstd.h