teambeef/jkxr
0
0
Fork 0
mirror of https://github.com/DrBeef/JKXR.git synced 2024-12-11 21:21:47 +00:00
Code Issues Projects Releases Packages Wiki Activity
jkxr/Projects/Android/jni/OpenJK/code/rd-gles/tr_WorldEffects.cpp

2366 lines
60 KiB
C++
Raw Blame History

/*
===========================================================================
Copyright (C) 2000 - 2013, Raven Software, Inc.
Copyright (C) 2001 - 2013, Activision, Inc.
Copyright (C) 2013 - 2015, OpenJK contributors
This file is part of the OpenJK source code.
OpenJK is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License version 2 as
published by the Free Software Foundation.
This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
===========================================================================
*/
////////////////////////////////////////////////////////////////////////////////////////
// RAVEN SOFTWARE - STAR WARS: JK II
// (c) 2002 Activision
//
// World Effects
//
//
////////////////////////////////////////////////////////////////////////////////////////
#include "../server/exe_headers.h"
////////////////////////////////////////////////////////////////////////////////////////
// Externs & Fwd Decl.
////////////////////////////////////////////////////////////////////////////////////////
extern void SetViewportAndScissor( void );
////////////////////////////////////////////////////////////////////////////////////////
// Includes
////////////////////////////////////////////////////////////////////////////////////////
#include "tr_local.h"
#include "tr_WorldEffects.h"
#include "../Ravl/CVec.h"
#include "../Ratl/vector_vs.h"
#include "../Ratl/bits_vs.h"
////////////////////////////////////////////////////////////////////////////////////////
// Defines
////////////////////////////////////////////////////////////////////////////////////////
#define GLS_ALPHA (GLS_SRCBLEND_SRC_ALPHA | GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA)
#define MAX_WIND_ZONES 12
#define MAX_WEATHER_ZONES 50 // so we can more zones that are smaller
#define MAX_PUFF_SYSTEMS 2
#define MAX_PARTICLE_CLOUDS 5
#define POINTCACHE_CELL_SIZE 32.0f
////////////////////////////////////////////////////////////////////////////////////////
// Globals
////////////////////////////////////////////////////////////////////////////////////////
float mMillisecondsElapsed = 0;
float mSecondsElapsed = 0;
bool mFrozen = false;
CVec3 mGlobalWindVelocity;
CVec3 mGlobalWindDirection;
float mGlobalWindSpeed;
int mParticlesRendered;
////////////////////////////////////////////////////////////////////////////////////////
// Handy Functions
////////////////////////////////////////////////////////////////////////////////////////
inline void VectorMA( vec3_t vecAdd, const float scale, const vec3_t vecScale)
{
vecAdd[0] += (scale * vecScale[0]);
vecAdd[1] += (scale * vecScale[1]);
vecAdd[2] += (scale * vecScale[2]);
}
inline void VectorFloor(vec3_t in)
{
in[0] = floorf(in[0]);
in[1] = floorf(in[1]);
in[2] = floorf(in[2]);
}
inline void VectorCeil(vec3_t in)
{
in[0] = ceilf(in[0]);
in[1] = ceilf(in[1]);
in[2] = ceilf(in[2]);
}
inline float FloatRand(void)
{
return ((float)rand() / (float)RAND_MAX);
}
inline float fast_flrand(float min, float max)
{
//return min + (max - min) * flrand;
return Q_flrand(min, max); //fixme?
}
inline void SnapFloatToGrid(float& f, int GridSize)
{
f = (int)(f);
bool fNeg = (f<0);
if (fNeg)
{
f *= -1; // Temporarly make it positive
}
int Offset = ((int)(f) % (int)(GridSize));
int OffsetAbs = abs(Offset);
if (OffsetAbs>(GridSize/2))
{
Offset = (GridSize - OffsetAbs) * -1;
}
f -= Offset;
if (fNeg)
{
f *= -1; // Put It Back To Negative
}
f = (int)(f);
assert(((int)(f)%(int)(GridSize)) == 0);
}
inline void SnapVectorToGrid(CVec3& Vec, int GridSize)
{
SnapFloatToGrid(Vec[0], GridSize);
SnapFloatToGrid(Vec[1], GridSize);
SnapFloatToGrid(Vec[2], GridSize);
}
////////////////////////////////////////////////////////////////////////////////////////
// Range Structures
////////////////////////////////////////////////////////////////////////////////////////
struct SVecRange
{
CVec3 mMins;
CVec3 mMaxs;
inline void Clear()
{
mMins.Clear();
mMaxs.Clear();
}
inline void Pick(CVec3& V)
{
V[0] = Q_flrand(mMins[0], mMaxs[0]);
V[1] = Q_flrand(mMins[1], mMaxs[1]);
V[2] = Q_flrand(mMins[2], mMaxs[2]);
}
inline void Wrap(CVec3& V)
{
if (V[0]<=mMins[0])
{
if ((mMins[0]-V[0])>500)
{
Pick(V);
return;
}
V[0] = mMaxs[0] - 10.0f;
}
if (V[0]>=mMaxs[0])
{
if ((V[0]-mMaxs[0])>500)
{
Pick(V);
return;
}
V[0] = mMins[0] + 10.0f;
}
if (V[1]<=mMins[1])
{
if ((mMins[1]-V[1])>500)
{
Pick(V);
return;
}
V[1] = mMaxs[1] - 10.0f;
}
if (V[1]>=mMaxs[1])
{
if ((V[1]-mMaxs[1])>500)
{
Pick(V);
return;
}
V[1] = mMins[1] + 10.0f;
}
if (V[2]<=mMins[2])
{
if ((mMins[2]-V[2])>500)
{
Pick(V);
return;
}
V[2] = mMaxs[2] - 10.0f;
}
if (V[2]>=mMaxs[2])
{
if ((V[2]-mMaxs[2])>500)
{
Pick(V);
return;
}
V[2] = mMins[2] + 10.0f;
}
}
inline bool In(const CVec3& V)
{
return (V>mMins && V<mMaxs);
}
};
struct SFloatRange
{
float mMin;
float mMax;
inline void Clear()
{
mMin = 0;
mMin = 0;
}
inline void Pick(float& V)
{
V = Q_flrand(mMin, mMax);
}
inline bool In(const float& V)
{
return (V>mMin && V<mMax);
}
};
struct SIntRange
{
int mMin;
int mMax;
inline void Clear()
{
mMin = 0;
mMin = 0;
}
inline void Pick(int& V)
{
V = Q_irand(mMin, mMax);
}
inline bool In(const int& V)
{
return (V>mMin && V<mMax);
}
};
////////////////////////////////////////////////////////////////////////////////////////
// The Particle Class
////////////////////////////////////////////////////////////////////////////////////////
class WFXParticle
{
public:
enum
{
FLAG_RENDER = 0,
FLAG_FADEIN,
FLAG_FADEOUT,
FLAG_RESPAWN,
FLAG_MAX
};
typedef ratl::bits_vs<FLAG_MAX> TFlags;
float mAlpha;
TFlags mFlags;
CVec3 mPosition;
CVec3 mVelocity;
float mMass; // A higher number will more greatly resist force and result in greater gravity
};
////////////////////////////////////////////////////////////////////////////////////////
// The Wind
////////////////////////////////////////////////////////////////////////////////////////
class CWindZone
{
public:
bool mGlobal;
SVecRange mRBounds;
SVecRange mRVelocity;
SIntRange mRDuration;
SIntRange mRDeadTime;
float mMaxDeltaVelocityPerUpdate;
float mChanceOfDeadTime;
CVec3 mCurrentVelocity;
CVec3 mTargetVelocity;
int mTargetVelocityTimeRemaining;
public:
////////////////////////////////////////////////////////////////////////////////////
// Initialize - Will setup default values for all data
////////////////////////////////////////////////////////////////////////////////////
void Initialize()
{
mRBounds.Clear();
mGlobal = true;
mRVelocity.mMins = -1500.0f;
mRVelocity.mMins[2] = -10.0f;
mRVelocity.mMaxs = 1500.0f;
mRVelocity.mMaxs[2] = 10.0f;
mMaxDeltaVelocityPerUpdate = 10.0f;
mRDuration.mMin = 1000;
mRDuration.mMax = 2000;
mChanceOfDeadTime = 0.3f;
mRDeadTime.mMin = 1000;
mRDeadTime.mMax = 3000;
mCurrentVelocity.Clear();
mTargetVelocity.Clear();
mTargetVelocityTimeRemaining = 0;
}
////////////////////////////////////////////////////////////////////////////////////
// Update - Changes wind when current target velocity expires
////////////////////////////////////////////////////////////////////////////////////
void Update()
{
if (mTargetVelocityTimeRemaining==0)
{
if (FloatRand()<mChanceOfDeadTime)
{
mRDeadTime.Pick(mTargetVelocityTimeRemaining);
mTargetVelocity.Clear();
}
else
{
mRDuration.Pick(mTargetVelocityTimeRemaining);
mRVelocity.Pick(mTargetVelocity);
}
}
else if (mTargetVelocityTimeRemaining!=-1)
{
mTargetVelocityTimeRemaining--;
CVec3 DeltaVelocity(mTargetVelocity - mCurrentVelocity);
float DeltaVelocityLen = VectorNormalize(DeltaVelocity.v);
if (DeltaVelocityLen > mMaxDeltaVelocityPerUpdate)
{
DeltaVelocityLen = mMaxDeltaVelocityPerUpdate;
}
DeltaVelocity *= (DeltaVelocityLen);
mCurrentVelocity += DeltaVelocity;
}
}
};
ratl::vector_vs<CWindZone, MAX_WIND_ZONES> mWindZones;
ratl::vector_vs<CWindZone*, MAX_WIND_ZONES> mLocalWindZones;
bool R_GetWindVector(vec3_t windVector, vec3_t atpoint)
{
VectorCopy(mGlobalWindDirection.v, windVector);
if (atpoint && mLocalWindZones.size())
{
for (int curLocalWindZone=0; curLocalWindZone<mLocalWindZones.size(); curLocalWindZone++)
{
if (mLocalWindZones[curLocalWindZone]->mRBounds.In(atpoint))
{
VectorAdd(windVector, mLocalWindZones[curLocalWindZone]->mCurrentVelocity.v, windVector);
}
}
VectorNormalize(windVector);
}
return true;
}
bool R_GetWindSpeed(float &windSpeed, vec3_t atpoint)
{
windSpeed = mGlobalWindSpeed;
if (atpoint && mLocalWindZones.size())
{
for (int curLocalWindZone=0; curLocalWindZone<mLocalWindZones.size(); curLocalWindZone++)
{
if (mLocalWindZones[curLocalWindZone]->mRBounds.In(atpoint))
{
windSpeed += VectorLength(mLocalWindZones[curLocalWindZone]->mCurrentVelocity.v);
}
}
}
return true;
}
bool R_GetWindGusting(vec3_t atpoint)
{
float windSpeed;
R_GetWindSpeed(windSpeed, atpoint);
return (windSpeed>1000.0f);
}
////////////////////////////////////////////////////////////////////////////////////////
// Outside Point Cache
////////////////////////////////////////////////////////////////////////////////////////
class COutside
{
#define COUTSIDE_STRUCT_VERSION 1 // you MUST increase this any time you change any binary (fields) inside this class, or cahced files will fuck up
public:
////////////////////////////////////////////////////////////////////////////////////
//Global Public Outside Variables
////////////////////////////////////////////////////////////////////////////////////
bool mOutsideShake;
float mOutsidePain;
CVec3 mFogColor;
int mFogColorInt;
bool mFogColorTempActive;
private:
////////////////////////////////////////////////////////////////////////////////////
// The Outside Cache
////////////////////////////////////////////////////////////////////////////////////
bool mCacheInit; // Has It Been Cached?
struct SWeatherZone
{
static bool mMarkedOutside;
uint32_t *mPointCache; // malloc block ptr
int miPointCacheByteSize; // size of block
SVecRange mExtents;
SVecRange mSize;
int mWidth;
int mHeight;
int mDepth;
void WriteToDisk( fileHandle_t f )
{
ri.FS_Write(&mMarkedOutside,sizeof(mMarkedOutside),f);
ri.FS_Write( mPointCache, miPointCacheByteSize, f );
}
void ReadFromDisk( fileHandle_t f )
{
ri.FS_Read(&mMarkedOutside,sizeof(mMarkedOutside),f);
ri.FS_Read( mPointCache, miPointCacheByteSize, f);
}
////////////////////////////////////////////////////////////////////////////////////
// Convert To Cell
////////////////////////////////////////////////////////////////////////////////////
inline void ConvertToCell(const CVec3& pos, int& x, int& y, int& z, int& bit)
{
x = (int)((pos[0] / POINTCACHE_CELL_SIZE) - mSize.mMins[0]);
y = (int)((pos[1] / POINTCACHE_CELL_SIZE) - mSize.mMins[1]);
z = (int)((pos[2] / POINTCACHE_CELL_SIZE) - mSize.mMins[2]);
bit = (z & 31);
z >>= 5;
}
////////////////////////////////////////////////////////////////////////////////////
// CellOutside - Test to see if a given cell is outside
////////////////////////////////////////////////////////////////////////////////////
inline bool CellOutside(int x, int y, int z, int bit)
{
if ((x < 0 || x >= mWidth) || (y < 0 || y >= mHeight) || (z < 0 || z >= mDepth) || (bit < 0 || bit >= 32))
{
return !(mMarkedOutside);
}
return (mMarkedOutside==(!!(mPointCache[((z * mWidth * mHeight) + (y * mWidth) + x)]&(1 << bit))));
}
};
ratl::vector_vs<SWeatherZone, MAX_WEATHER_ZONES> mWeatherZones;
private:
////////////////////////////////////////////////////////////////////////////////////
// Iteration Variables
////////////////////////////////////////////////////////////////////////////////////
int mWCells;
int mHCells;
int mXCell;
int mYCell;
int mZBit;
int mXMax;
int mYMax;
int mZMax;
private:
////////////////////////////////////////////////////////////////////////////////////
// Contents Outside
////////////////////////////////////////////////////////////////////////////////////
inline bool ContentsOutside(int contents)
{
if (contents&CONTENTS_WATER || contents&CONTENTS_SOLID)
{
return false;
}
if (mCacheInit)
{
if (SWeatherZone::mMarkedOutside)
{
return (!!(contents&CONTENTS_OUTSIDE));
}
return (!(contents&CONTENTS_INSIDE));
}
return !!(contents&CONTENTS_OUTSIDE);
}
public:
////////////////////////////////////////////////////////////////////////////////////
// Constructor - Will setup default values for all data
////////////////////////////////////////////////////////////////////////////////////
void Reset()
{
mOutsideShake = false;
mOutsidePain = 0.0;
mCacheInit = false;
SWeatherZone::mMarkedOutside = false;
mFogColor.Clear();
mFogColorInt = 0;
mFogColorTempActive = false;
for (int wz=0; wz<mWeatherZones.size(); wz++)
{
R_Free(mWeatherZones[wz].mPointCache);
mWeatherZones[wz].mPointCache = 0;
mWeatherZones[wz].miPointCacheByteSize = 0; // not really necessary because of .clear() below, but keeps things together in case stuff changes
}
mWeatherZones.clear();
}
COutside()
{
Reset();
}
~COutside()
{
Reset();
}
bool Initialized()
{
return mCacheInit;
}
////////////////////////////////////////////////////////////////////////////////////
// AddWeatherZone - Will add a zone of mins and maxes
////////////////////////////////////////////////////////////////////////////////////
void AddWeatherZone(vec3_t mins, vec3_t maxs)
{
if (mCacheInit)
{
return;
}
if (!mWeatherZones.full())
{
SWeatherZone& Wz = mWeatherZones.push_back();
Wz.mExtents.mMins = mins;
Wz.mExtents.mMaxs = maxs;
SnapVectorToGrid(Wz.mExtents.mMins, POINTCACHE_CELL_SIZE);
SnapVectorToGrid(Wz.mExtents.mMaxs, POINTCACHE_CELL_SIZE);
Wz.mSize.mMins = Wz.mExtents.mMins;
Wz.mSize.mMaxs = Wz.mExtents.mMaxs;
Wz.mSize.mMins /= POINTCACHE_CELL_SIZE;
Wz.mSize.mMaxs /= POINTCACHE_CELL_SIZE;
Wz.mWidth = (int)(Wz.mSize.mMaxs[0] - Wz.mSize.mMins[0]);
Wz.mHeight = (int)(Wz.mSize.mMaxs[1] - Wz.mSize.mMins[1]);
Wz.mDepth = ((int)(Wz.mSize.mMaxs[2] - Wz.mSize.mMins[2]) + 31) >> 5;
Wz.miPointCacheByteSize = (Wz.mWidth * Wz.mHeight * Wz.mDepth) * sizeof(uint32_t);
Wz.mPointCache = (uint32_t *)R_Malloc( Wz.miPointCacheByteSize, TAG_POINTCACHE, qtrue );
}
else
{
assert("MaxWeatherZones Hit!"==0);
}
}
const char *GenCachedWeatherFilename(void)
{
return va("maps/%s.weather", sv_mapname->string);
}
// weather file format...
//
struct WeatherFileHeader_t
{
int m_iVersion;
int m_iChecksum;
WeatherFileHeader_t()
{
m_iVersion = COUTSIDE_STRUCT_VERSION;
m_iChecksum = sv_mapChecksum->integer;
}
};
fileHandle_t WriteCachedWeatherFile( void )
{
fileHandle_t f = ri.FS_FOpenFileWrite( GenCachedWeatherFilename(), qtrue );
if (f)
{
WeatherFileHeader_t WeatherFileHeader;
ri.FS_Write(&WeatherFileHeader, sizeof(WeatherFileHeader), f);
return f;
}
else
{
ri.Printf( PRINT_WARNING, "(Unable to open weather file \"%s\" for writing!)\n",GenCachedWeatherFilename());
}
return 0;
}
// returns 0 for not-found or invalid file, else open handle to continue read from (which you then close yourself)...
//
fileHandle_t ReadCachedWeatherFile( void )
{
fileHandle_t f = 0;
ri.FS_FOpenFileRead( GenCachedWeatherFilename(), &f, qfalse );
if ( f )
{
// ok, it exists, but is it valid for this map?...
//
WeatherFileHeader_t WeatherFileHeaderForCompare;
WeatherFileHeader_t WeatherFileHeaderFromDisk;
ri.FS_Read(&WeatherFileHeaderFromDisk, sizeof(WeatherFileHeaderFromDisk), f);
if (!memcmp(&WeatherFileHeaderForCompare, &WeatherFileHeaderFromDisk, sizeof(WeatherFileHeaderFromDisk)))
{
// go for it...
//
return f;
}
ri.Printf( PRINT_WARNING, "( Cached weather file \"%s\" out of date, regenerating... )\n",GenCachedWeatherFilename());
ri.FS_FCloseFile( f );
}
else
{
ri.Printf( PRINT_WARNING, "( No cached weather file found, generating... )\n");
}
return 0;
}
////////////////////////////////////////////////////////////////////////////////////
// Cache - Will Scan the World, Creating The Cache
////////////////////////////////////////////////////////////////////////////////////
void Cache()
{
if (!tr.world || mCacheInit)
{
return;
}
// Record The Extents Of The World Incase No Other Weather Zones Exist
//---------------------------------------------------------------------
if (!mWeatherZones.size())
{
Com_Printf("WARNING: No Weather Zones Encountered\n");
AddWeatherZone(tr.world->bmodels[0].bounds[0], tr.world->bmodels[0].bounds[1]);
}
// all this piece of code does really is fill in the bool "SWeatherZone::mMarkedOutside", plus the mPointCache[] for each zone,
// so we can diskload those. Maybe.
fileHandle_t f = ReadCachedWeatherFile();
if ( f )
{
for (int iZone=0; iZone<mWeatherZones.size(); iZone++)
{
SWeatherZone wz = mWeatherZones[iZone];
wz.ReadFromDisk( f );
}
mCacheInit = true;
}
else
{
CVec3 CurPos;
CVec3 Size;
CVec3 Mins;
int x, y, z, q, zbase;
bool curPosOutside;
uint32_t contents;
uint32_t bit;
f = WriteCachedWeatherFile();
// Iterate Over All Weather Zones
//--------------------------------
for (int zone=0; zone<mWeatherZones.size(); zone++)
{
SWeatherZone wz = mWeatherZones[zone];
// Make Sure Point Contents Checks Occur At The CENTER Of The Cell
//-----------------------------------------------------------------
Mins = wz.mExtents.mMins;
for (x=0; x<3; x++)
{
Mins[x] += (POINTCACHE_CELL_SIZE/2);
}
// Start Scanning
//----------------
for(z = 0; z < wz.mDepth; z++)
{
for(q = 0; q < 32; q++)
{
bit = (1 << q);
zbase = (z << 5);
for(x = 0; x < wz.mWidth; x++)
{
for(y = 0; y < wz.mHeight; y++)
{
CurPos[0] = x * POINTCACHE_CELL_SIZE;
CurPos[1] = y * POINTCACHE_CELL_SIZE;
CurPos[2] = (zbase + q) * POINTCACHE_CELL_SIZE;
CurPos += Mins;
contents = ri.CM_PointContents(CurPos.v, 0);
if (contents&CONTENTS_INSIDE || contents&CONTENTS_OUTSIDE)
{
curPosOutside = ((contents&CONTENTS_OUTSIDE)!=0);
if (!mCacheInit)
{
mCacheInit = true;
SWeatherZone::mMarkedOutside = curPosOutside;
}
else if (SWeatherZone::mMarkedOutside!=curPosOutside)
{
assert(0);
Com_Error (ERR_DROP, "Weather Effect: Both Indoor and Outdoor brushs encountered in map.\n" );
return;
}
// Mark The Point
//----------------
wz.mPointCache[((z * wz.mWidth * wz.mHeight) + (y * wz.mWidth) + x)] |= bit;
}
}// for (y)
}// for (x)
}// for (q)
}// for (z)
if (f)
{
mWeatherZones[ zone ].WriteToDisk( f );
}
}
}
if (f)
{
ri.FS_FCloseFile(f);
f=0; // not really necessary, but wtf.
}
// If no indoor or outdoor brushes were found
//--------------------------------------------
if (!mCacheInit)
{
mCacheInit = true;
SWeatherZone::mMarkedOutside = false; // Assume All Is Outside, Except Solid
}
}
public:
////////////////////////////////////////////////////////////////////////////////////
// PointOutside - Test to see if a given point is outside
////////////////////////////////////////////////////////////////////////////////////
inline bool PointOutside(const CVec3& pos)
{
if (!mCacheInit)
{
return ContentsOutside(ri.CM_PointContents(pos.v, 0));
}
for (int zone=0; zone<mWeatherZones.size(); zone++)
{
SWeatherZone wz = mWeatherZones[zone];
if (wz.mExtents.In(pos))
{
int bit, x, y, z;
wz.ConvertToCell(pos, x, y, z, bit);
return wz.CellOutside(x, y, z, bit);
}
}
return !(SWeatherZone::mMarkedOutside);
}
////////////////////////////////////////////////////////////////////////////////////
// PointOutside - Test to see if a given bounded plane is outside
////////////////////////////////////////////////////////////////////////////////////
inline bool PointOutside(const CVec3& pos, float width, float height)
{
for (int zone=0; zone<mWeatherZones.size(); zone++)
{
SWeatherZone wz = mWeatherZones[zone];
if (wz.mExtents.In(pos))
{
int bit, x, y, z;
wz.ConvertToCell(pos, x, y, z, bit);
if (width<POINTCACHE_CELL_SIZE || height<POINTCACHE_CELL_SIZE)
{
return (wz.CellOutside(x, y, z, bit));
}
mWCells = ((int)width / POINTCACHE_CELL_SIZE);
mHCells = ((int)height / POINTCACHE_CELL_SIZE);
mXMax = x + mWCells;
mYMax = y + mWCells;
mZMax = bit + mHCells;
for (mXCell=x-mWCells; mXCell<=mXMax; mXCell++)
{
for (mYCell=y-mWCells; mYCell<=mYMax; mYCell++)
{
for (mZBit=bit-mHCells; mZBit<=mZMax; mZBit++)
{
if (!wz.CellOutside(mXCell, mYCell, z, mZBit))
{
return false;
}
}
}
}
return true;
}
}
return !(SWeatherZone::mMarkedOutside);
}
};
COutside mOutside;
bool COutside::SWeatherZone::mMarkedOutside = false;
void R_AddWeatherZone(vec3_t mins, vec3_t maxs)
{
mOutside.AddWeatherZone(mins, maxs);
}
bool R_IsOutside(vec3_t pos)
{
return mOutside.PointOutside(pos);
}
bool R_IsShaking(vec3_t pos)
{
return (mOutside.mOutsideShake && mOutside.PointOutside(pos));
}
float R_IsOutsideCausingPain(vec3_t pos)
{
return (mOutside.mOutsidePain && mOutside.PointOutside(pos));
}
bool R_SetTempGlobalFogColor(vec3_t color)
{
if (tr.world && tr.world->globalFog != -1)
{
// If Non Zero, Try To Set The Color
//-----------------------------------
if (color[0] || color[1] || color[2])
{
// Remember The Normal Fog Color
//-------------------------------
if (!mOutside.mFogColorTempActive)
{
mOutside.mFogColor = tr.world->fogs[tr.world->globalFog].parms.color;
mOutside.mFogColorInt = tr.world->fogs[tr.world->globalFog].colorInt;
mOutside.mFogColorTempActive = true;
}
// Set The New One
//-----------------
tr.world->fogs[tr.world->globalFog].parms.color[0] = color[0];
tr.world->fogs[tr.world->globalFog].parms.color[1] = color[1];
tr.world->fogs[tr.world->globalFog].parms.color[2] = color[2];
tr.world->fogs[tr.world->globalFog].colorInt = ColorBytes4 (
color[0] * tr.identityLight,
color[1] * tr.identityLight,
color[2] * tr.identityLight,
1.0 );
}
// If Unable TO Parse The Command Color Vector, Restore The Previous Fog Color
//-----------------------------------------------------------------------------
else if (mOutside.mFogColorTempActive)
{
mOutside.mFogColorTempActive = false;
tr.world->fogs[tr.world->globalFog].parms.color[0] = mOutside.mFogColor[0];
tr.world->fogs[tr.world->globalFog].parms.color[1] = mOutside.mFogColor[1];
tr.world->fogs[tr.world->globalFog].parms.color[2] = mOutside.mFogColor[2];
tr.world->fogs[tr.world->globalFog].colorInt = mOutside.mFogColorInt;
}
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////
// Particle Cloud
////////////////////////////////////////////////////////////////////////////////////////
class CParticleCloud
{
private:
////////////////////////////////////////////////////////////////////////////////////
// DYNAMIC MEMORY
////////////////////////////////////////////////////////////////////////////////////
image_t* mImage;
WFXParticle* mParticles;
private:
////////////////////////////////////////////////////////////////////////////////////
// RUN TIME VARIANTS
////////////////////////////////////////////////////////////////////////////////////
float mSpawnSpeed;
CVec3 mSpawnPlaneNorm;
CVec3 mSpawnPlaneRight;
CVec3 mSpawnPlaneUp;
SVecRange mRange;
CVec3 mCameraPosition;
CVec3 mCameraForward;
CVec3 mCameraLeft;
CVec3 mCameraDown;
CVec3 mCameraLeftPlusUp;
CVec3 mCameraLeftMinusUp;
int mParticleCountRender;
int mGLModeEnum;
bool mPopulated;
public:
////////////////////////////////////////////////////////////////////////////////////
// CONSTANTS
////////////////////////////////////////////////////////////////////////////////////
bool mOrientWithVelocity;
float mSpawnPlaneSize;
float mSpawnPlaneDistance;
SVecRange mSpawnRange;
float mGravity; // How much gravity affects the velocity of a particle
CVec4 mColor; // RGBA color
int mVertexCount; // 3 for triangle, 4 for quad, other numbers not supported
float mWidth;
float mHeight;
int mBlendMode; // 0 = ALPHA, 1 = SRC->SRC
int mFilterMode; // 0 = LINEAR, 1 = NEAREST
float mFade; // How much to fade in and out 1.0 = instant, 0.01 = very slow
SFloatRange mRotation;
float mRotationDelta;
float mRotationDeltaTarget;
float mRotationCurrent;
SIntRange mRotationChangeTimer;
int mRotationChangeNext;
SFloatRange mMass; // Determines how slowness to accelerate, higher number = slower
float mFrictionInverse; // How much air friction does this particle have 1.0=none, 0.0=nomove
int mParticleCount;
bool mWaterParticles;
public:
////////////////////////////////////////////////////////////////////////////////////
// Initialize - Create Image, Particles, And Setup All Values
////////////////////////////////////////////////////////////////////////////////////
void Initialize(int count, const char* texturePath, int VertexCount=4)
{
Reset();
assert(mParticleCount==0 && mParticles==0);
assert(mImage==0);
// Create The Image
//------------------
mImage = R_FindImageFile(texturePath, qfalse, qfalse, qfalse, GL_CLAMP);
if (!mImage)
{
Com_Error(ERR_DROP, "CParticleCloud: Could not texture %s", texturePath);
}
GL_Bind(mImage);
// Create The Particles
//----------------------
mParticleCount = count;
mParticles = new WFXParticle[mParticleCount];
WFXParticle* part=0;
for (int particleNum=0; particleNum<mParticleCount; particleNum++)
{
part = &(mParticles[particleNum]);
part->mPosition.Clear();
part->mVelocity.Clear();
part->mAlpha = 0.0f;
mMass.Pick(part->mMass);
}
mVertexCount = VertexCount;
#if defined(HAVE_GLES) // Check for point sprite use
if(mVertexCount == 1)
mGLModeEnum = GL_POINTS;
else
#endif
#ifdef HAVE_GLES
mGLModeEnum = (mVertexCount==3)?(GL_TRIANGLES):(GL_TRIANGLE_FAN);
#else
mGLModeEnum = (mVertexCount==3)?(GL_TRIANGLES):(GL_QUADS);
#endif
}
////////////////////////////////////////////////////////////////////////////////////
// Reset - Initializes all data to default values
////////////////////////////////////////////////////////////////////////////////////
void Reset()
{
if (mImage)
{
// TODO: Free Image?
}
mImage = 0;
if (mParticleCount)
{
delete [] mParticles;
}
mParticleCount = 0;
mParticles = 0;
mPopulated = 0;
// These Are The Default Startup Values For Constant Data
//========================================================
mOrientWithVelocity = false;
mWaterParticles = false;
mSpawnPlaneDistance = 500;
mSpawnPlaneSize = 500;
mSpawnRange.mMins = -(mSpawnPlaneDistance*1.25f);
mSpawnRange.mMaxs = (mSpawnPlaneDistance*1.25f);
mGravity = 300.0f; // Units Per Second
mColor = 1.0f;
mVertexCount = 4;
mWidth = 1.0f;
mHeight = 1.0f;
mBlendMode = 0;
mFilterMode = 0;
mFade = 10.0f;
mRotation.Clear();
mRotationDelta = 0.0f;
mRotationDeltaTarget= 0.0f;
mRotationCurrent = 0.0f;
mRotationChangeNext = -1;
mRotation.mMin = -0.7f;
mRotation.mMax = 0.7f;
mRotationChangeTimer.mMin = 500;
mRotationChangeTimer.mMax = 2000;
mMass.mMin = 5.0f;
mMass.mMax = 10.0f;
mFrictionInverse = 0.7f; // No Friction?
}
////////////////////////////////////////////////////////////////////////////////////
// Constructor - Will setup default values for all data
////////////////////////////////////////////////////////////////////////////////////
CParticleCloud()
{
mImage = 0;
mParticleCount = 0;
Reset();
}
////////////////////////////////////////////////////////////////////////////////////
// Initialize - Will setup default values for all data
////////////////////////////////////////////////////////////////////////////////////
~CParticleCloud()
{
Reset();
}
////////////////////////////////////////////////////////////////////////////////////
// UseSpawnPlane - Check To See If We Should Spawn On A Plane, Or Just Wrap The Box
////////////////////////////////////////////////////////////////////////////////////
inline bool UseSpawnPlane()
{
return (mGravity!=0.0f);
}
////////////////////////////////////////////////////////////////////////////////////
// Update - Applies All Physics Forces To All Contained Particles
////////////////////////////////////////////////////////////////////////////////////
void Update()
{
WFXParticle* part=0;
CVec3 partForce;
CVec3 partMoved;
CVec3 partToCamera;
bool partRendering;
bool partOutside;
bool partInRange;
bool partInView;
int particleNum;
float particleFade = (mFade * mSecondsElapsed);
int numLocalWindZones = mLocalWindZones.size();
int curLocalWindZone;
// Compute Camera
//----------------
{
mCameraPosition = backEnd.viewParms.ori.origin;
mCameraForward = backEnd.viewParms.ori.axis[0];
mCameraLeft = backEnd.viewParms.ori.axis[1];
mCameraDown = backEnd.viewParms.ori.axis[2];
if (mRotationChangeNext!=-1)
{
if (mRotationChangeNext==0)
{
mRotation.Pick(mRotationDeltaTarget);
mRotationChangeTimer.Pick(mRotationChangeNext);
if (mRotationChangeNext<=0)
{
mRotationChangeNext = 1;
}
}
mRotationChangeNext--;
float RotationDeltaDifference = (mRotationDeltaTarget - mRotationDelta);
if (fabsf(RotationDeltaDifference)>0.01)
{
mRotationDelta += RotationDeltaDifference; // Blend To New Delta
}
mRotationCurrent += (mRotationDelta * mSecondsElapsed);
float s = sinf(mRotationCurrent);
float c = cosf(mRotationCurrent);
CVec3 TempCamLeft(mCameraLeft);
mCameraLeft *= (c * mWidth);
mCameraLeft.ScaleAdd(mCameraDown, (s * mWidth * -1.0f));
mCameraDown *= (c * mHeight);
mCameraDown.ScaleAdd(TempCamLeft, (s * mHeight));
}
else
{
mCameraLeft *= mWidth;
mCameraDown *= mHeight;
}
}
// Compute Global Force
//----------------------
CVec3 force;
{
force.Clear();
// Apply Gravity
//---------------
force[2] = -1.0f * mGravity;
// Apply Wind Velocity
//---------------------
force += mGlobalWindVelocity;
}
// Update Range
//--------------
{
mRange.mMins = mCameraPosition + mSpawnRange.mMins;
mRange.mMaxs = mCameraPosition + mSpawnRange.mMaxs;
// If Using A Spawn Plane, Increase The Range Box A Bit To Account For Rotation On The Spawn Plane
//-------------------------------------------------------------------------------------------------
if (UseSpawnPlane())
{
for (int dim=0; dim<3; dim++)
{
if (force[dim]>0.01)
{
mRange.mMins[dim] -= (mSpawnPlaneDistance/2.0f);
}
else if (force[dim]<-0.01)
{
mRange.mMaxs[dim] += (mSpawnPlaneDistance/2.0f);
}
}
mSpawnPlaneNorm = force;
mSpawnSpeed = VectorNormalize(mSpawnPlaneNorm.v);
MakeNormalVectors(mSpawnPlaneNorm.v, mSpawnPlaneRight.v, mSpawnPlaneUp.v);
}
// Optimization For Quad Position Calculation
//--------------------------------------------
if (mVertexCount==4)
{
mCameraLeftPlusUp = (mCameraLeft - mCameraDown);
mCameraLeftMinusUp = (mCameraLeft + mCameraDown);
}
else
{
mCameraLeftPlusUp = (mCameraDown + mCameraLeft); // should really be called mCamera Left + Down
}
}
// Stop All Additional Processing
//--------------------------------
if (mFrozen)
{
return;
}
// Now Update All Particles
//--------------------------
mParticleCountRender = 0;
for (particleNum=0; particleNum<mParticleCount; particleNum++)
{
part = &(mParticles[particleNum]);
if (!mPopulated)
{
mRange.Pick(part->mPosition); // First Time Spawn Location
}
// Grab The Force And Apply Non Global Wind
//------------------------------------------
partForce = force;
if (numLocalWindZones)
{
for (curLocalWindZone=0; curLocalWindZone<numLocalWindZones; curLocalWindZone++)
{
if (mLocalWindZones[curLocalWindZone]->mRBounds.In(part->mPosition))
{
partForce += mLocalWindZones[curLocalWindZone]->mCurrentVelocity;
}
}
}
partForce /= part->mMass;
// Apply The Force
//-----------------
part->mVelocity += partForce;
part->mVelocity *= mFrictionInverse;
part->mPosition.ScaleAdd(part->mVelocity, mSecondsElapsed);
partToCamera = (part->mPosition - mCameraPosition);
partRendering = part->mFlags.get_bit(WFXParticle::FLAG_RENDER);
partOutside = mOutside.PointOutside(part->mPosition, mWidth, mHeight);
partInRange = mRange.In(part->mPosition);
partInView = (partOutside && partInRange && (partToCamera.Dot(mCameraForward)>0.0f));
// Process Respawn
//-----------------
if (!partInRange && !partRendering)
{
part->mVelocity.Clear();
// Reselect A Position On The Spawn Plane
//----------------------------------------
if (UseSpawnPlane())
{
part->mPosition = mCameraPosition;
part->mPosition -= (mSpawnPlaneNorm* mSpawnPlaneDistance);
part->mPosition += (mSpawnPlaneRight*Q_flrand(-mSpawnPlaneSize, mSpawnPlaneSize));
part->mPosition += (mSpawnPlaneUp* Q_flrand(-mSpawnPlaneSize, mSpawnPlaneSize));
}
// Otherwise, Just Wrap Around To The Other End Of The Range
//-----------------------------------------------------------
else
{
mRange.Wrap(part->mPosition);
}
partInRange = true;
}
// Process Fade
//--------------
{
// Start A Fade Out
//------------------
if (partRendering && !partInView)
{
part->mFlags.clear_bit(WFXParticle::FLAG_FADEIN);
part->mFlags.set_bit(WFXParticle::FLAG_FADEOUT);
}
// Switch From Fade Out To Fade In
//---------------------------------
else if (partRendering && partInView && part->mFlags.get_bit(WFXParticle::FLAG_FADEOUT))
{
part->mFlags.set_bit(WFXParticle::FLAG_FADEIN);
part->mFlags.clear_bit(WFXParticle::FLAG_FADEOUT);
}
// Start A Fade In
//-----------------
else if (!partRendering && partInView)
{
partRendering = true;
part->mAlpha = 0.0f;
part->mFlags.set_bit(WFXParticle::FLAG_RENDER);
part->mFlags.set_bit(WFXParticle::FLAG_FADEIN);
part->mFlags.clear_bit(WFXParticle::FLAG_FADEOUT);
}
// Update Fade
//-------------
if (partRendering)
{
// Update Fade Out
//-----------------
if (part->mFlags.get_bit(WFXParticle::FLAG_FADEOUT))
{
part->mAlpha -= particleFade;
if (part->mAlpha<=0.0f)
{
part->mAlpha = 0.0f;
part->mFlags.clear_bit(WFXParticle::FLAG_FADEOUT);
part->mFlags.clear_bit(WFXParticle::FLAG_FADEIN);
part->mFlags.clear_bit(WFXParticle::FLAG_RENDER);
partRendering = false;
}
}
// Update Fade In
//----------------
else if (part->mFlags.get_bit(WFXParticle::FLAG_FADEIN))
{
part->mAlpha += particleFade;
if (part->mAlpha>=mColor[3])
{
part->mFlags.clear_bit(WFXParticle::FLAG_FADEIN);
part->mAlpha = mColor[3];
}
}
}
}
// Keep Track Of The Number Of Particles To Render
//-------------------------------------------------
if (part->mFlags.get_bit(WFXParticle::FLAG_RENDER))
{
mParticleCountRender ++;
}
}
mPopulated = true;
}
////////////////////////////////////////////////////////////////////////////////////
// Render -
////////////////////////////////////////////////////////////////////////////////////
void Render()
{
WFXParticle* part=0;
int particleNum;
CVec3 partDirection;
// Set The GL State And Image Binding
//------------------------------------
GL_State((mBlendMode==0)?(GLS_ALPHA):(GLS_SRCBLEND_ONE | GLS_DSTBLEND_ONE));
GL_Bind(mImage);
// Enable And Disable Things
//---------------------------
/*
if (mGLModeEnum==GL_POINTS && qglPointParameteriNV)
{
qglEnable(GL_POINT_SPRITE_NV);
qglPointSize(mWidth);
qglPointParameterfEXT( GL_POINT_SIZE_MIN_EXT, 4.0f );
qglPointParameterfEXT( GL_POINT_SIZE_MAX_EXT, 2047.0f );
qglTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_TRUE);
}
else
*/
#ifdef HAVE_GLES
GLfloat tex[2*6*mParticleCount];
GLfloat vtx[3*6*mParticleCount];
GLfloat col[4*6*mParticleCount];
GLfloat curcol[4];
qglGetFloatv(GL_CURRENT_COLOR, curcol);
GLboolean text = qglIsEnabled(GL_TEXTURE_COORD_ARRAY);
GLboolean glcol = qglIsEnabled(GL_COLOR_ARRAY);
if (!text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
if (!glcol)
qglEnableClientState( GL_COLOR_ARRAY );
if (mGLModeEnum==GL_POINTS)
{
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
// Nothing to do ?!
}
#else
//FIXME use this extension?
const float attenuation[3] =
{
1, 0.0, 0.0004
};
if (mGLModeEnum == GL_POINTS && qglPointParameterfEXT)
{ //fixme use custom parameters but gotta make sure it expects them on same scale first
qglPointSize(10.0);
qglPointParameterfEXT(GL_POINT_SIZE_MIN_EXT, 1.0);
qglPointParameterfEXT(GL_POINT_SIZE_MAX_EXT, 4.0);
qglPointParameterfvEXT(GL_DISTANCE_ATTENUATION_EXT, (float *)attenuation);
}
#endif
else
{
qglEnable(GL_TEXTURE_2D);
//qglDisable(GL_CULL_FACE);
//naughty, you are making the assumption that culling is on when you get here. -rww
GL_Cull(CT_TWO_SIDED);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (mFilterMode==0)?(GL_LINEAR):(GL_NEAREST));
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (mFilterMode==0)?(GL_LINEAR):(GL_NEAREST));
// Setup Matrix Mode And Translation
//-----------------------------------
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
}
// Begin
//-------
#ifdef HAVE_GLES
int idx = 0;
#else
qglBegin(mGLModeEnum);
#endif
for (particleNum=0; particleNum<mParticleCount; particleNum++)
{
part = &(mParticles[particleNum]);
if (!part->mFlags.get_bit(WFXParticle::FLAG_RENDER))
{
continue;
}
// Blend Mode Zero -> Apply Alpha Just To Alpha Channel
//------------------------------------------------------
if (mBlendMode==0)
{
#ifdef HAVE_GLES
curcol[0]=mColor[0]; curcol[1]=mColor[1], curcol[2]=mColor[2]; curcol[3]=part->mAlpha;
#else
qglColor4f(mColor[0], mColor[1], mColor[2], part->mAlpha);
#endif
}
// Otherwise Apply Alpha To All Channels
//---------------------------------------
else
{
#ifdef HAVE_GLES
curcol[0]=mColor[0]*part->mAlpha; curcol[1]=mColor[1]*part->mAlpha, curcol[2]=mColor[2]*part->mAlpha; curcol[3]=mColor[3]*part->mAlpha;
#else
qglColor4f(mColor[0]*part->mAlpha, mColor[1]*part->mAlpha, mColor[2]*part->mAlpha, mColor[3]*part->mAlpha);
#endif
}
// Render A Point
//----------------
if (mGLModeEnum==GL_POINTS)
{
#ifdef HAVE_GLES
memcpy(vtx+idx*3, part->mPosition.v, 3*sizeof(GLfloat));
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
idx++;
#else
qglVertex3fv(part->mPosition.v);
#endif
}
// Render A Triangle
//-------------------
else if (mVertexCount==3)
{
#ifdef HAVE_GLES
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=1.0f; tex[idx*2+1]=0.0f;
vtx[idx*3+0]=part->mPosition[0];
vtx[idx*3+1]=part->mPosition[1];
vtx[idx*3+2]=part->mPosition[2];
memcpy(col+idx*4+4, curcol, 4*sizeof(GLfloat));
tex[idx*2+2]=0.0f; tex[idx*2+3]=1.0f;
vtx[idx*3+3]=part->mPosition[0] + mCameraLeft[0];
vtx[idx*3+4]=part->mPosition[1] + mCameraLeft[1];
vtx[idx*3+5]=part->mPosition[2] + mCameraLeft[2];
memcpy(col+idx*4+8, curcol, 4*sizeof(GLfloat));
tex[idx*2+4]=0.0f; tex[idx*2+5]=0.0f;
vtx[idx*3+6]=part->mPosition[0] + mCameraLeftPlusUp[0];
vtx[idx*3+7]=part->mPosition[1] + mCameraLeftPlusUp[1];
vtx[idx*3+8]=part->mPosition[2] + mCameraLeftPlusUp[2];
idx+=3;
#else
qglTexCoord2f(1.0, 0.0);
qglVertex3f(part->mPosition[0],
part->mPosition[1],
part->mPosition[2]);
qglTexCoord2f(0.0, 1.0);
qglVertex3f(part->mPosition[0] + mCameraLeft[0],
part->mPosition[1] + mCameraLeft[1],
part->mPosition[2] + mCameraLeft[2]);
qglTexCoord2f(0.0, 0.0);
qglVertex3f(part->mPosition[0] + mCameraLeftPlusUp[0],
part->mPosition[1] + mCameraLeftPlusUp[1],
part->mPosition[2] + mCameraLeftPlusUp[2]);
#endif
}
// Render A Quad
//---------------
else
{
#ifdef HAVE_GLES
/*tex[0]=0.0f; tex[1]=0.0f;
vtx[0]=part->mPosition[0] - mCameraLeftMinusUp[0];
vtx[1]=part->mPosition[1] - mCameraLeftMinusUp[1];
vtx[2]=part->mPosition[2] - mCameraLeftMinusUp[2];
tex[2]=1.0f; tex[3]=0.0f;
vtx[3]=part->mPosition[0] - mCameraLeftPlusUp[0];
vtx[4]=part->mPosition[1] - mCameraLeftPlusUp[1];
vtx[5]=part->mPosition[2] - mCameraLeftPlusUp[2];
tex[4]=1.0f; tex[5]=1.0f;
vtx[6]=part->mPosition[0] + mCameraLeftMinusUp[0];
vtx[7]=part->mPosition[1] + mCameraLeftMinusUp[1];
vtx[8]=part->mPosition[2] + mCameraLeftMinusUp[2];
tex[6]=0.0f; tex[7]=1.0f;
vtx[9]=part->mPosition[0] + mCameraLeftPlusUp[0];
vtx[10]=part->mPosition[1] + mCameraLeftPlusUp[1];
vtx[11]=part->mPosition[2] + mCameraLeftPlusUp[2];
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 3, GL_FLOAT, 0, vtx );
qglDrawArrays( GL_TRIANGLE_FAN, 0, 4 );*/
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=0.0f; tex[idx*2+1]=0.0f;
vtx[idx*3+0]=part->mPosition[0] - mCameraLeftMinusUp[0];
vtx[idx*3+1]=part->mPosition[1] - mCameraLeftMinusUp[1];
vtx[idx*3+2]=part->mPosition[2] - mCameraLeftMinusUp[2];
idx++;
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=1.0f; tex[idx*2+1]=0.0f;
vtx[idx*3+0]=part->mPosition[0] - mCameraLeftPlusUp[0];
vtx[idx*3+1]=part->mPosition[1] - mCameraLeftPlusUp[1];
vtx[idx*3+2]=part->mPosition[2] - mCameraLeftPlusUp[2];
idx++;
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=1.0f; tex[idx*2+1]=1.0f;
vtx[idx*3+0]=part->mPosition[0] + mCameraLeftMinusUp[0];
vtx[idx*3+1]=part->mPosition[1] + mCameraLeftMinusUp[1];
vtx[idx*3+2]=part->mPosition[2] + mCameraLeftMinusUp[2];
idx++;
// triangle 2
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=0.0f; tex[idx*2+1]=0.0f;
vtx[idx*3+0]=part->mPosition[0] - mCameraLeftMinusUp[0];
vtx[idx*3+1]=part->mPosition[1] - mCameraLeftMinusUp[1];
vtx[idx*3+2]=part->mPosition[2] - mCameraLeftMinusUp[2];
idx++;
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=1.0f; tex[idx*2+1]=1.0f;
vtx[idx*3+0]=part->mPosition[0] + mCameraLeftMinusUp[0];
vtx[idx*3+1]=part->mPosition[1] + mCameraLeftMinusUp[1];
vtx[idx*3+2]=part->mPosition[2] + mCameraLeftMinusUp[2];
idx++;
memcpy(col+idx*4, curcol, 4*sizeof(GLfloat));
tex[idx*2+0]=0.0f; tex[idx*2+1]=1.0f;
vtx[idx*3+0]=part->mPosition[0] + mCameraLeftPlusUp[0];
vtx[idx*3+1]=part->mPosition[1] + mCameraLeftPlusUp[1];
vtx[idx*3+2]=part->mPosition[2] + mCameraLeftPlusUp[2];
idx++;
#else
// Left bottom.
qglTexCoord2f( 0.0, 0.0 );
qglVertex3f(part->mPosition[0] - mCameraLeftMinusUp[0],
part->mPosition[1] - mCameraLeftMinusUp[1],
part->mPosition[2] - mCameraLeftMinusUp[2] );
// Right bottom.
qglTexCoord2f( 1.0, 0.0 );
qglVertex3f(part->mPosition[0] - mCameraLeftPlusUp[0],
part->mPosition[1] - mCameraLeftPlusUp[1],
part->mPosition[2] - mCameraLeftPlusUp[2] );
// Right top.
qglTexCoord2f( 1.0, 1.0 );
qglVertex3f(part->mPosition[0] + mCameraLeftMinusUp[0],
part->mPosition[1] + mCameraLeftMinusUp[1],
part->mPosition[2] + mCameraLeftMinusUp[2] );
// Left top.
qglTexCoord2f( 0.0, 1.0 );
qglVertex3f(part->mPosition[0] + mCameraLeftPlusUp[0],
part->mPosition[1] + mCameraLeftPlusUp[1],
part->mPosition[2] + mCameraLeftPlusUp[2] );
#endif
}
}
#ifndef HAVE_GLES
qglEnd();
#endif
if (mGLModeEnum==GL_POINTS)
{
//qglDisable(GL_POINT_SPRITE_NV);
//qglTexEnvi(GL_POINT_SPRITE_NV, GL_COORD_REPLACE_NV, GL_FALSE);
}
else
{
//qglEnable(GL_CULL_FACE);
//you don't need to do this when you are properly setting cull state.
#ifdef HAVE_GLES
// if (mGLModeEnum==GL_TRIANGLES) {
qglTexCoordPointer( 2, GL_FLOAT, 0, tex );
qglVertexPointer ( 3, GL_FLOAT, 0, vtx );
qglColorPointer (4, GL_FLOAT, 0, col );
qglDrawArrays( GL_TRIANGLES, 0, idx );
// }
#endif
qglPopMatrix();
}
#ifdef HAVE_GLES
if (!glcol)
qglDisableClientState( GL_COLOR_ARRAY );
if (mGLModeEnum == GL_POINTS ) {
if (!text)
qglDisableClientState( GL_TEXTURE_COORD_ARRAY );
} else {
if (text)
qglEnableClientState( GL_TEXTURE_COORD_ARRAY );
}
#endif
mParticlesRendered += mParticleCountRender;
}
};
ratl::vector_vs<CParticleCloud, MAX_PARTICLE_CLOUDS> mParticleClouds;
////////////////////////////////////////////////////////////////////////////////////////
// Init World Effects - Will Iterate Over All Particle Clouds, Clear Them Out, And Erase
////////////////////////////////////////////////////////////////////////////////////////
void R_InitWorldEffects(void)
{
for (int i=0; i<mParticleClouds.size(); i++)
{
mParticleClouds[i].Reset();
}
mParticleClouds.clear();
mWindZones.clear();
mLocalWindZones.clear();
mOutside.Reset();
mGlobalWindSpeed = 0.0f;
mGlobalWindDirection[0]=1.0f;
mGlobalWindDirection[1]=0.0f;
mGlobalWindDirection[2]=0.0f;
}
////////////////////////////////////////////////////////////////////////////////////////
// Init World Effects - Will Iterate Over All Particle Clouds, Clear Them Out, And Erase
////////////////////////////////////////////////////////////////////////////////////////
void R_ShutdownWorldEffects(void)
{
R_InitWorldEffects();
}
////////////////////////////////////////////////////////////////////////////////////////
// RB_RenderWorldEffects - If any particle clouds exist, this will update and render them
////////////////////////////////////////////////////////////////////////////////////////
void RB_RenderWorldEffects(void)
{
if (!tr.world ||
(tr.refdef.rdflags & RDF_NOWORLDMODEL) ||
(backEnd.refdef.rdflags & RDF_SKYBOXPORTAL) ||
!mParticleClouds.size() ||
ri.CL_IsRunningInGameCinematic())
{ // no world rendering or no world or no particle clouds
return;
}
SetViewportAndScissor();
qglMatrixMode(GL_MODELVIEW);
qglLoadMatrixf(backEnd.viewParms.world.modelMatrix);
// Calculate Elapsed Time For Scale Purposes
//-------------------------------------------
mMillisecondsElapsed = backEnd.refdef.frametime;
if (mMillisecondsElapsed<1)
{
mMillisecondsElapsed = 1.0f;
}
if (mMillisecondsElapsed>1000.0f)
{
mMillisecondsElapsed = 1000.0f;
}
mSecondsElapsed = (mMillisecondsElapsed / 1000.0f);
// Make Sure We Are Always Outside Cached
//----------------------------------------
if (!mOutside.Initialized())
{
mOutside.Cache();
}
else
{
// Update All Wind Zones
//-----------------------
if (!mFrozen)
{
mGlobalWindVelocity.Clear();
for (int wz=0; wz<mWindZones.size(); wz++)
{
mWindZones[wz].Update();
if (mWindZones[wz].mGlobal)
{
mGlobalWindVelocity += mWindZones[wz].mCurrentVelocity;
}
}
mGlobalWindDirection = mGlobalWindVelocity;
mGlobalWindSpeed = VectorNormalize(mGlobalWindDirection.v);
}
// Update All Particle Clouds
//----------------------------
mParticlesRendered = 0;
for (int i=0; i<mParticleClouds.size(); i++)
{
mParticleClouds[i].Update();
mParticleClouds[i].Render();
}
if (false)
{
Com_Printf( "Weather: %d Particles Rendered\n", mParticlesRendered);
}
}
}
void R_WorldEffect_f(void)
{
if (ri.Cvar_VariableIntegerValue("helpUsObi"))
{
char temp[2048];
ri.Cmd_ArgsBuffer(temp, sizeof(temp));
R_WorldEffectCommand(temp);
}
}
/*
==================
WE_ParseVector
Imported from MP/Ensiform's fixes --eez
==================
*/
qboolean WE_ParseVector( const char **text, int count, float *v ) {
char *token;
int i;
// FIXME: spaces are currently required after parens, should change parseext...
COM_BeginParseSession();
token = COM_ParseExt( text, qfalse );
if ( strcmp( token, "(" ) ) {
Com_Printf ("^3WARNING: missing parenthesis in weather effect\n" );
COM_EndParseSession();
return qfalse;
}
for ( i = 0 ; i < count ; i++ ) {
token = COM_ParseExt( text, qfalse );
if ( !token[0] ) {
Com_Printf ("^3WARNING: missing vector element in weather effect\n" );
COM_EndParseSession();
return qfalse;
}
v[i] = atof( token );
}
token = COM_ParseExt( text, qfalse );
COM_EndParseSession();
if ( strcmp( token, ")" ) ) {
Com_Printf ("^3WARNING: missing parenthesis in weather effect\n" );
return qfalse;
}
return qtrue;
}
void R_WorldEffectCommand(const char *command)
{
if ( !command )
{
return;
}
const char *token;//, *origCommand;
COM_BeginParseSession();
token = COM_ParseExt(&command, qfalse);
if ( !token )
{
COM_EndParseSession();
return;
}
// Clear - Removes All Particle Clouds And Wind Zones
//----------------------------------------------------
if (Q_stricmp(token, "clear") == 0)
{
for (int p=0; p<mParticleClouds.size(); p++)
{
mParticleClouds[p].Reset();
}
mParticleClouds.clear();
mWindZones.clear();
mLocalWindZones.clear();
}
// Freeze / UnFreeze - Stops All Particle Motion Updates
//--------------------------------------------------------
else if (Q_stricmp(token, "freeze") == 0)
{
mFrozen = !mFrozen;
}
// Add a zone
//---------------
else if (Q_stricmp(token, "zone") == 0)
{
vec3_t mins;
vec3_t maxs;
if (WE_ParseVector(&command, 3, mins) && WE_ParseVector(&command, 3, maxs))
{
mOutside.AddWeatherZone(mins, maxs);
}
}
// Basic Wind
//------------
else if (Q_stricmp(token, "wind") == 0)
{
if (mWindZones.full())
{
COM_EndParseSession();
return;
}
CWindZone& nWind = mWindZones.push_back();
nWind.Initialize();
}
// Constant Wind
//---------------
else if (Q_stricmp(token, "constantwind") == 0)
{
if (mWindZones.full())
{
COM_EndParseSession();
return;
}
CWindZone& nWind = mWindZones.push_back();
nWind.Initialize();
if (!WE_ParseVector(&command, 3, nWind.mCurrentVelocity.v))
{
nWind.mCurrentVelocity.Clear();
nWind.mCurrentVelocity[1] = 800.0f;
}
nWind.mTargetVelocityTimeRemaining = -1;
}
// Gusting Wind
//--------------
else if (Q_stricmp(token, "gustingwind") == 0)
{
if (mWindZones.full())
{
COM_EndParseSession();
return;
}
CWindZone& nWind = mWindZones.push_back();
nWind.Initialize();
nWind.mRVelocity.mMins = -3000.0f;
nWind.mRVelocity.mMins[2] = -100.0f;
nWind.mRVelocity.mMaxs = 3000.0f;
nWind.mRVelocity.mMaxs[2] = 100.0f;
nWind.mMaxDeltaVelocityPerUpdate = 10.0f;
nWind.mRDuration.mMin = 1000;
nWind.mRDuration.mMax = 3000;
nWind.mChanceOfDeadTime = 0.5f;
nWind.mRDeadTime.mMin = 2000;
nWind.mRDeadTime.mMax = 4000;
}
// Local Wind Zone
//-----------------
else if (Q_stricmp(token, "windzone") == 0)
{
if (mWindZones.full())
{
COM_EndParseSession();
return;
}
CWindZone& nWind = mWindZones.push_back();
nWind.Initialize();
nWind.mGlobal = false;
// Read Mins
if (!WE_ParseVector(&command, 3, nWind.mRBounds.mMins.v))
{
assert("Wind Zone: Unable To Parse Mins Vector!"==0);
mWindZones.pop_back();
COM_EndParseSession();
return;
}
// Read Maxs
if (!WE_ParseVector(&command, 3, nWind.mRBounds.mMaxs.v))
{
assert("Wind Zone: Unable To Parse Maxs Vector!"==0);
mWindZones.pop_back();
COM_EndParseSession();
return;
}
// Read Velocity
if (!WE_ParseVector(&command, 3, nWind.mCurrentVelocity.v))
{
nWind.mCurrentVelocity.Clear();
nWind.mCurrentVelocity[1] = 800.0f;
}
nWind.mTargetVelocityTimeRemaining = -1;
mLocalWindZones.push_back(&nWind);
}
// Create A Rain Storm
//---------------------
else if (Q_stricmp(token, "lightrain") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(500, "gfx/world/rain.jpg", 3);
nCloud.mHeight = 80.0f;
nCloud.mWidth = 1.2f;
nCloud.mGravity = 2000.0f;
nCloud.mFilterMode = 1;
nCloud.mBlendMode = 1;
nCloud.mFade = 100.0f;
nCloud.mColor = 0.5f;
nCloud.mOrientWithVelocity = true;
nCloud.mWaterParticles = true;
}
// Create A Rain Storm
//---------------------
else if (Q_stricmp(token, "rain") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
nCloud.mHeight = 80.0f;
nCloud.mWidth = 1.2f;
nCloud.mGravity = 2000.0f;
nCloud.mFilterMode = 1;
nCloud.mBlendMode = 1;
nCloud.mFade = 100.0f;
nCloud.mColor = 0.5f;
nCloud.mOrientWithVelocity = true;
nCloud.mWaterParticles = true;
}
// Create A Rain Storm
//---------------------
else if (Q_stricmp(token, "acidrain") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
nCloud.mHeight = 80.0f;
nCloud.mWidth = 2.0f;
nCloud.mGravity = 2000.0f;
nCloud.mFilterMode = 1;
nCloud.mBlendMode = 1;
nCloud.mFade = 100.0f;
nCloud.mColor[0] = 0.34f;
nCloud.mColor[1] = 0.70f;
nCloud.mColor[2] = 0.34f;
nCloud.mColor[3] = 0.70f;
nCloud.mOrientWithVelocity = true;
nCloud.mWaterParticles = true;
mOutside.mOutsidePain = 0.1f;
}
// Create A Rain Storm
//---------------------
else if (Q_stricmp(token, "heavyrain") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(1000, "gfx/world/rain.jpg", 3);
nCloud.mHeight = 80.0f;
nCloud.mWidth = 1.2f;
nCloud.mGravity = 2800.0f;
nCloud.mFilterMode = 1;
nCloud.mBlendMode = 1;
nCloud.mFade = 15.0f;
nCloud.mColor = 0.5f;
nCloud.mOrientWithVelocity = true;
nCloud.mWaterParticles = true;
}
// Create A Snow Storm
//---------------------
else if (Q_stricmp(token, "snow") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
int count = 1000;
const char* tempStr;
COM_ParseString(&command, &tempStr);
COM_ParseInt(&command, &count);
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(count, "gfx/effects/snowflake1.tga");
nCloud.mBlendMode = 1;
nCloud.mRotationChangeNext = 0;
nCloud.mColor = 0.75f;
nCloud.mWaterParticles = true;
}
// Create A Some stuff
//---------------------
else if (Q_stricmp(token, "spacedust") == 0)
{
int count;
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
token = COM_ParseExt(&command, qfalse);
count = atoi(token);
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(count, "gfx/effects/snowpuff1.tga");
nCloud.mHeight = 1.2f;
nCloud.mWidth = 1.2f;
nCloud.mGravity = 0.0f;
nCloud.mBlendMode = 1;
nCloud.mRotationChangeNext = 0;
nCloud.mColor = 0.75f;
nCloud.mWaterParticles = true;
nCloud.mMass.mMax = 30.0f;
nCloud.mMass.mMin = 10.0f;
nCloud.mSpawnRange.mMins[0] = -1500.0f;
nCloud.mSpawnRange.mMins[1] = -1500.0f;
nCloud.mSpawnRange.mMins[2] = -1500.0f;
nCloud.mSpawnRange.mMaxs[0] = 1500.0f;
nCloud.mSpawnRange.mMaxs[1] = 1500.0f;
nCloud.mSpawnRange.mMaxs[2] = 1500.0f;
}
// Create A Sand Storm
//---------------------
else if (Q_stricmp(token, "sand") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(400, "gfx/effects/alpha_smoke2b.tga");
nCloud.mGravity = 0;
nCloud.mWidth = 70;
nCloud.mHeight = 70;
nCloud.mColor[0] = 0.9f;
nCloud.mColor[1] = 0.6f;
nCloud.mColor[2] = 0.0f;
nCloud.mColor[3] = 0.5f;
nCloud.mFade = 5.0f;
nCloud.mMass.mMax = 30.0f;
nCloud.mMass.mMin = 10.0f;
nCloud.mSpawnRange.mMins[2] = -150;
nCloud.mSpawnRange.mMaxs[2] = 150;
nCloud.mRotationChangeNext = 0;
}
// Create Blowing Clouds Of Fog
//------------------------------
else if (Q_stricmp(token, "fog") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(60, "gfx/effects/alpha_smoke2b.tga");
nCloud.mBlendMode = 1;
nCloud.mGravity = 0;
nCloud.mWidth = 70;
nCloud.mHeight = 70;
nCloud.mColor = 0.2f;
nCloud.mFade = 5.0f;
nCloud.mMass.mMax = 30.0f;
nCloud.mMass.mMin = 10.0f;
nCloud.mSpawnRange.mMins[2] = -150;
nCloud.mSpawnRange.mMaxs[2] = 150;
nCloud.mRotationChangeNext = 0;
}
// Create Heavy Rain Particle Cloud
//-----------------------------------
else if (Q_stricmp(token, "heavyrainfog") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(70, "gfx/effects/alpha_smoke2b.tga");
nCloud.mBlendMode = 1;
nCloud.mGravity = 0;
nCloud.mWidth = 100;
nCloud.mHeight = 100;
nCloud.mColor = 0.3f;
nCloud.mFade = 1.0f;
nCloud.mMass.mMax = 10.0f;
nCloud.mMass.mMin = 5.0f;
nCloud.mSpawnRange.mMins = -(nCloud.mSpawnPlaneDistance*1.25f);
nCloud.mSpawnRange.mMaxs = (nCloud.mSpawnPlaneDistance*1.25f);
nCloud.mSpawnRange.mMins[2] = -150;
nCloud.mSpawnRange.mMaxs[2] = 150;
nCloud.mRotationChangeNext = 0;
}
// Create Blowing Clouds Of Fog
//------------------------------
else if (Q_stricmp(token, "light_fog") == 0)
{
if (mParticleClouds.full())
{
COM_EndParseSession();
return;
}
CParticleCloud& nCloud = mParticleClouds.push_back();
nCloud.Initialize(40, "gfx/effects/alpha_smoke2b.tga");
nCloud.mBlendMode = 1;
nCloud.mGravity = 0;
nCloud.mWidth = 100;
nCloud.mHeight = 100;
nCloud.mColor[0] = 0.19f;
nCloud.mColor[1] = 0.6f;
nCloud.mColor[2] = 0.7f;
nCloud.mColor[3] = 0.12f;
nCloud.mFade = 0.10f;
nCloud.mMass.mMax = 30.0f;
nCloud.mMass.mMin = 10.0f;
nCloud.mSpawnRange.mMins[2] = -150;
nCloud.mSpawnRange.mMaxs[2] = 150;
nCloud.mRotationChangeNext = 0;
}
else if (Q_stricmp(token, "outsideshake") == 0)
{
mOutside.mOutsideShake = !mOutside.mOutsideShake;
}
else if (Q_stricmp(token, "outsidepain") == 0)
{
mOutside.mOutsidePain = !mOutside.mOutsidePain;
}
else
{
Com_Printf( "Weather Effect: Please enter a valid command.\n" );
Com_Printf( " clear\n" );
Com_Printf( " freeze\n" );
Com_Printf( " zone (mins) (maxs)\n" );
Com_Printf( " wind\n" );
Com_Printf( " constantwind (velocity)\n" );
Com_Printf( " gustingwind\n" );
Com_Printf( " windzone (mins) (maxs) (velocity)\n" );
Com_Printf( " lightrain\n" );
Com_Printf( " rain\n" );
Com_Printf( " acidrain\n" );
Com_Printf( " heavyrain\n" );
Com_Printf( " snow\n" );
Com_Printf( " spacedust\n" );
Com_Printf( " sand\n" );
Com_Printf( " fog\n" );
Com_Printf( " heavyrainfog\n" );
Com_Printf( " light_fog\n" );
Com_Printf( " outsideshake\n" );
Com_Printf( " outsidepain\n" );
}
COM_EndParseSession();
}
float R_GetChanceOfSaberFizz()
{
float chance = 0.0f;
int numWater = 0;
for (int i=0; i<mParticleClouds.size(); i++)
{
if (mParticleClouds[i].mWaterParticles)
{
chance += (mParticleClouds[i].mGravity/20000.0f);
numWater ++;
}
}
if (numWater)
{
return (chance / numWater);
}
return 0.0f;
}
bool R_IsRaining()
{
return !mParticleClouds.empty();
}
bool R_IsPuffing()
{
return false;
}
Reference in a new issue View git blame Copy permalink