mirror of
https://github.com/love2d/love.git
synced 2026-08-16 00:02:12 +02:00
Moved most of the ParticleSystem code from modules/graphics/opengl/ to modules/graphics/
This commit is contained in:
Alex Szpakowski
@@ -0,0 +1,986 @@
|
||||
/**
|
||||
* Copyright (c) 2006-2015 LOVE Development Team
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
*
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
*
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
**/
|
||||
|
||||
//LOVE
|
||||
#include "common/config.h"
|
||||
#include "ParticleSystem.h"
|
||||
|
||||
#include "common/math.h"
|
||||
#include "modules/math/RandomGenerator.h"
|
||||
|
||||
// STD
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
|
||||
namespace love
|
||||
{
|
||||
namespace graphics
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
love::math::RandomGenerator rng;
|
||||
|
||||
float calculate_variation(float inner, float outer, float var)
|
||||
{
|
||||
float low = inner - (outer/2.0f)*var;
|
||||
float high = inner + (outer/2.0f)*var;
|
||||
float r = (float) rng.random();
|
||||
return low*(1-r)+high*r;
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
ParticleSystem::ParticleSystem(Texture *texture, uint32 size)
|
||||
: pMem(nullptr)
|
||||
, pFree(nullptr)
|
||||
, pHead(nullptr)
|
||||
, pTail(nullptr)
|
||||
, texture(texture)
|
||||
, active(true)
|
||||
, insertMode(INSERT_MODE_TOP)
|
||||
, maxParticles(0)
|
||||
, activeParticles(0)
|
||||
, emissionRate(0)
|
||||
, emitCounter(0)
|
||||
, areaSpreadDistribution(DISTRIBUTION_NONE)
|
||||
, lifetime(-1)
|
||||
, life(0)
|
||||
, particleLifeMin(0)
|
||||
, particleLifeMax(0)
|
||||
, direction(0)
|
||||
, spread(0)
|
||||
, speedMin(0)
|
||||
, speedMax(0)
|
||||
, linearAccelerationMin(0, 0)
|
||||
, linearAccelerationMax(0, 0)
|
||||
, radialAccelerationMin(0)
|
||||
, radialAccelerationMax(0)
|
||||
, tangentialAccelerationMin(0)
|
||||
, tangentialAccelerationMax(0)
|
||||
, linearDampingMin(0.0f)
|
||||
, linearDampingMax(0.0f)
|
||||
, sizeVariation(0)
|
||||
, rotationMin(0)
|
||||
, rotationMax(0)
|
||||
, spinStart(0)
|
||||
, spinEnd(0)
|
||||
, spinVariation(0)
|
||||
, offset(float(texture->getWidth())*0.5f, float(texture->getHeight())*0.5f)
|
||||
, defaultOffset(true)
|
||||
, relativeRotation(false)
|
||||
{
|
||||
if (size == 0 || size > MAX_PARTICLES)
|
||||
throw love::Exception("Invalid ParticleSystem size.");
|
||||
|
||||
sizes.push_back(1.0f);
|
||||
colors.push_back(Colorf(1.0f, 1.0f, 1.0f, 1.0f));
|
||||
setBufferSize(size);
|
||||
}
|
||||
|
||||
ParticleSystem::ParticleSystem(const ParticleSystem &p)
|
||||
: pMem(nullptr)
|
||||
, pFree(nullptr)
|
||||
, pHead(nullptr)
|
||||
, pTail(nullptr)
|
||||
, texture(p.texture)
|
||||
, active(p.active)
|
||||
, insertMode(p.insertMode)
|
||||
, maxParticles(p.maxParticles)
|
||||
, activeParticles(0)
|
||||
, emissionRate(p.emissionRate)
|
||||
, emitCounter(0.0f)
|
||||
, position(p.position)
|
||||
, prevPosition(p.prevPosition)
|
||||
, areaSpreadDistribution(p.areaSpreadDistribution)
|
||||
, areaSpread(p.areaSpread)
|
||||
, lifetime(p.lifetime)
|
||||
, life(p.lifetime) // Initialize with the maximum life time.
|
||||
, particleLifeMin(p.particleLifeMin)
|
||||
, particleLifeMax(p.particleLifeMax)
|
||||
, direction(p.direction)
|
||||
, spread(p.spread)
|
||||
, speedMin(p.speedMin)
|
||||
, speedMax(p.speedMax)
|
||||
, linearAccelerationMin(p.linearAccelerationMin)
|
||||
, linearAccelerationMax(p.linearAccelerationMax)
|
||||
, radialAccelerationMin(p.radialAccelerationMin)
|
||||
, radialAccelerationMax(p.radialAccelerationMax)
|
||||
, tangentialAccelerationMin(p.tangentialAccelerationMin)
|
||||
, tangentialAccelerationMax(p.tangentialAccelerationMax)
|
||||
, linearDampingMin(p.linearDampingMin)
|
||||
, linearDampingMax(p.linearDampingMax)
|
||||
, sizes(p.sizes)
|
||||
, sizeVariation(p.sizeVariation)
|
||||
, rotationMin(p.rotationMin)
|
||||
, rotationMax(p.rotationMax)
|
||||
, spinStart(p.spinStart)
|
||||
, spinEnd(p.spinEnd)
|
||||
, spinVariation(p.spinVariation)
|
||||
, offset(p.offset)
|
||||
, defaultOffset(p.defaultOffset)
|
||||
, colors(p.colors)
|
||||
, quads(p.quads)
|
||||
, relativeRotation(p.relativeRotation)
|
||||
{
|
||||
setBufferSize(maxParticles);
|
||||
}
|
||||
|
||||
ParticleSystem::~ParticleSystem()
|
||||
{
|
||||
deleteBuffers();
|
||||
}
|
||||
|
||||
void ParticleSystem::resetOffset()
|
||||
{
|
||||
if (quads.empty())
|
||||
offset = love::Vector(float(texture->getWidth())*0.5f, float(texture->getHeight())*0.5f);
|
||||
else
|
||||
{
|
||||
Quad::Viewport v = quads[0]->getViewport();
|
||||
offset = love::Vector(v.x*0.5f, v.y*0.5f);
|
||||
}
|
||||
}
|
||||
|
||||
void ParticleSystem::createBuffers(size_t size)
|
||||
{
|
||||
try
|
||||
{
|
||||
pFree = pMem = new Particle[size];
|
||||
maxParticles = (uint32) size;
|
||||
}
|
||||
catch (std::bad_alloc &)
|
||||
{
|
||||
deleteBuffers();
|
||||
throw love::Exception("Out of memory");
|
||||
}
|
||||
}
|
||||
|
||||
void ParticleSystem::deleteBuffers()
|
||||
{
|
||||
// Clean up for great gracefulness!
|
||||
delete[] pMem;
|
||||
|
||||
pMem = nullptr;
|
||||
maxParticles = 0;
|
||||
activeParticles = 0;
|
||||
}
|
||||
|
||||
void ParticleSystem::setBufferSize(uint32 size)
|
||||
{
|
||||
if (size == 0 || size > MAX_PARTICLES)
|
||||
throw love::Exception("Invalid buffer size");
|
||||
deleteBuffers();
|
||||
createBuffers(size);
|
||||
reset();
|
||||
}
|
||||
|
||||
uint32 ParticleSystem::getBufferSize() const
|
||||
{
|
||||
return maxParticles;
|
||||
}
|
||||
|
||||
void ParticleSystem::addParticle(float t)
|
||||
{
|
||||
if (isFull())
|
||||
return;
|
||||
|
||||
// Gets a free particle and updates the allocation pointer.
|
||||
Particle *p = pFree++;
|
||||
initParticle(p, t);
|
||||
|
||||
switch (insertMode)
|
||||
{
|
||||
default:
|
||||
case INSERT_MODE_TOP:
|
||||
insertTop(p);
|
||||
break;
|
||||
case INSERT_MODE_BOTTOM:
|
||||
insertBottom(p);
|
||||
break;
|
||||
case INSERT_MODE_RANDOM:
|
||||
insertRandom(p);
|
||||
break;
|
||||
}
|
||||
|
||||
activeParticles++;
|
||||
}
|
||||
|
||||
void ParticleSystem::initParticle(Particle *p, float t)
|
||||
{
|
||||
float min,max;
|
||||
|
||||
// Linearly interpolate between the previous and current emitter position.
|
||||
love::Vector pos = prevPosition + (position - prevPosition) * t;
|
||||
|
||||
min = particleLifeMin;
|
||||
max = particleLifeMax;
|
||||
if (min == max)
|
||||
p->life = min;
|
||||
else
|
||||
p->life = (float) rng.random(min, max);
|
||||
p->lifetime = p->life;
|
||||
|
||||
p->position = pos;
|
||||
|
||||
switch (areaSpreadDistribution)
|
||||
{
|
||||
case DISTRIBUTION_UNIFORM:
|
||||
p->position.x += (float) rng.random(-areaSpread.getX(), areaSpread.getX());
|
||||
p->position.y += (float) rng.random(-areaSpread.getY(), areaSpread.getY());
|
||||
break;
|
||||
case DISTRIBUTION_NORMAL:
|
||||
p->position.x += (float) rng.randomNormal(areaSpread.getX());
|
||||
p->position.y += (float) rng.randomNormal(areaSpread.getY());
|
||||
break;
|
||||
case DISTRIBUTION_NONE:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
p->origin = pos;
|
||||
|
||||
min = speedMin;
|
||||
max = speedMax;
|
||||
float speed = (float) rng.random(min, max);
|
||||
|
||||
min = direction - spread/2.0f;
|
||||
max = direction + spread/2.0f;
|
||||
float dir = (float) rng.random(min, max);
|
||||
|
||||
p->velocity = love::Vector(cosf(dir), sinf(dir)) * speed;
|
||||
|
||||
p->linearAcceleration.x = (float) rng.random(linearAccelerationMin.x, linearAccelerationMax.x);
|
||||
p->linearAcceleration.y = (float) rng.random(linearAccelerationMin.y, linearAccelerationMax.y);
|
||||
|
||||
min = radialAccelerationMin;
|
||||
max = radialAccelerationMax;
|
||||
p->radialAcceleration = (float) rng.random(min, max);
|
||||
|
||||
min = tangentialAccelerationMin;
|
||||
max = tangentialAccelerationMax;
|
||||
p->tangentialAcceleration = (float) rng.random(min, max);
|
||||
|
||||
min = linearDampingMin;
|
||||
max = linearDampingMax;
|
||||
p->linearDamping = (float) rng.random(min, max);
|
||||
|
||||
p->sizeOffset = (float) rng.random(sizeVariation); // time offset for size change
|
||||
p->sizeIntervalSize = (1.0f - (float) rng.random(sizeVariation)) - p->sizeOffset;
|
||||
p->size = sizes[(size_t)(p->sizeOffset - .5f) * (sizes.size() - 1)];
|
||||
|
||||
min = rotationMin;
|
||||
max = rotationMax;
|
||||
p->spinStart = calculate_variation(spinStart, spinEnd, spinVariation);
|
||||
p->spinEnd = calculate_variation(spinEnd, spinStart, spinVariation);
|
||||
p->rotation = (float) rng.random(min, max);
|
||||
|
||||
p->angle = p->rotation;
|
||||
if (relativeRotation)
|
||||
p->angle += atan2f(p->velocity.y, p->velocity.x);
|
||||
|
||||
p->color = colors[0];
|
||||
|
||||
p->quadIndex = 0;
|
||||
}
|
||||
|
||||
void ParticleSystem::insertTop(Particle *p)
|
||||
{
|
||||
if (pHead == nullptr)
|
||||
{
|
||||
pHead = p;
|
||||
p->prev = nullptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
pTail->next = p;
|
||||
p->prev = pTail;
|
||||
}
|
||||
p->next = nullptr;
|
||||
pTail = p;
|
||||
}
|
||||
|
||||
void ParticleSystem::insertBottom(Particle *p)
|
||||
{
|
||||
if (pTail == nullptr)
|
||||
{
|
||||
pTail = p;
|
||||
p->next = nullptr;
|
||||
}
|
||||
else
|
||||
{
|
||||
pHead->prev = p;
|
||||
p->next = pHead;
|
||||
}
|
||||
p->prev = nullptr;
|
||||
pHead = p;
|
||||
}
|
||||
|
||||
void ParticleSystem::insertRandom(Particle *p)
|
||||
{
|
||||
// Nonuniform, but 64-bit is so large nobody will notice. Hopefully.
|
||||
uint64 pos = rng.rand() % ((int64) activeParticles + 1);
|
||||
|
||||
// Special case where the particle gets inserted before the head.
|
||||
if (pos == activeParticles)
|
||||
{
|
||||
Particle *pA = pHead;
|
||||
if (pA)
|
||||
pA->prev = p;
|
||||
p->prev = nullptr;
|
||||
p->next = pA;
|
||||
pHead = p;
|
||||
return;
|
||||
}
|
||||
|
||||
// Inserts the particle after the randomly selected particle.
|
||||
Particle *pA = pMem + pos;
|
||||
Particle *pB = pA->next;
|
||||
pA->next = p;
|
||||
if (pB)
|
||||
pB->prev = p;
|
||||
else
|
||||
pTail = p;
|
||||
p->prev = pA;
|
||||
p->next = pB;
|
||||
}
|
||||
|
||||
ParticleSystem::Particle *ParticleSystem::removeParticle(Particle *p)
|
||||
{
|
||||
// The linked list is updated in this function and old pointers may be
|
||||
// invalidated. The returned pointer will inform the caller of the new
|
||||
// pointer to the next particle.
|
||||
Particle *pNext = nullptr;
|
||||
|
||||
// Removes the particle from the linked list.
|
||||
if (p->prev)
|
||||
p->prev->next = p->next;
|
||||
else
|
||||
pHead = p->next;
|
||||
|
||||
if (p->next)
|
||||
{
|
||||
p->next->prev = p->prev;
|
||||
pNext = p->next;
|
||||
}
|
||||
else
|
||||
pTail = p->prev;
|
||||
|
||||
// The (in memory) last particle can now be moved into the free slot.
|
||||
// It will skip the moving if it happens to be the removed particle.
|
||||
pFree--;
|
||||
if (p != pFree)
|
||||
{
|
||||
*p = *pFree;
|
||||
if (pNext == pFree)
|
||||
pNext = p;
|
||||
|
||||
if (p->prev)
|
||||
p->prev->next = p;
|
||||
else
|
||||
pHead = p;
|
||||
|
||||
if (p->next)
|
||||
p->next->prev = p;
|
||||
else
|
||||
pTail = p;
|
||||
}
|
||||
|
||||
activeParticles--;
|
||||
return pNext;
|
||||
}
|
||||
|
||||
void ParticleSystem::setTexture(Texture *tex)
|
||||
{
|
||||
texture.set(tex);
|
||||
|
||||
if (defaultOffset)
|
||||
resetOffset();
|
||||
}
|
||||
|
||||
Texture *ParticleSystem::getTexture() const
|
||||
{
|
||||
return texture.get();
|
||||
}
|
||||
|
||||
void ParticleSystem::setInsertMode(InsertMode mode)
|
||||
{
|
||||
insertMode = mode;
|
||||
}
|
||||
|
||||
ParticleSystem::InsertMode ParticleSystem::getInsertMode() const
|
||||
{
|
||||
return insertMode;
|
||||
}
|
||||
|
||||
void ParticleSystem::setEmissionRate(float rate)
|
||||
{
|
||||
if (rate < 0.0f)
|
||||
throw love::Exception("Invalid emission rate");
|
||||
emissionRate = rate;
|
||||
}
|
||||
|
||||
float ParticleSystem::getEmissionRate() const
|
||||
{
|
||||
return emissionRate;
|
||||
}
|
||||
|
||||
void ParticleSystem::setEmitterLifetime(float life)
|
||||
{
|
||||
this->life = lifetime = life;
|
||||
}
|
||||
|
||||
float ParticleSystem::getEmitterLifetime() const
|
||||
{
|
||||
return lifetime;
|
||||
}
|
||||
|
||||
void ParticleSystem::setParticleLifetime(float min, float max)
|
||||
{
|
||||
particleLifeMin = min;
|
||||
if (max == 0)
|
||||
particleLifeMax = min;
|
||||
else
|
||||
particleLifeMax = max;
|
||||
}
|
||||
|
||||
void ParticleSystem::getParticleLifetime(float &min, float &max) const
|
||||
{
|
||||
min = particleLifeMin;
|
||||
max = particleLifeMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setPosition(float x, float y)
|
||||
{
|
||||
position = love::Vector(x, y);
|
||||
prevPosition = position;
|
||||
}
|
||||
|
||||
const love::Vector &ParticleSystem::getPosition() const
|
||||
{
|
||||
return position;
|
||||
}
|
||||
|
||||
void ParticleSystem::moveTo(float x, float y)
|
||||
{
|
||||
position = love::Vector(x, y);
|
||||
}
|
||||
|
||||
void ParticleSystem::setAreaSpread(AreaSpreadDistribution distribution, float x, float y)
|
||||
{
|
||||
areaSpread = love::Vector(x, y);
|
||||
areaSpreadDistribution = distribution;
|
||||
}
|
||||
|
||||
ParticleSystem::AreaSpreadDistribution ParticleSystem::getAreaSpreadDistribution() const
|
||||
{
|
||||
return areaSpreadDistribution;
|
||||
}
|
||||
|
||||
const love::Vector &ParticleSystem::getAreaSpreadParameters() const
|
||||
{
|
||||
return areaSpread;
|
||||
}
|
||||
|
||||
void ParticleSystem::setDirection(float direction)
|
||||
{
|
||||
this->direction = direction;
|
||||
}
|
||||
|
||||
float ParticleSystem::getDirection() const
|
||||
{
|
||||
return direction;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSpread(float spread)
|
||||
{
|
||||
this->spread = spread;
|
||||
}
|
||||
|
||||
float ParticleSystem::getSpread() const
|
||||
{
|
||||
return spread;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSpeed(float speed)
|
||||
{
|
||||
speedMin = speedMax = speed;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSpeed(float min, float max)
|
||||
{
|
||||
speedMin = min;
|
||||
speedMax = max;
|
||||
}
|
||||
|
||||
void ParticleSystem::getSpeed(float &min, float &max) const
|
||||
{
|
||||
min = speedMin;
|
||||
max = speedMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setLinearAcceleration(float x, float y)
|
||||
{
|
||||
linearAccelerationMin.x = linearAccelerationMax.x = x;
|
||||
linearAccelerationMin.y = linearAccelerationMax.y = y;
|
||||
}
|
||||
|
||||
void ParticleSystem::setLinearAcceleration(float xmin, float ymin, float xmax, float ymax)
|
||||
{
|
||||
linearAccelerationMin = love::Vector(xmin, ymin);
|
||||
linearAccelerationMax = love::Vector(xmax, ymax);
|
||||
}
|
||||
|
||||
void ParticleSystem::getLinearAcceleration(love::Vector &min, love::Vector &max) const
|
||||
{
|
||||
min = linearAccelerationMin;
|
||||
max = linearAccelerationMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setRadialAcceleration(float acceleration)
|
||||
{
|
||||
radialAccelerationMin = radialAccelerationMax = acceleration;
|
||||
}
|
||||
|
||||
void ParticleSystem::setRadialAcceleration(float min, float max)
|
||||
{
|
||||
radialAccelerationMin = min;
|
||||
radialAccelerationMax = max;
|
||||
}
|
||||
|
||||
void ParticleSystem::getRadialAcceleration(float &min, float &max) const
|
||||
{
|
||||
min = radialAccelerationMin;
|
||||
max = radialAccelerationMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setTangentialAcceleration(float acceleration)
|
||||
{
|
||||
tangentialAccelerationMin = tangentialAccelerationMax = acceleration;
|
||||
}
|
||||
|
||||
void ParticleSystem::setTangentialAcceleration(float min, float max)
|
||||
{
|
||||
tangentialAccelerationMin = min;
|
||||
tangentialAccelerationMax = max;
|
||||
}
|
||||
|
||||
void ParticleSystem::getTangentialAcceleration(float &min, float &max) const
|
||||
{
|
||||
min = tangentialAccelerationMin;
|
||||
max = tangentialAccelerationMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setLinearDamping(float min, float max)
|
||||
{
|
||||
linearDampingMin = min;
|
||||
linearDampingMax = max;
|
||||
}
|
||||
|
||||
void ParticleSystem::getLinearDamping(float &min, float &max) const
|
||||
{
|
||||
min = linearDampingMin;
|
||||
max = linearDampingMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSize(float size)
|
||||
{
|
||||
sizes.resize(1);
|
||||
sizes[0] = size;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSizes(const std::vector<float> &newSizes)
|
||||
{
|
||||
sizes = newSizes;
|
||||
}
|
||||
|
||||
const std::vector<float> &ParticleSystem::getSizes() const
|
||||
{
|
||||
return sizes;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSizeVariation(float variation)
|
||||
{
|
||||
sizeVariation = variation;
|
||||
}
|
||||
|
||||
float ParticleSystem::getSizeVariation() const
|
||||
{
|
||||
return sizeVariation;
|
||||
}
|
||||
|
||||
void ParticleSystem::setRotation(float rotation)
|
||||
{
|
||||
rotationMin = rotationMax = rotation;
|
||||
}
|
||||
|
||||
void ParticleSystem::setRotation(float min, float max)
|
||||
{
|
||||
rotationMin = min;
|
||||
rotationMax = max;
|
||||
}
|
||||
|
||||
void ParticleSystem::getRotation(float &min, float &max) const
|
||||
{
|
||||
min = rotationMin;
|
||||
max = rotationMax;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSpin(float spin)
|
||||
{
|
||||
spinStart = spin;
|
||||
spinEnd = spin;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSpin(float start, float end)
|
||||
{
|
||||
spinStart = start;
|
||||
spinEnd = end;
|
||||
}
|
||||
|
||||
void ParticleSystem::getSpin(float &start, float &end) const
|
||||
{
|
||||
start = spinStart;
|
||||
end = spinEnd;
|
||||
}
|
||||
|
||||
void ParticleSystem::setSpinVariation(float variation)
|
||||
{
|
||||
spinVariation = variation;
|
||||
}
|
||||
|
||||
float ParticleSystem::getSpinVariation() const
|
||||
{
|
||||
return spinVariation;
|
||||
}
|
||||
|
||||
void ParticleSystem::setOffset(float x, float y)
|
||||
{
|
||||
offset = love::Vector(x, y);
|
||||
defaultOffset = false;
|
||||
}
|
||||
|
||||
love::Vector ParticleSystem::getOffset() const
|
||||
{
|
||||
return offset;
|
||||
}
|
||||
|
||||
void ParticleSystem::setColor(const std::vector<Colorf> &newColors)
|
||||
{
|
||||
colors = newColors;
|
||||
|
||||
for (Colorf &c : colors)
|
||||
{
|
||||
// We want to store the colors as [0, 1], rather than [0, 255].
|
||||
c.r /= 255.0f;
|
||||
c.g /= 255.0f;
|
||||
c.b /= 255.0f;
|
||||
c.a /= 255.0f;
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<Colorf> ParticleSystem::getColor() const
|
||||
{
|
||||
// The particle system stores colors in the range of [0, 1]...
|
||||
std::vector<Colorf> ncolors(colors);
|
||||
|
||||
for (Colorf &c : ncolors)
|
||||
{
|
||||
c.r *= 255.0f;
|
||||
c.g *= 255.0f;
|
||||
c.b *= 255.0f;
|
||||
c.a *= 255.0f;
|
||||
}
|
||||
|
||||
return ncolors;
|
||||
}
|
||||
|
||||
void ParticleSystem::setQuads(const std::vector<Quad *> &newQuads)
|
||||
{
|
||||
std::vector<StrongRef<Quad>> quadlist;
|
||||
quadlist.reserve(newQuads.size());
|
||||
|
||||
for (Quad *q : newQuads)
|
||||
quadlist.push_back(q);
|
||||
|
||||
quads = quadlist;
|
||||
|
||||
if (defaultOffset)
|
||||
resetOffset();
|
||||
}
|
||||
|
||||
void ParticleSystem::setQuads()
|
||||
{
|
||||
quads.clear();
|
||||
}
|
||||
|
||||
std::vector<Quad *> ParticleSystem::getQuads() const
|
||||
{
|
||||
std::vector<Quad *> quadlist;
|
||||
quadlist.reserve(quads.size());
|
||||
|
||||
for (const StrongRef<Quad> &q : quads)
|
||||
quadlist.push_back(q.get());
|
||||
|
||||
return quadlist;
|
||||
}
|
||||
|
||||
void ParticleSystem::setRelativeRotation(bool enable)
|
||||
{
|
||||
relativeRotation = enable;
|
||||
}
|
||||
|
||||
bool ParticleSystem::hasRelativeRotation() const
|
||||
{
|
||||
return relativeRotation;
|
||||
}
|
||||
|
||||
uint32 ParticleSystem::getCount() const
|
||||
{
|
||||
return activeParticles;
|
||||
}
|
||||
|
||||
void ParticleSystem::start()
|
||||
{
|
||||
active = true;
|
||||
}
|
||||
|
||||
void ParticleSystem::stop()
|
||||
{
|
||||
active = false;
|
||||
life = lifetime;
|
||||
emitCounter = 0;
|
||||
}
|
||||
|
||||
void ParticleSystem::pause()
|
||||
{
|
||||
active = false;
|
||||
}
|
||||
|
||||
void ParticleSystem::reset()
|
||||
{
|
||||
if (pMem == nullptr)
|
||||
return;
|
||||
|
||||
pFree = pMem;
|
||||
pHead = nullptr;
|
||||
pTail = nullptr;
|
||||
activeParticles = 0;
|
||||
life = lifetime;
|
||||
emitCounter = 0;
|
||||
}
|
||||
|
||||
void ParticleSystem::emit(uint32 num)
|
||||
{
|
||||
if (!active)
|
||||
return;
|
||||
|
||||
num = std::min(num, maxParticles - activeParticles);
|
||||
|
||||
while (num--)
|
||||
addParticle(1.0f);
|
||||
}
|
||||
|
||||
bool ParticleSystem::isActive() const
|
||||
{
|
||||
return active;
|
||||
}
|
||||
|
||||
bool ParticleSystem::isPaused() const
|
||||
{
|
||||
return !active && life < lifetime;
|
||||
}
|
||||
|
||||
bool ParticleSystem::isStopped() const
|
||||
{
|
||||
return !active && life >= lifetime;
|
||||
}
|
||||
|
||||
bool ParticleSystem::isEmpty() const
|
||||
{
|
||||
return activeParticles == 0;
|
||||
}
|
||||
|
||||
bool ParticleSystem::isFull() const
|
||||
{
|
||||
return activeParticles == maxParticles;
|
||||
}
|
||||
|
||||
void ParticleSystem::update(float dt)
|
||||
{
|
||||
if (pMem == nullptr || dt == 0.0f)
|
||||
return;
|
||||
|
||||
// Traverse all particles and update.
|
||||
Particle *p = pHead;
|
||||
|
||||
while (p)
|
||||
{
|
||||
// Decrease lifespan.
|
||||
p->life -= dt;
|
||||
|
||||
if (p->life <= 0)
|
||||
p = removeParticle(p);
|
||||
else
|
||||
{
|
||||
// Temp variables.
|
||||
love::Vector radial, tangential;
|
||||
love::Vector ppos = p->position;
|
||||
|
||||
// Get vector from particle center to particle.
|
||||
radial = ppos - p->origin;
|
||||
radial.normalize();
|
||||
tangential = radial;
|
||||
|
||||
// Resize radial acceleration.
|
||||
radial *= p->radialAcceleration;
|
||||
|
||||
// Calculate tangential acceleration.
|
||||
{
|
||||
float a = tangential.getX();
|
||||
tangential.setX(-tangential.getY());
|
||||
tangential.setY(a);
|
||||
}
|
||||
|
||||
// Resize tangential.
|
||||
tangential *= p->tangentialAcceleration;
|
||||
|
||||
// Update velocity.
|
||||
p->velocity += (radial + tangential + p->linearAcceleration) * dt;
|
||||
|
||||
// Apply damping.
|
||||
p->velocity *= 1.0f / (1.0f + p->linearDamping * dt);
|
||||
|
||||
// Modify position.
|
||||
ppos += p->velocity * dt;
|
||||
|
||||
p->position = ppos;
|
||||
|
||||
const float t = 1.0f - p->life / p->lifetime;
|
||||
|
||||
// Rotate.
|
||||
p->rotation += (p->spinStart * (1.0f - t) + p->spinEnd * t) * dt;
|
||||
|
||||
p->angle = p->rotation;
|
||||
|
||||
if (relativeRotation)
|
||||
p->angle += atan2f(p->velocity.y, p->velocity.x);
|
||||
|
||||
// Change size according to given intervals:
|
||||
// i = 0 1 2 3 n-1
|
||||
// |-------|-------|------|--- ... ---|
|
||||
// t = 0 1/(n-1) 3/(n-1) 1
|
||||
//
|
||||
// `s' is the interpolation variable scaled to the current
|
||||
// interval width, e.g. if n = 5 and t = 0.3, then the current
|
||||
// indices are 1,2 and s = 0.3 - 0.25 = 0.05
|
||||
float s = p->sizeOffset + t * p->sizeIntervalSize; // size variation
|
||||
s *= (float)(sizes.size() - 1); // 0 <= s < sizes.size()
|
||||
size_t i = (size_t)s;
|
||||
size_t k = (i == sizes.size() - 1) ? i : i + 1; // boundary check (prevents failing on t = 1.0f)
|
||||
s -= (float)i; // transpose s to be in interval [0:1]: i <= s < i + 1 ~> 0 <= s < 1
|
||||
p->size = sizes[i] * (1.0f - s) + sizes[k] * s;
|
||||
|
||||
// Update color according to given intervals (as above)
|
||||
s = t * (float)(colors.size() - 1);
|
||||
i = (size_t)s;
|
||||
k = (i == colors.size() - 1) ? i : i + 1;
|
||||
s -= (float)i; // 0 <= s <= 1
|
||||
p->color = colors[i] * (1.0f - s) + colors[k] * s;
|
||||
|
||||
// Update the quad index.
|
||||
k = quads.size();
|
||||
if (k > 0)
|
||||
{
|
||||
s = t * (float) k; // [0:numquads-1] (clamped below)
|
||||
i = (s > 0.0f) ? (size_t) s : 0;
|
||||
p->quadIndex = (int) ((i < k) ? i : k - 1);
|
||||
}
|
||||
|
||||
// Next particle.
|
||||
p = p->next;
|
||||
}
|
||||
}
|
||||
|
||||
// Make some more particles.
|
||||
if (active)
|
||||
{
|
||||
float rate = 1.0f / emissionRate; // the amount of time between each particle emit
|
||||
emitCounter += dt;
|
||||
float total = emitCounter - rate;
|
||||
while (emitCounter > rate)
|
||||
{
|
||||
addParticle(1.0f - (emitCounter - rate) / total);
|
||||
emitCounter -= rate;
|
||||
}
|
||||
/*int particles = (int)(emissionRate * dt);
|
||||
for (int i = 0; i != particles; i++)
|
||||
add();*/
|
||||
|
||||
life -= dt;
|
||||
if (lifetime != -1 && life < 0)
|
||||
stop();
|
||||
}
|
||||
|
||||
prevPosition = position;
|
||||
}
|
||||
|
||||
bool ParticleSystem::getConstant(const char *in, AreaSpreadDistribution &out)
|
||||
{
|
||||
return distributions.find(in, out);
|
||||
}
|
||||
|
||||
bool ParticleSystem::getConstant(AreaSpreadDistribution in, const char *&out)
|
||||
{
|
||||
return distributions.find(in, out);
|
||||
}
|
||||
|
||||
bool ParticleSystem::getConstant(const char *in, InsertMode &out)
|
||||
{
|
||||
return insertModes.find(in, out);
|
||||
}
|
||||
|
||||
bool ParticleSystem::getConstant(InsertMode in, const char *&out)
|
||||
{
|
||||
return insertModes.find(in, out);
|
||||
}
|
||||
|
||||
StringMap<ParticleSystem::AreaSpreadDistribution, ParticleSystem::DISTRIBUTION_MAX_ENUM>::Entry ParticleSystem::distributionsEntries[] =
|
||||
{
|
||||
{ "none", DISTRIBUTION_NONE },
|
||||
{ "uniform", DISTRIBUTION_UNIFORM },
|
||||
{ "normal", DISTRIBUTION_NORMAL },
|
||||
};
|
||||
|
||||
StringMap<ParticleSystem::AreaSpreadDistribution, ParticleSystem::DISTRIBUTION_MAX_ENUM> ParticleSystem::distributions(ParticleSystem::distributionsEntries, sizeof(ParticleSystem::distributionsEntries));
|
||||
|
||||
StringMap<ParticleSystem::InsertMode, ParticleSystem::INSERT_MODE_MAX_ENUM>::Entry ParticleSystem::insertModesEntries[] =
|
||||
{
|
||||
{ "top", INSERT_MODE_TOP },
|
||||
{ "bottom", INSERT_MODE_BOTTOM },
|
||||
{ "random", INSERT_MODE_RANDOM },
|
||||
};
|
||||
|
||||
StringMap<ParticleSystem::InsertMode, ParticleSystem::INSERT_MODE_MAX_ENUM> ParticleSystem::insertModes(ParticleSystem::insertModesEntries, sizeof(ParticleSystem::insertModesEntries));
|
||||
|
||||
} // graphics
|
||||
} // love
|
||||
@@ -0,0 +1,672 @@
|
||||
/**
|
||||
* Copyright (c) 2006-2015 LOVE Development Team
|
||||
*
|
||||
* This software is provided 'as-is', without any express or implied
|
||||
* warranty. In no event will the authors be held liable for any damages
|
||||
* arising from the use of this software.
|
||||
*
|
||||
* Permission is granted to anyone to use this software for any purpose,
|
||||
* including commercial applications, and to alter it and redistribute it
|
||||
* freely, subject to the following restrictions:
|
||||
*
|
||||
* 1. The origin of this software must not be misrepresented; you must not
|
||||
* claim that you wrote the original software. If you use this software
|
||||
* in a product, an acknowledgment in the product documentation would be
|
||||
* appreciated but is not required.
|
||||
* 2. Altered source versions must be plainly marked as such, and must not be
|
||||
* misrepresented as being the original software.
|
||||
* 3. This notice may not be removed or altered from any source distribution.
|
||||
**/
|
||||
|
||||
#ifndef LOVE_GRAPHICS_PARTICLE_SYSTEM_H
|
||||
#define LOVE_GRAPHICS_PARTICLE_SYSTEM_H
|
||||
|
||||
// LOVE
|
||||
#include "common/int.h"
|
||||
#include "common/math.h"
|
||||
#include "common/Vector.h"
|
||||
#include "Drawable.h"
|
||||
#include "Color.h"
|
||||
#include "Quad.h"
|
||||
#include "Texture.h"
|
||||
|
||||
// STL
|
||||
#include <vector>
|
||||
|
||||
namespace love
|
||||
{
|
||||
namespace graphics
|
||||
{
|
||||
|
||||
/**
|
||||
* A class for creating, moving and drawing particles.
|
||||
* A big thanks to bobthebloke.org
|
||||
**/
|
||||
class ParticleSystem : public Drawable
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Type of distribution new particles are drawn from: None, uniform, normal.
|
||||
*/
|
||||
enum AreaSpreadDistribution
|
||||
{
|
||||
DISTRIBUTION_NONE,
|
||||
DISTRIBUTION_UNIFORM,
|
||||
DISTRIBUTION_NORMAL,
|
||||
DISTRIBUTION_MAX_ENUM
|
||||
};
|
||||
|
||||
/**
|
||||
* Insertion modes of new particles in the list: top, bottom, random.
|
||||
*/
|
||||
enum InsertMode
|
||||
{
|
||||
INSERT_MODE_TOP,
|
||||
INSERT_MODE_BOTTOM,
|
||||
INSERT_MODE_RANDOM,
|
||||
INSERT_MODE_MAX_ENUM
|
||||
};
|
||||
|
||||
/**
|
||||
* Maximum numbers of particles in a ParticleSystem.
|
||||
* This limit comes from the fact that a quad requires four vertices and the
|
||||
* OpenGL API where GLsizei is a signed int.
|
||||
**/
|
||||
static const uint32 MAX_PARTICLES = LOVE_INT32_MAX / 4;
|
||||
|
||||
/**
|
||||
* Creates a particle system with the specified buffer size and texture.
|
||||
**/
|
||||
ParticleSystem(Texture *texture, uint32 buffer);
|
||||
ParticleSystem(const ParticleSystem &p);
|
||||
|
||||
/**
|
||||
* Deletes any allocated memory.
|
||||
**/
|
||||
virtual ~ParticleSystem();
|
||||
|
||||
/**
|
||||
* Creates an identical copy of this ParticleSystem. The clone does not
|
||||
* duplicate any existing particles from this ParticleSystem, just the
|
||||
* settable parameters.
|
||||
**/
|
||||
virtual ParticleSystem *clone() = 0;
|
||||
|
||||
/**
|
||||
* Sets the texture used in the particle system.
|
||||
* @param texture The new texture.
|
||||
**/
|
||||
void setTexture(Texture *texture);
|
||||
|
||||
/**
|
||||
* Returns the texture used when drawing the particle system.
|
||||
**/
|
||||
Texture *getTexture() const;
|
||||
|
||||
/**
|
||||
* Clears the current buffer and allocates the appropriate amount of space for the buffer.
|
||||
* @param size The new buffer size.
|
||||
**/
|
||||
virtual void setBufferSize(uint32 size);
|
||||
|
||||
/**
|
||||
* Returns the total amount of particles this ParticleSystem can have active
|
||||
* at any given point in time.
|
||||
**/
|
||||
uint32 getBufferSize() const;
|
||||
|
||||
/**
|
||||
* Sets the insert mode for new particles.
|
||||
* @param mode The new insert mode.
|
||||
*/
|
||||
void setInsertMode(InsertMode mode);
|
||||
|
||||
/**
|
||||
* Returns the current insert mode.
|
||||
*/
|
||||
InsertMode getInsertMode() const;
|
||||
|
||||
/**
|
||||
* Sets the emission rate.
|
||||
* @param rate The amount of particles per second.
|
||||
**/
|
||||
void setEmissionRate(float rate);
|
||||
|
||||
/**
|
||||
* Returns the number of particles created per second.
|
||||
**/
|
||||
float getEmissionRate() const;
|
||||
|
||||
/**
|
||||
* Sets the lifetime of the particle emitter (-1 means eternal)
|
||||
* @param life The lifetime (in seconds).
|
||||
**/
|
||||
void setEmitterLifetime(float life);
|
||||
|
||||
/**
|
||||
* Returns the lifetime of the particle emitter.
|
||||
**/
|
||||
float getEmitterLifetime() const;
|
||||
|
||||
/**
|
||||
* Sets the life range of the particles.
|
||||
* @param min The minimum life.
|
||||
* @param max The maximum life (if 0, then becomes the same as minimum life).
|
||||
**/
|
||||
void setParticleLifetime(float min, float max = 0);
|
||||
|
||||
/**
|
||||
* Gets the lifetime of a particle.
|
||||
* @param[out] min The minimum life.
|
||||
* @param[out] max The maximum life.
|
||||
**/
|
||||
void getParticleLifetime(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the position of the center of the emitter.
|
||||
* Used to move the emitter without changing the position of already existing particles.
|
||||
* @param x The x-coordinate.
|
||||
* @param y The y-coordinate.
|
||||
**/
|
||||
void setPosition(float x, float y);
|
||||
|
||||
/**
|
||||
* Returns the position of the emitter.
|
||||
**/
|
||||
const love::Vector &getPosition() const;
|
||||
|
||||
/**
|
||||
* Moves the position of the center of the emitter.
|
||||
* When update is called, newly spawned particles will appear in a line
|
||||
* between the old emitter position and where the emitter was moved to,
|
||||
* resulting in a smoother-feeling particle system if moveTo is called
|
||||
* repeatedly.
|
||||
**/
|
||||
void moveTo(float x, float y);
|
||||
|
||||
/**
|
||||
* Sets the emission area spread parameters and distribution type. The interpretation of
|
||||
* the parameters depends on the distribution type:
|
||||
*
|
||||
* * None: Parameters are ignored. No area spread.
|
||||
* * Uniform: Parameters denote maximal (symmetric) displacement from emitter position.
|
||||
* * Normal: Parameters denote the standard deviation in x and y direction. x and y are assumed to be uncorrelated.
|
||||
* @param x First parameter. Interpretation depends on distribution type.
|
||||
* @param y Second parameter. Interpretation depends on distribution type.
|
||||
* @param distribution Distribution type
|
||||
**/
|
||||
void setAreaSpread(AreaSpreadDistribution distribution, float x, float y);
|
||||
|
||||
/**
|
||||
* Returns area spread distribution type.
|
||||
**/
|
||||
AreaSpreadDistribution getAreaSpreadDistribution() const;
|
||||
|
||||
/**
|
||||
* Returns area spread parameters.
|
||||
**/
|
||||
const love::Vector &getAreaSpreadParameters() const;
|
||||
|
||||
/**
|
||||
* Sets the direction of the particle emitter.
|
||||
* @param direction The direction (in degrees).
|
||||
**/
|
||||
void setDirection(float direction);
|
||||
|
||||
/**
|
||||
* Returns the direction of the particle emitter (in radians).
|
||||
**/
|
||||
float getDirection() const;
|
||||
|
||||
/**
|
||||
* Sets the spread of the particle emitter.
|
||||
* @param spread The spread (in radians).
|
||||
**/
|
||||
void setSpread(float spread);
|
||||
|
||||
/**
|
||||
* Returns the directional spread of the emitter (in radians).
|
||||
**/
|
||||
float getSpread() const;
|
||||
|
||||
/**
|
||||
* Sets the speed of the particles.
|
||||
* @param speed The speed.
|
||||
**/
|
||||
void setSpeed(float speed);
|
||||
|
||||
/**
|
||||
* Sets the speed of the particles.
|
||||
* @param min The minimum speed.
|
||||
* @param max The maximum speed.
|
||||
**/
|
||||
void setSpeed(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the speed of the particles.
|
||||
* @param[out] min The minimum speed.
|
||||
* @param[out] max The maximum speed.
|
||||
**/
|
||||
void getSpeed(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the linear acceleration (the acceleration along the x and y axes).
|
||||
* @param x The acceleration along the x-axis.
|
||||
* @param y The acceleration along the y-axis.
|
||||
**/
|
||||
void setLinearAcceleration(float x, float y);
|
||||
|
||||
/**
|
||||
* Sets the linear acceleration (the acceleration along the x and y axes).
|
||||
* @param xmin The minimum amount of acceleration along the x-axis.
|
||||
* @param ymin The minimum amount of acceleration along the y-axis.
|
||||
* @param xmax The maximum amount of acceleration along the x-axis.
|
||||
* @param ymax The maximum amount of acceleration along the y-axis.
|
||||
**/
|
||||
void setLinearAcceleration(float xmin, float ymin, float xmax, float ymax);
|
||||
|
||||
/**
|
||||
* Gets the linear acceleration of the particles.
|
||||
* @param[out] min The minimum acceleration.
|
||||
* @param[out] max The maximum acceleration.
|
||||
**/
|
||||
void getLinearAcceleration(love::Vector &min, love::Vector &max) const;
|
||||
|
||||
/**
|
||||
* Sets the radial acceleration (the acceleration towards the particle emitter).
|
||||
* @param acceleration The amount of acceleration.
|
||||
**/
|
||||
void setRadialAcceleration(float acceleration);
|
||||
|
||||
/**
|
||||
* Sets the radial acceleration (the acceleration towards the particle emitter).
|
||||
* @param min The minimum acceleration.
|
||||
* @param max The maximum acceleration.
|
||||
**/
|
||||
void setRadialAcceleration(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the radial acceleration.
|
||||
* @param[out] min The minimum amount of radial acceleration.
|
||||
* @param[out] max The maximum amount of radial acceleration.
|
||||
**/
|
||||
void getRadialAcceleration(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the tangential acceleration (the acceleration perpendicular to the particle's direction).
|
||||
* @param acceleration The amount of acceleration.
|
||||
**/
|
||||
void setTangentialAcceleration(float acceleration);
|
||||
|
||||
/**
|
||||
* Sets the tangential acceleration (the acceleration perpendicular to the particle's direction).
|
||||
* @param min The minimum acceleration.
|
||||
* @param max The maximum acceleration.
|
||||
**/
|
||||
void setTangentialAcceleration(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the tangential acceleration.
|
||||
* @param[out] min The minimum tangential acceleration.
|
||||
* @param[out] max The maximum tangential acceleration.
|
||||
**/
|
||||
void getTangentialAcceleration(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the amount of linear damping. Damping reduces the velocity of
|
||||
* particles over time. A value of 0 corresponds to no damping.
|
||||
**/
|
||||
void setLinearDamping(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the current amount of linear damping.
|
||||
**/
|
||||
void getLinearDamping(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the size of the sprite (1.0 being the default size).
|
||||
* @param size The size of the sprite.
|
||||
**/
|
||||
void setSize(float size);
|
||||
|
||||
/**
|
||||
* Sets the sizes of the sprite upon creation and upon death (1.0 being the default size).
|
||||
* @param newSizes Array of sizes
|
||||
**/
|
||||
void setSizes(const std::vector<float> &newSizes);
|
||||
|
||||
/**
|
||||
* Returns the sizes of the particle sprites.
|
||||
**/
|
||||
const std::vector<float> &getSizes() const;
|
||||
|
||||
/**
|
||||
* Sets the amount of variation to the sprite's beginning size (0 being no variation and 1.0 a random size between start and end).
|
||||
* @param variation The amount of variation.
|
||||
**/
|
||||
void setSizeVariation(float variation);
|
||||
|
||||
/**
|
||||
* Returns the amount of initial size variation between particles.
|
||||
**/
|
||||
float getSizeVariation() const;
|
||||
|
||||
/**
|
||||
* Sets the amount of rotation a sprite starts out with.
|
||||
* @param rotation The amount of rotation.
|
||||
**/
|
||||
void setRotation(float rotation);
|
||||
|
||||
/**
|
||||
* Sets the amount of rotation a sprite starts out with (a random value between min and max).
|
||||
* @param min The minimum amount of rotation.
|
||||
* @param max The maximum amount of rotation.
|
||||
**/
|
||||
void setRotation(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the initial amount of rotation of a particle, in radians.
|
||||
* @param[out] min The minimum initial rotation.
|
||||
* @param[out] max The maximum initial rotation.
|
||||
**/
|
||||
void getRotation(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the spin of the sprite.
|
||||
* @param spin The spin of the sprite (in degrees).
|
||||
**/
|
||||
void setSpin(float spin);
|
||||
|
||||
/**
|
||||
* Sets the spin of the sprite upon particle creation and death.
|
||||
* @param start The spin of the sprite upon creation (in radians / second).
|
||||
* @param end The spin of the sprite upon death (in radians / second).
|
||||
**/
|
||||
void setSpin(float start, float end);
|
||||
|
||||
/**
|
||||
* Gets the amount of spin of a particle during its lifetime.
|
||||
* @param[out] start The initial spin, in radians / s.
|
||||
* @param[out] end The final spin, in radians / s.
|
||||
**/
|
||||
void getSpin(float &start, float &end) const;
|
||||
|
||||
/**
|
||||
* Sets the variation of the start spin (0 being no variation and 1 being a random spin between start and end).
|
||||
* @param variation The variation.
|
||||
**/
|
||||
void setSpinVariation(float variation);
|
||||
|
||||
/**
|
||||
* Returns the amount of variation of the start spin of a particle.
|
||||
**/
|
||||
float getSpinVariation() const;
|
||||
|
||||
/**
|
||||
* Sets the particles' offsets for rotation.
|
||||
* @param x The x offset.
|
||||
* @param y The y offset.
|
||||
**/
|
||||
void setOffset(float x, float y);
|
||||
|
||||
/**
|
||||
* Returns of the particle offset.
|
||||
**/
|
||||
love::Vector getOffset() const;
|
||||
|
||||
/**
|
||||
* Sets the color of the particles.
|
||||
* @param newColors Array of colors
|
||||
**/
|
||||
void setColor(const std::vector<Colorf> &newColors);
|
||||
|
||||
/**
|
||||
* Returns the color of the particles.
|
||||
**/
|
||||
std::vector<Colorf> getColor() const;
|
||||
|
||||
/**
|
||||
* Sets a list of Quads to use for particles over their lifetime.
|
||||
**/
|
||||
void setQuads(const std::vector<Quad *> &newQuads);
|
||||
void setQuads();
|
||||
|
||||
/**
|
||||
* Gets the Quads used when drawing the particles.
|
||||
**/
|
||||
std::vector<Quad *> getQuads() const;
|
||||
|
||||
/**
|
||||
* sets whether particle angles & rotations are relative to their velocities.
|
||||
**/
|
||||
void setRelativeRotation(bool enable);
|
||||
bool hasRelativeRotation() const;
|
||||
|
||||
/**
|
||||
* Returns the amount of particles that are currently active in the system.
|
||||
**/
|
||||
uint32 getCount() const;
|
||||
|
||||
/**
|
||||
* Starts/resumes the particle emitter.
|
||||
**/
|
||||
void start();
|
||||
|
||||
/**
|
||||
* Stops the particle emitter and resets.
|
||||
**/
|
||||
void stop();
|
||||
|
||||
/**
|
||||
* Pauses the particle emitter.
|
||||
**/
|
||||
void pause();
|
||||
|
||||
/**
|
||||
* Resets the particle emitter.
|
||||
**/
|
||||
void reset();
|
||||
|
||||
/**
|
||||
* Instantly emits a number of particles.
|
||||
* @param num The number of particles to emit.
|
||||
**/
|
||||
void emit(uint32 num);
|
||||
|
||||
/**
|
||||
* Returns whether the particle emitter is active.
|
||||
**/
|
||||
bool isActive() const;
|
||||
|
||||
/**
|
||||
* Returns whether the particle emitter is paused.
|
||||
**/
|
||||
bool isPaused() const;
|
||||
|
||||
bool isStopped() const;
|
||||
|
||||
/**
|
||||
* Returns whether the particle system is empty of particles or not.
|
||||
**/
|
||||
bool isEmpty() const;
|
||||
|
||||
/**
|
||||
* Returns whether the amount of particles has reached the buffer limit or not.
|
||||
**/
|
||||
bool isFull() const;
|
||||
|
||||
/**
|
||||
* Updates the particle system.
|
||||
* @param dt Time since last update.
|
||||
**/
|
||||
void update(float dt);
|
||||
|
||||
static bool getConstant(const char *in, AreaSpreadDistribution &out);
|
||||
static bool getConstant(AreaSpreadDistribution in, const char *&out);
|
||||
|
||||
static bool getConstant(const char *in, InsertMode &out);
|
||||
static bool getConstant(InsertMode in, const char *&out);
|
||||
|
||||
protected:
|
||||
|
||||
// Represents a single particle.
|
||||
struct Particle
|
||||
{
|
||||
Particle *prev;
|
||||
Particle *next;
|
||||
|
||||
float lifetime;
|
||||
float life;
|
||||
|
||||
love::Vector position;
|
||||
|
||||
// Particles gravitate towards this point.
|
||||
love::Vector origin;
|
||||
|
||||
love::Vector velocity;
|
||||
love::Vector linearAcceleration;
|
||||
float radialAcceleration;
|
||||
float tangentialAcceleration;
|
||||
|
||||
float linearDamping;
|
||||
|
||||
float size;
|
||||
float sizeOffset;
|
||||
float sizeIntervalSize;
|
||||
|
||||
float rotation; // Amount of rotation applied to the final angle.
|
||||
float angle;
|
||||
float spinStart;
|
||||
float spinEnd;
|
||||
|
||||
Colorf color;
|
||||
|
||||
int quadIndex;
|
||||
};
|
||||
|
||||
// Pointer to the beginning of the allocated memory.
|
||||
Particle *pMem;
|
||||
|
||||
// Pointer to a free particle.
|
||||
Particle *pFree;
|
||||
|
||||
// Pointer to the start of the linked list.
|
||||
Particle *pHead;
|
||||
|
||||
// Pointer to the end of the linked list.
|
||||
Particle *pTail;
|
||||
|
||||
// The texture to be drawn.
|
||||
StrongRef<Texture> texture;
|
||||
|
||||
// Whether the particle emitter is active.
|
||||
bool active;
|
||||
|
||||
// Insert mode of new particles.
|
||||
InsertMode insertMode;
|
||||
|
||||
// The maximum number of particles.
|
||||
uint32 maxParticles;
|
||||
|
||||
// The number of active particles.
|
||||
uint32 activeParticles;
|
||||
|
||||
// The emission rate (particles/sec).
|
||||
float emissionRate;
|
||||
|
||||
// Used to determine when a particle should be emitted.
|
||||
float emitCounter;
|
||||
|
||||
// The relative position of the particle emitter.
|
||||
love::Vector position;
|
||||
love::Vector prevPosition;
|
||||
|
||||
// Emission area spread.
|
||||
AreaSpreadDistribution areaSpreadDistribution;
|
||||
love::Vector areaSpread;
|
||||
|
||||
// The lifetime of the particle emitter (-1 means infinite) and the life it has left.
|
||||
float lifetime;
|
||||
float life;
|
||||
|
||||
// The particle life.
|
||||
float particleLifeMin;
|
||||
float particleLifeMax;
|
||||
|
||||
// The direction (and spread) the particles will be emitted in. Measured in radians.
|
||||
float direction;
|
||||
float spread;
|
||||
|
||||
// The speed.
|
||||
float speedMin;
|
||||
float speedMax;
|
||||
|
||||
// Acceleration along the x and y axes.
|
||||
love::Vector linearAccelerationMin;
|
||||
love::Vector linearAccelerationMax;
|
||||
|
||||
// Acceleration towards the emitter's center
|
||||
float radialAccelerationMin;
|
||||
float radialAccelerationMax;
|
||||
|
||||
// Acceleration perpendicular to the particle's direction.
|
||||
float tangentialAccelerationMin;
|
||||
float tangentialAccelerationMax;
|
||||
|
||||
float linearDampingMin;
|
||||
float linearDampingMax;
|
||||
|
||||
// Size.
|
||||
std::vector<float> sizes;
|
||||
float sizeVariation;
|
||||
|
||||
// Rotation
|
||||
float rotationMin;
|
||||
float rotationMax;
|
||||
|
||||
// Spin.
|
||||
float spinStart;
|
||||
float spinEnd;
|
||||
float spinVariation;
|
||||
|
||||
// Offsets
|
||||
love::Vector offset;
|
||||
|
||||
// Is the ParticleSystem using a default offset?
|
||||
bool defaultOffset;
|
||||
|
||||
// Color.
|
||||
std::vector<Colorf> colors;
|
||||
|
||||
// Quads.
|
||||
std::vector<StrongRef<Quad>> quads;
|
||||
|
||||
bool relativeRotation;
|
||||
|
||||
private:
|
||||
|
||||
void resetOffset();
|
||||
|
||||
void createBuffers(size_t size);
|
||||
void deleteBuffers();
|
||||
|
||||
void addParticle(float t);
|
||||
Particle *removeParticle(Particle *p);
|
||||
|
||||
// Called by addParticle.
|
||||
void initParticle(Particle *p, float t);
|
||||
void insertTop(Particle *p);
|
||||
void insertBottom(Particle *p);
|
||||
void insertRandom(Particle *p);
|
||||
|
||||
static StringMap<AreaSpreadDistribution, DISTRIBUTION_MAX_ENUM>::Entry distributionsEntries[];
|
||||
static StringMap<AreaSpreadDistribution, DISTRIBUTION_MAX_ENUM> distributions;
|
||||
|
||||
static StringMap<InsertMode, INSERT_MODE_MAX_ENUM>::Entry insertModesEntries[];
|
||||
static StringMap<InsertMode, INSERT_MODE_MAX_ENUM> insertModes;
|
||||
};
|
||||
|
||||
} // graphics
|
||||
} // love
|
||||
|
||||
#endif // LOVE_GRAPHICS_PARTICLE_SYSTEM_H
|
||||
File diff suppressed because it is too large
Load Diff
@@ -22,18 +22,9 @@
|
||||
#define LOVE_GRAPHICS_OPENGL_PARTICLE_SYSTEM_H
|
||||
|
||||
// LOVE
|
||||
#include "common/int.h"
|
||||
#include "common/math.h"
|
||||
#include "common/Vector.h"
|
||||
#include "graphics/Drawable.h"
|
||||
#include "graphics/Color.h"
|
||||
#include "graphics/Quad.h"
|
||||
#include "graphics/Texture.h"
|
||||
#include "graphics/ParticleSystem.h"
|
||||
#include "GLBuffer.h"
|
||||
|
||||
// STL
|
||||
#include <vector>
|
||||
|
||||
namespace love
|
||||
{
|
||||
namespace graphics
|
||||
@@ -41,643 +32,28 @@ namespace graphics
|
||||
namespace opengl
|
||||
{
|
||||
|
||||
/**
|
||||
* A class for creating, moving and drawing particles.
|
||||
* A big thanks to bobthebloke.org
|
||||
**/
|
||||
class ParticleSystem : public Drawable
|
||||
class ParticleSystem : public love::graphics::ParticleSystem
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Type of distribution new particles are drawn from: None, uniform, normal.
|
||||
*/
|
||||
enum AreaSpreadDistribution
|
||||
{
|
||||
DISTRIBUTION_NONE,
|
||||
DISTRIBUTION_UNIFORM,
|
||||
DISTRIBUTION_NORMAL,
|
||||
DISTRIBUTION_MAX_ENUM
|
||||
};
|
||||
|
||||
/**
|
||||
* Insertion modes of new particles in the list: top, bottom, random.
|
||||
*/
|
||||
enum InsertMode
|
||||
{
|
||||
INSERT_MODE_TOP,
|
||||
INSERT_MODE_BOTTOM,
|
||||
INSERT_MODE_RANDOM,
|
||||
INSERT_MODE_MAX_ENUM
|
||||
};
|
||||
|
||||
/**
|
||||
* Maximum numbers of particles in a ParticleSystem.
|
||||
* This limit comes from the fact that a quad requires four vertices and the
|
||||
* OpenGL API where GLsizei is a signed int.
|
||||
**/
|
||||
static const uint32 MAX_PARTICLES = LOVE_INT32_MAX / 4;
|
||||
|
||||
/**
|
||||
* Creates a particle system with the specified buffer size and texture.
|
||||
**/
|
||||
ParticleSystem(Texture *texture, uint32 buffer);
|
||||
ParticleSystem(const ParticleSystem &p);
|
||||
|
||||
/**
|
||||
* Deletes any allocated memory.
|
||||
**/
|
||||
virtual ~ParticleSystem();
|
||||
|
||||
/**
|
||||
* Creates an identical copy of this ParticleSystem. The clone does not
|
||||
* duplicate any existing particles from this ParticleSystem, just the
|
||||
* settable parameters.
|
||||
**/
|
||||
ParticleSystem *clone();
|
||||
ParticleSystem *clone() override;
|
||||
void setBufferSize(uint32 size) override;
|
||||
void draw(float x, float y, float angle, float sx, float sy, float ox, float oy, float kx, float ky) override;
|
||||
|
||||
/**
|
||||
* Sets the texture used in the particle system.
|
||||
* @param texture The new texture.
|
||||
**/
|
||||
void setTexture(Texture *texture);
|
||||
private:
|
||||
|
||||
/**
|
||||
* Returns the texture used when drawing the particle system.
|
||||
**/
|
||||
Texture *getTexture() const;
|
||||
|
||||
/**
|
||||
* Clears the current buffer and allocates the appropriate amount of space for the buffer.
|
||||
* @param size The new buffer size.
|
||||
**/
|
||||
void setBufferSize(uint32 size);
|
||||
|
||||
/**
|
||||
* Returns the total amount of particles this ParticleSystem can have active
|
||||
* at any given point in time.
|
||||
**/
|
||||
uint32 getBufferSize() const;
|
||||
|
||||
/**
|
||||
* Sets the insert mode for new particles.
|
||||
* @param mode The new insert mode.
|
||||
*/
|
||||
void setInsertMode(InsertMode mode);
|
||||
|
||||
/**
|
||||
* Returns the current insert mode.
|
||||
*/
|
||||
InsertMode getInsertMode() const;
|
||||
|
||||
/**
|
||||
* Sets the emission rate.
|
||||
* @param rate The amount of particles per second.
|
||||
**/
|
||||
void setEmissionRate(float rate);
|
||||
|
||||
/**
|
||||
* Returns the number of particles created per second.
|
||||
**/
|
||||
float getEmissionRate() const;
|
||||
|
||||
/**
|
||||
* Sets the lifetime of the particle emitter (-1 means eternal)
|
||||
* @param life The lifetime (in seconds).
|
||||
**/
|
||||
void setEmitterLifetime(float life);
|
||||
|
||||
/**
|
||||
* Returns the lifetime of the particle emitter.
|
||||
**/
|
||||
float getEmitterLifetime() const;
|
||||
|
||||
/**
|
||||
* Sets the life range of the particles.
|
||||
* @param min The minimum life.
|
||||
* @param max The maximum life (if 0, then becomes the same as minimum life).
|
||||
**/
|
||||
void setParticleLifetime(float min, float max = 0);
|
||||
|
||||
/**
|
||||
* Gets the lifetime of a particle.
|
||||
* @param[out] min The minimum life.
|
||||
* @param[out] max The maximum life.
|
||||
**/
|
||||
void getParticleLifetime(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the position of the center of the emitter.
|
||||
* Used to move the emitter without changing the position of already existing particles.
|
||||
* @param x The x-coordinate.
|
||||
* @param y The y-coordinate.
|
||||
**/
|
||||
void setPosition(float x, float y);
|
||||
|
||||
/**
|
||||
* Returns the position of the emitter.
|
||||
**/
|
||||
const love::Vector &getPosition() const;
|
||||
|
||||
/**
|
||||
* Moves the position of the center of the emitter.
|
||||
* When update is called, newly spawned particles will appear in a line
|
||||
* between the old emitter position and where the emitter was moved to,
|
||||
* resulting in a smoother-feeling particle system if moveTo is called
|
||||
* repeatedly.
|
||||
**/
|
||||
void moveTo(float x, float y);
|
||||
|
||||
/**
|
||||
* Sets the emission area spread parameters and distribution type. The interpretation of
|
||||
* the parameters depends on the distribution type:
|
||||
*
|
||||
* * None: Parameters are ignored. No area spread.
|
||||
* * Uniform: Parameters denote maximal (symmetric) displacement from emitter position.
|
||||
* * Normal: Parameters denote the standard deviation in x and y direction. x and y are assumed to be uncorrelated.
|
||||
* @param x First parameter. Interpretation depends on distribution type.
|
||||
* @param y Second parameter. Interpretation depends on distribution type.
|
||||
* @param distribution Distribution type
|
||||
**/
|
||||
void setAreaSpread(AreaSpreadDistribution distribution, float x, float y);
|
||||
|
||||
/**
|
||||
* Returns area spread distribution type.
|
||||
**/
|
||||
AreaSpreadDistribution getAreaSpreadDistribution() const;
|
||||
|
||||
/**
|
||||
* Returns area spread parameters.
|
||||
**/
|
||||
const love::Vector &getAreaSpreadParameters() const;
|
||||
|
||||
/**
|
||||
* Sets the direction of the particle emitter.
|
||||
* @param direction The direction (in degrees).
|
||||
**/
|
||||
void setDirection(float direction);
|
||||
|
||||
/**
|
||||
* Returns the direction of the particle emitter (in radians).
|
||||
**/
|
||||
float getDirection() const;
|
||||
|
||||
/**
|
||||
* Sets the spread of the particle emitter.
|
||||
* @param spread The spread (in radians).
|
||||
**/
|
||||
void setSpread(float spread);
|
||||
|
||||
/**
|
||||
* Returns the directional spread of the emitter (in radians).
|
||||
**/
|
||||
float getSpread() const;
|
||||
|
||||
/**
|
||||
* Sets the speed of the particles.
|
||||
* @param speed The speed.
|
||||
**/
|
||||
void setSpeed(float speed);
|
||||
|
||||
/**
|
||||
* Sets the speed of the particles.
|
||||
* @param min The minimum speed.
|
||||
* @param max The maximum speed.
|
||||
**/
|
||||
void setSpeed(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the speed of the particles.
|
||||
* @param[out] min The minimum speed.
|
||||
* @param[out] max The maximum speed.
|
||||
**/
|
||||
void getSpeed(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the linear acceleration (the acceleration along the x and y axes).
|
||||
* @param x The acceleration along the x-axis.
|
||||
* @param y The acceleration along the y-axis.
|
||||
**/
|
||||
void setLinearAcceleration(float x, float y);
|
||||
|
||||
/**
|
||||
* Sets the linear acceleration (the acceleration along the x and y axes).
|
||||
* @param xmin The minimum amount of acceleration along the x-axis.
|
||||
* @param ymin The minimum amount of acceleration along the y-axis.
|
||||
* @param xmax The maximum amount of acceleration along the x-axis.
|
||||
* @param ymax The maximum amount of acceleration along the y-axis.
|
||||
**/
|
||||
void setLinearAcceleration(float xmin, float ymin, float xmax, float ymax);
|
||||
|
||||
/**
|
||||
* Gets the linear acceleration of the particles.
|
||||
* @param[out] min The minimum acceleration.
|
||||
* @param[out] max The maximum acceleration.
|
||||
**/
|
||||
void getLinearAcceleration(love::Vector &min, love::Vector &max) const;
|
||||
|
||||
/**
|
||||
* Sets the radial acceleration (the acceleration towards the particle emitter).
|
||||
* @param acceleration The amount of acceleration.
|
||||
**/
|
||||
void setRadialAcceleration(float acceleration);
|
||||
|
||||
/**
|
||||
* Sets the radial acceleration (the acceleration towards the particle emitter).
|
||||
* @param min The minimum acceleration.
|
||||
* @param max The maximum acceleration.
|
||||
**/
|
||||
void setRadialAcceleration(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the radial acceleration.
|
||||
* @param[out] min The minimum amount of radial acceleration.
|
||||
* @param[out] max The maximum amount of radial acceleration.
|
||||
**/
|
||||
void getRadialAcceleration(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the tangential acceleration (the acceleration perpendicular to the particle's direction).
|
||||
* @param acceleration The amount of acceleration.
|
||||
**/
|
||||
void setTangentialAcceleration(float acceleration);
|
||||
|
||||
/**
|
||||
* Sets the tangential acceleration (the acceleration perpendicular to the particle's direction).
|
||||
* @param min The minimum acceleration.
|
||||
* @param max The maximum acceleration.
|
||||
**/
|
||||
void setTangentialAcceleration(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the tangential acceleration.
|
||||
* @param[out] min The minimum tangential acceleration.
|
||||
* @param[out] max The maximum tangential acceleration.
|
||||
**/
|
||||
void getTangentialAcceleration(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the amount of linear damping. Damping reduces the velocity of
|
||||
* particles over time. A value of 0 corresponds to no damping.
|
||||
**/
|
||||
void setLinearDamping(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the current amount of linear damping.
|
||||
**/
|
||||
void getLinearDamping(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the size of the sprite (1.0 being the default size).
|
||||
* @param size The size of the sprite.
|
||||
**/
|
||||
void setSize(float size);
|
||||
|
||||
/**
|
||||
* Sets the sizes of the sprite upon creation and upon death (1.0 being the default size).
|
||||
* @param newSizes Array of sizes
|
||||
**/
|
||||
void setSizes(const std::vector<float> &newSizes);
|
||||
|
||||
/**
|
||||
* Returns the sizes of the particle sprites.
|
||||
**/
|
||||
const std::vector<float> &getSizes() const;
|
||||
|
||||
/**
|
||||
* Sets the amount of variation to the sprite's beginning size (0 being no variation and 1.0 a random size between start and end).
|
||||
* @param variation The amount of variation.
|
||||
**/
|
||||
void setSizeVariation(float variation);
|
||||
|
||||
/**
|
||||
* Returns the amount of initial size variation between particles.
|
||||
**/
|
||||
float getSizeVariation() const;
|
||||
|
||||
/**
|
||||
* Sets the amount of rotation a sprite starts out with.
|
||||
* @param rotation The amount of rotation.
|
||||
**/
|
||||
void setRotation(float rotation);
|
||||
|
||||
/**
|
||||
* Sets the amount of rotation a sprite starts out with (a random value between min and max).
|
||||
* @param min The minimum amount of rotation.
|
||||
* @param max The maximum amount of rotation.
|
||||
**/
|
||||
void setRotation(float min, float max);
|
||||
|
||||
/**
|
||||
* Gets the initial amount of rotation of a particle, in radians.
|
||||
* @param[out] min The minimum initial rotation.
|
||||
* @param[out] max The maximum initial rotation.
|
||||
**/
|
||||
void getRotation(float &min, float &max) const;
|
||||
|
||||
/**
|
||||
* Sets the spin of the sprite.
|
||||
* @param spin The spin of the sprite (in degrees).
|
||||
**/
|
||||
void setSpin(float spin);
|
||||
|
||||
/**
|
||||
* Sets the spin of the sprite upon particle creation and death.
|
||||
* @param start The spin of the sprite upon creation (in radians / second).
|
||||
* @param end The spin of the sprite upon death (in radians / second).
|
||||
**/
|
||||
void setSpin(float start, float end);
|
||||
|
||||
/**
|
||||
* Gets the amount of spin of a particle during its lifetime.
|
||||
* @param[out] start The initial spin, in radians / s.
|
||||
* @param[out] end The final spin, in radians / s.
|
||||
**/
|
||||
void getSpin(float &start, float &end) const;
|
||||
|
||||
/**
|
||||
* Sets the variation of the start spin (0 being no variation and 1 being a random spin between start and end).
|
||||
* @param variation The variation.
|
||||
**/
|
||||
void setSpinVariation(float variation);
|
||||
|
||||
/**
|
||||
* Returns the amount of variation of the start spin of a particle.
|
||||
**/
|
||||
float getSpinVariation() const;
|
||||
|
||||
/**
|
||||
* Sets the particles' offsets for rotation.
|
||||
* @param x The x offset.
|
||||
* @param y The y offset.
|
||||
**/
|
||||
void setOffset(float x, float y);
|
||||
|
||||
/**
|
||||
* Returns of the particle offset.
|
||||
**/
|
||||
love::Vector getOffset() const;
|
||||
|
||||
/**
|
||||
* Sets the color of the particles.
|
||||
* @param newColors Array of colors
|
||||
**/
|
||||
void setColor(const std::vector<Colorf> &newColors);
|
||||
|
||||
/**
|
||||
* Returns the color of the particles.
|
||||
**/
|
||||
std::vector<Colorf> getColor() const;
|
||||
|
||||
/**
|
||||
* Sets a list of Quads to use for particles over their lifetime.
|
||||
**/
|
||||
void setQuads(const std::vector<Quad *> &newQuads);
|
||||
void setQuads();
|
||||
|
||||
/**
|
||||
* Gets the Quads used when drawing the particles.
|
||||
**/
|
||||
std::vector<Quad *> getQuads() const;
|
||||
|
||||
/**
|
||||
* sets whether particle angles & rotations are relative to their velocities.
|
||||
**/
|
||||
void setRelativeRotation(bool enable);
|
||||
bool hasRelativeRotation() const;
|
||||
|
||||
/**
|
||||
* Returns the amount of particles that are currently active in the system.
|
||||
**/
|
||||
uint32 getCount() const;
|
||||
|
||||
/**
|
||||
* Starts/resumes the particle emitter.
|
||||
**/
|
||||
void start();
|
||||
|
||||
/**
|
||||
* Stops the particle emitter and resets.
|
||||
**/
|
||||
void stop();
|
||||
|
||||
/**
|
||||
* Pauses the particle emitter.
|
||||
**/
|
||||
void pause();
|
||||
|
||||
/**
|
||||
* Resets the particle emitter.
|
||||
**/
|
||||
void reset();
|
||||
|
||||
/**
|
||||
* Instantly emits a number of particles.
|
||||
* @param num The number of particles to emit.
|
||||
**/
|
||||
void emit(uint32 num);
|
||||
|
||||
/**
|
||||
* Returns whether the particle emitter is active.
|
||||
**/
|
||||
bool isActive() const;
|
||||
|
||||
/**
|
||||
* Returns whether the particle emitter is paused.
|
||||
**/
|
||||
bool isPaused() const;
|
||||
|
||||
bool isStopped() const;
|
||||
|
||||
/**
|
||||
* Returns whether the particle system is empty of particles or not.
|
||||
**/
|
||||
bool isEmpty() const;
|
||||
|
||||
/**
|
||||
* Returns whether the amount of particles has reached the buffer limit or not.
|
||||
**/
|
||||
bool isFull() const;
|
||||
|
||||
/**
|
||||
* Draws the particle emitter at the specified position.
|
||||
* @param x The x-coordinate.
|
||||
* @param y The y-coordinate.
|
||||
**/
|
||||
virtual void draw(float x, float y, float angle, float sx, float sy, float ox, float oy, float kx, float ky);
|
||||
|
||||
/**
|
||||
* Updates the particle system.
|
||||
* @param dt Time since last update.
|
||||
**/
|
||||
void update(float dt);
|
||||
|
||||
static bool getConstant(const char *in, AreaSpreadDistribution &out);
|
||||
static bool getConstant(AreaSpreadDistribution in, const char *&out);
|
||||
|
||||
static bool getConstant(const char *in, InsertMode &out);
|
||||
static bool getConstant(InsertMode in, const char *&out);
|
||||
|
||||
protected:
|
||||
|
||||
// Represents a single particle.
|
||||
struct Particle
|
||||
{
|
||||
Particle *prev;
|
||||
Particle *next;
|
||||
|
||||
float lifetime;
|
||||
float life;
|
||||
|
||||
love::Vector position;
|
||||
|
||||
// Particles gravitate towards this point.
|
||||
love::Vector origin;
|
||||
|
||||
love::Vector velocity;
|
||||
love::Vector linearAcceleration;
|
||||
float radialAcceleration;
|
||||
float tangentialAcceleration;
|
||||
|
||||
float linearDamping;
|
||||
|
||||
float size;
|
||||
float sizeOffset;
|
||||
float sizeIntervalSize;
|
||||
|
||||
float rotation; // Amount of rotation applied to the final angle.
|
||||
float angle;
|
||||
float spinStart;
|
||||
float spinEnd;
|
||||
|
||||
Colorf color;
|
||||
|
||||
int quadIndex;
|
||||
};
|
||||
|
||||
// Pointer to the beginning of the allocated memory.
|
||||
Particle *pMem;
|
||||
|
||||
// Pointer to a free particle.
|
||||
Particle *pFree;
|
||||
|
||||
// Pointer to the start of the linked list.
|
||||
Particle *pHead;
|
||||
|
||||
// Pointer to the end of the linked list.
|
||||
Particle *pTail;
|
||||
void createVertices(size_t numparticles);
|
||||
|
||||
// array of transformed vertex data for all particles, for drawing
|
||||
Vertex *particleVerts;
|
||||
|
||||
// Vertex index buffer.
|
||||
QuadIndices quadIndices;
|
||||
|
||||
// The texture to be drawn.
|
||||
StrongRef<Texture> texture;
|
||||
|
||||
// Whether the particle emitter is active.
|
||||
bool active;
|
||||
|
||||
// Insert mode of new particles.
|
||||
InsertMode insertMode;
|
||||
|
||||
// The maximum number of particles.
|
||||
uint32 maxParticles;
|
||||
|
||||
// The number of active particles.
|
||||
uint32 activeParticles;
|
||||
|
||||
// The emission rate (particles/sec).
|
||||
float emissionRate;
|
||||
|
||||
// Used to determine when a particle should be emitted.
|
||||
float emitCounter;
|
||||
|
||||
// The relative position of the particle emitter.
|
||||
love::Vector position;
|
||||
love::Vector prevPosition;
|
||||
|
||||
// Emission area spread.
|
||||
AreaSpreadDistribution areaSpreadDistribution;
|
||||
love::Vector areaSpread;
|
||||
|
||||
// The lifetime of the particle emitter (-1 means infinite) and the life it has left.
|
||||
float lifetime;
|
||||
float life;
|
||||
|
||||
// The particle life.
|
||||
float particleLifeMin;
|
||||
float particleLifeMax;
|
||||
|
||||
// The direction (and spread) the particles will be emitted in. Measured in radians.
|
||||
float direction;
|
||||
float spread;
|
||||
|
||||
// The speed.
|
||||
float speedMin;
|
||||
float speedMax;
|
||||
|
||||
// Acceleration along the x and y axes.
|
||||
love::Vector linearAccelerationMin;
|
||||
love::Vector linearAccelerationMax;
|
||||
|
||||
// Acceleration towards the emitter's center
|
||||
float radialAccelerationMin;
|
||||
float radialAccelerationMax;
|
||||
|
||||
// Acceleration perpendicular to the particle's direction.
|
||||
float tangentialAccelerationMin;
|
||||
float tangentialAccelerationMax;
|
||||
|
||||
float linearDampingMin;
|
||||
float linearDampingMax;
|
||||
|
||||
// Size.
|
||||
std::vector<float> sizes;
|
||||
float sizeVariation;
|
||||
|
||||
// Rotation
|
||||
float rotationMin;
|
||||
float rotationMax;
|
||||
|
||||
// Spin.
|
||||
float spinStart;
|
||||
float spinEnd;
|
||||
float spinVariation;
|
||||
|
||||
// Offsets
|
||||
love::Vector offset;
|
||||
|
||||
// Is the ParticleSystem using a default offset?
|
||||
bool defaultOffset;
|
||||
|
||||
// Color.
|
||||
std::vector<Colorf> colors;
|
||||
|
||||
// Quads.
|
||||
std::vector<StrongRef<Quad>> quads;
|
||||
|
||||
bool relativeRotation;
|
||||
|
||||
void resetOffset();
|
||||
|
||||
void createBuffers(size_t size);
|
||||
void deleteBuffers();
|
||||
|
||||
void addParticle(float t);
|
||||
Particle *removeParticle(Particle *p);
|
||||
|
||||
// Called by addParticle.
|
||||
void initParticle(Particle *p, float t);
|
||||
void insertTop(Particle *p);
|
||||
void insertBottom(Particle *p);
|
||||
void insertRandom(Particle *p);
|
||||
|
||||
static StringMap<AreaSpreadDistribution, DISTRIBUTION_MAX_ENUM>::Entry distributionsEntries[];
|
||||
static StringMap<AreaSpreadDistribution, DISTRIBUTION_MAX_ENUM> distributions;
|
||||
|
||||
static StringMap<InsertMode, INSERT_MODE_MAX_ENUM>::Entry insertModesEntries[];
|
||||
static StringMap<InsertMode, INSERT_MODE_MAX_ENUM> insertModes;
|
||||
};
|
||||
|
||||
} // opengl
|
||||
|
||||
Reference in New Issue
Block a user