How do I render textures on an Ortho projection in Android

Greetings. I've dabbled in OpenGL in the past and as far as I understood it the best way to do 2d games with sprite-based animation was eliminate the z plane and set up an orthographic projection so you can just use Cartesian coordinates for textures and drawing positions.

So I've been trying to implement this in android. I was just using all the build in draw functions but rendering a few hundred images separately with the vanilla drawbitmap functions was killing my framerate.

A rect shows up on the screen all right but the texture refuses to show. if you could take a look and let me know where I'm going wrong here I'd really appreciate it. Be warned I don;t have nearly as comprehensive understanding of opengl as I would like. I respect anyone that can wrap their heads around this stuff.

This is the sprite class which draws the rect with the bound texture:

public class Sprite {

private FloatBuffer vertexBuffer;   // buffer holding the vertices
private FloatBuffer textureBuffer;
private int[] textures = new int[1];


private float vertices[] = {
         0.0f,  0.0f,
         0.0f, 32.0f,
         32.0f,  0.0f,
         32.0f, 32.0f

};

private float texture[] = {
        0.0f,  0.0f,
         0.0f, 16.0f,
         16.0f,  0.0f,
         16.0f, 16.0f

};

public Sprite() {
    ByteBuffer byteBuffer = ByteBuffer.allocate开发者_StackOverflowDirect(vertices.length * 4);
    byteBuffer.order(ByteOrder.nativeOrder());
    vertexBuffer = byteBuffer.asFloatBuffer();
    vertexBuffer.put(vertices);
    vertexBuffer.position(0);

    byteBuffer = ByteBuffer.allocateDirect(texture.length * 4);
    byteBuffer.order(ByteOrder.nativeOrder());
    textureBuffer = byteBuffer.asFloatBuffer();
    textureBuffer.put(texture);
    textureBuffer.position(0);

}

public void loadGLTexture(GL10 gl, Context context)
{
    Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), 
            R.drawable.charactersprites);

    gl.glGenTextures(1, textures, 0);
    gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);

    //Not sure if I need these...
    //gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
    //gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

    GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);
    bitmap.recycle();

}

/** The draw method for the triangle with the GL context */
public void draw(GL10 gl) {
    gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);


    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

    //gl.glFrontFace(GL10.GL_CW);//is this necessary?

    // set the colour for the triangle
    //gl.glColor4f(0.0f, 1.0f, 0.0f, 0.5f);

    // Point to our vertex buffer
    gl.glVertexPointer(2, GL10.GL_FLOAT, 0, vertexBuffer);
    gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, textureBuffer);


    // Draw the vertices as triangle strip
    gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 2);

    //Disable the client state before leaving
    gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
    gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

}
}

And this is the renderer...i pass in the srfaceview to hold onto so i can get the height and width for the projection

public class GlRenderer implements Renderer {

private Sprite sprite;
private GLSurfaceView surfaceView;
private Context context;

/** Constructor to set the handed over context */
public GlRenderer(GLSurfaceView surfaceView, Context context) {
    this.sprite = new Sprite();
    this.surfaceView = surfaceView;
    this.context = context;
}

@Override
public void onDrawFrame(GL10 gl) {
    // clear Screen and Depth Buffer
    gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
    gl.glMatrixMode(GL10.GL_PROJECTION);

    // Reset the Modelview Matrix
    gl.glLoadIdentity();
    gl.glOrthof(0.0f, surfaceView.getWidth(), surfaceView.getHeight(), 0.0f, -1.0f, 1.0f);

    sprite.draw(gl);    

}

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    sprite.loadGLTexture(gl, this.context);

    gl.glEnable(GL10.GL_TEXTURE_2D);
    gl.glShadeModel(GL10.GL_SMOOTH);
    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
    gl.glClearDepthf(1.0f); 
    gl.glEnable(GL10.GL_DEPTH_TEST);
    gl.glDepthFunc(GL10.GL_LEQUAL);

    gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);     
}
}

Have you tried

glActiveTexture(GL10.GL_TEXTURE0);

before rendering sprite?

Try setting the texture environment to GL_REPLACE (using glTexEnv). If it is set to GL_MODULATE, the texture color will be multiplied by the current color (or the color from lighting, if enabled) and if this color is black, the result is just black.

Below works on my Galaxy S but I'm having trouble getting it to work on my friend's HTC using projective. Though they do work in model space... Could you try?

public void draw(GL10 gl) {
    gl.glActiveTexture(GL10.GL_TEXTURE0);

    gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID);
    gl.glEnable(GL10.GL_TEXTURE_2D);
    gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
    gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mCoordinateBuffer);

    // Draw the mesh
    gl.glFrontFace(GL10.GL_CCW);
    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);
    gl.glNormalPointer(GL10.GL_FLOAT, 0, mNormalBuffer);
    gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, mIndexBuffer.limit(), GL10.GL_UNSIGNED_BYTE, mIndexBuffer);

    // Disable texture
    gl.glDisable(GL10.GL_TEXTURE_2D);
    gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
}

public void loadTexture(Context context, GL10 gl) {
    Bitmap bmp;
    try {
            bmp = BitmapFactory.decodeStream(context.getResources().openRawResource(R.drawable.texture_loading));

            int[] textures = new int[1];
            gl.glGenTextures(1, textures, 0);
            mTextureID = textures[0];
            gl.glBindTexture(GL10.GL_TEXTURE_2D, mTextureID);

            // Mendatory, tells openGL how to render the texture, nearest will look sharp, smooth will look blurry
            gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
            gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_NEAREST);

            // Not mendatory, tells openGL what to do when sprite is bigger than object
            gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
            gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);

            // Mendatory, 
            // GL_REPLACE replaces all color info, 
            // GL_MODULATE modulates, texture will be affected by lightning 
            gl.glTexEnvx(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_REPLACE);

            bmp.recycle();
    } catch (Error e) {

    }

}