You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1027 lines
40 KiB
C
1027 lines
40 KiB
C
|
|
#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 */
|
|
|
|
|