Pourquoi mon WebGL shader ne me laisse pas utiliser les variations?

Question

Lorsque je tente de relier mon sommet et fragment shaders dans un programme, WebGL jette Varyings with the same name but different type, or statically used varyings in fragment shader are not declared in vertex shader: textureCoordinates

J'ai varying vec2 test dans mes deux vertex shaders et fragment, et on ne voit aucune raison pour laquelle le compilateur ne serait pas en mesure de trouver le même varying dans les deux.

Vertex Shader:

varying vec2 test; 
void main(void) { 
    gl_Position = vec4(0.0, 0.0, 0.0, 0.0); 
    test = vec2(1.0, 0.0); 
} 

Fragment Shader:

precision highp float; 
varying vec2 test; 
void main(void) { 
    gl_FragColor = vec4(test.xy, 0.0, 1.0); 
} 

Code d'essai:

const canvas = document.createElement('canvas'); 
gl = canvas.getContext('webgl') 
let vert = gl.createShader(gl.VERTEX_SHADER); 
gl.shaderSource(vert, "varying vec2 test;\nvoid main(void) {\n gl_Position = vec4(0.0, 0.0, 0.0, 0.0);\n test = vec2(1.0, 0.0);\n}"); 
gl.compileShader(vert); 

let frag = gl.createShader(gl.FRAGMENT_SHADER); 
gl.shaderSource(frag, "precision highp float;\nvarying vec2 test;\nvoid main() {\n\tgl_FragColor = vec4(test.xy, 0.0, 1.0);\n}"); 
gl.compileShader(frag); 

let program = gl.createProgram(); 
gl.attachShader(program, vert); 
gl.attachShader(program, frag); 

gl.linkProgram(program); 
gl.useProgram(program); 

Answer 1

Juste une supposition, mais je me demande si c'est parce que vous n'êtes pas en utilisant la textureCoordinates dans votre fragment shader. Les noms & correspondent très bien, donc je ne pense pas que ce soit le problème. Je l'ai fait la même chose ici:

Frag:

// The fragment shader is the rasterization process of webgl 

// use float precision for this shader 
precision mediump float; 

// the input texture coordinate values from the vertex shader 
varying vec2 vTextureCoord; 
// the texture data, this is bound via gl.bindTexture() 
uniform sampler2D texture; 
// the colour uniform 
uniform vec3 color; 

void main(void) { 
    // gl_FragColor is the output colour for a particular pixel. 
    // use the texture data, specifying the texture coordinate, and modify it by the colour value. 
    gl_FragColor = texture2D(texture, vec2(vTextureCoord.s, vTextureCoord.t)) * vec4(color, 1.0); 
} 

Vert:

// setup passable attributes for the vertex position & texture coordinates 
attribute vec3 aVertexPosition; 
attribute vec2 aTextureCoord; 

// setup a uniform for our perspective * lookat * model view matrix 
uniform mat4 uMatrix; 
// setup an output variable for our texture coordinates 
varying vec2 vTextureCoord; 
void main() { 
    // take our final matrix to modify the vertex position to display the data on screen in a perspective way 
    // With shader code here, you can modify the look of an image in all sorts of ways 
    // the 4th value here is the w coordinate, and it is called Homogeneous coordinates, (x,y,z,w). 
    // It effectively allows the perspective math to work. With 3d graphics, it should be set to 1. Less than 1 will appear too big 
    // Greater than 1 will appear too small 
    gl_Position = uMatrix * vec4(aVertexPosition, 1); 
    vTextureCoord = aTextureCoord; 
} 

Answer 2

problème a été résolu par la mise à jour Chrome pour Mac OS X de v51.something à 52.0.2743.82 (64- Un peu étrange.