1121 lines
36 KiB
C++
1121 lines
36 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program 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.
|
|
*
|
|
* 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/>.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2006-2010 - Frictional Games
|
|
*
|
|
* This file is part of HPL1 Engine.
|
|
*/
|
|
|
|
// NEW
|
|
#include "hpl1/engine/graphics/Graphics.h"
|
|
// ---
|
|
#include "hpl1/engine/graphics/ParticleEmitter3D_UserData.h"
|
|
//#include "hpl1/engine/graphics/Mesh.h"
|
|
//#include "hpl1/engine/graphics/SubMesh.h"
|
|
#include "hpl1/engine/graphics/ParticleSystem3D.h"
|
|
#include "hpl1/engine/graphics/RenderList.h"
|
|
|
|
#include "hpl1/engine/impl/tinyXML/tinyxml.h"
|
|
|
|
#include "hpl1/engine/resources/MaterialManager.h"
|
|
#include "hpl1/engine/resources/Resources.h"
|
|
//#include "hpl1/engine/resources/MeshManager.h"
|
|
|
|
#include "hpl1/engine/physics/PhysicsBody.h"
|
|
#include "hpl1/engine/physics/PhysicsWorld.h"
|
|
|
|
#include "hpl1/engine/scene/World3D.h"
|
|
|
|
#include "hpl1/engine/math/Math.h"
|
|
|
|
namespace hpl {
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// LOADER
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
cParticleEmitterData3D_UserData::cParticleEmitterData3D_UserData(
|
|
const tString &asName, cResources *apResources, cGraphics *apGraphics)
|
|
: iParticleEmitterData(asName, apResources, apGraphics) {
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
iParticleEmitter *cParticleEmitterData3D_UserData::Create(tString asName, cVector3f avSize) {
|
|
iParticleEmitter3D *pPE = hplNew(cParticleEmitter3D_UserData, (asName, &mvMaterials, avSize,
|
|
mpGraphics, mpResources, this));
|
|
|
|
cMatrixf mtxOffset = cMath::MatrixRotate(mvAngleOffset, eEulerRotationOrder_XYZ);
|
|
mtxOffset.SetTranslation(mvPosOffset);
|
|
pPE->SetMatrix(mtxOffset);
|
|
|
|
return pPE;
|
|
}
|
|
|
|
//////////////////////////
|
|
|
|
// NEW
|
|
static ePEType GetPEType(const char *apString) {
|
|
if (apString == NULL)
|
|
return ePEType_Normal;
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "beam")
|
|
return ePEType_Beam;
|
|
else if (sType == "normal")
|
|
return ePEType_Normal;
|
|
|
|
return ePEType_Normal;
|
|
}
|
|
|
|
// ---
|
|
|
|
/////////////////////////
|
|
|
|
static ePEStartPosType GetStartPosType(const char *apString) {
|
|
if (apString == NULL)
|
|
return ePEStartPosType_Box;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "box")
|
|
return ePEStartPosType_Box;
|
|
else if (sType == "sphere")
|
|
return ePEStartPosType_Sphere;
|
|
|
|
return ePEStartPosType_Box;
|
|
}
|
|
|
|
/////////////////////////
|
|
|
|
static eParticleEmitter3DCoordSystem GetCoordSystem(const char *apString) {
|
|
if (apString == NULL)
|
|
return eParticleEmitter3DCoordSystem_World;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "world")
|
|
return eParticleEmitter3DCoordSystem_World;
|
|
else if (sType == "local")
|
|
return eParticleEmitter3DCoordSystem_Local;
|
|
|
|
return eParticleEmitter3DCoordSystem_World;
|
|
}
|
|
|
|
/////////////////////////
|
|
|
|
static ePEDeathType GetDeathType(const char *apString) {
|
|
if (apString == NULL)
|
|
return ePEDeathType_Age;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "age")
|
|
return ePEDeathType_Age;
|
|
|
|
return ePEDeathType_Age;
|
|
}
|
|
|
|
/////////////////////////
|
|
|
|
static eParticleEmitter3DType GetDrawType(const char *apString) {
|
|
if (apString == NULL)
|
|
return eParticleEmitter3DType_DynamicPoint;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "point")
|
|
return eParticleEmitter3DType_DynamicPoint;
|
|
else if (sType == "line")
|
|
return eParticleEmitter3DType_Line;
|
|
else if (sType == "axis")
|
|
return eParticleEmitter3DType_Axis;
|
|
|
|
return eParticleEmitter3DType_DynamicPoint;
|
|
}
|
|
|
|
/////////////////////////
|
|
|
|
static ePEGravityType GetGravityType(const char *apString) {
|
|
if (apString == NULL)
|
|
return ePEGravityType_None;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "none")
|
|
return ePEGravityType_None;
|
|
else if (sType == "vector")
|
|
return ePEGravityType_Vector;
|
|
else if (sType == "center")
|
|
return ePEGravityType_Center;
|
|
|
|
return ePEGravityType_None;
|
|
}
|
|
|
|
/////////////////////////
|
|
|
|
static ePESubDivType GetSubDivType(const char *apString) {
|
|
if (apString == NULL)
|
|
return ePESubDivType_Random;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "random")
|
|
return ePESubDivType_Random;
|
|
else if (sType == "animation")
|
|
return ePESubDivType_Animation;
|
|
|
|
return ePESubDivType_Random;
|
|
}
|
|
|
|
////////////////////////
|
|
/// NEW
|
|
|
|
static ePEPartSpinType GetPartSpinType(const char *apString) {
|
|
if (apString == NULL)
|
|
return ePEPartSpinType_Constant;
|
|
|
|
tString sType = cString::ToLowerCase(apString);
|
|
|
|
if (sType == "constant")
|
|
return ePEPartSpinType_Constant;
|
|
else if (sType == "movement")
|
|
return ePEPartSpinType_Movement;
|
|
|
|
return ePEPartSpinType_Constant;
|
|
}
|
|
|
|
/// ---
|
|
|
|
/////////////////////////
|
|
|
|
void cParticleEmitterData3D_UserData::LoadFromElement(TiXmlElement *apElement) {
|
|
///////// GENERAL /////////////
|
|
msName = cString::ToString(apElement->Attribute("Name"), "");
|
|
|
|
// NEW
|
|
|
|
mPEType = GetPEType(apElement->Attribute("PEType"));
|
|
|
|
// ---
|
|
|
|
mlMaxParticleNum = cString::ToInt(apElement->Attribute("MaxParticleNum"), 1);
|
|
|
|
mbRespawn = cString::ToBool(apElement->Attribute("Respawn"), false);
|
|
|
|
mfParticlesPerSecond = cString::ToFloat(apElement->Attribute("ParticlesPerSecond"), 1);
|
|
mfStartTimeOffset = cString::ToFloat(apElement->Attribute("StartTimeOffset"), 0);
|
|
|
|
mfWarmUpTime = cString::ToFloat(apElement->Attribute("WarmUpTime"), 0);
|
|
mfWarmUpStepsPerSec = cString::ToFloat(apElement->Attribute("WarmUpStepsPerSec"), 60);
|
|
|
|
mfMinPauseLength = cString::ToFloat(apElement->Attribute("MinPauseLength"), 0);
|
|
mfMaxPauseLength = cString::ToFloat(apElement->Attribute("MaxPauseLength"), 0);
|
|
|
|
mfMinPauseInterval = cString::ToFloat(apElement->Attribute("MinPauseInterval"), 0);
|
|
mfMaxPauseInterval = cString::ToFloat(apElement->Attribute("MaxPauseInterval"), 0);
|
|
|
|
mvPosOffset = cString::ToVector3f(apElement->Attribute("PosOffset"), 0);
|
|
mvAngleOffset = cString::ToVector3f(apElement->Attribute("AngleOffset"), 0);
|
|
mvAngleOffset.x = cMath::ToRad(mvAngleOffset.x);
|
|
mvAngleOffset.y = cMath::ToRad(mvAngleOffset.y);
|
|
mvAngleOffset.z = cMath::ToRad(mvAngleOffset.z);
|
|
|
|
/////////// MATERIAL ////////
|
|
int lMaterialNum = cString::ToInt(apElement->Attribute("MaterialNum"), 1);
|
|
float fAnimationLength = cString::ToFloat(apElement->Attribute("AnimationLength"), 1);
|
|
tString sMaterial = cString::ToString(apElement->Attribute("Material"), "");
|
|
|
|
mvSubDiv = cString::ToVector2l(apElement->Attribute("SubDiv"), 1);
|
|
mSubDivType = GetSubDivType(apElement->Attribute("SubDivType"));
|
|
|
|
if (lMaterialNum <= 1) {
|
|
sMaterial = cString::SetFileExt(sMaterial, "mat");
|
|
iMaterial *pMaterial = mpResources->GetMaterialManager()->CreateMaterial(sMaterial);
|
|
|
|
if (pMaterial)
|
|
mvMaterials.push_back(pMaterial);
|
|
} else {
|
|
for (int i = 1; i < lMaterialNum + 1; ++i) {
|
|
tString sFileName;
|
|
if (i > 9)
|
|
sFileName = sMaterial + cString::ToString(i);
|
|
else
|
|
sFileName = sMaterial + "0" + cString::ToString(i);
|
|
|
|
sFileName = cString::SetFileExt(sFileName, "mat");
|
|
|
|
iMaterial *pMaterial = mpResources->GetMaterialManager()->CreateMaterial(sFileName);
|
|
if (pMaterial)
|
|
mvMaterials.push_back(pMaterial);
|
|
}
|
|
}
|
|
|
|
mfFrameStep = 1 / (fAnimationLength / (float)mvMaterials.size());
|
|
mfMaxFrameTime = ((float)mvMaterials.size()) - 0.0001f;
|
|
|
|
///////// START POS //////////
|
|
mStartPosType = GetStartPosType(apElement->Attribute("StartPosType"));
|
|
|
|
mvMinStartPos = cString::ToVector3f(apElement->Attribute("MinStartPos"), 0);
|
|
mvMaxStartPos = cString::ToVector3f(apElement->Attribute("MaxStartPos"), 0);
|
|
|
|
mvMinStartAngles = cString::ToVector2f(apElement->Attribute("MinStartAngles"), 0);
|
|
mvMaxStartAngles = cString::ToVector2f(apElement->Attribute("MaxStartAngles"), 0);
|
|
mvMinStartAngles.x = cMath::ToRad(mvMinStartAngles.x);
|
|
mvMinStartAngles.y = cMath::ToRad(mvMinStartAngles.y);
|
|
mvMaxStartAngles.x = cMath::ToRad(mvMaxStartAngles.x);
|
|
mvMaxStartAngles.y = cMath::ToRad(mvMaxStartAngles.y);
|
|
|
|
mfMinStartRadius = cString::ToFloat(apElement->Attribute("MinStartRadius"), 0);
|
|
mfMaxStartRadius = cString::ToFloat(apElement->Attribute("MaxStartRadius"), 0);
|
|
|
|
// NEW
|
|
// cMesh *mshTempMesh = mpResources->GetMeshManager()->CreateMesh("character_roach.dae");
|
|
// mVBMeshData = mshTempMesh->GetSubMeshName("polySurfaceShape38")->GetVertexBuffer();
|
|
// mpfMeshVtxData = mVBMeshData->GetArray(eVertexFlag_Position);
|
|
|
|
// ---
|
|
|
|
/////////// MOVEMENT ////////
|
|
mStartVelType = GetStartPosType(apElement->Attribute("StartVelType"));
|
|
|
|
mvMinStartVel = cString::ToVector3f(apElement->Attribute("MinStartVel"), 0);
|
|
mvMaxStartVel = cString::ToVector3f(apElement->Attribute("MaxStartVel"), 0);
|
|
|
|
mvMinStartVelAngles = cString::ToVector2f(apElement->Attribute("MinStartVelAngles"), 0);
|
|
mvMaxStartVelAngles = cString::ToVector2f(apElement->Attribute("MaxStartVelAngles"), 0);
|
|
mvMinStartVelAngles.x = cMath::ToRad(mvMinStartVelAngles.x);
|
|
mvMinStartVelAngles.y = cMath::ToRad(mvMinStartVelAngles.y);
|
|
mvMaxStartVelAngles.x = cMath::ToRad(mvMaxStartVelAngles.x);
|
|
mvMaxStartVelAngles.y = cMath::ToRad(mvMaxStartVelAngles.y);
|
|
|
|
mfMinStartVelSpeed = cString::ToFloat(apElement->Attribute("MinStartVelSpeed"), 0);
|
|
mfMaxStartVelSpeed = cString::ToFloat(apElement->Attribute("MaxStartVelSpeed"), 0);
|
|
|
|
mfMinSpeedMultiply = cString::ToFloat(apElement->Attribute("MinSpeedMultiply"), 0);
|
|
mfMaxSpeedMultiply = cString::ToFloat(apElement->Attribute("MaxSpeedMultiply"), 0);
|
|
|
|
mvMinStartAcc = cString::ToVector3f(apElement->Attribute("MinStartAcc"), 0);
|
|
mvMaxStartAcc = cString::ToVector3f(apElement->Attribute("MaxStartAcc"), 0);
|
|
|
|
mfMinVelMaximum = cString::ToFloat(apElement->Attribute("MinVelMaximum"), 0);
|
|
mfMaxVelMaximum = cString::ToFloat(apElement->Attribute("MaxVelMaximum"), 0);
|
|
|
|
mbUsesDirection = cString::ToBool(apElement->Attribute("UsesDirection"), false);
|
|
|
|
mGravityType = GetGravityType(apElement->Attribute("GravityType"));
|
|
|
|
mvGravityAcc = cString::ToVector3f(apElement->Attribute("GravityAcc"), 0);
|
|
|
|
mCoordSystem = GetCoordSystem(apElement->Attribute("CoordSystem"));
|
|
|
|
// NEW
|
|
|
|
mbUsePartSpin = cString::ToBool(apElement->Attribute("UsePartSpin"), false);
|
|
mPartSpinType = GetPartSpinType(apElement->Attribute("PartSpinType"));
|
|
mfMinSpinRange = cString::ToFloat(apElement->Attribute("MinSpinRange"), 0);
|
|
mfMaxSpinRange = cString::ToFloat(apElement->Attribute("MaxSpinRange"), 0);
|
|
|
|
mbUseRevolution = cString::ToBool(apElement->Attribute("UseRevolution"), false);
|
|
mvMinRevVel = cString::ToVector3f(apElement->Attribute("MinRevVel"), 0);
|
|
mvMaxRevVel = cString::ToVector3f(apElement->Attribute("MaxRevVel"), 0);
|
|
|
|
// ---
|
|
|
|
/////////// LIFESPAN ////////
|
|
mfMinLifeSpan = cString::ToFloat(apElement->Attribute("MinLifeSpan"), 0);
|
|
mfMaxLifeSpan = cString::ToFloat(apElement->Attribute("MaxLifeSpan"), 0);
|
|
|
|
mDeathType = GetDeathType(apElement->Attribute("DeathType"));
|
|
|
|
msDeathPS = cString::ToString(apElement->Attribute("DeathPS"), "");
|
|
|
|
/////////// RENDERING ////////
|
|
mDrawType = GetDrawType(apElement->Attribute("DrawType"));
|
|
|
|
// eParticleEmitter3DType Heading
|
|
// cVector2l subdivisions.
|
|
|
|
mvMinStartSize = cString::ToVector2f(apElement->Attribute("MinStartSize"), 1);
|
|
mvMaxStartSize = cString::ToVector2f(apElement->Attribute("MaxStartSize"), 1);
|
|
|
|
mfStartRelSize = cString::ToFloat(apElement->Attribute("StartRelSize"), 0);
|
|
mfMiddleRelSize = cString::ToFloat(apElement->Attribute("MiddleRelSize"), 0);
|
|
mfMiddleRelSizeTime = cString::ToFloat(apElement->Attribute("MiddleRelSizeTime"), 0);
|
|
mfMiddleRelSizeLength = cString::ToFloat(apElement->Attribute("MiddleRelSizeLength"), 0);
|
|
mfEndRelSize = cString::ToFloat(apElement->Attribute("EndRelSize"), 0);
|
|
|
|
mbMultiplyRGBWithAlpha = cString::ToBool(apElement->Attribute("MultiplyRGBWithAlpha"), false);
|
|
|
|
/////////// COLOR ////////
|
|
|
|
mMinStartColor = cString::ToColor(apElement->Attribute("MinStartColor"), cColor(1, 1));
|
|
mMaxStartColor = cString::ToColor(apElement->Attribute("MaxStartColor"), cColor(1, 1));
|
|
|
|
mStartRelColor = cString::ToColor(apElement->Attribute("StartRelColor"), cColor(1, 1));
|
|
mMiddleRelColor = cString::ToColor(apElement->Attribute("MiddleRelColor"), cColor(1, 1));
|
|
mfMiddleRelColorTime = cString::ToFloat(apElement->Attribute("MiddleRelColorTime"), 0);
|
|
mfMiddleRelColorLength = cString::ToFloat(apElement->Attribute("MiddleRelColorLength"), 0);
|
|
mEndRelColor = cString::ToColor(apElement->Attribute("EndRelColor"), cColor(1, 1));
|
|
|
|
/////////// COLLISION ////////
|
|
mbCollides = cString::ToBool(apElement->Attribute("Collides"), false);
|
|
|
|
mfMinBounceAmount = cString::ToFloat(apElement->Attribute("MinBounceAmount"), 0);
|
|
mfMaxBounceAmount = cString::ToFloat(apElement->Attribute("MaxBounceAmount"), 0);
|
|
|
|
mlMinCollisionMax = cString::ToInt(apElement->Attribute("MinCollisionMax"), 0);
|
|
mlMaxCollisionMax = cString::ToInt(apElement->Attribute("MaxCollisionMax"), 0);
|
|
|
|
mlCollisionUpdateRate = cString::ToInt(apElement->Attribute("CollisionUpdateRate"), 0);
|
|
|
|
// NEW
|
|
////////// BEAM SPECIFIC //////////
|
|
|
|
mbUseBeamNoise = cString::ToBool(apElement->Attribute("UseBeamNoise"), false);
|
|
|
|
mlLowFreqPoints = cString::ToInt(apElement->Attribute("LowFreqPoints"), 4);
|
|
mlHighFreqPoints = cString::ToInt(apElement->Attribute("HighFreqPoints"), 5);
|
|
|
|
mvMinLowFreqNoise = cString::ToVector3f(apElement->Attribute("MinLowFreqNoise"), 0);
|
|
mvMaxLowFreqNoise = cString::ToVector3f(apElement->Attribute("MaxLowFreqNoise"), 0);
|
|
|
|
mvMinHighFreqNoise = cString::ToVector3f(apElement->Attribute("MinHighFreqNoise"), 0);
|
|
mvMaxHighFreqNoise = cString::ToVector3f(apElement->Attribute("MaxHighFreqNoise"), 0);
|
|
|
|
// ---
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
bool cParticleEmitterData3D_UserData::OnIntersect(iPhysicsBody *pBody, cPhysicsRayParams *apParams) {
|
|
if (pBody->IsActive() == false || pBody->GetCollide() == false || pBody->IsCharacter()) {
|
|
return true;
|
|
}
|
|
|
|
if (mfShortestDist > apParams->mfDist) {
|
|
mbIntersected = true;
|
|
mfShortestDist = apParams->mfDist;
|
|
*mpIntersectPos = apParams->mvPoint;
|
|
*mpIntersectNormal = apParams->mvNormal;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool cParticleEmitterData3D_UserData::CheckCollision(const cVector3f &avStart,
|
|
const cVector3f &avEnd,
|
|
iPhysicsWorld *apPhysicsWorld,
|
|
cVector3f *apNormalVec,
|
|
cVector3f *apPosVec) {
|
|
mfShortestDist = 99999.0f;
|
|
mbIntersected = false;
|
|
|
|
mpIntersectPos = apPosVec;
|
|
mpIntersectNormal = apNormalVec;
|
|
|
|
apPhysicsWorld->CastRay(this, avStart, avEnd, true, true, true);
|
|
|
|
return mbIntersected;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CONSTRUCTORS
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
cParticleEmitter3D_UserData::cParticleEmitter3D_UserData(
|
|
tString asName, tMaterialVec *apMaterials,
|
|
cVector3f avSize, cGraphics *apGraphics, cResources *apResources,
|
|
cParticleEmitterData3D_UserData *apData)
|
|
: iParticleEmitter3D(asName, apMaterials, apData->mlMaxParticleNum,
|
|
avSize, apGraphics, apResources) {
|
|
mpData = apData;
|
|
|
|
mvDrawSize = 1;
|
|
|
|
mfTime = 0;
|
|
|
|
mfCreateCount = 0;
|
|
|
|
mfPauseCount = 0;
|
|
mfPauseWaitCount = 0;
|
|
mbPaused = false;
|
|
|
|
mfCollideCount = 1.0f / (float)mpData->mlCollisionUpdateRate;
|
|
|
|
mCoordSystem = apData->mCoordSystem;
|
|
|
|
mDrawType = apData->mDrawType;
|
|
|
|
mbUsesDirection = apData->mbUsesDirection;
|
|
|
|
// mbDying = !apData->mbRespawn;
|
|
mbRespawn = apData->mbRespawn;
|
|
|
|
SetSubDivUV(mpData->mvSubDiv);
|
|
|
|
// NEW
|
|
mbUsePartSpin = apData->mbUsePartSpin;
|
|
mbUseRevolution = apData->mbUseRevolution;
|
|
|
|
mPEType = apData->mPEType;
|
|
|
|
// Calculate max size of particles.
|
|
float fSizeMul = apData->mfStartRelSize;
|
|
if (fSizeMul < apData->mfMiddleRelSize)
|
|
fSizeMul = apData->mfMiddleRelSize;
|
|
if (fSizeMul < apData->mfEndRelSize)
|
|
fSizeMul = apData->mfEndRelSize;
|
|
mvMaxDrawSize = apData->mvMaxStartSize * fSizeMul;
|
|
|
|
/* int i = 0;
|
|
int j = 0;
|
|
int k = 0;
|
|
switch ( mPEType )
|
|
{
|
|
case ePEType_Beam:
|
|
hplDelete(mpVtxBuffer); // Destroy the current Vertex Buffer, as it's filled with quads we don't need now :)
|
|
|
|
if ( apData->mbUseBeamNoise )
|
|
{
|
|
// Calculate the Frequency Points Lookup Table, this is needed to create the Vertex Buffer.It is also needed by every beam particle created,
|
|
// as it needs to know the type and index of each when updating.
|
|
while ( (i < apData->mlLowFreqPoints) && (j < apData->mlHighFreqPoints) )
|
|
{
|
|
float fLowRelPos = (float) i / (apData->mlLowFreqPoints -1 );
|
|
float fHighRelPos = (float) j / (apData->mlHighFreqPoints -1 );
|
|
float fLastLowRelPos = 0.0f;
|
|
|
|
tBeamNoisePoint tempBNP;
|
|
|
|
// tempBNP.lLowFreqNoiseIdx = i;
|
|
// tempBNP.lHighFreqNoiseIdx = j;
|
|
tempBNP.fRelToBendPos = (fHighRelPos-fLastLowRelPos)/(fLowRelPos-fLastLowRelPos);
|
|
|
|
if ( fLowRelPos <= fHighRelPos )
|
|
{
|
|
if ( fLowRelPos == fHighRelPos )
|
|
{
|
|
tempBNP.noiseType = ePENoiseType_Both;
|
|
++i;
|
|
++j;
|
|
}
|
|
else
|
|
{
|
|
tempBNP.noiseType = ePENoiseType_LowFreq;
|
|
++i;
|
|
}
|
|
|
|
tempBNP.fRelToBeamPos = fLowRelPos;
|
|
apData->mvLFIndices.push_back (k);
|
|
|
|
}
|
|
else
|
|
{
|
|
tempBNP.fRelToBeamPos = fHighRelPos;
|
|
tempBNP.noiseType = ePENoiseType_HighFreq;
|
|
++j;
|
|
}
|
|
|
|
fLastLowRelPos = fLowRelPos;
|
|
|
|
|
|
mpData->mvBeamNoisePoints.push_back(tempBNP);
|
|
++k;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tBeamNoisePoint tempBNP;
|
|
|
|
tempBNP.fRelToBeamPos = 0.0f;
|
|
tempBNP.fRelToBendPos = 0.0f;
|
|
tempBNP.noiseType = ePENoiseType_None;
|
|
|
|
mpData->mvBeamNoisePoints.push_back(tempBNP);
|
|
|
|
tempBNP.fRelToBeamPos = 1.0f;
|
|
tempBNP.fRelToBendPos = 1.0f;
|
|
tempBNP.noiseType = ePENoiseType_None;
|
|
|
|
mpData->mvBeamNoisePoints.push_back(tempBNP);
|
|
}
|
|
|
|
mpVtxBuffer = apGraphics->GetLowLevel()->CreateVertexBuffer ( eVertexFlag_Position, // Now that we know how many points we have, we create the Vertex Buffer
|
|
eVertexBufferDrawType_Tri, eVertexBufferUsageType_Stream,
|
|
mlMaxParticles*mpData->mvBeamNoisePoints.size()*2, mlMaxParticles*(mpData->mvBeamNoisePoints.size()-1)*6);
|
|
|
|
for ( int i = 0; i < (int) mlMaxParticles; ++i )
|
|
{
|
|
for ( int j = 0; j < (int) mpData->mvBeamNoisePoints.size()-1; ++j )
|
|
{
|
|
int lStart = j*2;
|
|
mpVtxBuffer->AddIndex(lStart); // Half quad ( tri )
|
|
mpVtxBuffer->AddIndex(lStart+1);
|
|
mpVtxBuffer->AddIndex(lStart+3);
|
|
|
|
mpVtxBuffer->AddIndex(lStart+3); // The other half
|
|
mpVtxBuffer->AddIndex(lStart+2);
|
|
mpVtxBuffer->AddIndex(lStart);
|
|
}
|
|
|
|
}
|
|
|
|
for ( int i = 0; i < (int) mlMaxParticles; ++i )
|
|
{
|
|
for (int j = 0; j < (int) mpData->mvBeamNoisePoints.size(); ++j )
|
|
{
|
|
mpVtxBuffer->AddVertex(eVertexFlag_Texture0, cVector2f(mpData->mvBeamNoisePoints[j].fRelToBeamPos,1));
|
|
mpVtxBuffer->AddVertex(eVertexFlag_Texture0, cVector2f(mpData->mvBeamNoisePoints[j].fRelToBeamPos,0));
|
|
}
|
|
}
|
|
|
|
for ( int i = 0; i < (int) mlMaxParticles; ++i )
|
|
{
|
|
for (int j = 0; j < (int) mpData->mvBeamNoisePoints.size()*2; ++j )
|
|
{
|
|
mpVtxBuffer->AddVertex(eVertexFlag_Position, 0);
|
|
mpVtxBuffer->AddColor(eVertexFlag_Color0, cColor(1,1));
|
|
}
|
|
}
|
|
|
|
mpVtxBuffer->Compile(0);
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
case ePEType_Normal:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
*/
|
|
// ---
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
cParticleEmitter3D_UserData::~cParticleEmitter3D_UserData() {
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// PUBLIC METHODS
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
bool cParticleEmitter3D_UserData::IsDying() {
|
|
if (mbRespawn == false || mbDying)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cParticleEmitter3D_UserData::Kill() {
|
|
mbRespawn = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// PRIVATE METHODS
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cParticleEmitter3D_UserData::SetParticleDefaults(cParticle *apParticle) {
|
|
///////////////////////////////////
|
|
// Start Color
|
|
apParticle->mStartColor = cMath::RandRectColor(mpData->mMinStartColor, mpData->mMaxStartColor);
|
|
apParticle->mColor = apParticle->mStartColor * mpData->mStartRelColor;
|
|
|
|
///////////////////////////////////
|
|
// Start Size
|
|
if (mpData->mvMinStartSize.y == 0 && mpData->mvMaxStartSize.y == 0)
|
|
apParticle->mvStartSize = cMath::RandRectf(mpData->mvMinStartSize.x, mpData->mvMaxStartSize.x);
|
|
else
|
|
apParticle->mvStartSize = cMath::RandRectVector2f(mpData->mvMinStartSize, mpData->mvMaxStartSize);
|
|
apParticle->mvSize = apParticle->mvStartSize * mpData->mfStartRelSize;
|
|
|
|
////////////////////////////////////
|
|
// Start sub division
|
|
if (mvSubDivUV.size() > 1) {
|
|
if (mpData->mSubDivType == ePESubDivType_Animation) {
|
|
apParticle->mlSubDivNum = 0;
|
|
} else {
|
|
apParticle->mlSubDivNum = cMath::RandRectl(0, (int)mvSubDivUV.size() - 1);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////
|
|
// Start collision
|
|
apParticle->mfBounceAmount = cMath::RandRectf(mpData->mfMinBounceAmount, mpData->mfMaxBounceAmount);
|
|
apParticle->mlBounceCount = cMath::RandRectl(mpData->mlMinCollisionMax, mpData->mlMaxCollisionMax);
|
|
|
|
////////////////////////////////////
|
|
// Start Position
|
|
|
|
// Matrix to start from
|
|
cMatrixf mtxStart;
|
|
if (mpData->mCoordSystem == eParticleEmitter3DCoordSystem_World) {
|
|
mtxStart = GetWorldMatrix();
|
|
} else {
|
|
// Not what should be here, perhaps only identity.
|
|
mtxStart = GetLocalMatrix();
|
|
}
|
|
|
|
// Sphere or box start
|
|
if (mpData->mStartPosType == ePEStartPosType_Box) {
|
|
apParticle->mvPos = mtxStart.GetTranslation() +
|
|
cMath::RandRectVector3f(mpData->mvMinStartPos, mpData->mvMaxStartPos);
|
|
} else if (mpData->mStartPosType == ePEStartPosType_Sphere) {
|
|
cVector2f vRot = cMath::RandRectVector2f(mpData->mvMinStartAngles,
|
|
mpData->mvMaxStartAngles);
|
|
cMatrixf mtxRot = cMath::MatrixRotate(vRot, eEulerRotationOrder_XYZ);
|
|
cVector3f vPos = cVector3f(0, cMath::RandRectf(mpData->mfMinStartRadius, mpData->mfMaxStartRadius), 0);
|
|
|
|
apParticle->mvPos = mtxStart.GetTranslation() + cMath::MatrixMul(mtxRot, vPos);
|
|
}
|
|
|
|
// NEW
|
|
|
|
// if (mpData->mVBMeshData)
|
|
// {
|
|
/*
|
|
cVector3f vTrans = mtxStart.GetTranslation();
|
|
posI = cMath::RandRectl(0,mpData->mVBMeshData->GetVertexNum()-1);
|
|
vTrans.x += mpData->mpfMeshVtxData[posI*4];
|
|
vTrans.y += mpData->mpfMeshVtxData[posI*4 + 1];
|
|
vTrans.z += mpData->mpfMeshVtxData[posI*4 + 2];
|
|
|
|
apParticle->mvPos = vTrans;
|
|
*/
|
|
// apParticle->mvPos = mtxStart.GetTranslation() + mpData->mVBMeshData->GetVector3( eVertexFlag_Position, cMath::RandRectl(0,mpData->mVBMeshData->GetVertexNum()-1) );
|
|
// ++posI;
|
|
// if ( posI == mpData->mVBMeshData->GetVertexNum() )
|
|
// posI = 0;
|
|
// }
|
|
|
|
// ---
|
|
|
|
apParticle->mvLastPos = apParticle->mvPos;
|
|
apParticle->mvLastCollidePos = apParticle->mvPos;
|
|
|
|
////////////////////////////////////
|
|
// Start Velocity
|
|
|
|
// Sphere or box start
|
|
if (mpData->mStartVelType == ePEStartPosType_Box) {
|
|
apParticle->mvVel = cMath::RandRectVector3f(mpData->mvMinStartVel, mpData->mvMaxStartVel);
|
|
} else if (mpData->mStartVelType == ePEStartPosType_Sphere) {
|
|
cVector2f vRot = cMath::RandRectVector2f(mpData->mvMinStartVelAngles,
|
|
mpData->mvMaxStartVelAngles);
|
|
cMatrixf mtxRot = cMath::MatrixRotate(vRot, eEulerRotationOrder_XYZ);
|
|
cVector3f vPos = cVector3f(0, cMath::RandRectf(mpData->mfMinStartVelSpeed, mpData->mfMaxStartVelSpeed), 0);
|
|
|
|
apParticle->mvVel = cMath::MatrixMul(mtxRot, vPos);
|
|
}
|
|
|
|
// If it uses the direction,
|
|
if (mpData->mbUsesDirection && mpData->mCoordSystem == eParticleEmitter3DCoordSystem_World) {
|
|
apParticle->mvVel = cMath::MatrixMul(mtxStart.GetRotation(), apParticle->mvVel);
|
|
}
|
|
|
|
apParticle->mfMaxSpeed = cMath::RandRectf(mpData->mfMinVelMaximum, mpData->mfMaxVelMaximum);
|
|
|
|
apParticle->mfSpeedMul = cMath::RandRectf(mpData->mfMinSpeedMultiply, mpData->mfMaxSpeedMultiply);
|
|
|
|
////////////////////////////////////
|
|
// Start Acceleration
|
|
apParticle->mvAcc = cMath::RandRectVector3f(mpData->mvMinStartAcc, mpData->mvMaxStartAcc);
|
|
|
|
// NEW
|
|
////////////////////////////////////
|
|
// Start Spin Velocity
|
|
if (mpData->mPartSpinType == ePEPartSpinType_Constant) {
|
|
apParticle->mfSpinVel = cMath::RandRectf(mpData->mfMinSpinRange, mpData->mfMaxSpinRange);
|
|
} else if (mpData->mPartSpinType == ePEPartSpinType_Movement) {
|
|
apParticle->mfSpinFactor = cMath::RandRectf(mpData->mfMinSpinRange, mpData->mfMaxSpinRange);
|
|
apParticle->mfSpinVel = 0.0f;
|
|
}
|
|
apParticle->mfSpin = cMath::RandRectf(0.0f, k2Pif);
|
|
|
|
////////////////////////////////////
|
|
// Start Revolution Velocity
|
|
apParticle->mvRevolutionVel = cMath::RandRectVector3f(mpData->mvMinRevVel, mpData->mvMaxRevVel);
|
|
|
|
// ---
|
|
|
|
///////////////////////////////////
|
|
// Life Span
|
|
apParticle->mfStartLife = cMath::RandRectf(mpData->mfMinLifeSpan, mpData->mfMaxLifeSpan);
|
|
apParticle->mfLife = apParticle->mfStartLife;
|
|
|
|
apParticle->mfLifeSize_MiddleStart = apParticle->mfLife * (1 - mpData->mfMiddleRelSizeTime);
|
|
apParticle->mfLifeSize_MiddleEnd = apParticle->mfLife * (1 - (mpData->mfMiddleRelSizeTime +
|
|
mpData->mfMiddleRelSizeLength));
|
|
|
|
apParticle->mfLifeColor_MiddleStart = apParticle->mfLife * (1 - mpData->mfMiddleRelColorTime);
|
|
apParticle->mfLifeColor_MiddleEnd = apParticle->mfLife * (1 - (mpData->mfMiddleRelColorTime +
|
|
mpData->mfMiddleRelColorLength));
|
|
|
|
/*Log("Created particle with Pos: (%s) Color: (%s) Size (%s) Vel: (%s) Acc: (%s) Life: %f SizeMiddleStart: %f SizeMiddleEnd: %f\n",
|
|
apParticle->mvPos.ToString().c_str(),
|
|
apParticle->mColor.ToString().c_str(),
|
|
apParticle->mvSize.ToString().c_str(),
|
|
apParticle->mvVel.ToString().c_str(),
|
|
apParticle->mvAcc.ToString().c_str(),
|
|
apParticle->mfLife,
|
|
apParticle->mfLifeSize_MiddleStart,
|
|
apParticle->mfLifeSize_MiddleEnd);*/
|
|
// NEW
|
|
/////////////////////////////////////
|
|
// Beam Specific
|
|
if (mPEType == ePEType_Beam) {
|
|
/*
|
|
if (apParticle->mvBeamPoints.size() == 0 )
|
|
{
|
|
for (int i = 0; i < (int) mpData->mvBeamNoisePoints.size(); ++i)
|
|
apParticle->mvBeamPoints.push_back(cVector(0.0f));
|
|
}
|
|
|
|
|
|
int j = 1;
|
|
cVector3f vLFPointPos = apParticle->mvPos + apParticle->mvVel * mpData->mvBeamNoisePoints.at(mpData->mvLFIndices[j]).fRelToBeamPos;
|
|
cVector3f vLastLFPointPos = apParticle->mvPos;
|
|
cVector3f vDir;
|
|
for ( int i = 1; i < (int) mpData->mvBeamNoisePoints.size(); ++i )
|
|
{
|
|
apParticle->mvBeamPoints[i] = vLastLFPointPos + vDir * mpData->mvBeamNoisePoints[i].fRelToBendPos;
|
|
|
|
switch (mpData->mvBeamNoisePoints[i].noiseType)
|
|
{
|
|
|
|
case ePENoiseType_HighFreq:
|
|
apParticle->mvBeamPoints[i] += cMath::RandRectVector3f(mpData->mvMinHighFreqNoise, mpData->mvMaxHighFreqNoise);
|
|
break;
|
|
case ePENoiseType_LowFreq:
|
|
++j;
|
|
vLastLFPointPos = vLFPointPos;
|
|
vLFPointPos = apParticle->mvPos + apParticle->mvVel * mpData->mvBeamNoisePoints.at(mpData->mvLFIndices[j]).fRelToBeamPos + cMath::RandRectVector3f(mpData->mvMinLowFreqNoise, mpData->mvMaxLowFreqNoise);
|
|
vDir = vLFPointPos - vLastLFPointPos;
|
|
break;
|
|
case ePENoiseType_Both:
|
|
apParticle->mvBeamPoints[i] += cMath::RandRectVector3f(mpData->mvMinHighFreqNoise, mpData->mvMaxHighFreqNoise);
|
|
++j;
|
|
vLastLFPointPos = vLFPointPos;
|
|
vLFPointPos = apParticle->mvPos + apParticle->mvVel * mpData->mvBeamNoisePoints.at(mpData->mvLFIndices[j]).fRelToBeamPos + cMath::RandRectVector3f(mpData->mvMinLowFreqNoise, mpData->mvMaxLowFreqNoise);
|
|
vDir = vLFPointPos - vLastLFPointPos;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
// ---
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
|
|
void cParticleEmitter3D_UserData::UpdateMotion(float afTimeStep) {
|
|
///////////////////////////////////////////////
|
|
// If not rendered this previous frame check if it should be paused.
|
|
// To be safe skip systems that has a parent...
|
|
if (mbDying == false && mbRespawn && mpParentSystem->GetParent() == NULL) {
|
|
if (GetGlobalRenderCount() != cRenderList::GetGlobalRenderCount()) {
|
|
if (mlUpdateCount > 120) {
|
|
return;
|
|
}
|
|
mlUpdateCount++;
|
|
} else {
|
|
mlUpdateCount = 0;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// Check if the emitter is ready to start.
|
|
if (mfTime < mpData->mfStartTimeOffset) {
|
|
mfTime += afTimeStep;
|
|
return;
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// Delay check
|
|
if (mbPaused) {
|
|
mfPauseCount -= afTimeStep;
|
|
if (mfPauseCount <= 0) {
|
|
mbPaused = false;
|
|
|
|
mfPauseWaitCount = cMath::RandRectf(mpData->mfMinPauseInterval, mpData->mfMaxPauseInterval);
|
|
}
|
|
} else if (mpData->mfMinPauseLength > 0 && mpData->mfMinPauseInterval > 0) {
|
|
mfPauseWaitCount -= afTimeStep;
|
|
if (mfPauseWaitCount <= 0) {
|
|
mfPauseCount = cMath::RandRectf(mpData->mfMinPauseLength, mpData->mfMaxPauseLength);
|
|
mbPaused = true;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// Particle creation
|
|
if (mbPaused == false && mlNumOfParticles < mlMaxParticles) {
|
|
mfCreateCount += mpData->mfParticlesPerSecond * afTimeStep;
|
|
|
|
while (mfCreateCount >= 0.99999f && (mlNumOfParticles < mlMaxParticles)) {
|
|
SetParticleDefaults(CreateParticle());
|
|
mfCreateCount -= 1.0f;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// Collision Update
|
|
bool bColliding = false;
|
|
if (mpData->mbCollides) {
|
|
mfCollideCount -= afTimeStep;
|
|
if (mfCollideCount <= 0) {
|
|
mfCollideCount = 1.0f / (float)mpData->mlCollisionUpdateRate;
|
|
bColliding = true;
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// Particle update
|
|
for (unsigned int i = 0; i < mlNumOfParticles; ++i) {
|
|
cParticle *pParticle = mvParticles[i];
|
|
|
|
////////////
|
|
// Position Update
|
|
pParticle->mvLastPos = pParticle->mvPos;
|
|
|
|
pParticle->mvPos += pParticle->mvVel * afTimeStep;
|
|
|
|
////////////
|
|
// Speed Update
|
|
pParticle->mvVel += pParticle->mvAcc * afTimeStep;
|
|
|
|
// gravity
|
|
switch (mpData->mGravityType) {
|
|
case ePEGravityType_None: {
|
|
break;
|
|
}
|
|
case ePEGravityType_Vector: {
|
|
pParticle->mvVel += mpData->mvGravityAcc * afTimeStep;
|
|
break;
|
|
}
|
|
case ePEGravityType_Center: {
|
|
cVector3f vDir;
|
|
cMatrixf mtxStart;
|
|
if (mpData->mCoordSystem == eParticleEmitter3DCoordSystem_World) {
|
|
vDir = pParticle->mvPos - GetWorldMatrix().GetTranslation();
|
|
} else {
|
|
// Perhaps on mvPos is needed.. and no subtraction.
|
|
vDir = pParticle->mvPos - GetLocalMatrix().GetTranslation();
|
|
}
|
|
|
|
vDir.Normalise();
|
|
|
|
pParticle->mvVel += vDir * mpData->mvGravityAcc.y * afTimeStep;
|
|
|
|
break;
|
|
}
|
|
case ePEGravityType_LastEnum:
|
|
break;
|
|
}
|
|
|
|
if (pParticle->mfMaxSpeed > 0) {
|
|
float fSpeed = pParticle->mvVel.Length();
|
|
if (fSpeed > pParticle->mfMaxSpeed) {
|
|
pParticle->mvVel = (pParticle->mvVel / fSpeed) * pParticle->mfMaxSpeed;
|
|
}
|
|
}
|
|
|
|
if (pParticle->mfSpeedMul != 0 && pParticle->mfSpeedMul != 1) {
|
|
pParticle->mvVel = pParticle->mvVel * pow(pParticle->mfSpeedMul, afTimeStep);
|
|
}
|
|
|
|
// NEW
|
|
///////////
|
|
// Spin Update
|
|
if (mpData->mbUsePartSpin) {
|
|
pParticle->mfSpin += pParticle->mfSpinVel * afTimeStep;
|
|
|
|
if (mpData->mPartSpinType == ePEPartSpinType_Movement)
|
|
pParticle->mfSpinVel = pParticle->mvVel.Length() * pParticle->mfSpinFactor;
|
|
|
|
if (pParticle->mfSpin >= k2Pif)
|
|
pParticle->mfSpin -= k2Pif;
|
|
else if (pParticle->mfSpin <= -k2Pif)
|
|
pParticle->mfSpin += k2Pif;
|
|
}
|
|
|
|
// ---
|
|
|
|
// NEW
|
|
// Revolution
|
|
if (mbUseRevolution) {
|
|
// pParticle->mvRevolution += pParticle->mvRevolutionVel * afTimeStep;
|
|
cMatrixf mtxRotationMatrix = cMath::MatrixRotate(pParticle->mvRevolutionVel * afTimeStep, eEulerRotationOrder_XYZ);
|
|
pParticle->mvPos = cMath::MatrixMul(mtxRotationMatrix, pParticle->mvPos);
|
|
pParticle->mvVel = cMath::MatrixMul(mtxRotationMatrix, pParticle->mvVel);
|
|
}
|
|
|
|
// ---
|
|
|
|
////////////
|
|
// Collison update
|
|
if (bColliding) {
|
|
cVector3f vPos, vNormal;
|
|
|
|
if (mpData->CheckCollision(pParticle->mvLastCollidePos, pParticle->mvPos,
|
|
mpWorld->GetPhysicsWorld(),
|
|
&vNormal, &vPos)) {
|
|
// Log("Coll pos: %s\n",vPos.ToString().c_str());
|
|
// Log("Coll normal: %s\n",vNormal.ToString().c_str());
|
|
|
|
pParticle->mvPos = vPos;
|
|
|
|
float fSpeed = pParticle->mvVel.Length();
|
|
|
|
cVector3f vReflection = pParticle->mvVel -
|
|
(vNormal * 2 * cMath::Vector3Dot(pParticle->mvVel, vNormal));
|
|
vReflection.Normalise();
|
|
|
|
pParticle->mvVel = vReflection * (fSpeed * pParticle->mfBounceAmount);
|
|
|
|
pParticle->mlBounceCount--;
|
|
if (pParticle->mlBounceCount <= 0) {
|
|
pParticle->mfLife = 0;
|
|
}
|
|
}
|
|
|
|
pParticle->mvLastCollidePos = pParticle->mvPos;
|
|
}
|
|
|
|
////////////
|
|
// Life Update
|
|
pParticle->mfLife -= afTimeStep;
|
|
|
|
if (pParticle->mfLife <= 0) {
|
|
if (mbRespawn) {
|
|
if (mbPaused)
|
|
SwapRemove(i);
|
|
else
|
|
SetParticleDefaults(pParticle);
|
|
} else {
|
|
SwapRemove(i);
|
|
mlMaxParticles--;
|
|
|
|
if (mlMaxParticles <= 0) {
|
|
mbDying = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////
|
|
// Subdiv Update
|
|
|
|
if (mpData->mSubDivType == ePESubDivType_Animation) {
|
|
float fLifePercent = (1.0f - (pParticle->mfLife / pParticle->mfStartLife));
|
|
pParticle->mlSubDivNum = (int)(fLifePercent * (float)mvSubDivUV.size() - 0.0001f);
|
|
}
|
|
|
|
////////////
|
|
// Color Update
|
|
|
|
// Start
|
|
if (pParticle->mfLife > pParticle->mfLifeColor_MiddleStart) {
|
|
float fT = (pParticle->mfLife - pParticle->mfLifeColor_MiddleStart) /
|
|
(pParticle->mfStartLife - pParticle->mfLifeColor_MiddleStart);
|
|
|
|
pParticle->mColor = (pParticle->mStartColor * mpData->mStartRelColor * fT) +
|
|
(pParticle->mStartColor * mpData->mMiddleRelColor * (1 - fT));
|
|
}
|
|
// Middle
|
|
else if (pParticle->mfLife > pParticle->mfLifeColor_MiddleEnd) {
|
|
pParticle->mColor = pParticle->mStartColor * mpData->mMiddleRelColor;
|
|
}
|
|
// End
|
|
else {
|
|
float fT = pParticle->mfLife / pParticle->mfLifeColor_MiddleEnd;
|
|
|
|
pParticle->mColor = (pParticle->mStartColor * mpData->mMiddleRelColor * fT) +
|
|
(pParticle->mStartColor * mpData->mEndRelColor * (1 - fT));
|
|
}
|
|
|
|
if (mpData->mbMultiplyRGBWithAlpha) {
|
|
pParticle->mColor.r *= pParticle->mColor.a;
|
|
pParticle->mColor.g *= pParticle->mColor.a;
|
|
pParticle->mColor.b *= pParticle->mColor.a;
|
|
}
|
|
|
|
////////////
|
|
// Size Update
|
|
|
|
// Start
|
|
if (pParticle->mfLife > pParticle->mfLifeSize_MiddleStart) {
|
|
float fT = (pParticle->mfLife - pParticle->mfLifeSize_MiddleStart) /
|
|
(pParticle->mfStartLife - pParticle->mfLifeSize_MiddleStart);
|
|
|
|
pParticle->mvSize = (pParticle->mvStartSize * mpData->mfStartRelSize * fT) +
|
|
(pParticle->mvStartSize * mpData->mfMiddleRelSize * (1 - fT));
|
|
}
|
|
// Middle
|
|
else if (pParticle->mfLife > pParticle->mfLifeSize_MiddleEnd) {
|
|
pParticle->mvSize = pParticle->mvStartSize * mpData->mfMiddleRelSize;
|
|
}
|
|
// End
|
|
else {
|
|
float fT = pParticle->mfLife / pParticle->mfLifeSize_MiddleEnd;
|
|
|
|
pParticle->mvSize = (pParticle->mvStartSize * mpData->mfMiddleRelSize * fT) +
|
|
(pParticle->mvStartSize * mpData->mfEndRelSize * (1 - fT));
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////
|
|
// Frame Update
|
|
if (mvMaterials->size() > 1) {
|
|
mfFrame += mpData->mfFrameStep * afTimeStep;
|
|
if (mfFrame >= mpData->mfMaxFrameTime) {
|
|
mfFrame = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------
|
|
} // namespace hpl
|