Jump to content

  • Log In with Google      Sign In   
  • Create Account

FREE SOFTWARE GIVEAWAY

We have 4 x Pro Licences (valued at $59 each) for 2d modular animation software Spriter to give away in this Thursday's GDNet Direct email newsletter.


Read more in this forum topic or make sure you're signed up (from the right-hand sidebar on the homepage) and read Thursday's newsletter to get in the running!


#Actualhandoman

Posted 14 May 2013 - 10:07 PM

So, I've been following the tuts from http://www.opengl-tutorial.org, (using the opengl 2.1 versions) and came across a problem in Tutorial 8: Basic Shading. Basically, my shading comes out calculated wrong(noticable around the edges of the triangle faces).

KhGooen.jpg

After hours of comparing the tut code with my code, i could find anythign wrong. I finally jus copied and pasted everything from the tut, but nothing help. I am pretty sure the problem with the shaders, here is the code:

#version 120

// Interpolated values from the vertex shaders
varying vec2 UV;
varying vec3 Position_worldspace;
varying vec3 Normal_cameraspace;
varying vec3 EyeDirection_cameraspace;
varying vec3 LightDirection_cameraspace;

// Values that stay constant for the whole mesh.
uniform sampler2D myTextureSampler;
uniform mat4 MV;
uniform vec3 LightPosition_worldspace;

void main(){

	// Light emission properties
	// You probably want to put them as uniforms
	vec3 LightColor = vec3(1,1,1);
	float LightPower = 30.0;

	// Material properties
	vec3 MaterialDiffuseColor = texture2D(myTextureSampler,UV).rgb;
	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;
	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);

	// Distance to the light
	float distance2 = length( LightPosition_worldspace - Position_worldspace );

	// Normal of the computed fragment, in camera space
	vec3 n = normalize( Normal_cameraspace );
	// Direction of the light (from the fragment to the light)
	vec3 l = normalize( LightDirection_cameraspace );
	// Cosine of the angle between the normal and the light direction,
	// clamped above 0
	//  - light is at the vertical of the triangle -> 1
	//  - light is perpendicular to the triangle -> 0
	//  - light is behind the triangle -> 0
	float cosTheta = clamp( dot( n,l ), 0.0,1.0);

	// Eye vector (towards the camera)
	vec3 E = normalize(EyeDirection_cameraspace);
	// Direction in which the triangle reflects the light
	vec3 R = reflect(-l,n);
	// Cosine of the angle between the Eye vector and the Reflect vector,
	// clamped to 0
	//  - Looking into the reflection -> 1
	//  - Looking elsewhere -> < 1
	float cosAlpha = clamp( dot( E,R ), 0,1 );

	gl_FragColor.rgb =

		// Diffuse : "color" of the object
		MaterialDiffuseColor* LightColor * LightPower /(distance2*distance2) ;

}
 
#version 120

// Input vertex data, different for all executions of this shader.
attribute vec3 vertexPosition_modelspace;
attribute vec2 vertexUV;
attribute vec3 vertexNormal_modelspace;

// Output data ; will be interpolated for each fragment.
varying vec2 UV;
varying vec3 Position_worldspace;
varying vec3 Normal_cameraspace;
varying vec3 EyeDirection_cameraspace;
varying vec3 LightDirection_cameraspace;

// Values that stay constant for the whole mesh.
uniform mat4 MVP;
uniform mat4 V;
uniform mat4 M;
uniform vec3 LightPosition_worldspace;
uniform int vertex_image_type;

void main(){

	// Output position of the vertex, in clip space : MVP * position
	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);

	// Position of the vertex, in worldspace : M * position
	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;

	// Vector that goes from the vertex to the camera, in camera space.
	// In camera space, the camera is at the origin (0,0,0).
	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;
	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;

	// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.
	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;
	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;

	// Normal of the the vertex, in camera space
	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.

	// UV of the vertex. No special space for this one.
	UV = vertexUV;
	if (vertex_image_type==2)
	{
        UV.y =-UV.y;//invierse v if dds
	}
}
 

 

 i just kept the diffuse, thats where the problem seems to be. maybe the problem is with the glsl and opengl versions? edit: Just to add some more info. I kinda think the problem has something to do with that cosTheta variable. when I remove it from the equation, the problem is no longer there(but faces are lit up eventhough they are facing away from the light) I understand the purpose of the cosTheta is to calculate the brightness based on the angle of the face compared to the angle of the light, but maybe there is something wrong here...


#5handoman

Posted 14 May 2013 - 10:02 PM

