Fast dynamic vertices in OpenGL ES 2.0 on Android

Question

I am trying to batch draw a bunch of lines on Android using OpenGL ES 2.0 and I need to know the best way to do this.

Right now I made a class called LineEngine which builds up a FloatBuffer of all the vertices to draw and then draws all the lines at once. The problem is that apparently FloatBuffer.put() is very slow and is gobbling up CPU time like crazy.

Here is my class

public class LineEngine {
    private static final float[] IDENTIY = new float[16];
    private FloatBuffer mLinePoints;
    private FloatBuffer mLineColors;
    private int mCount;

    public LineEngine(int maxLines) {
        Matrix.setIdentityM(IDENTIY, 0);

        ByteBuffer byteBuf = ByteBuffer.allocateDirect(maxLines * 2 * 4 * 4);
        byteBuf.order(ByteOrder.nativeOrder());
        mLinePoints = byteBuf.asFloatBuffer();

        byteBuf = ByteBuffer.allocateDirect(maxLines * 2 * 4 * 4);
        byteBuf.order(ByteOrder.nativeOrder());
        mLineColors = byteBuf.asFloatBuffer();

        reset();
    }

    public void addLine(float[] position, float[] color){
        mLinePoints.put(position, 0, 8); //These lines
        mLineColors.put(color, 0, 4); // are taking
        mLineColors.put(color, 0, 4); // the longest!
        mCount++;
    }

    public void reset(){
        mLinePoints.position(0);
        mLineColors.position(0);
        mCount = 0;
    }

    public void draw(){
        mLinePoints.position(0);
        mLineColors.position(0);
        GraphicsEngine.setMMatrix(IDENTIY);
        GraphicsEngine.setColors(mLineColors);
        GraphicsEngine.setVertices4d(mLinePoints);
        GraphicsEngine.disableTexture();
        GLES20.glDrawArrays(GLES20.GL_LINES, 0, mCount * 2);
        GraphicsEngine.disableColors();
        reset();
    }
}

Is there a better way to batch all these lines together?

Answer 1

What you are trying to do is called SpriteBatching. If you want your program to be robust in openGL es you have to check the following( a list of what makes your program slow ) :

-Changing to many opengl ES states each frame.

-Enable//Dissable (textures etc) again and again. Once you enable something you dont have to do it again it will be applied automaticly its frame.

-Using to many assets instead of spriteSheets. Yes thats make a huge performance impact. For example if you have 10 images you have to load for each image a different texture and that is SLOW. A better way to do this is to create a spriteSheet.(You can check google for free spriteSheet creators).

-Your images are high quality. Yes! check your resolution and file extension. Prefer .png files.

-Care for the api 8 float buffer bug(you have to use int buffer instead to fix the bug).

-Using java containers. This is the biggest pitfall, if you use string concatenation(that's not a container but it returns a new string each time) or a List or any other container that RETURNS A NEW CLASS INSTANCE chances are your program will be slow due to garbage collection. For input handling i would suggest you to search a teqnique called the Pool Class. Its use is to recycle objects instead of creating new ones. Garbage collector is the big enemy, try to make him happy and avoid any programming technique that might call him.

-Never load things on the fly, instead make a loader class and load all the necessary assets in the begining of the app.

If you do implement this list then your chances are your program will be robust.

One last adition. What is a sprite batcher? A spriteBatcher is a class that uses a single texture to render multiple objects. It will create automaticly vertices, indices, colors, u - v coords and it will render them as a batch. This pattern will save GPU power as well as cpu power. From your posted code i can't be sure what causes the cpu to slow down but from my experience is due to one(or more) things of the list i previously mention. Check the list, follow it, search google for spriteBatching and i am sure your program will run fast. Hope i helped!

Edit: I think i found what causes your program to slow down, you dont flip the buffer dude! You just reset the position. You just add add add more objects and you cause buffer overload. In the reset method just flip the buffer. mLineColors.flip mLinePaints.flip will do the job. Make sure you call them each frame if you send new verices each frame.