Message ID | 20110721123631.17019.24693.launchpad@loganberry.canonical.com |
---|---|

State | Accepted |

Headers | show |

=== modified file 'data/shaders/light-basic.frag' --- data/shaders/light-basic.frag 2010-07-08 15:17:11 +0000 +++ data/shaders/light-basic.frag 2010-07-08 15:48:22 +0000 @@ -1,24 +1,6 @@ -// Because we are using the varying float Diffuse in -// our vertex shader, if we wish to read it in here, we -// need to set the same variable, so I have done this -// first. - -// After that, I am simply changing the line: -// gl_FragColor = vec4(0,0,1,1) -// to -// gl_FragColor = Diffuse * vec4(0,0,1,1); -// This multiplies the intensity of the light by the -// color we originally set the cube to. - -// This can or cannot eliminate the need for materials, -// depending on your needs, but just for the record -// (and future tutorials), materials are worth while -// and can be read from inside GLSL :) - -varying float Diffuse; +varying vec4 Color; void main(void) { - // Multiply the light Diffuse intensity by the color of the - gl_FragColor = Diffuse * vec4(0.0, 0.0, 1.0, 1.0); + gl_FragColor = Color; } === modified file 'data/shaders/light-basic.vert' --- data/shaders/light-basic.vert 2010-07-08 15:17:11 +0000 +++ data/shaders/light-basic.vert 2010-07-08 15:48:22 +0000 @@ -1,63 +1,3 @@ -// For this tutorial, I am going show you how to perform per -// vertex lighting using shaders. Yes, shaders support per pixel -// but this is just a starting point. - -// First I am going to teach you about varying variables. These -// are variables that can be shared between the vertex and fragment -// shaders. These variables are set inside the vertex shader, and -// then read from the fragment shader. In this case we are going -// to share a float type variable from the Vertex shader to the -// Fragment shader. This variable is going to be called Diffuse -// and will hold a number that will tell us how lit our vertex -// should be. - -// Because we are using per vertex lighting, the GLSL shader will -// automatically interpolate the color between the vertices. Just -// like OpenGL does. - -// Now first off we need to know the surface normal of the current -// vertex. Because I am using a GLUT cube, these are already -// calculated and sent off with the glNormal command. Any numbers -// sent from OpenGL through glNormal(1,2,3); can be read with -// the variable gl_Normal. In later tutorials, I will be using -// self calculated normals, using my own normal generation code. - -// Now as for our normal, I am storing it in the variable vec3 Normal. -// But first, I have to multiply the surface normal (gl_Normal) by -// the gl_NormalMatrix. This places the normal in coordinates that -// we can use. (Later on I will show you how to use tangent space -// normals). We also then have to normalize this multiplication so -// that all of the normal vectors are between (and including) -1 and 1. -// This makes sure that we have no scaling errors. - -// Next on, we are going to work with our light. I am storing this -// in a variable called vec3 Light. In this, I am calling for the -// position of glLight0. This is gathered by the call: -// gl_LightSource[0].position.xyz -// This gives us the position of glLight0, and to get the position of -// any other light, we just change the number 0 to the light number we -// are after. We do not need to multiply this expression by the -// gl_NormalMatrix, but we do have to normalize it still. - -// Now that we have our surface Normal and the position of our Light. -// We can now calculate the Diffuse value of our lighting at the -// given vertex. To do this we need to take the dot product of both -// the Normal and the Light together. If you have any idea on -// calculating Normals, then you should have a fair idea of what the -// dot product does. It works as such: -// dot(a,b) = (x1 * x2) + (y1 * y2) + (z1 * z3) -// If this happens to be equal to 0, then the vectors a and b are -// perpendicular (the light meets the surface at a 90 degree angle). -// Because this point is when the light is at its brightest, we need -// to set the maximum value for our diffuse value to 0.0. -// So our Diffuse equation becomes: -// Diffuse = max(dot(Normal, Light),0.0); - -// And from that, we have now calculated the intensity of the light -// at the given vertex. That started to turn into a bit of a maths -// lesson, but it even cleared up some stuff for me without even -// thinking about it. GO MATHS :) - attribute vec3 position; attribute vec3 normal; attribute vec2 texture; @@ -68,15 +8,21 @@ uniform vec3 LightSourceDiffuse; uniform vec3 MaterialDiffuse; -varying float Diffuse; +varying vec4 Color; void main(void) { + // Transform the normal to eye coordinates vec3 N = normalize(vec3(NormalMatrix * vec4(normal, 1.0))); + // The LightSourcePosition is actually its direction for directional light vec3 L = normalize(LightSourcePosition.xyz); - Diffuse = max(dot(N, L), 0.0); + // Multiply the diffuse value by the vertex color (which is fixed in this case) + // to get the actual color that we will use to draw this vertex with + float diffuse = max(dot(N, L), 0.0); + Color = diffuse * vec4(0.0, 0.0, 1.0, 1.0); + // Transform the position to clip coordinates gl_Position = ModelViewProjectionMatrix * vec4(position, 1.0); }