So, I've been following the tuts from http://www.opengl-tutorial.org, (using the opengl 2.1 versions) and came across a problem in Tutorial 8: Basic Shading. Basically, my shading comes out calculated wrong(noticable around the edges of the triangle faces). KhGooen.jpg After hours of comparing the tut code with my code, i could find anythign wrong. I finally jus copied and pasted everything from the tut, but nothing help. I am pretty sure the problem with the shaders, here is the code:

#version 120// Input vertex data, different for all executions of this shader.attribute vec3 vertexPosition_modelspace;attribute vec2 vertexUV;attribute vec3 vertexNormal_modelspace;// Output data ; will be interpolated for each fragment.varying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform mat4 MVP;uniform mat4 V;uniform mat4 M;uniform vec3 LightPosition_worldspace;uniform int vertex_image_type;void main(){ // Output position of the vertex, in clip space : MVP * position gl_Position = MVP * vec4(vertexPosition_modelspace,1); // Position of the vertex, in worldspace : M * position Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz; // Vector that goes from the vertex to the camera, in camera space. // In camera space, the camera is at the origin (0,0,0). vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz; EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace; // Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity. vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz; LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace; // Normal of the the vertex, in camera space Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not. // UV of the vertex. No special space for this one. UV = vertexUV; if (vertex_image_type==2) { UV.y =-UV.y; //inverts UVs for dds files }}
#version 120// Interpolated values from the vertex shadersvarying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform sampler2D myTextureSampler;uniform mat4 MV;uniform vec3 LightPosition_worldspace;void main(){ // Light emission properties // You probably want to put them as uniforms vec3 LightColor = vec3(1,1,1); float LightPower = 30.0; // Material properties vec3 MaterialDiffuseColor = texture2D(myTextureSampler,UV).rgb; vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor; vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3); // Distance to the light float distance1 = length( LightPosition_worldspace - Position_worldspace ); // Normal of the computed fragment, in camera space vec3 n = normalize( Normal_cameraspace ); // Direction of the light (from the fragment to the light) vec3 l = normalize( LightDirection_cameraspace ); // Cosine of the angle between the normal and the light direction, // clamped above 0 // - light is at the vertical of the triangle -> 1 // - light is perpendicular to the triangle -> 0 // - light is behind the triangle -> 0 float cosTheta = clamp( dot( n,l ), 0.0,1.0); // Eye vector (towards the camera) vec3 E = normalize(EyeDirection_cameraspace); // Direction in which the triangle reflects the light vec3 R = reflect(-l,n); // Cosine of the angle between the Eye vector and the Reflect vector, // clamped to 0 // - Looking into the reflection -> 1 // - Looking elsewhere -> < 1 float cosAlpha = clamp( dot( E,R ), 0,1 ); gl_FragColor.rgb = // Diffuse : "color" of the object MaterialDiffuseColor* LightColor * LightPower * cosTheta / (distance1*distance1) ;}
i just kept the diffuse, thats where the problem seems to be. maybe the problem is with the glsl and opengl versions? edit: Just to add some more info. I kinda think the problem has something to do with that cosTheta variable. when I remove it from the equation, the problem is no longer there(but faces are lit up eventhough they are facing away from the light) I understand the purpose of the cosTheta is to calculate the brightness based on the angle of the face compared to the angle of the light, but maybe there is something wrong here...

#4handoman

Posted 14 May 2013 - 10:01 PM

