Cube nicht in OpenGL ES 3.0 auf Android gezeichnet

Question

Ich möchte einen einfachen Würfel in OpenGLES 3.0 auf meinem Android-Gerät, aber es wird nicht gerendert. Das ist mein Surface Setup:

public GLContextView(Context context){ 
    super(context); 

    setEGLContextClientVersion(3); 

    setRenderer(renderer); 
} 

Render-Code:

public void onSurfaceCreated(javax.microedition.khronos.opengles.GL10 unused, javax.microedition.khronos.egl.EGLConfig p2){ 
    GLES30.glEnable(GLES30.GL_DEPTH_TEST); 
    GLES30.glEnable(GLES30.GL_BLEND); 
    GLES30.glEnable(GLES30.GL_CULL_FACE); 
    GLES30.glDepthFunc(GLES30.GL_LEQUAL); 
    GLES30.glCullFace(GLES30.GL_BACK); 

    GLES30.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); 

    cubeProgram = RenderHelper.createShaderProgram(Shader.CubeVertexShader, Shader.CubeFragmentShader); 

    int[] array = new int[2]; 
    GLES30.glGenVertexArrays(1, array, 0); 
    vaId = array[0]; 
    GLES30.glBindVertexArray(vaId); 


    GLES30.glGenBuffers(2, array, 0); 
    vbId = array[0]; 
    ibId = array[1]; 

    GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbId); 
    GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, RenderCube.vertices.length * 4, RenderCube.vBuffer, GLES30.GL_STATIC_DRAW); 
    GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, 0); 
    GLES30.glEnableVertexAttribArray(positionHandle); 

    GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER, ibId); 
    GLES30.glBufferData(GLES30.GL_ELEMENT_ARRAY_BUFFER, RenderCube.indices.length * 4, RenderCube.iBuffer, GLES30.GL_STATIC_DRAW); 

    colorHandle = GLES30.glGetUniformLocation(cubeProgram, "in_color"); 

    GLES30.glBindVertexArray(0); 
} 

public void onDrawFrame(GL10 p1){ 
    GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT | GLES30.GL_DEPTH_BUFFER_BIT); 

    GLES30.glUseProgram(cubeProgram); 

    GLES30.glBindVertexArray(vaId); 

    GLES30.glUniform4f(colorHandle, 1.0f, 1.0f, 1.0f, 1.0f); 

    GLES30.glDrawElements(GLES30.GL_TRIANGLES, RenderCube.indices.length, GLES30.GL_UNSIGNED_INT, 0); 

} 


public void onSurfaceChanged(GL10 p1, int p2, int p3){ 
    GLES30.glViewport(0, 0, p2, p3); 
} 

RenderCube Klasse mit Vertex- und Indexdaten:

class RenderCube{ 
    public static float[] vertices = { 
     0.0f, 0.0f, 0.0f, 
     1.0f, 0.0f, 0.0f, 
     0.0f, 0.0f, 1.0f, 
     1.0f, 0.0f, 1.0f, 

     0.0f, 1.0f, 0.0f, 
     1.0f, 1.0f, 0.0f, 
     0.0f, 1.0f, 1.0f, 
     1.0f, 1.0f, 1.0f, 
    }; 

    public static int[] indices = { 
     0, 3, 1, 0, 2, 3, //Bottom 
     4, 7, 5, 4, 6, 7, //Top 
     0, 5, 1, 0, 4, 5, //Back 
     2, 7, 3, 2, 6, 7, //Front 
     0, 6, 2, 0, 4, 6, //Left 
     1, 7, 3, 1, 5, 7 //Right 
    }; 

    public static FloatBuffer vBuffer = RenderHelper.createFloatBuffer(vertices.length * 4, vertices); 
    public static IntBuffer iBuffer = RenderHelper.createIntBuffer(indices.length * 4, indices); 

}; 

Shaders:

final class Shader{ 

    public static final String CubeVertexShader = 
    "#version 300 es\n" + 
    "layout (location = 0) in vec3 pos;" + 
    "void main(){" + 
    " gl_Position = vec4(pos, 1.0f);" + 
    "}"; 

    public static final String CubeFragmentShader = 
    "#version 300 es\n" + 
    "precision mediump float;" + 
    "uniform vec4 in_color;" + 
    "out vec4 color;" + 
    "void main(){" + 
    " color = in_color;" + 
    "}"; 
} 

Es kompiliert fein und keine opengl Fehler ar e gedruckt. Was mache ich falsch?

Answer 1

Ich denke, Sie haben einfach keine sichtbaren Dreiecke.

Die Dreiecke der unteren, oberen, linken und rechten Seite sind unsichtbar, da sie orthogonal zur Betrachtungsebene sind. Sie betrachten sie also als Kante, und sie enden als degenerierte Dreiecke (d. H. Dreiecke mit null Fläche).

Wie Sie sie definiert haben, haben die Dreiecke der Vorder- und Rückseite alle im Uhrzeigersinn. Erweiterung der Indizes dieser vier Dreiecke, und nur die x- und y-Koordinaten der entsprechenden Eckpunkte zeigen:

0, 5, 1 -> (0.0f, 0.0f), (1.0f, 1.0f), (1.0f, 0.0f) 
0, 4, 5 -> (0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 1.0f) 
2, 7, 3 -> (0.0f, 0.0f), (1.0f, 1.0f), (1.0f, 0.0f) 
2, 6, 7 -> (0.0f, 0.0f), (0.0f, 1.0f), (1.0f, 1.0f) 

Wie Sie sehen können, diese Dreiecke sind alle im Uhrzeigersinn. Da Sie Keulung von Rückflächen zu ermöglichen, wählte:

GLES30.glEnable(GLES30.GL_CULL_FACE); 
GLES30.glCullFace(GLES30.GL_BACK); 

und die Standardreihenfolge für die vorderen Wicklungsflächen gegen den Uhrzeigersinn ist was bedeutet, dass der Rücken der Wicklung steht im Uhrzeigersinn ist, alle diese Dreiecke werden gekeult werden.

Da die Frontfläche bei z = 1,0 ist, ist es auch genau auf der vorderen Clip-Ebene. Die Art, wie ich die Spezifikation lese, Geometrie, die genau auf einer Clipping-Ebene ist, sollte immer noch sichtbar sein. Aber es ist wahrscheinlich sicherer, es deutlich in das Clip-Volumen zu platzieren.