Particle Engine

class ParticleEngine {
public:
    ParticleEngine(Level *level, Textures *textures);
    
    void add(shared_ptr<Particle> p);
    void tick();
    void render(shared_ptr<Entity> player, float a);
    void renderLit(shared_ptr<Entity> player, float a);
};

static const int MISC_TEXTURE = 0;           // particles.png
static const int TERRAIN_TEXTURE = 1;        // terrain.png
static const int ITEM_TEXTURE = 2;           // gui/items.png
static const int ENTITY_PARTICLE_TEXTURE = 3;// Entity-based particles
static const int DRAGON_BREATH_TEXTURE = 4;  // Dragon breath effect

static const int TEXTURE_COUNT = 5;

deque<shared_ptr<Particle>> particles[3][TEXTURE_COUNT];

static const int MAX_PARTICLES_PER_LAYER = 200;      // Standard limit
static const int MAX_DRAGON_BREATH_PARTICLES = 1000; // Special case

if ((t != DRAGON_BREATH_TEXTURE && particles[l][t].size() >= MAX_PARTICLES_PER_LAYER) 
    || particles[l][t].size() >= MAX_DRAGON_BREATH_PARTICLES)
    particles[l][t].pop_front();

class Particle : public Entity {
protected:
    int texX, texY;        // Texture coordinates
    float uo, vo;          // UV offsets
    int age;               // Current age in ticks
    int lifetime;          // Maximum lifetime
    float size;            // Particle size
    float gravity;         // Gravity effect
    float rCol, gCol, bCol;// Color
    float alpha;           // Transparency
    Icon *tex;            // Texture reference
public:
    static double xOff, yOff, zOff;  // Camera offset
};

virtual void render(Tesselator *t, float a, float xa, float ya, float za,
                   float xa2, float za2);

class TerrainParticle : public Particle {
    // Uses terrain texture atlas
    // Shows block texture
};

void ParticleEngine::destroy(int x, int y, int z, int tid, int data)

void ParticleEngine::crack(int x, int y, int z, int face)

class BubbleParticle : public Particle {
    virtual void tick();
};

class DragonBreathParticle : public Particle {
    // Dragon breath attack
    // Lingering effect
};

class BreakingItemParticle : public Particle {
    virtual int getParticleTexture() { return ITEM_TEXTURE; }
    virtual void render(Tesselator *t, float a, float xa, float ya, float za,
                       float xa2, float za2);
};

void ParticleEngine::render(shared_ptr<Entity> player, float a)

void ParticleEngine::renderLit(shared_ptr<Entity> player, float a)

if (SharedConstants::TEXTURE_LIGHTING) {
    t->tex2(p->getLightColor(a));
}

void ParticleEngine::tick()

if (p->removed) {
    particles[l][tt][i] = particles[l][tt].back();
    particles[l][tt].pop_back();
    i--;  // Check swapped particle
}

int l = level->dimension->id == 0 ? 0 : 
        (level->dimension->id == -1 ? 1 : 2);

void ParticleEngine::add(shared_ptr<Particle> p)

void LevelRenderer::addParticle(ePARTICLE_TYPE eParticleType, 
                                double x, double y, double z,
                                double xa, double ya, double za);

for (unsigned int i = 0; i < particles[l][tt].size(); i++) {
    if(t->hasMaxVertices()) {
        t->end();
        t->begin();
    }
    p->render(t, a, xa, ya, za, xa2, za2);
}

Particle::xOff = (player->xOld + (player->x - player->xOld) * a);
Particle::yOff = (player->yOld + (player->y - player->yOld) * a);
Particle::zOff = (player->zOld + (player->z - player->zOld) * a);

wstring ParticleEngine::countParticles()

particleEngine->destroy(x, y, z, tileId, data);

particleEngine->crack(x, y, z, face);

class MyCustomParticle : public Particle {
public:
    MyCustomParticle(Level *level, double x, double y, double z)
        : Particle(level, x, y, z, 0, 0, 0) {
        // Set particle properties
        lifetime = 20;  // 1 second
        size = 0.5f;
        gravity = 0.1f;
        setMiscTex(0);  // Particle texture index
    }
    
    virtual void tick() override {
        // Custom behavior
        Particle::tick();  // Call base
    }
};