2

基本的な形状にテクスチャリングを追加するために、 Android のサンプル OpenGL 2.0 プロジェクトの上にかなり単純な拡張機能を追加しようとしました。これ非常に簡単に思えますが、特定のデバイス (Samsung Nexus S、LG Optimus 3D、Samsung Galaxy S) ではテクスチャがレンダリングされません。

これは実際には私がはるかに大きなプロジェクトで抱えている問題ですが、コードのどこに問題があるか、または GL を具体的に設計する方法を誰かが知っていることを期待して、以下の単純なプロジェクトで問題を再現することができました。これらのデバイスのテクスチャ (デバイスに問題がある可能性があります)。

このオブジェクトがどのように使用されるかを理解するには: GLSurfaceView.Renderer のメソッドでオブジェクトをonSurfaceCreatedインスタンス化し、メソッドで Square のメソッドを呼び出しています。ただし、テクスチャの処理に関連するすべてのコードは、Google 自身の例とほぼ同じであるこの Square クラスに表示されるはずです。Square()onDrawFramedraw()

これにクラックを入れてくれた人には、事前に感謝します。

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

1 に答える 1

4

これは2の累乗の問題だと思います。

デフォルトでは、のGL_TEXTURE_WRAP設定glTexParameterはに設定されてGL_REPEATおり、使用するテクスチャは2の累乗のサイズであるGL_REPEAT 必要があります。

同様に、テクスチャ画像の幅または高さが2の累乗ではなく、GL_TEXTURE_MIN_FILTERがミップマップを必要とする関数の1つに設定されている か、GL_TEXTURE_WRAP_SまたはGL_TEXTURE_WRAP_TがGL_CLAMP_TO_EDGEに設定されていない場合、テクスチャ画像ユニットは(R 、G、B、A)=(0、0、0、1)。

2の累乗のテクスチャから始めることもできますが、を使用しBitmapFactory.decodeResourceてビットマップを生成すると、デバイスの密度に基づいてこれを効果的に(?)スケーリングします。たとえばdrawable、HDPIデバイスのフォルダから512 * 512のソーステクスチャをロードすると、1.5倍にスケーリングされると思います。そのため、Po2ではないものが残ります。

これにより、大量のデバイスでテクスチャが機能しないという結果が得られます。これらのデバイスはすべて密度が高いため、不正なテクスチャサイズが生成されるためです。

この場合の解決策は、(2の累乗の)ソーステクスチャをリソースフォルダdrawable-nodpiに配置することです。これにより、密度ベースのスケーリングが防止されます。それか、Po2を気にしないCLAMP_TO_EDGEを使用してください。

于 2012-11-06T21:12:58.317 に答える