GLES20纹理无法在某些设备上工作

Question

我试图在Android's example OpenGL 2.0 project之上添加一个相当简单的扩展，以便为基本形状添加纹理。这似乎非常简单，但在某些设备（三星Nexus S，LG Optimus 3D，三星Galaxy S）纹理只是不渲染。

这实际上是一个我在一个更大的项目上遇到的问题，但是我能够用下面的简单项目重现问题，希望这里的某个人能够知道我的代码在哪里出现问题，或者如何专门为这些设备构建GL纹理（可能存在设备问题）。

为了让这如何对象用于一个想法：在GLSurfaceView.Renderer的onSurfaceCreated方法，我实例化一个Square()对象，并在方法我打电话广场的draw()方法。但是，处理纹理的所有相关代码都应该出现在这个Square类中，这与Google自己的示例几乎完全相同。

非常感谢任何人谁在这方面的裂缝。

class Square { 

private final String vertexShaderCode = 
    // This matrix member variable provides a hook to manipulate 
    // the coordinates of the objects that use this vertex shader 
    "uniform mat4 uMVPMatrix;" + 

    "attribute vec4 vPosition;" + 
    "attribute vec2 a_TexCoordinate;" + 

    "varying vec2 v_TexCoordinate;" + 

    "void main() {" + 
    // the matrix must be included as a modifier of gl_Position 
    " gl_Position = vPosition * uMVPMatrix;" + 
    " v_TexCoordinate = a_TexCoordinate;" + 
    "}"; 

private final String fragmentShaderCode = 
    "precision mediump float;" + 

    "uniform sampler2D u_Texture;" + 

    "varying vec2 v_TexCoordinate;" + 

    "void main() {" + 
    " gl_FragColor = texture2D(u_Texture, v_TexCoordinate);" + 
    "}"; 

private final FloatBuffer vertexBuffer; 
private final FloatBuffer textureBuffer; 
private final ShortBuffer drawListBuffer; 
private final int mProgram; 
private int mPositionHandle; 
private int mColorHandle; 
private int mMVPMatrixHandle; 

// number of coordinates per vertex in this array 
static final int COORDS_PER_VERTEX = 3; 
static float squareCoords[] = { -0.5f, 0.5f, 0.0f, // top left 
           -0.5f, -0.5f, 0.0f, // bottom left 
           0.5f, -0.5f, 0.0f, // bottom right 
           0.5f, 0.5f, 0.0f }; // top right 

final float[] previewTextureCoordinateData = 
    { 
     0.0f, 1.0f, 
     0.0f, 0.0f, 
     1.0f, 1.0f, 
     1.0f, 0.0f 
    }; 

private int textureDataHandle; 
private int textureUniformHandle; 
private int textureCoordinateHandle; 

private final short drawOrder[] = { 0, 1, 2, 0, 2, 3 }; // order to draw vertices 

private final int vertexStride = COORDS_PER_VERTEX * 4; // 4 bytes per vertex 

// Set color with red, green, blue and alpha (opacity) values 
float color[] = { 0.2f, 0.709803922f, 0.898039216f, 1.0f }; 

private int loadTexture(final Context context, final int resourceId) 
{ 
    final int[] textureHandle = new int[1]; 

    GLES20.glGenTextures(1, textureHandle, 0); 

    if (textureHandle[0] != 0) 
    { 
     final BitmapFactory.Options options = new BitmapFactory.Options(); 
     options.inScaled = false; // No pre-scaling 

     // Read in the resource 
     final Bitmap bitmap = BitmapFactory.decodeResource(context.getResources(), resourceId, options); 

     // Bind to the texture in OpenGL 
     GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureHandle[0]); 

     // Set filtering 
     GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST); 
     GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_NEAREST); 

     // Load the bitmap into the bound texture. 
     GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0); 

     // Recycle the bitmap, since its data has been loaded into OpenGL. 
     bitmap.recycle(); 
    } 

    if (textureHandle[0] == 0) 
    { 
     throw new RuntimeException("Error loading texture."); 
    } 

    return textureHandle[0]; 
} 

