Problèmes de calques, de profondeur et de fusion dans openGL

Question

J'ai besoin de superposer certaines textures sur une vidéo en couches (c'est-à-dire que la première texture doit apparaître sous, la deuxième texture quand elles sont toutes deux semi-transparentes). Les textures ont toutes des valeurs Z différentes, il ne devrait donc y avoir aucun conflit. Les images parlent un millier de mots donc j'en ai joint un ci-dessous:

Comme vous pouvez le voir, les flèches sont semi-transparentes sont croisées les unes sur les autres. Cependant, seules les flèches bleues et rouges semblent interagir. Par exemple, disons que les flèches rouges ont une valeur z (verticale dans ce cas) de 4, le bleu de 6 et le blanc de 10. La fonction de fusion que j'utilise est: gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); et GL_DEPTH_TEST est activée. Je cherche toutes les textures superposées pour interagir de la même façon que les rouges et bleus. C'est-à-dire que vous pouvez voir la flèche rouge sous la flèche blanche et un rouge plus foncé à l'endroit où les 2 flèches rouges les plus sombres se croisent. Est-ce que quelqu'un peut-il me montrer la bonne direction?

EDIT: Voici le code utilisé pour configurer openGL pour chaque rendu d'image.

public void display(final GL gl, final GLProjection projection, final FieldMask fieldMask) 
{ 
    layerTextureShader.updateShader(gl, projection, fieldMask); 
    if (useMask) 
    { 
     layerMaskShader.updateShader(gl, projection, fieldMask); 
    } 

    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE); 

    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, getVertexBufferObject()); 
    gl.glBufferData(GL.GL_ARRAY_BUFFER, getNoOfVertices() * 3 * 4, getVertices(), GL.GL_STREAM_DRAW); 
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); 

    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, getTexCoordBufferObject()); 
    gl.glBufferData(GL.GL_ARRAY_BUFFER, getNoOfVertices() * 2 * 4, getTexCoords(), GL.GL_STREAM_DRAW); 
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); 

    gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, getIndicesBufferObject()); 
    gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, getNoOfIndices() * 4, getIndices(), GL.GL_STREAM_DRAW); 
    gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0); 

    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, getColorBufferObject()); 
    gl.glBufferData(GL.GL_ARRAY_BUFFER, getNoOfVertices() * 4 * 4, getColors(), GL.GL_STREAM_DRAW); 
    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); 

    if (useMask) 
    { 
     gl.glBindBuffer(GL.GL_ARRAY_BUFFER, getMaskColorBufferObject()); 
     gl.glBufferData(GL.GL_ARRAY_BUFFER, getNoOfVertices() * 4 * 4, getMaskColors(), GL.GL_STREAM_DRAW); 
     gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); 
    } 

    gl.glEnable(GL.GL_TEXTURE_2D); 
    gl.glActiveTexture(GL.GL_TEXTURE0); 
    gl.glBindTexture(GL.GL_TEXTURE_2D, textureId); 

    gl.glEnable(GL.GL_BLEND); 
    gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); 

    if (useMask) 
    { 
     gl.glBlendEquation(GL.GL_MIN); 

     layerMaskShader.use(gl); 

     display(gl, true); 

     layerMaskShader.release(gl); 
    } 

    gl.glBlendEquation(GL.GL_MAX); 

    layerTextureShader.use(gl); 

    display(gl, false); 

    layerTextureShader.release(gl); 

    gl.glDisable(GL.GL_TEXTURE_2D); 

    gl.glDepthMask(true); 

    gl.glDisable(GL.GL_BLEND); 
} 

Answer 1

Pour la fusion alpha, vous devez vous assurer que vous les dessinez dans le bon ordre ou les dessiner avec un mélange additif.

Une approche commune pour ce faire consiste à séparer vos éléments alpha mélangés des éléments non alpha. Rendez tous vos éléments standards, triez vos Alpha-Blended d'arrière en avant et restituez-les dans cet ordre. Si les fratries sont un problème (si vous avez plusieurs éléments à trier), vous pouvez trier plusieurs images.