I've been trying out the shader examples in the GLGraphics library, but having some problems to make them work. I'm on WinXP with an ATI Radeon 4800 series graphics card.

1) I installed the CG toolkit from NVidia, but the CGShader and CGFX examples don't work correctly, giving me the following message in the console: GL_ARB_geometry_shader4 extension not available.

2) The provided GLSLShader example does work, but I'm having trouble using other GLSL shaders. I installed RenderMonkey and Shader Designer to create new shaders. RenderMonkey seems to be quite elaborate, making it difficult for a beginner to cross-over the needed files, so that one's on hold. Shader Designer is a lot clearer in it's approach. You have the vertex and fragment shader code and the preview. However when you use that code in the GLGraphics library it doesn't work. I've tried all the example shaders from Shader Designer with the GLGraphics library by replacing the shaders from the GLGraphics toon shader example sketch. Conclusion: none of them really work, even though most seem to run without errors.

Here is a graphical example. On the left how the shader should look, on the right how it comes out in Processing.



The Processing console output when running with this code is error-free:

Vertex shader polkadot3d.vert compilation:
Vertex shader was successfully compiled to run on hardware.

Fragment shader polkadot3d.frag compilation:
Fragment shader was successfully compiled to run on hardware.

GLSL program validation:
Fragment shader(s) linked, vertex shader(s) linked.
 Validation successful.

Here is the full code for the vertex and fragment shader.

1. // Vertex Shader for three dimensional polka dots.
2. // author(s):  Joshua Doss
3. // Copyright (C) 2002-2004  3Dlabs Inc. Ltd.
4. 
   
5. //Create uniform variables for lighting to allow user interaction
6. uniform float SpecularContribution;
7. uniform vec3 LightPosition;
8. varying vec3 MCPosition;
9. varying float LightIntensity;
10. void main(void)
11. {
12.     float diffusecontribution  = 1.0 - SpecularContribution;
13.    
14.     // compute the vertex position in eye coordinates
15.     vec3  ecPosition           = vec3(gl_ModelViewMatrix * gl_Vertex);
16.    
17.     // compute the transformed normal
18.     vec3  tnorm                = normalize(gl_NormalMatrix * gl_Normal);
19.    
20.     // compute a vector from the model to the light position
21.     vec3  lightVec             = normalize(LightPosition - ecPosition);
22.    
23.     // compute the reflection vector
24.     vec3  reflectVec           = reflect(-lightVec, tnorm);
25.    
26.     // compute a unit vector in direction of viewing position
27.     vec3  viewVec              = normalize(-ecPosition);
28.    
29.     // calculate amount of diffuse light based on normal and light angle
30.     float diffuse              = max(dot(lightVec, tnorm), 0.0);
31.     float spec                 = 0.0;
32.    
33.     // if there is diffuse lighting, calculate specular
34.     if(diffuse > 0.0)
35.        {
36.           spec = max(dot(reflectVec, viewVec), 0.0);
37.           spec = pow(spec, 16.0);
38.        }
39.    
40.     // add up the light sources, since this is a varying (global) it will pass to frag shader    
41.     LightIntensity  = diffusecontribution * diffuse * 1.5 +
42.                           SpecularContribution * spec;
43.    
44.     // the varying variable MCPosition will be used by the fragment shader to determine where
45.     //    in model space the current pixel is                     
46.     MCPosition      = vec3 (gl_Vertex);
47.    
48.     // send vertex information
49.     gl_Position     = gl_ModelViewProjectionMatrix * gl_Vertex;
50. }

1. // Fragment shader for 3 dimensional polka dot shader.
2. // Author: Joshua Doss
3. // Copyright (C) 2002-2004  3Dlabs Inc. Ltd.
4. 
   
5. varying float LightIntensity;
6. varying vec3 MCPosition;
7. //Create uniform variables so dots can be spaced and scaled by user
8. uniform vec3 Spacing;
9. uniform float DotSize;
10. //Create colors as uniform variables so they can be easily changed
11. uniform vec3 ModelColor, PolkaDotColor;
12. void main(void)
13. {
14.    float insidesphere, sphereradius, scaledpointlength;
15.    vec3 scaledpoint, finalcolor;
16.    // Scale the coordinate system
17.    // The following line of code is not yet implemented in current drivers:
18.    // mcpos = mod(Spacing, MCposition);
19.    // We will use a workaround found below for now
20.    scaledpoint       = MCPosition - (Spacing * floor(MCPosition/Spacing));
21.    // Bring the scaledpoint vector into the center of the scaled coordinate system
22.    scaledpoint       = scaledpoint - Spacing/2.0;
23.    // Find the length of the scaledpoint vector and compare it to the dotsize
24.    scaledpointlength = length(scaledpoint);
25.    insidesphere      = step(scaledpointlength,DotSize);
26.   
27.    // Determine final output color before lighting
28.    finalcolor        = vec3(mix(ModelColor, PolkaDotColor, insidesphere));
29.    // Output final color and factor in lighting
30.    gl_FragColor      = clamp((vec4( finalcolor, 1.0 ) * LightIntensity), vec4(0.0), vec4(1.0));
31. }

The above code it just to make the discussion a little less abstract, but like I said, none of the shaders I tried work. I even tried a brick example vertex and fragment shader directly from the "OpenGL Shading Language, Third Edition" book, but alas. I'll be the first to admit I have currently no knowledge of OPENGL or GLSL, which severely limits by problem-solving abilities on this issue.

So what could be the problem?

3) Finally a more general point. During my search today, I noticed that a lot of the websites were from (many) years back. Which makes me wonder if GLSL is the one I should be getting into. Or has it been replaced by modern alternatives? Since for me at this point there's no path dependency to go with one over the other, should there be other options. The goal being (1) using the GPU for faster sketches and (2) creating cool new effects.