public Square(Context context) { 
    // initialize vertex byte buffer for shape coordinates 
    ByteBuffer bb = ByteBuffer.allocateDirect(
    // (# of coordinate values * 4 bytes per float) 
      squareCoords.length * 4); 
    bb.order(ByteOrder.nativeOrder()); 
    vertexBuffer = bb.asFloatBuffer(); 
    vertexBuffer.put(squareCoords); 
    vertexBuffer.position(0); 

    // initialize byte buffer for the draw list 
    ByteBuffer dlb = ByteBuffer.allocateDirect(
    // (# of coordinate values * 2 bytes per short) 
      drawOrder.length * 2); 
    dlb.order(ByteOrder.nativeOrder()); 
    drawListBuffer = dlb.asShortBuffer(); 
    drawListBuffer.put(drawOrder); 
    drawListBuffer.position(0); 


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

    // prepare shaders and OpenGL program 
    int vertexShader = MyGLRenderer.loadShader(GLES20.GL_VERTEX_SHADER, 
               vertexShaderCode); 
    int fragmentShader = MyGLRenderer.loadShader(GLES20.GL_FRAGMENT_SHADER, 
               fragmentShaderCode); 

    textureDataHandle = loadTexture(context, R.drawable.color_texture); 

    mProgram = GLES20.glCreateProgram();    // create empty OpenGL Program 
    GLES20.glAttachShader(mProgram, vertexShader); // add the vertex shader to program 
    GLES20.glAttachShader(mProgram, fragmentShader); // add the fragment shader to program 
    GLES20.glLinkProgram(mProgram);     // create OpenGL program executables 
} 

public void draw(float[] mvpMatrix) { 
    // Add program to OpenGL environment 
    GLES20.glUseProgram(mProgram); 

    // get handle to vertex shader's vPosition member 
    mPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition"); 

    // Enable a handle to the triangle vertices 
    GLES20.glEnableVertexAttribArray(mPositionHandle); 

    // Prepare the triangle coordinate data 
    GLES20.glVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, 
           GLES20.GL_FLOAT, false, 
           vertexStride, vertexBuffer); 

    textureCoordinateHandle = GLES20.glGetAttribLocation(mProgram, "a_TexCoordinate"); 
    GLES20.glVertexAttribPointer(textureCoordinateHandle, 2, GLES20.GL_FLOAT, false, 
      0, textureBuffer); 
    GLES20.glEnableVertexAttribArray(textureCoordinateHandle); 

    textureUniformHandle = GLES20.glGetUniformLocation(mProgram, "u_Texture"); 
    MyGLRenderer.checkGlError("glGetUniformLocation"); 
    GLES20.glActiveTexture(GLES20.GL_TEXTURE0); 
    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureDataHandle); 
    GLES20.glUniform1i(textureUniformHandle, 0);  

    // get handle to shape's transformation matrix 
    mMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix"); 
    MyGLRenderer.checkGlError("glGetUniformLocation"); 

    // Apply the projection and view transformation 
    GLES20.glUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0); 
    MyGLRenderer.checkGlError("glUniformMatrix4fv"); 

    // Draw the square 
    GLES20.glDrawElements(GLES20.GL_TRIANGLES, drawOrder.length, 
          GLES20.GL_UNSIGNED_SHORT, drawListBuffer); 

    // Disable vertex array 
    GLES20.glDisableVertexAttribArray(mPositionHandle); 
} 
} 

Answer 1

我猜测这是一个幂级别问题。

缺省情况下，glTexParameter的GL_TEXTURE_WRAP设置被设置为GL_REPEAT，以及使用GL_REPEAT必须纹理是幂的2尺寸：

类似地，如果宽度或高度的纹理图像的是两个不权力和任一 GL_TEXTURE_MIN_FILTER被设置为的功能之一要求的mipmap 或GL_TEXTURE_WRAP_S或GL_TEXTURE_WRAP_T不 集到GL_CLAMP_TO_EDGE，则纹理图像单元瓦特（R，G，B，A）=（0,0,0,1）。

您可以用电源的两纹理开始，但是当你使用一个BitmapFactory.decodeResource生成位图，它有益（？）扩展此基础上的设备的密度。因此，例如，如果您从HDPI设备上的drawable文件夹加载512 * 512源纹理，我相信它会将其缩小1.5倍，所以您剩下的东西不是Po2。

这给你的结果是你的纹理不适用于大量的设备，因为这些设备都是密度，导致你产生非法的纹理尺寸。

这种情况下的解决方案是将您的（源代码为2）源纹理放入资源文件夹drawable-nodpi，这将防止任何基于密度的缩放。要么或者使用CLAMP_TO_EDGE，它不关心Po2。