Webgl Textur interlaced Flimmern auf dedizierten GPU

Question

Ich habe ein Vertex-Puffer-Objekt, das alle Scheitelpunkte für ein Array von Oberflächenobjekten enthält. Jedes Objekt kann eine andere Textur verwenden, bis zu 16 für meinen Browser unterstützt nur bis zu 16. Mein Problem ist, dass ich auf den meisten Oberflächen interlaced flackere, während einige andere nicht.

Hier ist mein Fragment-Shader:

 

precision mediump float; 
    varying vec2 texCoord; 
    varying float texNum; 

    uniform sampler2D texture0; 
    uniform sampler2D texture1; 
    uniform sampler2D texture2; 
    uniform sampler2D texture3; 
    uniform sampler2D texture4; 
    uniform sampler2D texture5; 
    uniform sampler2D texture6; 
    uniform sampler2D texture7; 
    uniform sampler2D texture8; 
    uniform sampler2D texture9; 
    uniform sampler2D texture10; 
    uniform sampler2D texture11; 
    uniform sampler2D texture12; 
    uniform sampler2D texture13; 
    uniform sampler2D texture14; 
    uniform sampler2D texture15; 

    void main(void){ 
     if(texNum == 0.0){ 
      gl_FragColor = texture2D(texture0,texCoord); 
     }else if(texNum == 1.0){ 
      gl_FragColor = texture2D(texture1,texCoord); 
     }else if(texNum == 2.0){ 
      gl_FragColor = texture2D(texture2,texCoord); 
     }else if(texNum == 3.0){ 
      gl_FragColor = texture2D(texture3,texCoord); 
     }else if(texNum == 4.0){ 
      gl_FragColor = texture2D(texture4,texCoord); 
     }else if(texNum == 5.0){ 
      gl_FragColor = texture2D(texture5,texCoord); 
     }else if(texNum == 6.0){ 
      gl_FragColor = texture2D(texture6,texCoord); 
     }else if(texNum == 7.0){ 
      gl_FragColor = texture2D(texture7,texCoord); 
     }else if(texNum == 8.0){ 
      gl_FragColor = texture2D(texture8,texCoord); 
     }else if(texNum == 9.0){ 
      gl_FragColor = texture2D(texture9,texCoord); 
     }else if(texNum == 10.0){ 
      gl_FragColor = texture2D(texture10,texCoord); 
     }else if(texNum == 11.0){ 
      gl_FragColor = texture2D(texture11,texCoord); 
     }else if(texNum == 12.0){ 
      gl_FragColor = texture2D(texture12,texCoord); 
     }else if(texNum == 13.0){ 
      gl_FragColor = texture2D(texture13,texCoord); 
     }else if(texNum == 14.0){ 
      gl_FragColor = texture2D(texture14,texCoord); 
     }else if(texNum == 15.0){ 
      gl_FragColor = texture2D(texture15,texCoord); 
     } 

     if(gl_FragColor.a < 0.1) discard; 
    } 

Ein Bild von dem, was passiert ist:

Nun, hier ist der Deal. Dies funktioniert perfekt auf einer Maschine mit Intel HD integrierte Grafik; kein Flackern. Dies geschieht nur, wenn ich es auf meinem Desktop mit gtx 770 dedizierte GPU ausführen.

Warum? Wie?

Answer 1

Ich fand die Lösung: Das Problem war von der Float-Gleichheit Vergleich, die wegen der Float-Präzision Rand Fehler meiner GPU die meiste Zeit zu falsch ergab.

Alles, was ich tun musste, war zu testen, ob der Unterschied zwischen meiner texNum und der unmittelbaren Texturzahl kleiner als eine Fehlermarge von 0,00001 namens Epsilon war.

Im Code ersetzt ich alle Vergleich Schwimmer Gleichheit zum Beispiel des ersten:

if(texNum == 0.0){ 
    gl_FragColor = texture2D(texture0,texCoord); 
} 

Dazu:

if((texNum - 0.0) < 0.00001){ 
    gl_FragColor = texture2D(texture0,texCoord); 
}