This is just a test for GS. I try to render a cube but glDrawRangeElements is throwing GL_INVALID_OPERATION. It’s a little bit hard to know what the problem is. I am rendering with GL_TRIANGLES. I’m not using GL_TRIANGLES_ADJACENCY_EXT because I think I don’t need it.
The shader compiles ok.
Is FXcomposer or Rendermonkey updated to support GL_EXT_geometry_shader4?
VS:
#version 110
//UNIFORM
uniform mat4 ProjectionModelviewMatrix;
uniform vec4 TexMatrix0_a;
uniform vec4 TexMatrix0_b;
uniform vec4 LightPosition0;
uniform mat4 ModelviewMatrix;
//VARYING
varying vec2 VTexCoord0;
varying vec3 VHalfVector0;
varying vec3 VEyeNormal;
varying vec3 VEyeVertex;
//GLOBALFUNCTION
void main()
{
//TEMP
vec3 eyeVertex;
vec3 lightVector, eyeVector;
gl_Position = ProjectionModelviewMatrix * gl_Vertex;
VTexCoord0.x = dot(TexMatrix0_a, gl_MultiTexCoord0);
VTexCoord0.y = dot(TexMatrix0_b, gl_MultiTexCoord0);
eyeVertex = vec3(ModelviewMatrix * gl_Vertex);
VEyeVertex = eyeVertex;
eyeVector = normalize(-eyeVertex);
lightVector = LightPosition0.xyz;
VHalfVector0 = lightVector + eyeVector; //No need to normalize the sum
VEyeNormal = vec3(ModelviewMatrix * vec4(gl_Normal, 0.0));
}
GS:
#version 120
#extension GL_EXT_geometry_shader4 : enable
//UNIFORM
uniform mat4 ProjectionMatrix;
//VARYING
varying in vec2 VTexCoord0[3];
varying in vec3 VHalfVector0[3];
varying in vec3 VEyeNormal[3];
varying in vec3 VEyeVertex[3];
varying out vec2 TexCoord0;
varying out vec3 HalfVector0;
varying out vec3 EyeNormal;
//GLOBALFUNCTION
void main()
{
int i;
vec3 newVertex;
//Pass through the original vertex
for(i=0; i<gl_VerticesIn; i++)
{
gl_Position = gl_PositionIn[i];
TexCoord0 = VTexCoord0[i];
HalfVector0 = VHalfVector0[i];
EyeNormal = VEyeNormal[i];
EmitVertex();
}
EndPrimitive();
//Push the vertex out a little using the normal
for(i=0; i<gl_VerticesIn; i++)
{
newVertex = VEyeNormal[i] + VEyeVertex[i];
gl_Position = ProjectionMatrix * vec4(newVertex, 1.0);
TexCoord0 = VTexCoord0[i];
HalfVector0 = VHalfVector0[i];
EyeNormal = VEyeNormal[i];
EmitVertex();
}
EndPrimitive();
}
FS:
#version 110
//UNIFORM
uniform sampler2D Texture0;
uniform vec4 LightPosition0;
uniform vec4 AllLightAmbient_MaterialAmbient;
uniform vec4 LightMaterialDiffuse0;
uniform vec4 LightMaterialSpecular0;
uniform float MaterialShininess;
//VARYING
varying vec2 TexCoord0;
varying vec3 HalfVector0;
varying vec3 EyeNormal;
//GLOBALFUNCTION
//eyeNormal must be normalized already
//lightVector must be normalized already. xyz is lightvector and w is light distance from vertex
//halfVector must be normalized already
//
//output diffuse color and output specular color
//Then do diffuse * texture_color + specular
//diffuse.a = material_diffuse.a
void ComputeDirectionalLight(out vec4 diffuseColor, out vec4 specularColor, in vec3 eyeNormal, in vec3 lightVector, in vec3 halfVector, in vec4 lightMaterialDiffuse, in vec4 lightMaterialSpecular)
{
float dotProduct;
dotProduct = clamp(dot(eyeNormal, lightVector), 0.0, 1.0);
diffuseColor = dotProduct * lightMaterialDiffuse;
specularColor = vec4(0.0);
dotProduct = clamp(dot(eyeNormal, halfVector), 0.0, 1.0);
if(dotProduct>0.0)
specularColor = pow(dotProduct, MaterialShininess) * lightMaterialSpecular;
}
void main()
{
//TEMP
vec4 texel, diffuseColor, specularColor;
vec4 ColorSum;
vec3 eyeNormal, halfVector;
texel = texture2D(Texture0, TexCoord0);
eyeNormal = normalize(EyeNormal);
halfVector = normalize(HalfVector0);
ComputeDirectionalLight(diffuseColor, specularColor, eyeNormal, LightPosition0.xyz, halfVector, LightMaterialDiffuse0, LightMaterialSpecular0);
ColorSum = (AllLightAmbient_MaterialAmbient + diffuseColor) * texel + specularColor;
ColorSum.a = texel.a * LightMaterialDiffuse0.a;
gl_FragColor = clamp(ColorSum, 0.0, 1.0);
}