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。