spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

for (int i = 0; i < 10000; i++)
{
   if (v[i]);
}

C-/C++-Quelltext

#include <SFML\Graphics.hpp>
#include "Resources.hpp"


#define particleNumber 100000

struct particles
{
    enum Type
    {
        energy,
        airSplit,
        smoke,
        fire,
        typeCount
    };


    particles() { for (int i = 0; i < particleNumber; i++) isActive[i] = false; }

    bool isActive[particleNumber];
    float leftLifeTime[particleNumber];
    float xVelocity[particleNumber];
    float yVelocity[particleNumber];
};


class particleSystem : public sf::Drawable
{
public:
    explicit particleSystem(particles::Type type);

    void update(sf::Time timePerFrame);
    void addParticle(float xPos, float yPos, float xDirectionVelocity, float yDirectionVelocity);
    unsigned int getParticleCount() const;


private:
    void draw(sf::RenderTarget& target, sf::RenderStates states) const override;

private:
    particles::Type mType;
    float particleLifetime;
    const sf::Texture* mTexture;
    float xHalfTextureSize;
    float yHalfTextureSize;

    unsigned int nextFreeParticle;

    particles mParticles;
    sf::Vertex vertices[4 * particleNumber];
};

C-/C++-Quelltext

#include "particleSystem.hpp"



particleSystem::particleSystem(particles::Type type)
    :
    mType(type),
    mTexture(nullptr),
    nextFreeParticle(0)
{
    switch (type)
    {
    case particles::energy:
    {
        particleLifetime = 15.f;
        mTexture = &Resources::get()->getResource(Holder::particles, Texture::energy);
        break;
    }
    case particles::fire:
    {
        particleLifetime = 0.3f;
        mTexture = &Resources::get()->getResource(Holder::particles, Texture::fire);
        break;
    }
    case particles::smoke:
    {
        particleLifetime = 1.6f;
        mTexture = &Resources::get()->getResource(Holder::particles, Texture::smoke);
        break;
    }
    case particles::airSplit:
    {
        particleLifetime = 0.8f;
        mTexture = &Resources::get()->getResource(Holder::particles, Texture::airSplit);
        break;
    }
    default:
    {
        assert(false);
    }
    }

    xHalfTextureSize = (sf::Vector2f(mTexture->getSize()) / 2.f).x;
    yHalfTextureSize = (sf::Vector2f(mTexture->getSize()) / 2.f).y;

    for (int i = 0; i < 4 * particleNumber; i += 4)
    {
        vertices[i].texCoords = sf::Vector2f(0, 0);
        vertices[i + 1].texCoords = sf::Vector2f(mTexture->getSize().x, 0);
        vertices[i + 2].texCoords = sf::Vector2f(mTexture->getSize().x, mTexture->getSize().y);
        vertices[i + 3].texCoords = sf::Vector2f(0, mTexture->getSize().y);
    }
}


void particleSystem::update(sf::Time timePerFrame)
{
    float dt = timePerFrame.asSeconds();
    float xPos = 0;
    float yPos = 0;
    float alpha = 0;

    for (int i = 0; i < particleNumber; i++)
    {
        if (mParticles.isActive[i])
        {
            mParticles.leftLifeTime[i] -= dt;
            if (mParticles.leftLifeTime[i] <= 0)
            {
                mParticles.isActive[i] = false;

                vertices[4 * i].color.a = 0;
                vertices[4 * i + 1].color.a = 0;
                vertices[4 * i + 2].color.a = 0;
                vertices[4 * i + 3].color.a = 0;
            }
            else
            {
                xPos = vertices[4 * i].position.x + xHalfTextureSize;
                yPos = vertices[4 * i].position.y + yHalfTextureSize;
                xPos += mParticles.xVelocity[i] * dt;
                yPos += mParticles.yVelocity[i] * dt;

                vertices[4 * i].position.x = xPos - xHalfTextureSize;
                vertices[4 * i].position.y = yPos - yHalfTextureSize;
                vertices[4 * i + 1].position.x = xPos + xHalfTextureSize;
                vertices[4 * i + 1].position.y = yPos - yHalfTextureSize;
                vertices[4 * i + 2].position.x = xPos + xHalfTextureSize;
                vertices[4 * i + 2].position.y = yPos + yHalfTextureSize;
                vertices[4 * i + 3].position.x = xPos - xHalfTextureSize;
                vertices[4 * i + 3].position.y = yPos + yHalfTextureSize;


                alpha = mParticles.leftLifeTime[i] / particleLifetime * 255.f;

                vertices[4 * i].color.a = alpha;
                vertices[4 * i + 1].color.a = alpha;
                vertices[4 * i + 2].color.a = alpha;
                vertices[4 * i + 3].color.a = alpha;
            }
        }
    }
}


void particleSystem::addParticle(float xPos, float yPos, float xDirectionVelocity, float yDirectionVelocity)
{
    mParticles.isActive[nextFreeParticle] = true;
    mParticles.leftLifeTime[nextFreeParticle] = particleLifetime;
    mParticles.xVelocity[nextFreeParticle] = xDirectionVelocity;
    mParticles.yVelocity[nextFreeParticle] = yDirectionVelocity;

    vertices[4 * nextFreeParticle].position.x = xPos - xHalfTextureSize;
    vertices[4 * nextFreeParticle].position.y = yPos - yHalfTextureSize;
    vertices[4 * nextFreeParticle + 1].position.x = xPos + xHalfTextureSize;
    vertices[4 * nextFreeParticle + 1].position.y = yPos - yHalfTextureSize;
    vertices[4 * nextFreeParticle + 2].position.x = xPos + xHalfTextureSize;
    vertices[4 * nextFreeParticle + 2].position.y = yPos + yHalfTextureSize;
    vertices[4 * nextFreeParticle + 3].position.x = xPos - xHalfTextureSize;
    vertices[4 * nextFreeParticle + 3].position.y = yPos + yHalfTextureSize;

    vertices[4 * nextFreeParticle].color.a = 255;
    vertices[4 * nextFreeParticle + 1].color.a = 255;
    vertices[4 * nextFreeParticle + 2].color.a = 255;
    vertices[4 * nextFreeParticle + 3].color.a = 255;

    nextFreeParticle++;
    if (nextFreeParticle >= particleNumber) nextFreeParticle = 0;
}


unsigned int particleSystem::getParticleCount() const
{
    unsigned int count = 0;
    for (int i = 0; i < particleNumber; i++) if (mParticles.isActive[i]) count++;
    return count;
}


void particleSystem::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
    states.texture = mTexture;
    target.draw(&vertices[0], 4 * particleNumber, sf::PrimitiveType::Quads, states);
}