marko10_000
/
openclonk
forked from Mirrors/openclonk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
openclonk/src/landscape/C4Particles.cpp

1538 lines
45 KiB
C++
Raw Blame History

/*
* OpenClonk, http://www.openclonk.org
*
* Copyright (c) 2013-2016, The OpenClonk Team and contributors
*
* Distributed under the terms of the ISC license; see accompanying file
* "COPYING" for details.
*
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
* See accompanying file "TRADEMARK" for details.
*
* To redistribute this file separately, substitute the full license texts
* for the above references.
*/
#include "C4Include.h"
#include "landscape/C4Particles.h"
// headers for particle loading
#include "lib/C4Log.h"
#include "c4group/C4Components.h"
#include "config/C4Config.h"
#ifndef USE_CONSOLE
// headers for particle execution
#include "script/C4Aul.h"
#include "game/C4Application.h"
#include "script/C4Value.h"
#include "script/C4ValueArray.h"
#include "landscape/C4Material.h"
#include "object/C4MeshAnimation.h"
#include "graphics/C4DrawGL.h"
#include "lib/C4Random.h"
#include "landscape/C4Landscape.h"
#include "landscape/C4Weather.h"
#include "object/C4Object.h"
#endif
void C4ParticleDefCore::CompileFunc(StdCompiler * pComp)
{
pComp->Value(mkNamingAdapt(toC4CStrBuf(Name), "Name", ""));
pComp->Value(mkNamingAdapt(GfxFace, "Face"));
}
C4ParticleDefCore::C4ParticleDefCore()
{
GfxFace.Default();
}
bool C4ParticleDefCore::Compile(char *particle_source, const char *name)
{
return CompileFromBuf_LogWarn<StdCompilerINIRead>(mkNamingAdapt(*this, "Particle"),
StdStrBuf(particle_source), name);
}
C4ParticleDef::C4ParticleDef() : C4ParticleDefCore()
{
// zero fields
Gfx.Default();
// link into list
if (!Particles.definitions.first)
{
previous = NULL;
Particles.definitions.first = this;
}
else
{
previous = Particles.definitions.last;
previous->next = this;
}
Particles.definitions.last = this;
next = 0;
}
C4ParticleDef::~C4ParticleDef()
{
// clear
Clear();
// unlink from list
if (previous) previous->next = next; else Particles.definitions.first = next;
if (next) next->previous = previous; else Particles.definitions.last = previous;
}
void C4ParticleDef::Clear()
{
Name.Clear();
}
bool C4ParticleDef::Load(C4Group &group)
{
// store file
Filename.Copy(group.GetFullName());
// load
char *particle_source;
if (group.LoadEntry(C4CFN_ParticleCore,&particle_source,NULL,1))
{
if (!Compile(particle_source, Filename.getData()))
{
DebugLogF("invalid particle def at '%s'", group.GetFullName().getData());
delete [] particle_source; return false;
}
delete [] particle_source;
// load graphics
if (!Gfx.Load(group, C4CFN_DefGraphics, C4FCT_Full, C4FCT_Full, false, C4SF_MipMap))
{
DebugLogF("particle %s has no valid graphics defined", Name.getData());
return false;
}
// set facet, if assigned - otherwise, assume full surface
if (GfxFace.Wdt) Gfx.Set(Gfx.Surface, GfxFace.x, GfxFace.y, GfxFace.Wdt, GfxFace.Hgt);
// set phase num
int32_t Q; Gfx.GetPhaseNum(PhasesX, Q);
Length = PhasesX * Q;
if (!Length)
{
DebugLogF("invalid facet for particle '%s'", Name.getData());
return false;
}
// calc aspect
Aspect=(float) Gfx.Hgt/Gfx.Wdt;
// particle overloading
C4ParticleDef *def_overload;
if ((def_overload = Particles.definitions.GetDef(Name.getData(), this)))
{
if (Config.Graphics.VerboseObjectLoading >= 1)
{ char ostr[250]; sprintf(ostr,LoadResStr("IDS_PRC_DEFOVERLOAD"),def_overload->Name.getData(),"<particle>"); Log(ostr); }
delete def_overload;
}
// success
return true;
}
return false;
}
bool C4ParticleDef::Reload()
{
// no file?
if (!Filename[0]) return false;
// open group
C4Group group;
if (!group.Open(Filename.getData())) return false;
// reset class
Clear();
// load
return Load(group);
}
#ifndef USE_CONSOLE
const int C4Particle::DrawingData::vertexCountPerParticle(4);
void C4Particle::DrawingData::SetPosition(float x, float y, float size, float rotation, float stretch)
{
if (size != originalSize || stretch != currentStretch)
{
currentStretch = stretch;
originalSize = std::max(size, 0.0001f); // a size of zero results in undefined behavior
sizeX = originalSize / aspect;
sizeY = originalSize * currentStretch;
}
if (rotation == 0.f)
{
vertices[0].x = x - sizeX + offsetX;
vertices[0].y = y + sizeY + offsetY;
vertices[1].x = x - sizeX + offsetX;
vertices[1].y = y - sizeY + offsetY;
vertices[2].x = x + sizeX + offsetX;
vertices[2].y = y + sizeY + offsetY;
vertices[3].x = x + sizeX + offsetX;
vertices[3].y = y - sizeY + offsetY;
}
else
{
float sine = sinf(rotation);
float cosine = cosf(rotation);
vertices[0].x = x + ((-sizeX) * cosine - (+sizeY) * sine) + offsetX;
vertices[0].y = y + ((-sizeX) * sine + (+sizeY) * cosine) + offsetY;
vertices[1].x = x + ((-sizeX) * cosine - (-sizeY) * sine) + offsetX;
vertices[1].y = y + ((-sizeX) * sine + (-sizeY) * cosine) + offsetY;
vertices[2].x = x + ((+sizeX) * cosine - (+sizeY) * sine) + offsetX;
vertices[2].y = y + ((+sizeX) * sine + (+sizeY) * cosine) + offsetY;
vertices[3].x = x + ((+sizeX) * cosine - (-sizeY) * sine) + offsetX;
vertices[3].y = y + ((+sizeX) * sine + (-sizeY) * cosine) + offsetY;
}
}
void C4Particle::DrawingData::SetPhase(int phase, C4ParticleDef *sourceDef)
{
this->phase = phase;
phase = phase % sourceDef->Length;
int offsetY = phase / sourceDef->PhasesX;
int offsetX = phase % sourceDef->PhasesX;
float wdt = 1.0f / (float)sourceDef->PhasesX;
int numOfLines = sourceDef->Length / sourceDef->PhasesX;
float hgt = 1.0f / (float)numOfLines;
float x = wdt * (float)offsetX;
float y = hgt * (float)offsetY;
float xr = x + wdt;
float yr = y + hgt;
vertices[0].u = x; vertices[0].v = yr;
vertices[1].u = x; vertices[1].v = y;
vertices[2].u = xr; vertices[2].v = yr;
vertices[3].u = xr; vertices[3].v = y;
}
C4ParticleValueProvider & C4ParticleValueProvider::operator= (const C4ParticleValueProvider &other)
{
startValue = other.startValue;
endValue = other.endValue;
currentValue = other.currentValue;
rerollInterval = other.rerollInterval;
smoothing = other.smoothing;
valueFunction = other.valueFunction;
isConstant = other.isConstant;
keyFrameCount = other.keyFrameCount;
if (keyFrameCount > 0)
{
keyFrames.reserve(2 * keyFrameCount);
keyFrames.assign(other.keyFrames.begin(), other.keyFrames.end());
}
typeOfValueToChange = other.typeOfValueToChange;
switch (typeOfValueToChange)
{
case VAL_TYPE_FLOAT:
floatValueToChange = other.floatValueToChange;
break;
case VAL_TYPE_INT:
intValueToChange = other.intValueToChange;
break;
case VAL_TYPE_KEYFRAMES:
keyFrameIndex = other.keyFrameIndex;
break;
default:
assert (false && "Trying to copy C4ParticleValueProvider with invalid value type");
break;
}
// copy the other's children, too
for (std::vector<C4ParticleValueProvider*>::const_iterator iter = other.childrenValueProviders.begin(); iter != other.childrenValueProviders.end(); ++iter)
{
childrenValueProviders.push_back(new C4ParticleValueProvider(**iter)); // custom copy constructor usage
}
return (*this);
}
void C4ParticleValueProvider::SetParameterValue(int type, const C4Value &value, float C4ParticleValueProvider::*floatVal, int C4ParticleValueProvider::*intVal, size_t keyFrameIndex)
{
// just an atomic data type
if (value.GetType() == C4V_Int)
{
if (type == VAL_TYPE_FLOAT)
this->*floatVal = (float)value.getInt();
else if (type == VAL_TYPE_INT)
this->*intVal = value.getInt();
else if (type == VAL_TYPE_KEYFRAMES)
this->keyFrames[keyFrameIndex] = (float)value.getInt();
}
else if (value.GetType() == C4V_Array)
{
// might be another value provider!
C4ParticleValueProvider *child = new C4ParticleValueProvider();
childrenValueProviders.push_back(child);
child->Set(*value.getArray());
child->typeOfValueToChange = type;
if (type == VAL_TYPE_FLOAT)
{
child->floatValueToChange = floatVal;
}
else if (type == VAL_TYPE_INT)
{
child->intValueToChange = intVal;
}
else if (type == VAL_TYPE_KEYFRAMES)
{
child->keyFrameIndex = keyFrameIndex;
}
}
else // invalid
{
if (type == VAL_TYPE_FLOAT)
this->*floatVal = 0.f;
else if (type == VAL_TYPE_INT)
this->*intVal = 0;
else if (type == VAL_TYPE_KEYFRAMES)
this->keyFrames[keyFrameIndex] = 0.f;
}
}
void C4ParticleValueProvider::UpdatePointerValue(C4Particle *particle, C4ParticleValueProvider *parent)
{
switch (typeOfValueToChange)
{
case VAL_TYPE_FLOAT:
parent->*floatValueToChange = GetValue(particle);
break;
case VAL_TYPE_INT:
parent->*intValueToChange = (int) GetValue(particle);
break;
case VAL_TYPE_KEYFRAMES:
parent->keyFrames[keyFrameIndex] = GetValue(particle);
break;
default:
assert (false);
}
}
void C4ParticleValueProvider::UpdateChildren(C4Particle *particle)
{
for (std::vector<C4ParticleValueProvider*>::iterator iter = childrenValueProviders.begin(); iter != childrenValueProviders.end(); ++iter)
{
(*iter)->UpdatePointerValue(particle, this);
}
}
void C4ParticleValueProvider::FloatifyParameterValue(float C4ParticleValueProvider::*value, float denominator, size_t keyFrameIndex)
{
if (value == 0)
this->keyFrames[keyFrameIndex] /= denominator;
else
this->*value /= denominator;
for (std::vector<C4ParticleValueProvider*>::iterator iter = childrenValueProviders.begin(); iter != childrenValueProviders.end(); ++iter)
{
C4ParticleValueProvider *child = *iter;
if (value == 0)
{
if (child->typeOfValueToChange == VAL_TYPE_KEYFRAMES && child->keyFrameIndex == keyFrameIndex)
child->Floatify(denominator);
}
else
{
if (child->floatValueToChange == value)
child->Floatify(denominator);
}
}
}
void C4ParticleValueProvider::Floatify(float denominator)
{
assert (denominator != 0.f && "Trying to floatify C4ParticleValueProvider with denominator of 0");
if (valueFunction == &C4ParticleValueProvider::Direction)
{
FloatifyParameterValue(&C4ParticleValueProvider::startValue, 1000.f);
return;
}
FloatifyParameterValue(&C4ParticleValueProvider::startValue, denominator);
FloatifyParameterValue(&C4ParticleValueProvider::endValue, denominator);
FloatifyParameterValue(&C4ParticleValueProvider::currentValue, denominator);
// special treatment for keyframes
if (valueFunction == &C4ParticleValueProvider::KeyFrames)
{
for (size_t i = 0; i < keyFrameCount; ++i)
{
FloatifyParameterValue(0, 1000.f, 2 * i); // even numbers are the time values
FloatifyParameterValue(0, denominator, 2 * i + 1); // odd numbers are the actual values
}
}
else if (valueFunction == &C4ParticleValueProvider::Speed || valueFunction == &C4ParticleValueProvider::Wind || valueFunction == &C4ParticleValueProvider::Gravity)
{
FloatifyParameterValue(&C4ParticleValueProvider::speedFactor, 1000.0f);
}
else if (valueFunction == &C4ParticleValueProvider::Step)
{
FloatifyParameterValue(&C4ParticleValueProvider::maxValue, denominator);
}
else if (valueFunction == &C4ParticleValueProvider::Sin || valueFunction == &C4ParticleValueProvider::Cos)
{
FloatifyParameterValue(&C4ParticleValueProvider::parameterValue, 1.0f);
FloatifyParameterValue(&C4ParticleValueProvider::maxValue, denominator);
}
}
void C4ParticleValueProvider::RollRandom(const C4Particle *forParticle)
{
if (randomSeed == -1) return RollRandomUnseeded();
return RollRandomSeeded(forParticle);
}
void C4ParticleValueProvider::RollRandomUnseeded()
{
float range = endValue - startValue;
float rnd = (float)(SafeRandom(RAND_MAX)) / (float)(RAND_MAX);
currentValue = startValue + rnd * range;
}
void C4ParticleValueProvider::RollRandomSeeded(const C4Particle *forParticle)
{
// We need a particle-local additional seed.
// Since this is by no means synchronisation relevant and since the particles lie on the heap
// we just use the address here.
// These conversion steps here just make it explicit that we do not care about the upper 32bit
// of a pointer in case it's too long.
const std::uintptr_t ourAddress = reinterpret_cast<std::uintptr_t>(forParticle);
const unsigned long mostSignificantBits = ourAddress & 0xffffffff;
const unsigned long particleLocalSeed = mostSignificantBits;
// The actual seed is then calculated from the last random value (or initial seed) and the local seed.
unsigned long seed = static_cast<unsigned long>(randomSeed) + particleLocalSeed;
// This is a simple linear congruential generator which should suffice for our graphical effects.
// https://en.wikipedia.org/wiki/Linear_congruential_generator
const unsigned long maxRandomValue = 32767;
auto roll = [&seed, &maxRandomValue]()
{
const unsigned long value = seed * 1103515245l + 12345l;
return static_cast<unsigned int>(value / 65536) % (maxRandomValue + 1);
};
const unsigned int randomNumber = roll();
assert(randomNumber >= 0 && randomNumber <= maxRandomValue);
// Now force the integer-random-value into our float-range.
const float range = endValue - startValue;
const float rnd = static_cast<float>(randomNumber) / static_cast<float>(maxRandomValue);
currentValue = startValue + rnd * range;
// Finally update our seed to the new random value.
randomSeed = static_cast<int> (randomNumber);
}
float C4ParticleValueProvider::GetValue(C4Particle *forParticle)
{
UpdateChildren(forParticle);
return (this->*valueFunction)(forParticle);
}
float C4ParticleValueProvider::Linear(C4Particle *forParticle)
{
return startValue + (endValue - startValue) * forParticle->GetRelativeAge();
}
float C4ParticleValueProvider::Const(C4Particle *forParticle)
{
return startValue;
}
float C4ParticleValueProvider::Random(C4Particle *forParticle)
{
// We need to roll again if..
const bool needToReevaluate =
// .. we haven't rolled yet
alreadyRolled == 0
// .. we are still in the intialization stage (and thus, this value provider could be an intialization term for multiple particles)
|| (forParticle->lifetime == forParticle->startingLifetime)
// .. or the reroll interval is set and expired.
|| (rerollInterval != 0 && ((int)forParticle->GetAge() % rerollInterval == 0));
if (needToReevaluate)
{
alreadyRolled = 1;
RollRandom(forParticle);
}
return currentValue;
}
float C4ParticleValueProvider::Direction(C4Particle *forParticle)
{
float distX = forParticle->currentSpeedX;
float distY = forParticle->currentSpeedY;
if (distX == 0.f) return distY > 0.f ? M_PI : 0.f;
if (distY == 0.f) return distX < 0.f ? 3.0f * M_PI_2 : M_PI_2;
return startValue * (atan2(distY, distX) + (float)M_PI_2);
}
float C4ParticleValueProvider::Step(C4Particle *forParticle)
{
float value = currentValue + startValue * forParticle->GetAge() / delay;
if (maxValue != 0.0f && value > maxValue) value = maxValue;
return value;
}
float C4ParticleValueProvider::KeyFrames(C4Particle *forParticle)
{
float age = forParticle->GetRelativeAge();
// todo, implement smoothing
//if (smoothing == 0) // linear
{
for (size_t i = 0; i < keyFrameCount; ++i)
{
if (age > keyFrames[i * 2]) continue;
assert(i >= 1);
float x1 = keyFrames[(i - 1) * 2];
float x2 = keyFrames[i * 2];
float y1 = keyFrames[(i - 1) * 2 + 1];
float y2 = keyFrames[i * 2 + 1];
float position = (age - x1) / (x2 - x1);
float totalRange = (y2 - y1);
float value = position * totalRange + y1;
return value;
}
}
return startValue;
}
float C4ParticleValueProvider::Sin(C4Particle *forParticle)
{
return sin(parameterValue * M_PI / 180.0f) * maxValue + startValue;
}
float C4ParticleValueProvider::Cos(C4Particle *forParticle)
{
return cos(parameterValue * M_PI / 180.0f) * maxValue + startValue;
}
float C4ParticleValueProvider::Speed(C4Particle *forParticle)
{
float distX = forParticle->currentSpeedX;
float distY = forParticle->currentSpeedY;
float speed = sqrtf((distX * distX) + (distY * distY));
return startValue + speedFactor * speed;
}
float C4ParticleValueProvider::Wind(C4Particle *forParticle)
{
return startValue + (0.01f * speedFactor * ::Weather.GetWind((int)forParticle->positionX, (int)forParticle->positionY));
}
float C4ParticleValueProvider::Gravity(C4Particle *forParticle)
{
return startValue + (speedFactor * ::Landscape.GetGravity());
}
void C4ParticleValueProvider::SetType(C4ParticleValueProviderID what)
{
switch (what)
{
case C4PV_Const:
valueFunction = &C4ParticleValueProvider::Const;
break;
case C4PV_Linear:
valueFunction = &C4ParticleValueProvider::Linear;
break;
case C4PV_Random:
valueFunction = &C4ParticleValueProvider::Random;
break;
case C4PV_Direction:
valueFunction = &C4ParticleValueProvider::Direction;
break;
case C4PV_Step:
valueFunction = &C4ParticleValueProvider::Step;
break;
case C4PV_KeyFrames:
valueFunction = &C4ParticleValueProvider::KeyFrames;
break;
case C4PV_Sin:
valueFunction = &C4ParticleValueProvider::Sin;
break;
case C4PV_Cos:
valueFunction = &C4ParticleValueProvider::Cos;
break;
case C4PV_Speed:
valueFunction = &C4ParticleValueProvider::Speed;
break;
case C4PV_Wind:
valueFunction = &C4ParticleValueProvider::Wind;
break;
case C4PV_Gravity:
valueFunction = &C4ParticleValueProvider::Gravity;
break;
default:
assert(false && "Invalid C4ParticleValueProvider ID passed");
};
if (what != C4PV_Const)
{
isConstant = false;
}
}
void C4ParticleValueProvider::Set(const C4ValueArray &fromArray)
{
startValue = endValue = 1.0f;
valueFunction = &C4ParticleValueProvider::Const;
size_t arraySize = (size_t) fromArray.GetSize();
if (arraySize < 2) return;
int type = fromArray[0].getInt();
switch (type)
{
case C4PV_Const:
if (arraySize >= 2)
{
SetType(C4PV_Const);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::startValue);
}
break;
case C4PV_Linear:
if (arraySize >= 3)
{
SetType(C4PV_Linear);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::startValue);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::endValue);
}
break;
case C4PV_Random:
if (arraySize >= 3)
{
SetType(C4PV_Random);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::startValue);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::endValue);
if (arraySize >= 4 && fromArray[3].GetType() != C4V_Type::C4V_Nil)
SetParameterValue(VAL_TYPE_INT, fromArray[3], 0, &C4ParticleValueProvider::rerollInterval);
if (arraySize >= 5 && fromArray[4].GetType() != C4V_Type::C4V_Nil)
SetParameterValue(VAL_TYPE_INT, fromArray[4], 0, &C4ParticleValueProvider::randomSeed);
alreadyRolled = 0;
}
break;
case C4PV_Direction:
if (arraySize >= 2)
{
SetType(C4PV_Direction);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::startValue);
}
break;
case C4PV_Step:
if (arraySize >= 4)
{
SetType(C4PV_Step);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::startValue);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::currentValue);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[3], &C4ParticleValueProvider::delay);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[4], &C4ParticleValueProvider::maxValue);
if (delay == 0.f) delay = 1.f;
}
break;
case C4PV_KeyFrames:
if (arraySize >= 5)
{
SetType(C4PV_KeyFrames);
SetParameterValue(VAL_TYPE_INT, fromArray[1], 0, &C4ParticleValueProvider::smoothing);
keyFrames.resize(arraySize + 4 - 1); // 2*2 additional information floats at the beginning and ending, offset the first array item, though
keyFrameCount = 0;
const size_t startingOffset = 2;
size_t i = startingOffset;
for (; i < arraySize; ++i)
{
SetParameterValue(VAL_TYPE_KEYFRAMES, fromArray[(int32_t)i], 0, 0, 2 + i - startingOffset);
}
keyFrameCount = (i - startingOffset) / 2 + 2;
startValue = keyFrames[2 + 1];
endValue = keyFrames[2 * keyFrameCount - 1];
// add two points for easier interpolation at beginning and ending
keyFrames[0] = -500.f;
keyFrames[1] = keyFrames[2 + 1];
keyFrames[2 * keyFrameCount - 2] = 1500.f;
keyFrames[2 * keyFrameCount - 1] = keyFrames[keyFrameCount - 1 - 2];
}
break;
case C4PV_Sin: // fallthrough
case C4PV_Cos:
if (arraySize >= 3)
{
SetType(static_cast<C4ParticleValueProviderID> (type)); // Sin(parameterValue) * maxValue + startValue
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::parameterValue);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::maxValue);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[3], &C4ParticleValueProvider::startValue);
}
break;
case C4PV_Speed:
if (arraySize >= 3)
{
SetType(C4PV_Speed);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::speedFactor);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::startValue);
}
break;
case C4PV_Wind:
if (arraySize >= 3)
{
SetType(C4PV_Wind);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::speedFactor);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::startValue);
}
break;
case C4PV_Gravity:
if (arraySize >= 3)
{
SetType(C4PV_Gravity);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[1], &C4ParticleValueProvider::speedFactor);
SetParameterValue(VAL_TYPE_FLOAT, fromArray[2], &C4ParticleValueProvider::startValue);
}
break;
default:
throw C4AulExecError("invalid particle value provider supplied");
break;
}
}
void C4ParticleValueProvider::Set(const C4Value &value)
{
C4ValueArray *valueArray= value.getArray();
if (valueArray != 0)
Set(*valueArray);
else
Set((float)value.getInt());
}
void C4ParticleValueProvider::Set(float to)
{
SetType(C4PV_Const);
startValue = endValue = to;
}
C4ParticleProperties::C4ParticleProperties()
{
blitMode = 0;
attachment = C4ATTACH_None;
hasConstantColor = false;
hasCollisionVertex = false;
collisionCallback = 0;
bouncyness = 0.f;
// all values in pre-floatified range (f.e. 0..255 instead of 0..1)
collisionDensity.Set(static_cast<float>(C4M_Solid));
collisionVertex.Set(0.f);
size.Set(8.f);
stretch.Set(1000.f);
forceX.Set(0.f);
forceY.Set(0.f);
speedDampingX.Set(1000.f);
speedDampingY.Set(1000.f);
colorR.Set(255.f);
colorG.Set(255.f);
colorB.Set(255.f);
colorAlpha.Set(255.f);
rotation.Set(0.f);
phase.Set(0.f);
}
void C4ParticleProperties::Floatify()
{
bouncyness /= 1000.f;
collisionDensity.Floatify(1.f);
collisionVertex.Floatify(1000.f);
size.Floatify(2.f);
stretch.Floatify(1000.f);
forceX.Floatify(100.f);
forceY.Floatify(100.f);
speedDampingX.Floatify(1000.f);
speedDampingY.Floatify(1000.f);
colorR.Floatify(255.f);
colorG.Floatify(255.f);
colorB.Floatify(255.f);
colorAlpha.Floatify(255.f);
rotation.Floatify(180.0f / (float)M_PI);
phase.Floatify(1.f);
hasConstantColor = colorR.IsConstant() && colorG.IsConstant() && colorB.IsConstant() && colorAlpha.IsConstant();
}
void C4ParticleProperties::Set(C4PropList *dataSource)
{
if (!dataSource) return;
C4PropList::Iterator iter = dataSource->begin(), end = dataSource->end();
for (;iter != end; ++iter)
{
const C4Property * p = *iter;
C4String *key = p->Key;
assert(key && "PropList returns non-string as key");
const C4Value &property = p->Value;
if(&Strings.P[P_R] == key)
{
colorR.Set(property);
}
else if(&Strings.P[P_G] == key)
{
colorG.Set(property);
}
else if(&Strings.P[P_B] == key)
{
colorB.Set(property);
}
else if(&Strings.P[P_Alpha] == key)
{
colorAlpha.Set(property);
}
else if(&Strings.P[P_ForceX] == key)
{
forceX.Set(property);
}
else if(&Strings.P[P_ForceY] == key)
{
forceY.Set(property);
}
else if(&Strings.P[P_DampingX] == key)
{
speedDampingX.Set(property);
}
else if(&Strings.P[P_DampingY] == key)
{
speedDampingY.Set(property);
}
else if(&Strings.P[P_Size] == key)
{
size.Set(property);
}
else if(&Strings.P[P_Stretch] == key)
{
stretch.Set(property);
}
else if(&Strings.P[P_Rotation] == key)
{
rotation.Set(property);
}
else if(&Strings.P[P_BlitMode] == key)
{
// needs to be constant
blitMode = (uint32_t) property.getInt();
}
else if(&Strings.P[P_Attach] == key)
{
// needs to be constant
attachment = (uint32_t) property.getInt();
}
else if(&Strings.P[P_Phase] == key)
{
phase.Set(property);
}
else if(&Strings.P[P_CollisionVertex] == key)
{
collisionVertex.Set(property);
if (property.GetType() != C4V_Nil)
hasCollisionVertex = true;
}
else if (&Strings.P[P_CollisionDensity] == key)
{
collisionDensity.Set(property);
}
else if(&Strings.P[P_OnCollision] == key)
{
SetCollisionFunc(property);
}
}
}
void C4ParticleProperties::SetCollisionFunc(const C4Value &source)
{
C4ValueArray *valueArray;
if (!(valueArray = source.getArray())) return;
int arraySize = valueArray->GetSize();
if (arraySize < 1) return;
int type = (*valueArray)[0].getInt();
switch (type)
{
case C4PC_Die:
collisionCallback = &C4ParticleProperties::CollisionDie;
break;
case C4PC_Bounce:
collisionCallback = &C4ParticleProperties::CollisionBounce;
bouncyness = 1.f;
if (arraySize >= 2)
bouncyness = ((float)(*valueArray)[1].getInt());
break;
case C4PC_Stop:
collisionCallback = &C4ParticleProperties::CollisionStop;
break;
default:
assert(false);
break;
}
}
bool C4ParticleProperties::CollisionBounce(C4Particle *forParticle)
{
forParticle->currentSpeedX = -forParticle->currentSpeedX * bouncyness;
forParticle->currentSpeedY = -forParticle->currentSpeedY * bouncyness;
return true;
}
bool C4ParticleProperties::CollisionStop(C4Particle *forParticle)
{
forParticle->currentSpeedX = 0.f;
forParticle->currentSpeedY = 0.f;
return true;
}
void C4Particle::Init()
{
currentSpeedX = currentSpeedY = 0.f;
positionX = positionY = 0.f;
lifetime = startingLifetime = 5.f * 38.f;
}
bool C4Particle::Exec(C4Object *obj, float timeDelta, C4ParticleDef *sourceDef)
{
// die of old age? :<
lifetime -= timeDelta;
// check only if we had a maximum lifetime to begin with (for permanent particles)
if (startingLifetime > 0.f)
{
if (lifetime <= 0.f) return false;
}
// movement
float currentForceX = properties.forceX.GetValue(this);
float currentForceY = properties.forceY.GetValue(this);
currentSpeedX += currentForceX;
currentSpeedY += currentForceY;
if (currentSpeedX != 0.f || currentSpeedY != 0.f)
{
float currentDampingX = properties.speedDampingX.GetValue(this);
float currentDampingY = properties.speedDampingY.GetValue(this);
float size = properties.size.GetValue(this);
currentSpeedX *= currentDampingX;
currentSpeedY *= currentDampingY;
// move & collision check
// note: accessing Landscape.GetDensity here is not protected by locks
// it is assumed that the particle system is cleaned up before, f.e., the landscape memory is freed
bool collided = false;
if (properties.hasCollisionVertex)
{
float collisionPoint = properties.collisionVertex.GetValue(this);
float size_x = (currentSpeedX > 0.f ? size : -size) * 0.5f * collisionPoint;
float size_y = (currentSpeedY > 0.f ? size : -size) * 0.5f * collisionPoint;
float density = static_cast<float>(GBackDensity(positionX + size_x + timeDelta * currentSpeedX, positionY + size_y + timeDelta * currentSpeedY));
if (density + 0.5f >= properties.collisionDensity.GetValue(this)) // Small offset against floating point insanities.
{
// exec collision func
if (properties.collisionCallback != 0 && !(properties.*properties.collisionCallback)(this)) return false;
collided = true;
}
}
if (!collided)
{
positionX += timeDelta * currentSpeedX;
positionY += timeDelta * currentSpeedY;
}
drawingData.SetPosition(positionX, positionY, size, properties.rotation.GetValue(this), properties.stretch.GetValue(this));
}
else if(!properties.size.IsConstant() || !properties.rotation.IsConstant() || !properties.stretch.IsConstant())
{
drawingData.SetPosition(positionX, positionY, properties.size.GetValue(this), properties.rotation.GetValue(this), properties.stretch.GetValue(this));
}
// adjust color
if (!properties.hasConstantColor)
{
drawingData.SetColor(properties.colorR.GetValue(this), properties.colorG.GetValue(this), properties.colorB.GetValue(this), properties.colorAlpha.GetValue(this));
}
int currentPhase = (int)(properties.phase.GetValue(this) + 0.5f);
if (currentPhase != drawingData.phase)
drawingData.SetPhase(currentPhase, sourceDef);
return true;
}
void C4ParticleChunk::Clear()
{
for (size_t i = 0; i < particleCount; ++i)
{
delete particles[i];
}
particleCount = 0;
particles.clear();
vertexCoordinates.clear();
ClearBufferObjects();
}
void C4ParticleChunk::DeleteAndReplaceParticle(size_t indexToReplace, size_t indexFrom)
{
C4Particle *oldParticle = particles[indexToReplace];
// try to replace the soon-to-be empty slot in the array
if (indexFrom != indexToReplace) // false when "replacing" the last one
{
std::copy(&vertexCoordinates[indexFrom * C4Particle::DrawingData::vertexCountPerParticle], &vertexCoordinates[indexFrom * C4Particle::DrawingData::vertexCountPerParticle] + C4Particle::DrawingData::vertexCountPerParticle, &vertexCoordinates[indexToReplace * C4Particle::DrawingData::vertexCountPerParticle]);
particles[indexToReplace] = particles[indexFrom];
particles[indexToReplace]->drawingData.SetPointer(&vertexCoordinates[indexToReplace * C4Particle::DrawingData::vertexCountPerParticle]);
}
delete oldParticle;
}
bool C4ParticleChunk::Exec(C4Object *obj, float timeDelta)
{
for (size_t i = 0; i < particleCount; ++i)
{
if (!particles[i]->Exec(obj, timeDelta, sourceDefinition))
{
DeleteAndReplaceParticle(i, particleCount - 1);
--particleCount;
}
}
return particleCount > 0;
}
void C4ParticleChunk::Draw(C4TargetFacet cgo, C4Object *obj, C4ShaderCall& call, int texUnit, const StdProjectionMatrix& modelview)
{
if (particleCount == 0) return;
const int stride = sizeof(C4Particle::DrawingData::Vertex);
assert(sourceDefinition && "No source definition assigned to particle chunk.");
C4TexRef *textureRef = sourceDefinition->Gfx.GetFace().texture.get();
assert(textureRef != 0 && "Particle definition had no texture assigned.");
// use a relative offset?
// (note the normal matrix is unaffected by this)
if ((attachment & C4ATTACH_MoveRelative) && (obj != 0))
{
StdProjectionMatrix new_modelview(modelview);
Translate(new_modelview, fixtof(obj->GetFixedX()), fixtof(obj->GetFixedY()), 0.0f);
call.SetUniformMatrix4x4(C4SSU_ModelViewMatrix, new_modelview);
}
else
{
call.SetUniformMatrix4x4(C4SSU_ModelViewMatrix, modelview);
}
// enable additive blending for particles with that blit mode
glBlendFunc(GL_SRC_ALPHA, (blitMode & C4GFXBLIT_ADDITIVE) ? GL_ONE : GL_ONE_MINUS_SRC_ALPHA);
glActiveTexture(texUnit);
glBindTexture(GL_TEXTURE_2D, textureRef->texName);
// generate the buffer as necessary
if (drawingDataVertexBufferObject == 0)
{
// clear up old data
ClearBufferObjects();
// generate new buffer objects
glGenBuffers(1, &drawingDataVertexBufferObject);
assert (drawingDataVertexBufferObject != 0 && "Could not generate OpenGL buffer object.");
// Immediately bind the buffer.
// glVertexAttribPointer requires a valid GL_ARRAY_BUFFER to be bound and we need the buffer to be created for glObjectLabel.
glBindBuffer(GL_ARRAY_BUFFER, drawingDataVertexBufferObject);
pGL->ObjectLabel(GL_BUFFER, drawingDataVertexBufferObject, -1, "<particles>/VBO");
// generate new VAO ID
drawingDataVertexArraysObject = pGL->GenVAOID();
assert (drawingDataVertexArraysObject != 0 && "Could not generate a VAO ID.");
}
// Push the new vertex data
glBindBuffer(GL_ARRAY_BUFFER, drawingDataVertexBufferObject);
glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(C4Particle::DrawingData::Vertex) * particleCount, &vertexCoordinates[0], GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// set up the vertex array structure
GLuint vao;
const bool has_vao = pGL->GetVAO(drawingDataVertexArraysObject, vao);
glBindVertexArray(vao);
assert ((drawingDataVertexBufferObject != 0) && "No buffer object has been created yet.");
assert ((drawingDataVertexArraysObject != 0) && "No vertex arrays object has been created yet.");
if (!has_vao)
{
glBindBuffer(GL_ARRAY_BUFFER, drawingDataVertexBufferObject);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ::Particles.GetIBO());
pGL->ObjectLabel(GL_VERTEX_ARRAY, vao, -1, "<particles>/VAO");
glEnableVertexAttribArray(call.GetAttribute(C4SSA_Position));
glEnableVertexAttribArray(call.GetAttribute(C4SSA_Color));
glEnableVertexAttribArray(call.GetAttribute(C4SSA_TexCoord));
glVertexAttribPointer(call.GetAttribute(C4SSA_Position), 2, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<GLvoid*>(offsetof(C4Particle::DrawingData::Vertex, x)));
glVertexAttribPointer(call.GetAttribute(C4SSA_TexCoord), 2, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<GLvoid*>(offsetof(C4Particle::DrawingData::Vertex, u)));
glVertexAttribPointer(call.GetAttribute(C4SSA_Color), 4, GL_FLOAT, GL_FALSE, stride, reinterpret_cast<GLvoid*>(offsetof(C4Particle::DrawingData::Vertex, r)));
}
glDrawElements(GL_TRIANGLE_STRIP, static_cast<GLsizei> (5 * particleCount), GL_UNSIGNED_INT, 0);
// reset buffer data
glBindVertexArray(0);
}
bool C4ParticleChunk::IsOfType(C4ParticleDef *def, uint32_t _blitMode, uint32_t _attachment) const
{
return def == sourceDefinition && blitMode == _blitMode && attachment == _attachment;
}
void C4ParticleChunk::ClearBufferObjects()
{
if (drawingDataVertexBufferObject != 0) // the value 0 as a buffer index is reserved and will never be returned by glGenBuffers
glDeleteBuffers(1, &drawingDataVertexBufferObject);
if (drawingDataVertexArraysObject != 0)
pGL->FreeVAOID(drawingDataVertexArraysObject);
drawingDataVertexArraysObject = 0;
drawingDataVertexBufferObject = 0;
}
void C4ParticleChunk::ReserveSpace(uint32_t forAmount)
{
uint32_t newSize = static_cast<uint32_t>(particleCount) + forAmount + 1;
::Particles.PreparePrimitiveRestartIndices(newSize);
if (particles.capacity() < newSize)
particles.reserve(std::max<uint32_t>(newSize, particles.capacity() * 2));
// resizing the points vector is relatively costly, hopefully we only do it rarely
while (vertexCoordinates.capacity() <= newSize * C4Particle::DrawingData::vertexCountPerParticle)
{
vertexCoordinates.reserve(std::max<uint32_t>(C4Particle::DrawingData::vertexCountPerParticle * newSize, vertexCoordinates.capacity() * 2));
// update all existing particles' pointers..
for (size_t i = 0; i < particleCount; ++i)
particles[i]->drawingData.SetPointer(&vertexCoordinates[i * C4Particle::DrawingData::vertexCountPerParticle]);
}
}
C4Particle *C4ParticleChunk::AddNewParticle()
{
size_t currentIndex = particleCount++;
if (currentIndex < particles.size())
{
particles[currentIndex] = new C4Particle();
}
else
{
particles.push_back(new C4Particle());
vertexCoordinates.resize(vertexCoordinates.size() + C4Particle::DrawingData::vertexCountPerParticle);
}
C4Particle *newParticle = particles[currentIndex];
newParticle->drawingData.SetPointer(&vertexCoordinates[currentIndex * C4Particle::DrawingData::vertexCountPerParticle], true);
return newParticle;
}
void C4ParticleList::Exec(float timeDelta)
{
if (particleChunks.empty()) return;
accessMutex.Enter();
for (std::list<C4ParticleChunk*>::iterator iter = particleChunks.begin(); iter != particleChunks.end();++iter)
{
C4ParticleChunk *chunk = *iter;
chunk->Exec(targetObject, timeDelta);
}
accessMutex.Leave();
}
void C4ParticleList::Draw(C4TargetFacet cgo, C4Object *obj)
{
if (particleChunks.empty()) return;
pDraw->DeactivateBlitModulation();
pDraw->ResetBlitMode();
glPrimitiveRestartIndex(0xffffffff);
glEnable(GL_PRIMITIVE_RESTART);
// enable shader
C4ShaderCall call(pGL->GetSpriteShader(true, false, false));
// apply zoom and upload shader uniforms
StdProjectionMatrix modelview = StdProjectionMatrix::Identity();
pGL->SetupMultiBlt(call, NULL, 0, 0, 0, 0, &modelview);
// go to correct output position (note the normal matrix is unaffected
// by this)
Translate(modelview, cgo.X-cgo.TargetX, cgo.Y-cgo.TargetY, 0.0f);
// allocate texture unit for particle texture, and remember allocated
// texture unit. Will be used for each particle chunk to bind
// their texture to this unit.
const GLint texUnit = call.AllocTexUnit(C4SSU_BaseTex);
accessMutex.Enter();
for (std::list<C4ParticleChunk*>::iterator iter = particleChunks.begin(); iter != particleChunks.end(); )
{
if ((*iter)->IsEmpty())
{
delete *iter;
iter = particleChunks.erase(iter);
lastAccessedChunk = 0;
}
else
{
(*iter)->Draw(cgo, obj, call, texUnit, modelview);
++iter;
}
}
accessMutex.Leave();
glDisable(GL_PRIMITIVE_RESTART);
}
void C4ParticleList::Clear()
{
accessMutex.Enter();
for (std::list<C4ParticleChunk*>::iterator iter = particleChunks.begin(); iter != particleChunks.end(); ++iter)
delete *iter;
particleChunks.clear();
if (targetObject)
{
if (this == targetObject->FrontParticles) targetObject->FrontParticles = NULL;
else if (this == targetObject->BackParticles) targetObject->BackParticles = NULL;
}
else
if(this == ::Particles.globalParticles) ::Particles.globalParticles = NULL;
accessMutex.Leave();
}
C4ParticleChunk *C4ParticleList::GetFittingParticleChunk(C4ParticleDef *def, uint32_t blitMode, uint32_t attachment, bool alreadyLocked)
{
if (!alreadyLocked)
accessMutex.Enter();
// if not cached, find correct chunk in list
C4ParticleChunk *chunk = 0;
if (lastAccessedChunk && lastAccessedChunk->IsOfType(def, blitMode, attachment))
chunk = lastAccessedChunk;
else
{
for (std::list<C4ParticleChunk*>::iterator iter = particleChunks.begin(); iter != particleChunks.end(); ++iter)
{
C4ParticleChunk *current = *iter;
if (!current->IsOfType(def, blitMode, attachment)) continue;
chunk = current;
break;
}
}
// add new chunk?
if (!chunk)
{
particleChunks.push_back(new C4ParticleChunk());
chunk = particleChunks.back();
chunk->sourceDefinition = def;
chunk->blitMode = blitMode;
chunk->attachment = attachment;
}
assert(chunk && "No suitable particle chunk could be found or created.");
lastAccessedChunk = chunk;
if (!alreadyLocked)
accessMutex.Leave();
return chunk;
}
void C4ParticleSystem::CalculationThread::Execute()
{
Particles.ExecuteCalculation();
}
C4ParticleSystem::C4ParticleSystem() : frameCounterAdvancedEvent(false)
{
currentSimulationTime = 0;
globalParticles = 0;
ibo = 0;
ibo_size = 0;
}
C4ParticleSystem::~C4ParticleSystem()
{
Clear();
calculationThread.SignalStop();
CalculateNextStep();
}
void C4ParticleSystem::ExecuteCalculation()
{
frameCounterAdvancedEvent.WaitFor(INFINITE);
frameCounterAdvancedEvent.Reset();
int gameTime = Game.FrameCounter;
if (currentSimulationTime < gameTime)
{
float timeDelta = 1.f;
if (currentSimulationTime != 0)
timeDelta = (float)(gameTime - currentSimulationTime);
currentSimulationTime = gameTime;
particleListAccessMutex.Enter();
for (std::list<C4ParticleList>::iterator iter = particleLists.begin(); iter != particleLists.end(); ++iter)
{
iter->Exec(timeDelta);
}
particleListAccessMutex.Leave();
}
}
#endif
C4ParticleList *C4ParticleSystem::GetNewParticleList(C4Object *forObject)
{
#ifdef USE_CONSOLE
return 0;
#else
C4ParticleList *newList = 0;
particleListAccessMutex.Enter();
particleLists.emplace_back(forObject);
newList = &particleLists.back();
particleListAccessMutex.Leave();
return newList;
#endif
}
void C4ParticleSystem::ReleaseParticleList(C4ParticleList *first, C4ParticleList *second)
{
#ifndef USE_CONSOLE
particleListAccessMutex.Enter();
for(std::list<C4ParticleList>::iterator iter = particleLists.begin(); iter != particleLists.end();)
{
C4ParticleList *list = &(*iter);
if (list == first || list == second)
{
iter = particleLists.erase(iter);
}
else
{
++iter;
}
}
particleListAccessMutex.Leave();
#endif
}
#ifndef USE_CONSOLE
void C4ParticleSystem::Create(C4ParticleDef *of_def, C4ParticleValueProvider &x, C4ParticleValueProvider &y, C4ParticleValueProvider &speedX, C4ParticleValueProvider &speedY, C4ParticleValueProvider &lifetime, C4PropList *properties, int amount, C4Object *object)
{
// todo: check amount etc
C4ParticleList * pxList(0);
// initialize the particle properties
// this is done here, because it would also be the right place to implement caching
C4ParticleProperties particleProperties;
particleProperties.Set(properties);
speedX.Floatify(10.f);
speedY.Floatify(10.f);
// position offset that will be added to the particle
float xoff(0.f), yoff(0.f);
// offset only for the drawing position - this is needed so that particles relative to an object work correctly
float drawingOffsetX(0.f), drawingOffsetY(0.f);
if (object != 0)
{
// for all types of particles add object's offset (mainly for collision etc.)
xoff = object->GetX();
yoff = object->GetY();
if (particleProperties.attachment & C4ATTACH_MoveRelative)
{
drawingOffsetX = -xoff;
drawingOffsetY = -yoff;
// move relative implies that the particle needs to be in the object's particle list (back OR front)
// just select the front particles here - will be overwritten below if necessary
if (!(particleProperties.attachment & C4ATTACH_Front) && !(particleProperties.attachment & C4ATTACH_Back))
particleProperties.attachment |= C4ATTACH_Front;
}
// figure out particle list to use
if (particleProperties.attachment & C4ATTACH_Front)
{
if (!object->FrontParticles) object->FrontParticles = GetNewParticleList(object);
pxList = object->FrontParticles;
}
else if (particleProperties.attachment & C4ATTACH_Back)
{
if (!object->BackParticles) object->BackParticles = GetNewParticleList(object);
pxList = object->BackParticles;
}
}
// no assigned list implies that we are going to use the global particles
if (!pxList)
{
if (!globalParticles) globalParticles = GetNewParticleList();
pxList = globalParticles;
}
// It is necessary to lock the particle list, because we will have it create a particle first that we are going to modify.
// Inbetween creation of the particle and modification, the particle list's calculations should not be executed
// (this could f.e. lead to the particle being removed before it was fully instantiated).
pxList->Lock();
// retrieve the fitting chunk for the particle (note that we tell the particle list, we already locked it)
C4ParticleChunk *chunk = pxList->GetFittingParticleChunk(of_def, particleProperties.blitMode, particleProperties.attachment, true);
// set up chunk to be able to contain enough particles
chunk->ReserveSpace(static_cast<uint32_t>(amount));
while (amount--)
{
// create a particle in the fitting chunk (note that we tell the particle list, we already locked it)
C4Particle *particle = chunk->AddNewParticle();
// initialize some more properties
particle->properties = particleProperties;
// this will adjust the initial values of the (possibly cached) particle properties
particle->properties.Floatify();
// setup some more non-property attributes of the particle
// The particle having lifetime == startingLifetime will force all random values to alway-reevaluate.
// Thus we need to guarantee that even before setting the lifetime (to allow a PV_Random for the lifetime).
particle->lifetime = particle->startingLifetime = 0.0f;
const float lifetime_value = lifetime.GetValue(particle);
// Negative values are not allowed (would crash later); using a value of 0 is most likely visible to the scripter.
if (lifetime_value >= 0.0f)
particle->lifetime = particle->startingLifetime = lifetime_value;
particle->currentSpeedX = speedX.GetValue(particle);
particle->currentSpeedY = speedY.GetValue(particle);
particle->drawingData.aspect = of_def->Aspect;
particle->drawingData.SetOffset(drawingOffsetX, drawingOffsetY);
particle->SetPosition(x.GetValue(particle) + xoff, y.GetValue(particle) + yoff);
particle->drawingData.SetColor(particle->properties.colorR.GetValue(particle), particle->properties.colorG.GetValue(particle), particle->properties.colorB.GetValue(particle), particle->properties.colorAlpha.GetValue(particle));
particle->drawingData.SetPhase((int)(particle->properties.phase.GetValue(particle) + 0.5f), of_def);
}
pxList->Unlock();
}
void C4ParticleSystem::PreparePrimitiveRestartIndices(uint32_t forAmount)
{
// prepare array with indices, separated by special primitive restart index
const uint32_t PRI = 0xffffffff;
size_t neededAmount = 5 * forAmount;
if (ibo == 0) glGenBuffers(1, &ibo);
if (ibo_size < neededAmount * sizeof(GLuint))
{
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
std::vector<GLuint> ibo_data;
ibo_data.reserve(neededAmount);
unsigned int index = 0;
for (unsigned int i = 0; i < neededAmount; ++i)
{
if ((i+1) % 5 == 0)
ibo_data.push_back(PRI);
else
ibo_data.push_back(index++);
}
ibo_size = neededAmount * sizeof(GLuint);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, ibo_size, &ibo_data[0], GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
}
#endif
void C4ParticleSystem::Clear()
{
#ifndef USE_CONSOLE
if (ibo != 0) glDeleteBuffers(1, &ibo);
ibo = 0; ibo_size = 0;
currentSimulationTime = 0;
ClearAllParticles();
#endif
// clear definitions even in console mode
definitions.Clear();
}
void C4ParticleSystem::ClearAllParticles()
{
#ifndef USE_CONSOLE
particleListAccessMutex.Enter();
particleLists.clear();
particleListAccessMutex.Leave();
#endif
}
C4ParticleDef *C4ParticleSystemDefinitionList::GetDef(const char *name, C4ParticleDef *exclude)
{
#ifndef USE_CONSOLE
// seek list
for (C4ParticleDef *def = first; def != 0; def=def->next)
if (def != exclude && def->Name == name)
return def;
#endif
// nothing found
return 0;
}
void C4ParticleSystemDefinitionList::Clear()
{
// the particle definitions update the list in their destructor
while (first)
delete first;
}
C4ParticleSystem Particles;
Reference in New Issue View Git Blame Copy Permalink