Question

我正在尝试通过使用数组访问它来在纹理旧学校中做一些像素工作。我的方法是生成一个纹理，然后使用该纹理每个连续的帧写入并根据需要修改我的纹理。但是，当我在Android模拟器中运行此代码时，我得到的只是一张白色图像。我的纹理大小是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

经过一番探讨之后，我发现在Android上的GLES 1.1中不支持gl.glTexSubImage2D（它是内置的，但它没有做任何事情：https://www.google.com/search?ix=hea&sourceid=chrome&ie=UTF-8&q=android+opengl+glTexSubImage2D）

此外，没有其他人在将来浪费时间，忘记尝试使用glDrawPixels发送到帧缓冲区。在任何 GLES 1.1 / 2.0实现（Android，iPhone）等中也不支持。

解决方案是使用名为“Richard Quirk”的优秀文章中所述的NDK，他有自己的博客：http://quirkygba.blogspot.com/2010/10/android-native-coding-in-c.html，并且碰巧也是Stack Overflow常规：{{ 3}}

谢谢理查德！

Answer 2

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

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

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

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

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

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

2 个答案: