GLSL Motif en Damier

je veux à l'ombre du quad avec les checkers:

f(P)=[étage(Px)+sol(Py)]mod2.

Mon quad est:

glBegin(GL_QUADS);    
  glVertex3f(0,0,0.0);    
  glVertex3f(4,0,0.0);    
  glVertex3f(4,4,0.0);   
  glVertex3f(0,4, 0.0); 
glEnd();

Le vertex shader fichier:

varying float factor;
float x,y;
void main(){
  x=floor(gl_Position.x);
  y=floor(gl_Position.y);
  factor = mod((x+y),2.0);
}

Et le fragment shader fichier est:

varying float factor;
void main(){
  gl_FragColor = vec4(factor,factor,factor,1.0);
}

Mais im obtenir ceci:

GLSL Motif en Damier

Il semble que la fonction mod doeasn pas de travail ou peut-être quelque chose d'autre...
Toute aide?

Intéressant. Le résultat montre que le quad est effectivement rendu que deux triangles (topleft/bottomright). Sinon, le résultat serait plus comme un lissé damier. Si c'était le cas, vous pouvez utiliser un seuillage de la fonction dans votre fragment shader pour obtenir un bon damier. Comme il est, l'interpolation est inutile pour un effet damier.

OriginalL'auteur Sanich | 2011-01-14

glsl

Il est préférable de calculer cet effet dans le fragment shader, quelque chose comme ça:

programme de vertex =>

varying vec2 texCoord;

void main(void)
{
   gl_Position = vec4( gl_Vertex.xy, 0.0, 1.0 );
   gl_Position = sign( gl_Position );

   texCoord = (vec2( gl_Position.x, gl_Position.y ) 
             + vec2( 1.0 ) ) / vec2( 2.0 );      
}

fragment de programme =>

#extension GL_EXT_gpu_shader4 : enable
uniform sampler2D Texture0;
varying vec2 texCoord;

void main(void)
{
    ivec2 size = textureSize2D(Texture0,0);
    float total = floor(texCoord.x*float(size.x)) +
                  floor(texCoord.y*float(size.y));
    bool isEven = mod(total,2.0)==0.0;
    vec4 col1 = vec4(0.0,0.0,0.0,1.0);
    vec4 col2 = vec4(1.0,1.0,1.0,1.0);
    gl_FragColor = (isEven)? col1:col2;
}

De sortie =>

GLSL Motif en Damier

Bonne chance!

pourquoi ne pas utiliser des entiers x,y et appliquer peu simple ET (pas de division à l'intérieur du fragment)

OriginalL'auteur Agnius Vasiliauskas

3

Ce que votre code n'est calculer le facteur 4 fois (une fois pour chaque sommet, puisque c'est de vertex shader code) puis d'interpoler les valeurs (parce que c'est écrit en différentes varible) puis sortie variable de la couleur dans le fragment shader.

De sorte qu'il ne fonctionne pas de cette façon. Vous avez besoin de faire le calcul directement dans le fragment shader. Vous pouvez obtenir le fragment de position à l'aide de la gl_FragCoord variable intégrée dans le fragment shader.

OriginalL'auteur Matias Valdenegro
3

Essayer cette fonction dans le fragment shader:
```
vec3 checker(in float u, in float v)
{
  float checkSize = 2;
  float fmodResult = mod(floor(checkSize * u) + floor(checkSize * v), 2.0);
  float fin = max(sign(fmodResult), 0.0);
  return vec3(fin, fin, fin);
}
```
Puis, en principal, vous pouvez l'appeler à l'aide :
```
vec3 check = checker(fs_vertex_texture.x, fs_vertex_texture.y);
```
Et tout simplement passer à x et y que vous obtenez à partir du vertex shader. Tout ce que vous avez à faire après est à inclure dans le calcul de votre vFragColor.

Garder à l'esprit que vous pouvez changer chec taille simplement en modifiant checkSize valeur.

OriginalL'auteur Fengson

Vous devez vous connecter pour publier un commentaire.