I've started to learn openGL one month ago , I've proceeded now with Shaders.

I have a vertex shader that does not calculate lighting... It just show me weird things...

thats my shader:

VertexShader:

uniform vec3 lightPos[1];
float density =0.009;


void main(void)
{
    // normal MVP transform
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;


    vec3 N = normalize(gl_NormalMatrix * gl_Normal);
    vec4 V = gl_ModelViewMatrix * gl_Vertex;
    vec3 L = normalize(lightPos[0] - V.xyz);
    vec3 H = normalize(L + vec3(0.0, 0.0, 1.0));
    const float specularExp = 128.0;


    // calculate diffuse lighting
    float NdotL = max(0.0, dot(N, L));
    vec4 diffuse = gl_Color * vec4(NdotL);


    // calculate specular lighting
    float NdotH = max(0.0, dot(N, H));
    vec4 specular = vec4(0.0);
    if (NdotL > 0.0) 
        specular = vec4(pow(NdotH, specularExp));


    // calculate 2nd order exponential fog factor
    const float e = 2.71828;
    float fogFactor = (density * length(V));
    fogFactor *= fogFactor;
    fogFactor = clamp(pow(e, -fogFactor), 0.0, 1.0);


    // sum the diffuse and specular components, then
    // blend with the fog color based on fog factor
    const vec4 fogColor = vec4(0.5, 0.8, 0.5, 1.0);
    gl_FrontColor = mix(fogColor, clamp(diffuse + specular, 0.0, 1.0), 
                        fogFactor);
}

Images of the result:

http://tinypic.com/view.php?pic=34fe35k&s=5

http://tinypic.com/view.php?pic=20itemr&s=5

Yes. It's the same scene.

I'm moving my scene with modelview matrix (not projection), for example if I go back I move the whole scene forward.

With fog calculations only It works nice.

-------------------------------------------------------

I have trouble understanding Fragment shader image processing.
I'm learning with openGL superbible 4th edition, trying to figure out why he calculates offsets and uses a Scene texture.

Fragment shader:

// blur.fs//
// blur (low-pass) 3x3 kernel


uniform sampler2D sampler0;
uniform vec2 tc_offset[9];


void main(void)
{
    vec4 sample[9];


    for (int i = 0; i < 9; i++)
    {
        sample[i] = texture2D(sampler0, 
                              gl_TexCoord[0].st + tc_offset[i]);
    }


//   1 2 1
//   2 1 2   / 13
//   1 2 1


    gl_FragColor = (sample[0] + (4.0*sample[1]) + sample[2] + 
                    (4.0*sample[3]) + sample[4] + (4.0*sample[5]) + 
                    sample[6] + (4.0*sample[7]) + sample[8]) / 13.0;
}

and the code that generates offsets:(CPP CODE)

  xInc = 1.0f / (GLfloat)textureWidth;    yInc = 1.0f / (GLfloat)textureHeight;


    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 3; j++)
        {
            texCoordOffsets[(((i*3)+j)*2)+0] = (-1.0f * xInc) + ((GLfloat)i * xInc);
            texCoordOffsets[(((i*3)+j)*2)+1] = (-1.0f * yInc) + ((GLfloat)j * yInc);
        }
    }

Can someone explain me more about this? Thank you :)

Up.

This is kind of important to me.