So, I've been following the tuts from http://www.opengl-tutorial.org, (using the opengl 2.1 versions) and came across a problem in Tutorial 8: Basic Shading. Basically, my shading comes out calculated wrong(noticable around the edges of the triangle faces).
KhGooen.jpg
After hours of comparing the tut code with my code, i could find anythign wrong. I finally jus copied and pasted everything from the tut, but nothing help. I am pretty sure the problem with the shaders, here is the code:
#version 120// Input vertex data, different for all executions of this shader.attribute vec3 vertexPosition_modelspace;attribute vec2 vertexUV;attribute vec3 vertexNormal_modelspace;// Output data ; will be interpolated for each fragment.varying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform mat4 MVP;uniform mat4 V;uniform mat4 M;uniform vec3 LightPosition_worldspace;uniform int vertex_image_type;void main(){	// Output position of the vertex, in clip space : MVP * position	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);	// Position of the vertex, in worldspace : M * position	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;	// Vector that goes from the vertex to the camera, in camera space.	// In camera space, the camera is at the origin (0,0,0).	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;	// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;	// Normal of the the vertex, in camera space	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.	// UV of the vertex. No special space for this one.	UV = vertexUV;	if (vertex_image_type==2)	{        UV.y =-UV.y; //inverts UVs for dds files	}}
#version 120// Interpolated values from the vertex shadersvarying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform sampler2D myTextureSampler;uniform mat4 MV;uniform vec3 LightPosition_worldspace;void main(){	// Light emission properties	// You probably want to put them as uniforms	vec3 LightColor = vec3(1,1,1);	float LightPower = 30.0;	// Material properties	vec3 MaterialDiffuseColor = texture2D(myTextureSampler,UV).rgb;	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);	// Distance to the light	float distance1 = length( LightPosition_worldspace - Position_worldspace );	// Normal of the computed fragment, in camera space	vec3 n = normalize( Normal_cameraspace );	// Direction of the light (from the fragment to the light)	vec3 l = normalize( LightDirection_cameraspace );	// Cosine of the angle between the normal and the light direction,	// clamped above 0	//  - light is at the vertical of the triangle -> 1	//  - light is perpendicular to the triangle -> 0	//  - light is behind the triangle -> 0	float cosTheta = clamp( dot( n,l ), 0.0,1.0);	// Eye vector (towards the camera)	vec3 E = normalize(EyeDirection_cameraspace);	// Direction in which the triangle reflects the light	vec3 R = reflect(-l,n);	// Cosine of the angle between the Eye vector and the Reflect vector,	// clamped to 0	//  - Looking into the reflection -> 1	//  - Looking elsewhere -> < 1	float cosAlpha = clamp( dot( E,R ), 0,1 );	gl_FragColor.rgb =		// Diffuse : "color" of the object        MaterialDiffuseColor* LightColor * LightPower * cosTheta / (distance1*distance1) ;}

i just kept the diffuse, thats where the problem seems to be. maybe the problem is with the glsl and opengl versions?

edit:
Just to add some more info. I kinda think the problem has something to do with that cosTheta variable. when I remove it from the equation, the problem is no longer there(but faces are lit up eventhough they are facing away from the light) I understand the purpose of the cosTheta is to calculate the brightness based on the angle of the face compared to the angle of the light, but maybe there is something wrong here...

#3handoman

Posted 14 May 2013 - 10:00 PM

So, I've been following the tuts from http://www.opengl-tutorial.org, (using the opengl 2.1 versions) and came across a problem in Tutorial 8: Basic Shading. Basically, my shading comes out calculated wrong(noticable around the edges of the triangle faces).
KhGooen.jpg
After hours of comparing the tut code with my code, i could find anythign wrong. I finally jus copied and pasted everything from the tut, but nothing help. I am pretty sure the problem with the shaders, here is the code:
#version 120// Input vertex data, different for all executions of this shader.attribute vec3 vertexPosition_modelspace;attribute vec2 vertexUV;attribute vec3 vertexNormal_modelspace;// Output data ; will be interpolated for each fragment.varying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform mat4 MVP;uniform mat4 V;uniform mat4 M;uniform vec3 LightPosition_worldspace;uniform int vertex_image_type;void main(){	// Output position of the vertex, in clip space : MVP * position	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);	// Position of the vertex, in worldspace : M * position	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;	// Vector that goes from the vertex to the camera, in camera space.	// In camera space, the camera is at the origin (0,0,0).	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;	// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;	// Normal of the the vertex, in camera space	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.	// UV of the vertex. No special space for this one.	UV = vertexUV;	if (vertex_image_type==2)	{        UV.y =-UV.y; //inverts UVs for dds files	}}
#version 120// Interpolated values from the vertex shadersvarying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform sampler2D myTextureSampler;uniform mat4 MV;uniform vec3 LightPosition_worldspace;void main(){	// Light emission properties	// You probably want to put them as uniforms	vec3 LightColor = vec3(1,1,1);	float LightPower = 30.0;	// Material properties	vec3 MaterialDiffuseColor = texture2D(myTextureSampler,UV).rgb;	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);	// Distance to the light	float distance1 = length( LightPosition_worldspace - Position_worldspace );	// Normal of the computed fragment, in camera space	vec3 n = normalize( Normal_cameraspace );	// Direction of the light (from the fragment to the light)	vec3 l = normalize( LightDirection_cameraspace );	// Cosine of the angle between the normal and the light direction,	// clamped above 0	//  - light is at the vertical of the triangle -> 1	//  - light is perpendicular to the triangle -> 0	//  - light is behind the triangle -> 0	float cosTheta = clamp( dot( n,l ), 0.0,1.0);	// Eye vector (towards the camera)	vec3 E = normalize(EyeDirection_cameraspace);	// Direction in which the triangle reflects the light	vec3 R = reflect(-l,n);	// Cosine of the angle between the Eye vector and the Reflect vector,	// clamped to 0	//  - Looking into the reflection -> 1	//  - Looking elsewhere -> < 1	float cosAlpha = clamp( dot( E,R ), 0,1 );	gl_FragColor.rgb =		// Diffuse : "color" of the object        MaterialDiffuseColor* LightColor * LightPower * cosTheta / (distance1*distance1) ;}

