mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-30 16:11:11 +00:00
218 lines
7.7 KiB
C++
218 lines
7.7 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __DECLPARTICLE_H__
|
|
#define __DECLPARTICLE_H__
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
idDeclParticle
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
class idParticleParm {
|
|
public:
|
|
idParticleParm( void ) { table = NULL; from = to = 0.0f; }
|
|
|
|
const idDeclTable * table;
|
|
float from;
|
|
float to;
|
|
|
|
float Eval( float frac, idRandom &rand ) const;
|
|
float Integrate( float frac, idRandom &rand ) const;
|
|
};
|
|
|
|
|
|
typedef enum {
|
|
PDIST_RECT, // ( sizeX sizeY sizeZ )
|
|
PDIST_CYLINDER, // ( sizeX sizeY sizeZ )
|
|
PDIST_SPHERE // ( sizeX sizeY sizeZ ringFraction )
|
|
// a ringFraction of zero allows the entire sphere, 0.9 would only
|
|
// allow the outer 10% of the sphere
|
|
} prtDistribution_t;
|
|
|
|
typedef enum {
|
|
PDIR_CONE, // parm0 is the solid cone angle
|
|
PDIR_OUTWARD // direction is relative to offset from origin, parm0 is an upward bias
|
|
} prtDirection_t;
|
|
|
|
typedef enum {
|
|
PPATH_STANDARD,
|
|
PPATH_HELIX, // ( sizeX sizeY sizeZ radialSpeed climbSpeed )
|
|
PPATH_FLIES,
|
|
PPATH_ORBIT,
|
|
PPATH_DRIP
|
|
} prtCustomPth_t;
|
|
|
|
typedef enum {
|
|
POR_VIEW,
|
|
POR_AIMED, // angle and aspect are disregarded
|
|
POR_X,
|
|
POR_Y,
|
|
POR_Z
|
|
} prtOrientation_t;
|
|
|
|
typedef struct renderEntity_s renderEntity_t;
|
|
typedef struct renderView_s renderView_t;
|
|
|
|
typedef struct {
|
|
const renderEntity_t * renderEnt; // for shaderParms, etc
|
|
const renderView_t * renderView;
|
|
int index; // particle number in the system
|
|
float frac; // 0.0 to 1.0
|
|
idRandom random;
|
|
idVec3 origin; // dynamic smoke particles can have individual origins and axis
|
|
idMat3 axis;
|
|
|
|
|
|
float age; // in seconds, calculated as fraction * stage->particleLife
|
|
idRandom originalRandom; // needed so aimed particles can reset the random for another origin calculation
|
|
float animationFrameFrac; // set by ParticleTexCoords, used to make the cross faded version
|
|
} particleGen_t;
|
|
|
|
|
|
//
|
|
// single particle stage
|
|
//
|
|
class idParticleStage {
|
|
public:
|
|
idParticleStage( void );
|
|
virtual ~idParticleStage( void ) {}
|
|
|
|
void Default();
|
|
virtual int NumQuadsPerParticle() const; // includes trails and cross faded animations
|
|
// returns the number of verts created, which will range from 0 to 4*NumQuadsPerParticle()
|
|
virtual int CreateParticle( particleGen_t *g, idDrawVert *verts ) const;
|
|
|
|
void ParticleOrigin( particleGen_t *g, idVec3 &origin ) const;
|
|
int ParticleVerts( particleGen_t *g, const idVec3 origin, idDrawVert *verts ) const;
|
|
void ParticleTexCoords( particleGen_t *g, idDrawVert *verts ) const;
|
|
void ParticleColors( particleGen_t *g, idDrawVert *verts ) const;
|
|
|
|
const char * GetCustomPathName();
|
|
const char * GetCustomPathDesc();
|
|
int NumCustomPathParms();
|
|
void SetCustomPathType( const char *p );
|
|
void operator=( const idParticleStage &src );
|
|
|
|
|
|
//------------------------------
|
|
|
|
const idMaterial * material;
|
|
|
|
int totalParticles; // total number of particles, although some may be invisible at a given time
|
|
float cycles; // allows things to oneShot ( 1 cycle ) or run for a set number of cycles
|
|
// on a per stage basis
|
|
|
|
int cycleMsec; // ( particleLife + deadTime ) in msec
|
|
|
|
float spawnBunching; // 0.0 = all come out at first instant, 1.0 = evenly spaced over cycle time
|
|
float particleLife; // total seconds of life for each particle
|
|
float timeOffset; // time offset from system start for the first particle to spawn
|
|
float deadTime; // time after particleLife before respawning
|
|
|
|
//------------------------------- // standard path parms
|
|
|
|
prtDistribution_t distributionType;
|
|
float distributionParms[4];
|
|
|
|
prtDirection_t directionType;
|
|
float directionParms[4];
|
|
|
|
idParticleParm speed;
|
|
float gravity; // can be negative to float up
|
|
bool worldGravity; // apply gravity in world space
|
|
bool randomDistribution; // randomly orient the quad on emission ( defaults to true )
|
|
bool entityColor; // force color from render entity ( fadeColor is still valid )
|
|
|
|
//------------------------------ // custom path will completely replace the standard path calculations
|
|
|
|
prtCustomPth_t customPathType; // use custom C code routines for determining the origin
|
|
float customPathParms[8];
|
|
|
|
//--------------------------------
|
|
|
|
idVec3 offset; // offset from origin to spawn all particles, also applies to customPath
|
|
|
|
int animationFrames; // if > 1, subdivide the texture S axis into frames and crossfade
|
|
float animationRate; // frames per second
|
|
|
|
float initialAngle; // in degrees, random angle is used if zero ( default )
|
|
idParticleParm rotationSpeed; // half the particles will have negative rotation speeds
|
|
|
|
prtOrientation_t orientation; // view, aimed, or axis fixed
|
|
float orientationParms[4];
|
|
|
|
idParticleParm size;
|
|
idParticleParm aspect; // greater than 1 makes the T axis longer
|
|
|
|
idVec4 color;
|
|
idVec4 fadeColor; // either 0 0 0 0 for additive, or 1 1 1 0 for blended materials
|
|
float fadeInFraction; // in 0.0 to 1.0 range
|
|
float fadeOutFraction; // in 0.0 to 1.0 range
|
|
float fadeIndexFraction; // in 0.0 to 1.0 range, causes later index smokes to be more faded
|
|
|
|
bool hidden; // for editor use
|
|
//-----------------------------------
|
|
|
|
float boundsExpansion; // user tweak to fix poorly calculated bounds
|
|
|
|
idBounds bounds; // derived
|
|
};
|
|
|
|
|
|
//
|
|
// group of particle stages
|
|
//
|
|
class idDeclParticle : public idDecl {
|
|
public:
|
|
|
|
virtual size_t Size( void ) const;
|
|
virtual const char * DefaultDefinition( void ) const;
|
|
virtual bool Parse( const char *text, const int textLength );
|
|
virtual void FreeData( void );
|
|
|
|
bool Save( const char *fileName = NULL );
|
|
|
|
idList<idParticleStage *>stages;
|
|
idBounds bounds;
|
|
float depthHack;
|
|
|
|
private:
|
|
bool RebuildTextSource( void );
|
|
void GetStageBounds( idParticleStage *stage );
|
|
idParticleStage * ParseParticleStage( idLexer &src );
|
|
void ParseParms( idLexer &src, float *parms, int maxParms );
|
|
void ParseParametric( idLexer &src, idParticleParm *parm );
|
|
void WriteStage( idFile *f, idParticleStage *stage );
|
|
void WriteParticleParm( idFile *f, idParticleParm *parm, const char *name );
|
|
};
|
|
|
|
#endif /* !__DECLPARTICLE_H__ */
|