Libgdx: Drawing lots of particles

Question

What is the best way to draw lots of particles (circles) moving in the background in LibGDX? 200 particles running in the background is what I can get out of my app. Anything above will get my app to stutter. Ive actually tested an App where it's possible to run up to 200.000 particles in the background without having to sacrifice fps. This is my Game class in short:

public Array<Particles> particlesArray;
SpriteBatch batch;
OrthographicCamera camera;
Texture sParticlesTexture;

public void create(){
    camera = new OrthographicCamera();
    camera.setToOrtho(false, 1080, 1920);
    batch = new SpriteBatch;

    Pixmap pixmap = new Pixmap(Particles.MAX_PARTICLE_RADIUS*2, Particles.MAX_PARTICLE_RADIUS*2, Pixmap.Format.RGBA4444);
    pixmap.setColor(Color.WHITE);
    pixmap.fillCircle(pixmap.getWidth() / 2, pixmap.getHeight() / 2, Particles.MAX_PARTICLE_RADIUS);
    sParticlesTexture = new Texture(pixmap);
    pixmap.dispose();

    size = random(2, Particles.MAX_PARTICLE_RADIUS+1);

    for(int i=0; i<200; i++){
        particlesArray.add(new Particles(random(size, width-size),
            random(0, height),
            0,
            random(0.15f*height, 0.25f*height)*0.15f*size,
            size));
    }

public void render(float deltaTime){
    Gdx.gl.glClearColor(0, 0, 0, 1);
    Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
    //update camera and draw in camera
    camera.update();
    batch.setProjectionMatrix(camera.combined);

    batch.begin();
    drawFallingObjects(particlesArray, batch);
    batch.end()

    moveParticles(particlesArray, deltaTime);
}

public <T extends Objects> void drawFallingObjects(Array<T> objects, SpriteBatch batch){
    for(T item: objects){
        item.draw(batch);
    }
}

public void moveParticles(Array<Particles> particlesArray, float deltaTime){
    for(Particles item: particlesArray){
        size = random(2, Particles.MAX_PARTICLE_RADIUS+1);
        item.move(deltaTime);
        //creating particles if out of scale
        if(item.y+item.mDiameter<0){
            item.x = random(size, width-size);
            item.y = height+20;
            item.vy = random(0.15f*height, 0.25f*height)*0.15f*size;
            item.mDiameter = size;
        }
    }
}

And this my Particles class:

import com....sParticlesTexture;
public class Particles{

public static int MAX_PARTICLE_RADIUS = 4;

public Particles(float x, float y, float vx, float vy, float mDiameter){
    super(x, y, vx, vy, mDiameter);
    radius = mDiameter/2;
}

@Override
public void draw(SpriteBatch batch){
    batch.draw(sParticlesTexture, x-radius, y-radius, mDiameter, mDiameter);
}

@Override
public void move(float deltaTime){
    y -= ceil(vy*deltaTime);
    x += ceil(vx*deltaTime);
}

public void dispose() {
    sParticlesTexture.dispose();
}

All Particles objects use one and the same texture. This improves a lot instead of creating hundred different textures. So what can be done now? I've googled a lot. What would help in my case? A Framebuffer, shader? And how should I implement these in my game? What about CPUSpriteBatch?

I also came across the particle system from LibGDX but it doesn't work differently than what I do.

Answer 1

As Nabin said, libgdx has a particle system in place already which is already tuned to be efficient. Libgdx also has a tool called the 2D Particle editor which allows you to view and edit particles before you add them to your application. A guide on the Editor can be found on the libgdx site and gamedevelopment.blog.

From the code samples you provided, I think you could also possibly use a shader to create the same effect. The bonus to this is its all done on the GPU. Some example shaders can be found on Shadertoy and guide on shaders from GamesFromScratch or GLSL Shader Tutorial for Libgdx

Answer 2

First of all have a look at Particle effect which is much more efficient. https://github.com/libgdx/libgdx/wiki/2D-ParticleEffects

If you are not trying to get that kind of effect and want to use a lot of particles, you may not want to perform such large number of calculations in the Java. Rather use NDK and calculate the values from C/C++.