Procedureal Texture Generation

• This is from the red book.
• Generating texture in the fragment shader
  • This is the benifit of a "full-featured, high level programming language".
  • He claims we can do things that were never possible before.
  • Computatations in the shader (like removing "invisible" pixels)
  • Benifits of computed textures
    • Low memory requirements.
    • No fixed resolution, so no problems with replication or mapping 2D onto 3D.
    • Parameters can alter the texture on the fly
    • More realistic CSG
  • And some disadvantages
    • Writing the program to do it.
    • Computation time might be high.
    • Antialiasing becomes the problem of the programmer.
    • Hardware is not yet standardized, so results across platforms may vary.
  • Something funkey groovey
    • Based on the texture

    • tmp =   texture2D(tex, Texcoord);
      
      if ((tmp.r + tmp.g+tmp.b)  > 0.45) {
                 discard;
      }
      gl_FragColor =  color;
      	     

    • The 0.45 is purely arbitrary, pick you own or better yet, let someone else set it via a uniform parameter.
  • A checkerboard pattern of my own design.
    • Like that took any brains.

      i = int(mod(Texcoord.s*10.0,2.0));
      j = int(mod(Texcoord.t*10.0,2.0));
      if (( i == 1 && j == 0 )|| (i == 0 && j == 1)) {
           gl_FragColor =  vec4(1.0, 1.0, 1.0, 1.0) - color;
      } else {
           gl_FragColor =  color;
      }
      	     

    • Math in glsl is a bit strange.
    • And I really want version 4.0 or better to do this ...
  • A brick function from the book
    • This shows off shader math to compute brick edges in a pattern
    • Two uniforms that I made constant.
      • brickSize, a vec 2, x and y dimensions of a brick.
      • brickPct, a 2 vec percent of brick to mortar in each direction.
    • genType: a generic float type, input=output
      • float, double, vec2, vec3 ...
      • genDtype is an int equivelent
    • Three glsl functions
      • genType fract(genType x);
        • for all i, x[i]-floor(x[i])
      • genType step(genType edge, genType x);
        • for all i, return (x[i] < edge[i])
      • genType mix(genType x, genType y, genType a);
        • for all i, (1-a)x[i] + ay[i]

      vec2 position;
      vec2 useBrick;
      
      // should be uniform variables.
      vec2 brickPct = vec2(0.96, 0.96);
      vec2 brickSize = vec2(0.5, 0.25);
      
      position = Position / brickSize;
      
      if (fract(position.y * 0.5 ) > 0.5)
          position.x += 0.5;
      position = fract(position);
      useBrick = step(position, brickPct);
      gl_FragColor = mix(vec4(0.0, 0.0, 0.0, 1.0), color,
                      useBrick.x * useBrick.y);
      	     

• He discusses bump mapping
  • Peterb the normals slightly in the lighting model, but a random amount.
  • Think the skin of an orange or surface of a golf ball.