通过OpenGL ES Android将像素写入纹理

Question

我正在尝试做一些像素工作，在一个纹理老学校通过访问它使用数组。我的方法是生成一个纹理，然后在每个连续的帧中使用该纹理，并根据需要编写和修改我的纹理。但是，当我在Android Emulator中运行这段代码时，我得到的只是一个白色图像。我的纹理大小是2的幂，所以我有点惊讶。如果有什么不同的话，我会期望看到一个完全黑色的图像。下面是我的自定义渲染器代码：

package com.gltest;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;
import android.opengl.GLU;
import android.opengl.GLSurfaceView.Renderer;

public class OpenGLRenderer implements Renderer {

    private ByteBuffer buf;
    private int cwidth, cheight;
    private FloatBuffer vertexBuffer, texelBuffer;
    private ShortBuffer indexBuffer;
    int[] textures = new int[1];

    float vertices[] = {
               0.0f,  1.0f, 0.0f,
               0.0f,  0.0f, 0.0f,
               1.0f,  0.0f, 0.0f,
               1.0f,  1.0f, 0.0f
        };
    private float texels[] = {
            0.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 0.0f,
            1.0f, 1.0f
        };
    private short[] indices = { 0, 1, 2, 0, 2, 3 };

    @Override
    public void onDrawFrame(GL10 gl) {
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
        updateTexture(gl);
    }

    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL10.GL_PROJECTION);
        gl.glLoadIdentity();
        GLU.gluOrtho2D(gl, 0, width, 0, height);
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        gl.glLoadIdentity();

        buf = ByteBuffer.allocateDirect(128 * 128 * 3).order(ByteOrder.nativeOrder());
        cwidth = width;
        cheight= height;;

        for( int i=0; i<vertices.length; i+=3 ) {
            vertices[i] *= cwidth;
            vertices[i+1] *= cheight;
        }
        gl.glEnable(GL10.GL_TEXTURE_2D);
        gl.glGenTextures(1, textures, 0);
        gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_NEAREST);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
        gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, 3, 128, 128, 0, GL10.GL_RGB, GL10.GL_UNSIGNED_BYTE, buf);

        ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
        vbb.order(ByteOrder.nativeOrder());
        vertexBuffer = vbb.asFloatBuffer();
        vertexBuffer.put(vertices);
        vertexBuffer.position(0);

        ByteBuffer tbb = ByteBuffer.allocateDirect(texels.length * 4);
        tbb.order(ByteOrder.nativeOrder());
        texelBuffer = tbb.asFloatBuffer();
        texelBuffer.put(texels);
        texelBuffer.position(0);

        ByteBuffer ibb = ByteBuffer.allocateDirect(indices.length * 2);
        ibb.order(ByteOrder.nativeOrder());
        indexBuffer = ibb.asShortBuffer();
        indexBuffer.put(indices);
        indexBuffer.position(0);
    }

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        gl.glClearColor(1.0f, 0.0f, 0.0f, 0.5f);  
        gl.glShadeModel(GL10.GL_SMOOTH);
        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);
    }

    void updateTexture(GL10 gl)
    {   
        // Update pixels
        // write random r g or b values to random locations
        for(int y = 0; y < 128; ++y)        
            for(int x = 0; x < 128; ++x)
                buf.put(x+y*128, (byte)(Math.random()*255));

        buf.position(0);
        gl.glEnable(GL10.GL_TEXTURE_2D);
        gl.glBindTexture(gl.GL_TEXTURE_2D, textures[0]);

        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);

        gl.glTexSubImage2D(GL10.GL_TEXTURE_2D, 0, 0, 0, 128, 128, GL10.GL_RGB, GL10.GL_UNSIGNED_BYTE, buf);
        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
        gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texelBuffer);
        gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);

        gl.glDrawElements(GL10.GL_TRIANGLES, indices.length, GL10.GL_UNSIGNED_SHORT, indexBuffer);

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

    }
}

Answer 1

老实说，我不认为这是一个非常方便的解决方案的性能。

这种改变/效果应该在使用顶点和片段着色器的可编程管道模型中完成，例如OPENGL ES 2.0。

由于以下原因，您正在尝试实现的解决方案并不方便：

• 负载完全在CPU上，而您根本没有使用GPU的能力
• 纹理数据操作函数是众所周知的当今GPU的性能杀手

我强烈建议你在片段着色器中实现效果，以获得最好的性能。

Answer 2

在仔细研究之后，我发现安卓系统上的GLES1.1不支持gl.glTexSubImage2D (它是内置的，但不能做任何事情：https://www.google.com/search?ix=hea&sourceid=chrome&ie=UTF-8&q=android+opengl+glTexSubImage2D)

此外，为了不让其他人在将来浪费时间，请忘记尝试使用glDrawPixels发送到帧缓冲区。在任何gles1.1/ 2.0实现(Android、iPhone)等中也不支持该功能。

解决方案是使用NDK，这篇出色的文章由一个名叫"Richard Quirk“的程序员撰写，他有自己的博客：http://quirkygba.blogspot.com/2010/10/android-native-coding-in-c.html，而且碰巧也是一个堆栈溢出规则：https://stackoverflow.com/users/4596/richq。

谢谢Richard！