// Lights
uniform bool lightsOn[8];
uniform vec4 lightsPos[8];
+uniform vec4 lightsPosI[8];
-uniform vec4 lightsDiffuse[8];
-uniform vec4 lightsAmbient[8];
-uniform vec4 lightsSpecular[8];
+uniform vec3 lightsDiffuse[8];
+uniform vec3 lightsAmbient[8];
+uniform vec3 lightsSpecular[8];
-uniform vec4 globalAmbient;
+uniform vec3 globalAmbient;
uniform bool lightingOn;
+// Material
+uniform bool perVertexColor;
+uniform vec3 matDiffuse;
+uniform vec3 matAmbient;
+uniform vec3 matSpecular;
+uniform vec3 matEmissive;
+uniform float matOpacity;
+uniform float matPower;
+uniform bool matTwoSided;
+
in vec2 texCoord;
in vec3 vertex;
in vec3 normal;
if(lightingOn)
{
int i;
- vec4 diffuseColor = current_color * color;
- vec4 ambientColor = diffuseColor;
+ vec3 diffuseColor = perVertexColor ? color.xyz : matDiffuse;
+ vec3 ambientColor = perVertexColor ? color.xyz : matAmbient;
+ float opacity = perVertexColor ? color.w : matOpacity;
+ vec3 c = vec3(0);
+ vec3 ecPosition3 = vec3(gl_Position) / gl_Position.w;
+ vec3 eye = vec3(0.0, 0.0, 1.0);
fColor = vec4(0);
for(i = 0; i < 8; i++)
if(lightsOn[i])
{
vec4 l = lightsPos[i];
- fColor += diffuseColor * min(1, max(0, dot(n, l.xyz))) * lightsDiffuse[i];
+ float d = dot(n, l.xyz);
+ float pf = 0;
+ if(matTwoSided)
+ {
+ float d2 = dot(n, lightsPosI[i].xyz);
+ if(d2 > d)
+ d = d2;
+ }
+ if(matPower != 0.0)
+ {
+ vec3 VP = l.xyz;
+ vec3 halfVector = normalize(VP + eye);
+ float nDotVP = max(0, dot(n, VP));
+ if(nDotVP != 0.0)
+ {
+ float nDotHV = max(0.0, dot(n, halfVector));
+ pf = pow(nDotHV, matPower);
+ }
+ }
+
+ c += diffuseColor * min(1, max(0, d)) * lightsDiffuse[i];
+ c += matSpecular * pf * lightsSpecular[i];
+ c += matAmbient * lightsAmbient[i];
}
- fColor += ambientColor * globalAmbient;
+
+ c += ambientColor * globalAmbient;
+ c += matEmissive;
+ fColor = vec4(c, opacity);
}
else
fColor = current_color * color;
int uGlobalAmbient;
int uLightsOn[8];
int uLightsPos[8];
+int uLightsPosI[8];
int uLightsDiffuse[8];
int uLightsAmbient[8];
int uLightsSpecular[8];
+int uPerVertexColor;
+int uMatDiffuse;
+int uMatAmbient;
+int uMatSpecular;
+int uMatEmissive;
+int uMatPower;
+int uMatOpacity;
+int uMatTwoSided;
void shader_LoadMatrixf(MatrixMode mode, float * m)
{
void shader_setGlobalAmbient(float r, float g, float b, float a)
{
- glUniform4f(uGlobalAmbient, r, g, b, a);
+ glUniform3f(uGlobalAmbient, r, g, b);
}
void shader_color(float r, float g, float b, float a)
glUniform1ui(uTexturingOn, on);
}
+void shader_setMaterial(Material material, bool perVertexColor)
+{
+ glUniform1ui(uPerVertexColor, perVertexColor);
+ glUniform1ui(uMatTwoSided, !material.flags.singleSideLight);
+ glUniform3f(uMatDiffuse, material.diffuse.r, material.diffuse.g, material.diffuse.b);
+ glUniform3f(uMatAmbient, material.ambient.r, material.ambient.g, material.ambient.b);
+ glUniform3f(uMatSpecular, material.specular.r, material.specular.g, material.specular.b);
+ glUniform3f(uMatEmissive, material.emissive.r, material.emissive.g, material.emissive.b);
+ glUniform1f(uMatPower, material.power);
+ glUniform1f(uMatOpacity, material.opacity);
+}
+
void shader_setLight(Display display, uint id, Light light)
{
if(light != null)
if(!multiplier) multiplier = 1.0f;
- glUniform4f(uLightsDiffuse[id],
+ glUniform3f(uLightsDiffuse[id],
light.diffuse.r * multiplier,
light.diffuse.g * multiplier,
- light.diffuse.b * multiplier, 1.0);
+ light.diffuse.b * multiplier);
- glUniform4f(uLightsAmbient[id],
+ glUniform3f(uLightsAmbient[id],
light.ambient.r * multiplier,
light.ambient.g * multiplier,
- light.ambient.b * multiplier, 1.0);
+ light.ambient.b * multiplier);
- glUniform4f(uLightsSpecular[id],
+ glUniform3f(uLightsSpecular[id],
light.specular.r * multiplier,
light.specular.g * multiplier,
- light.specular.b * multiplier, 1.0);
+ light.specular.b * multiplier);
if(lightObject)
{
}
else
{
- Vector3Df l;
+ Vector3Df l, li;
Vector3Df vector { 0,0,-1 };
- Vector3Df direction;
+ Vector3Df vectorI { 0,0, 1 };
+ Vector3Df direction, directionI;
Matrix mat;
mat.RotationQuaternion(light.orientation);
direction.MultMatrix(vector, mat);
+ directionI.MultMatrix(vectorI, mat);
if(!display.display3D || !display.display3D.camera)
{
// Light in View Space (SetLight before setting camera)
l.Normalize(direction);
l.z *= -1;
+
+ li.Normalize(directionI);
+ li.z *= -1;
}
else
{
m.Scale(1,1,-1);
vector.MultMatrix(direction, m);
l.Normalize(vector);
+
+ vectorI.MultMatrix(directionI, m);
+ li.Normalize(vectorI);
}
glUniform4f(uLightsPos[id], l.x, l.y, l.z, 0);
+ glUniform4f(uLightsPosI[id], li.x, li.y, li.z, 0);
}
}
else
uTexturingOn = glGetUniformLocation(program, "texturingOn");
uLightingOn = glGetUniformLocation(program, "lightingOn");
uGlobalAmbient = glGetUniformLocation(program, "globalAmbient");
+ uPerVertexColor = glGetUniformLocation(program, "perVertexColor");
+ uMatDiffuse = glGetUniformLocation(program, "matDiffuse");
+ uMatAmbient = glGetUniformLocation(program, "matAmbient");
+ uMatSpecular = glGetUniformLocation(program, "matSpecular");
+ uMatEmissive = glGetUniformLocation(program, "matEmissive");
+ uMatPower = glGetUniformLocation(program, "matPower");
+ uMatOpacity = glGetUniformLocation(program, "matOpacity");
+ uMatTwoSided = glGetUniformLocation(program, "matTwoSided");
for(i = 0; i < 8; i++)
{
sprintf(name, "lightsPos[%d]", i);
uLightsPos[i] = glGetUniformLocation(program, name);
+ sprintf(name, "lightsPosI[%d]", i);
+ uLightsPosI[i] = glGetUniformLocation(program, name);
+
sprintf(name, "lightsDiffuse[%d]", i);
uLightsDiffuse[i] = glGetUniformLocation(program, name);