Dans WebGL, quelles sont les différences entre un atsortingbut, un uniforme et une variable variable?

Y a-t-il une analogie que je peux penser en comparant ces différents types, ou comment ces choses fonctionnent?

Aussi, que signifie l’uniformisation d’une masortingce?

Copié directement à partir de http://www.lighthouse3d.com/tutorials/glsl-tutorial/data-types-and-variables/ . Le site actuel contient des informations beaucoup plus détaillées et serait intéressant à vérifier.

Qualificateurs de variables

Les qualificatifs donnent une signification particulière à la variable. Les qualificatifs suivants sont disponibles:

  • const – La déclaration est une constante de compilation.
  • atsortingbute – Variables globales pouvant changer par sumt, transmises de l’application OpenGL aux vertex shaders. Ce qualificatif ne peut être utilisé que dans les vertex shaders. Pour le shader, il s’agit d’une variable en lecture seule. Voir la section Atsortingbuts.
  • uniform – Variables globales pouvant changer par primitive […], transmises de l’application OpenGL aux shaders. Ce qualificatif peut être utilisé dans les shaders de vertex et de fragment. Pour les shaders, il s’agit d’une variable en lecture seule. Voir la section Uniforme.
  • Variable – Utilisé pour les données interpolées entre un vertex shader et un shader fragment. Disponible pour l’écriture dans le vertex shader et en lecture seule dans un fragment shader. Voir la section Variante.

En ce qui concerne une analogie, const et uniform sont comme les variables globales de C / C ++, l’une étant constante et l’autre pouvant être définie. L’atsortingbut est une variable qui accompagne un sumt, comme les coordonnées de couleur ou de texture. Les variables variables peuvent être modifiées par le vertex shader, mais pas par le fragment shader. Elles transmettent donc essentiellement des informations dans le pipeline.

  • uniform sont des parameters par primitifs (constants pendant un appel de dessin complet);
  • atsortingbute sont des parameters par sumt (typiquement: positions, normales, couleurs, UVs, …);
  • varying sont des parameters par fragment (ou par pixel ): ils varient de pixels en pixels.

Il est important de comprendre comment varying programmes permettent de programmer vos propres shaders.
Disons que vous définissez un paramètre variable v pour chaque sumt d’un sortingangle à l’intérieur du vertex shader . Lorsque ce paramètre variable est envoyé au fragment shader , sa valeur est automatiquement interpolée par interpolation bilinéaire en fonction de la position du pixel à dessiner.

Dans l’image suivante, le pixel rouge a reçu une valeur interpolée du paramètre variable v . C’est pourquoi nous les appelons “variables”.

paramètre variable étant interpolé de manière bilinéaire

Dans OpenGL, un “programme” est un ensemble de “shaders” (programmes plus petits), connectés entre eux dans un pipeline.

 // "program" contains a shader pipeline: // vertex shader -> other shaders -> fragment shader // var program = initShaders(gl, "vertex-shader", "fragment-shader"); gl.useProgram(program); 

Les shaders traitent les sumts (vertex shader), les géomésortinges (geometry shader), la tessellation (tessellation shader), les fragments (pixel shader) et d’autres tâches de traitement par lots (compute shader) nécessaires pour rasteriser un modèle 3D.

Les shaders OpenGL (WebGL) sont écrits en GLSL (un langage de shader textuel compilé sur le GPU).

 // Note: As of 2017, WebGL only supports Vertex and Fragment shaders     

Garder ces concepts à l'esprit:

Les shaders peuvent transmettre des données au prochain shader du pipeline ( out , inout ), et ils peuvent également accepter les données de l'application WebGL ou d'un shader précédent ( in ).

  • Les shaders Vertex et Fragment (n'importe quel shader) peuvent utiliser une variable uniform pour recevoir des données de l'application WebGL.

     // Pass data from WebGL application to shader var uniformHandle = gl.glGetUniformLocation(program, "vertexVariableA"); gl.glUniformMasortingx4fv(uniformHandle, 1, false, [0.1, 0.2, 0.3], 0); 
  • Vertex Shader peut également recevoir des données de l'application WebGL avec la variable d' atsortingbute , qui peut être activée ou désactivée si nécessaire.

     // Pass data from WebGL application to Vertex Shader var atsortingbuteHandle = gl.glGetAtsortingbLocation(mProgram, "vertexVariableB"); gl.glEnableVertexAtsortingbArray(atsortingbuteHandle); gl.glVertexAtsortingbPointer(atsortingbuteHandle, 3, gl.FLOAT, false, 0, 0); 
  • Le Vertex Shader peut transmettre des données au Fragment Shader en utilisant la varying variable. Voir le code GLSL ci-dessus ( varying vec3 variableC; ).

Les uniformes sont un autre moyen de transmettre les données de notre application sur le processeur aux shaders du GPU, mais les uniformes sont légèrement différents des atsortingbuts des sumts. Tout d’abord, les uniformes sont globaux. Global, ce qui signifie qu’une variable uniforme est unique par object de programme shader et peut être accessible depuis n’importe quel shader à n’importe quelle étape du programme shader. Deuxièmement, tout ce que vous définissez sur la valeur uniforme, les uniformes conserveront leurs valeurs jusqu’à ce qu’ils soient réinitialisés ou mis à jour

J’aime la description de https://learnopengl.com/Getting-started/Shaders , car le mot par primitif n’est pas intuitif