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

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

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);

    }
}

package com.gltest；
导入java.nio.ByteBuffer；
导入java.nio.ByteOrder；
导入java.nio.FloatBuffer；
导入java.nio.IntBuffer；
导入java.nio.ShortBuffer；
导入javax.microedition.khronos.egl.EGLConfig；
导入javax.microedition.khronos.opengles.GL10；
导入android.opengl.GLU；
导入android.opengl.GLSurfaceView.Renderer；
公共类OpenGLRenderer实现渲染器{
私人ByteBuffer buf；
切伊特国际私人酒店；
私有FloatBuffer vertexBuffer，texelBuffer；
私人短缓冲区索引缓冲区；
int[]纹理=新的int[1]；
浮动顶点[]={
0.0f，1.0f，0.0f，
0.0f，0.0f，0.0f，
1.0f，0.0f，0.0f，
1.0f，1.0f，0.0f
};
专用浮动纹理[]={
0.0f，1.0f，
0.0f，0.0f，
1.0f，0.0f，
1.0f，1.0f
};
私有短[]索引={0,1,2,0,2,3}；
@凌驾
公共框架（GL10 gl）{
gl.glClear（GL10.gl_颜色_缓冲_位| GL10.gl_深度_缓冲_位）；
更新结构（gl）；
}
@凌驾
表面上的公共空隙已更改（GL10 gl，整型宽度，整型高度）{
gl.glViewport（0，0，宽度，高度）；
gl.glMatrixMode（GL10.gl_投影）；
gl.glLoadIdentity（）；
GLU.gluOrtho2D（gl，0，宽度，0，高度）；
gl.glMatrixMode（GL10.gl_MODELVIEW）；
gl.glLoadIdentity（）；
buf=ByteBuffer.allocateDirect（128*128*3）.order（ByteOrder.nativeOrder（））；
cwidth=宽度；
cheight=高度；；
对于（int i=0；i经过一番探索，我发现gl.glTexSubImage2D在Android上的GLES 1.1中不受支持（它是内置的，但没有任何功能：）

另外，为了避免将来有人浪费时间，忘了尝试使用glDrawPixels发送到帧缓冲区。这在任何GLE1.1/2.0实现（Android、iPhone）中都不支持

解决方案是使用NDK，正如一些名为“Richard Quirk”的程序员在这篇优秀的文章中所概述的那样，他有自己的博客：而且，碰巧也是一个堆栈溢出规则：

谢谢Richard！
老实说，我不认为这是一个非常方便的解决方案，因为从性能角度来看

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

您尝试实现的解决方案不方便，原因如下：


负载完全在CPU上，您根本不使用GPU的电源
纹理数据处理函数是当今GPU的性能杀手

我强烈建议您尽可能在片段着色器中实现效果，以获得最佳性能。
这似乎是正确的想法。但是如果我调用gl_FragColor=texture2D（u_texture，v_texcoord）我还需要更新每一个TEXEL。我如何得到我的字节/int数组，这取决于你需要做什么。通常不方便的实时计算效果，你必须欺骗预先计算的效果。但这完全取决于你的实际需要，我没有足够的信息。你在CPU上实现这种效果你很快就会让CPU被要做的事情淹没，例如在游戏中，处理输入、图形、效果、opengl调用、逻辑、AI、物理……试着在GPU上尽可能多地授权。这是一条要遵循的黄金规则：）