i just kept the diffuse, thats where the problem seems to be. maybe the problem is with the glsl and opengl versions?

edit:
Just to add some more info. I kinda think the problem has something to do with that cosTheta variable. when I remove it from the equation, the problem is no longer there(but faces are lit up eventhough they are facing away from the light) I understand the purpose of the cosTheta is to calculate the brightness based on the angle of the face compared to the angle of the light, but maybe there is something wrong here...

#2handoman

Posted 14 May 2013 - 10:00 PM

So, I've been following the tuts from http://www.opengl-tutorial.org, (using the opengl 2.1 versions) and came across a problem in Tutorial 8: Basic Shading. Basically, my shading comes out calculated wrong(noticable around the edges of the triangle faces).
KhGooen.jpg
After hours of comparing the tut code with my code, i could find anythign wrong. I finally jus copied and pasted everything from the tut, but nothing help. I am pretty sure the problem with the shaders, here is the code:
#version 120// Input vertex data, different for all executions of this shader.attribute vec3 vertexPosition_modelspace;attribute vec2 vertexUV;attribute vec3 vertexNormal_modelspace;// Output data ; will be interpolated for each fragment.varying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform mat4 MVP;uniform mat4 V;uniform mat4 M;uniform vec3 LightPosition_worldspace;uniform int vertex_image_type;void main(){	// Output position of the vertex, in clip space : MVP * position	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);	// Position of the vertex, in worldspace : M * position	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;	// Vector that goes from the vertex to the camera, in camera space.	// In camera space, the camera is at the origin (0,0,0).	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;	// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;	// Normal of the the vertex, in camera space	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.	// UV of the vertex. No special space for this one.	UV = vertexUV;	if (vertex_image_type==2)	{        UV.y =-UV.y; //inverts UVs for dds files	}}
#version 120// Interpolated values from the vertex shadersvarying vec2 UV;varying vec3 Position_worldspace;varying vec3 Normal_cameraspace;varying vec3 EyeDirection_cameraspace;varying vec3 LightDirection_cameraspace;// Values that stay constant for the whole mesh.uniform sampler2D myTextureSampler;uniform mat4 MV;uniform vec3 LightPosition_worldspace;void main(){	// Light emission properties	// You probably want to put them as uniforms	vec3 LightColor = vec3(1,1,1);	float LightPower = 30.0;	// Material properties	vec3 MaterialDiffuseColor = texture2D(myTextureSampler,UV).rgb;	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);	// Distance to the light	float distance1 = length( LightPosition_worldspace - Position_worldspace );	// Normal of the computed fragment, in camera space	vec3 n = normalize( Normal_cameraspace );	// Direction of the light (from the fragment to the light)	vec3 l = normalize( LightDirection_cameraspace );	// Cosine of the angle between the normal and the light direction,	// clamped above 0	//  - light is at the vertical of the triangle -> 1	//  - light is perpendicular to the triangle -> 0	//  - light is behind the triangle -> 0	float cosTheta = clamp( dot( n,l ), 0.0,1.0);	// Eye vector (towards the camera)	vec3 E = normalize(EyeDirection_cameraspace);	// Direction in which the triangle reflects the light	vec3 R = reflect(-l,n);	// Cosine of the angle between the Eye vector and the Reflect vector,	// clamped to 0	//  - Looking into the reflection -> 1	//  - Looking elsewhere -> < 1	float cosAlpha = clamp( dot( E,R ), 0,1 );	gl_FragColor.rgb =		// Diffuse : "color" of the object        MaterialDiffuseColor* LightColor * LightPower * cosTheta / (distance1*distance1) ;}

i just kept the diffuse, thats where the problem seems to be. maybe the problem is with the glsl and opengl versions?

edit:
Just to add some more info. I kinda think the problem has something to do with that cosTheta variable. when I remove it from the equation, the problem is no longer there(but faces are lit up eventhough they are facing away from the light) I understand the purpose of the cosTheta is to calculate the brightness based on the angle of the face compared to the angle of the light, but maybe there is something wrong here...

#1handoman

Posted 14 May 2013 - 09:45 PM

