# Equivalent of gl_LightSource[0].halfVector?

I can’t seem to get compute the right half vector, where L = light vector, V = view vector and H =L + V. Am I doing this correctly?

``````
varying vec3 v;
...
v = vec3(gl_ModelViewMatrix * gl_Vertex);

``````

``````
varying vec3 v;
...
vec3 L = normalize(gl_LightSource[0].position.xyz - v);
vec3 V = normalize(-v);
vec3 H = normalize(L + V);

``````

I found an Orange book example that is similar but requires eyePosition:

``````
// extract positions from input uniforms
vec3 lightPosition = gl_LightSource[0].position.xyz;
vec3 eyePosition   = -osg_ViewMatrix[3].xyz / osg_ViewMatrix[3].w;

// H = halfway vector between light and viewer from vertex
vec3 P = vec3(gl_ModelViewMatrix * gl_Vertex);
vec3 L = normalize(lightPosition - P);
vec3 V = normalize(eyePosition - P);
vec3 H = L + V;

``````

thanks

I can’t seem to get compute the right half vector, where L = light vector, V = view vector and H =L + V.

How do you know you can’t? How do you know what you’re getting is the wrong value?

Also, is L in the same space as V?

I found an Orange book example that is similar but requires eyePosition:

I don’t know how that works. P is in camera space. eyePosition is in… world space?

Thanks for response Alfonse.

How do you know you can’t? How do you know what you’re getting is the wrong value?

I render using gl_LightSource[0].halfVector, switch code to my halfVector equiv and re-render. not the same

is L in the same space as V?

if you mean in modelview space, then I’d say yes.

``````
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glPushMatrix();

glUseProgramObjectARB(0);
glColor3f(0,1,1);
update_lights();
if (drawlights)
draw_lights();

render_objects();

glPopMatrix();

glutSwapBuffers();

``````

I could not find anything in the documentation on how gl_LightSource[0].position is handled or half vector is computed. Good thing there is Mesa3d library to guide an answer. I found this in src/mesa/shader/prog_statevars.c :

``````
const GLuint ln = (GLuint) state[2];
GLfloat p[3];
/* Compute infinite half angle vector:
*   halfVector = normalize(normalize(lightPos) + (0, 0, 1))
* light.EyePosition.w should be 0 for infinite lights.
*/
COPY_3V(p, ctx->Light.Light[ln]._Position);
NORMALIZE_3FV(p);
NORMALIZE_3FV(value);
value[3] = 1.0;

``````

So I changed the vertex shader:

``````
varying vec3 halfVector, n;
...
//halfVector = normalize(gl_LightSource[0].halfVector.xyz);
halfVector = normalize(normalize(gl_LightSource[0].position.xyz) + vec3(0, 0, 1));

``````

``````
varying vec3 halfVector, n;
...
float NH = max(dot(n,halfVector),0.0);
vec4 spec = gl_FrontMaterial.specular * gl_LightSource[0].specular *
pow(NH,gl_FrontMaterial.shininess);

``````

Works!

I only wish I could see how to derive this solution.

This topic was automatically closed 183 days after the last reply. New replies are no longer allowed.