So, I've been following the tuts from http://www.opengl-tutorial.org, (using the opengl 2.1 versions) and came across a problem in Tutorial 8: Basic Shading. Basically, my shading comes out calculated wrong(noticable around the edges of the triangle faces).

KhGooen.jpg

After hours of comparing the tut code with my code, i could find anythign wrong. I finally jus copied and pasted everything from the tut, but nothing help. I am pretty sure the problem with the shaders, here is the code:

#version 120

// Input vertex data, different for all executions of this shader.
attribute vec3 vertexPosition_modelspace;
attribute vec2 vertexUV;
attribute vec3 vertexNormal_modelspace;

// Output data ; will be interpolated for each fragment.
varying vec2 UV;
varying vec3 Position_worldspace;
varying vec3 Normal_cameraspace;
varying vec3 EyeDirection_cameraspace;
varying vec3 LightDirection_cameraspace;

// Values that stay constant for the whole mesh.
uniform mat4 MVP;
uniform mat4 V;
uniform mat4 M;
uniform vec3 LightPosition_worldspace;
uniform int vertex_image_type;

void main(){

	// Output position of the vertex, in clip space : MVP * position
	gl_Position =  MVP * vec4(vertexPosition_modelspace,1);

	// Position of the vertex, in worldspace : M * position
	Position_worldspace = (M * vec4(vertexPosition_modelspace,1)).xyz;

	// Vector that goes from the vertex to the camera, in camera space.
	// In camera space, the camera is at the origin (0,0,0).
	vec3 vertexPosition_cameraspace = ( V * M * vec4(vertexPosition_modelspace,1)).xyz;
	EyeDirection_cameraspace = vec3(0,0,0) - vertexPosition_cameraspace;

	// Vector that goes from the vertex to the light, in camera space. M is ommited because it's identity.
	vec3 LightPosition_cameraspace = ( V * vec4(LightPosition_worldspace,1)).xyz;
	LightDirection_cameraspace = LightPosition_cameraspace + EyeDirection_cameraspace;

	// Normal of the the vertex, in camera space
	Normal_cameraspace = ( V * M * vec4(vertexNormal_modelspace,0)).xyz; // Only correct if ModelMatrix does not scale the model ! Use its inverse transpose if not.

	// UV of the vertex. No special space for this one.
	UV = vertexUV;
	if (vertex_image_type==2)
	{
        UV.y =-UV.y; //inverts UVs for dds files
	}
}

 

#version 120

// Interpolated values from the vertex shaders
varying vec2 UV;
varying vec3 Position_worldspace;
varying vec3 Normal_cameraspace;
varying vec3 EyeDirection_cameraspace;
varying vec3 LightDirection_cameraspace;

// Values that stay constant for the whole mesh.
uniform sampler2D myTextureSampler;
uniform mat4 MV;
uniform vec3 LightPosition_worldspace;

void main(){

	// Light emission properties
	// You probably want to put them as uniforms
	vec3 LightColor = vec3(1,1,1);
	float LightPower = 30.0;

	// Material properties
	vec3 MaterialDiffuseColor = texture2D(myTextureSampler,UV).rgb;
	vec3 MaterialAmbientColor = vec3(0.1,0.1,0.1) * MaterialDiffuseColor;
	vec3 MaterialSpecularColor = vec3(0.3,0.3,0.3);

	// Distance to the light
	float distance1 = length( LightPosition_worldspace - Position_worldspace );

	// Normal of the computed fragment, in camera space
	vec3 n = normalize( Normal_cameraspace );
	// Direction of the light (from the fragment to the light)
	vec3 l = normalize( LightDirection_cameraspace );
	// Cosine of the angle between the normal and the light direction,
	// clamped above 0
	//  - light is at the vertical of the triangle -> 1
	//  - light is perpendicular to the triangle -> 0
	//  - light is behind the triangle -> 0
	float cosTheta = clamp( dot( n,l ), 0.0,1.0);

	// Eye vector (towards the camera)
	vec3 E = normalize(EyeDirection_cameraspace);
	// Direction in which the triangle reflects the light
	vec3 R = reflect(-l,n);
	// Cosine of the angle between the Eye vector and the Reflect vector,
	// clamped to 0
	//  - Looking into the reflection -> 1
	//  - Looking elsewhere -> < 1
	float cosAlpha = clamp( dot( E,R ), 0,1 );

	gl_FragColor.rgb =

		// Diffuse : "color" of the object
        MaterialDiffuseColor* LightColor * LightPower * cosTheta / (distance1*distance1) ;

}

 

i just kept the diffuse, thats where the problem seems to be. maybe the problem is with the glsl and opengl versions? 


PARTNERS