Texture problem

[AndreasJ]

Possibly this should go in the bugs forum, but I imagine the problem is with me/my system rather than Celestia. Anyway, when I run 1.5.1 the textures work for stars and galaxies, but planets, moons, rings, spacecraft etc are shown as pure red. What gives?

I'm running Windows XP Professional (SP2) and have a Nvidia Geforce 6600 GT graphics card. Near as I can tell, I've got the most recent drivers for the card.

[selden]

Red objects means that the vertex shader routines are returning an error.
Vertex shaders are compiled at runtime by the OpenGL graphics driver.
Celestia writes a log of the vertex shader compilation into the file shaders.log.
It's written to Celestia's default directory, which is the Windows Desktop if you started Celestia by clicking on its icon on the desktop.

Please provide a copy of your system's shaders.log.

[AndreasJ]

Thank you. The board won't let me attach a .log file, so I've just copied the contents here:

Code: Select all

Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: uniform float textureOffset;
  9: uniform vec3 atmosphereRadius;
 10: uniform float mieCoeff;
 11: uniform float mieH;
 12: uniform float mieK;
 13: uniform vec3 rayleighCoeff;
 14: uniform float rayleighH;
 15: uniform vec3 scatterCoeffSum;
 16: uniform vec3 invScatterCoeffSum;
 17: uniform vec3 extinctionCoeff;
 18: vec3 eyeDir = normalize(eyePosition - gl_Vertex.xyz);
 19: float NV = dot(gl_Normal, eyeDir);
 20: varying vec4 diffFactors;
 21: varying vec3 normal;
 22: varying vec3 lightHalfVec0;
 23: varying vec3 scatterEx;
 24:
 25: void main(void)
 26: {
 27: float NL;
 28: normal = gl_Normal;
 29: NL = max(0.0, dot(gl_Normal, light0_direction));
 30: diffFactors.x = NL;
 31: lightHalfVec0 = light0_direction + eyeDir;
 32: diffTexCoord = gl_MultiTexCoord0.st + vec2(textureOffset, 0.0);
 33: {
 34:     float rq = dot(eyePosition, eyeDir);
 35:     float qq = dot(eyePosition, eyePosition) - atmosphereRadius.y;
 36:     float d = sqrt(rq * rq - qq);
 37:     vec3 atmEnter = eyePosition + min(0.0, (-rq + d)) * eyeDir;
 38:     vec3 atmLeave = gl_Vertex.xyz;
 39:     vec3 atmSamplePoint = (atmEnter + atmLeave) * 0.5;
 40:     vec3 atmSamplePointSun = atmEnter * 0.5 + atmLeave * 0.5;
 41:     rq = dot(atmSamplePointSun, light0_direction);
 42:     qq = dot(atmSamplePointSun, atmSamplePointSun) - atmosphereRadius.y;
 43:     d = sqrt(rq * rq - qq);
 44:     float distSun = -rq + d;
 45:     float distAtm = length(atmEnter - atmLeave);
 46:     float density = 0.0;
 47:     atmSamplePoint = atmEnter * 0.333 + atmLeave * 0.667;
 48:     float h = max(0.0, length(atmSamplePoint) - atmosphereRadius.z);
 49:     density += exp(-h * mieH);
 50:     atmSamplePoint = atmEnter * 0.667 + atmLeave * 0.333;
 51:     h = max(0.0, length(atmSamplePoint) - atmosphereRadius.z);
 52:     density += exp(-h * mieH);
 53:     vec3 sunColor = exp(-extinctionCoeff * density * distSun);
 54:     vec3 ex = exp(-extinctionCoeff * density * distAtm);
 55:     float cosTheta = dot(eyeDir, light0_direction);
 56:     float phMie = (1.0 - mieK * mieK) / ((1.0 - mieK * cosTheta) * (1.0 - mieK * cosTheta));
 57:     float phRayleigh = 1.0;
 58:     scatterEx = ex;
 59:     gl_FrontSecondaryColor.rgb = (phRayleigh * rayleighCoeff + phMie * mieCoeff) * invScatterCoeffSum * sunColor * (1.0 - exp(-scatterCoeffSum * density * distAtm));
 60: }
 61: gl_Position = ftransform();
 62: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: varying vec2 diffTexCoord;
  4: uniform vec3 ambientColor;
  5: uniform float opacity;
  6: varying vec4 diffFactors;
  7: vec4 diff = vec4(ambientColor, opacity);
  8: varying vec3 normal;
  9: vec4 spec = vec4(0.0);
 10: uniform float shininess;
 11: varying vec3 lightHalfVec0;
 12: uniform vec3 lightcolor0;
 13: uniform vec3 lightspecColor0;
 14: varying vec3 scatterEx;
 15:
 16: void main(void)
 17: {
 18: vec4 color;
 19: float NH;
 20: vec3 n = normalize(normal);
 21: diff.rgb += diffFactors.x * lightcolor0;
 22: NH = max(0.0, dot(n, normalize(lightHalfVec0)));
 23: spec.rgb += diffFactors.x * pow(NH, shininess) * lightspecColor0;
 24: color = texture2D(diffTex, diffTexCoord.st);
 25: gl_FragColor = color * diff + float(color.a) * spec;
 26: gl_FragColor.rgb = gl_FragColor.rgb * scatterEx + gl_SecondaryColor.rgb;
 27: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: uniform float textureOffset;
  9: uniform vec3 atmosphereRadius;
 10: uniform float mieCoeff;
 11: uniform float mieH;
 12: uniform float mieK;
 13: uniform vec3 rayleighCoeff;
 14: uniform float rayleighH;
 15: uniform vec3 scatterCoeffSum;
 16: uniform vec3 invScatterCoeffSum;
 17: uniform vec3 extinctionCoeff;
 18: vec3 eyeDir = normalize(eyePosition - gl_Vertex.xyz);
 19: float NV = dot(gl_Normal, eyeDir);
 20: uniform vec3 ambientColor;
 21: uniform float opacity;
 22: varying vec4 diff;
 23: varying vec3 scatterEx;
 24:
 25: void main(void)
 26: {
 27: float NL;
 28: diff = vec4(ambientColor, opacity);
 29: NL = max(0.0, dot(gl_Normal, light0_direction));
 30: diff.rgb += light0_diffuse * NL;
 31: diffTexCoord = gl_MultiTexCoord0.st + vec2(textureOffset, 0.0);
 32: {
 33:     float rq = dot(eyePosition, eyeDir);
 34:     float qq = dot(eyePosition, eyePosition) - atmosphereRadius.y;
 35:     float d = sqrt(rq * rq - qq);
 36:     vec3 atmEnter = eyePosition + min(0.0, (-rq + d)) * eyeDir;
 37:     vec3 atmLeave = gl_Vertex.xyz;
 38:     vec3 atmSamplePoint = (atmEnter + atmLeave) * 0.5;
 39:     vec3 atmSamplePointSun = atmEnter * 0.5 + atmLeave * 0.5;
 40:     rq = dot(atmSamplePointSun, light0_direction);
 41:     qq = dot(atmSamplePointSun, atmSamplePointSun) - atmosphereRadius.y;
 42:     d = sqrt(rq * rq - qq);
 43:     float distSun = -rq + d;
 44:     float distAtm = length(atmEnter - atmLeave);
 45:     float density = 0.0;
 46:     atmSamplePoint = atmEnter * 0.333 + atmLeave * 0.667;
 47:     float h = max(0.0, length(atmSamplePoint) - atmosphereRadius.z);
 48:     density += exp(-h * mieH);
 49:     atmSamplePoint = atmEnter * 0.667 + atmLeave * 0.333;
 50:     h = max(0.0, length(atmSamplePoint) - atmosphereRadius.z);
 51:     density += exp(-h * mieH);
 52:     vec3 sunColor = exp(-extinctionCoeff * density * distSun);
 53:     vec3 ex = exp(-extinctionCoeff * density * distAtm);
 54:     float cosTheta = dot(eyeDir, light0_direction);
 55:     float phMie = (1.0 - mieK * mieK) / ((1.0 - mieK * cosTheta) * (1.0 - mieK * cosTheta));
 56:     float phRayleigh = 1.0;
 57:     scatterEx = ex;
 58:     gl_FrontSecondaryColor.rgb = (phRayleigh * rayleighCoeff + phMie * mieCoeff) * invScatterCoeffSum * sunColor * (1.0 - exp(-scatterCoeffSum * density * distAtm));
 59: }
 60: gl_Position = ftransform();
 61: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: varying vec2 diffTexCoord;
  4: varying vec4 diff;
  5: varying vec3 scatterEx;
  6:
  7: void main(void)
  8: {
  9: vec4 color;
 10: color = texture2D(diffTex, diffTexCoord.st);
 11: gl_FragColor = color * diff;
 12: gl_FragColor.rgb = gl_FragColor.rgb * scatterEx + gl_SecondaryColor.rgb;
 13: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: varying vec2 normTexCoord;
  9: uniform float textureOffset;
 10: vec3 eyeDir = normalize(eyePosition - gl_Vertex.xyz);
 11: attribute vec3 tangent;
 12: varying vec3 lightDir_tan_0;
 13: varying vec3 eyeDir_tan;
 14:
 15: void main(void)
 16: {
 17: float NL;
 18: vec3 bitangent = cross(gl_Normal, tangent);
 19: eyeDir_tan.x = dot(tangent, eyeDir);
 20: eyeDir_tan.y = dot(-bitangent, eyeDir);
 21: eyeDir_tan.z = dot(gl_Normal, eyeDir);
 22: NL = max(0.0, dot(gl_Normal, light0_direction));
 23: lightDir_tan_0.x = dot(tangent, light0_direction);
 24: lightDir_tan_0.y = dot(-bitangent, light0_direction);
 25: lightDir_tan_0.z = dot(gl_Normal, light0_direction);
 26: diffTexCoord = gl_MultiTexCoord0.st + vec2(textureOffset, 0.0);
 27: normTexCoord = gl_MultiTexCoord1.st + vec2(textureOffset, 0.0);
 28: gl_Position = ftransform();
 29: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: uniform sampler2D normTex;
  4: varying vec2 diffTexCoord;
  5: varying vec2 normTexCoord;
  6: uniform vec3 ambientColor;
  7: uniform float opacity;
  8: vec4 diff = vec4(ambientColor, opacity);
  9: varying vec3 eyeDir_tan;
 10: vec4 spec = vec4(0.0);
 11: uniform float shininess;
 12: uniform float lunarLambert;
 13: varying vec3 lightDir_tan_0;
 14: uniform vec3 lightcolor0;
 15:
 16: void main(void)
 17: {
 18: vec4 color;
 19: vec3 n = texture2D(normTex, normTexCoord.st).xyz * 2.0 - vec3(1.0, 1.0, 1.0);
 20: float l;
 21: vec3 V = normalize(eyeDir_tan);
 22: float NV = dot(n, V);
 23: float NL;
 24: NL = dot(lightDir_tan_0, n);
 25: NL = max(0.0, NL);
 26: l = mix(NL, (NL / (max(NV, 0.001) + NL)), lunarLambert) * clamp(lightDir_tan_0.z * 8.0, 0.0, 1.0);
 27: diff.rgb += l * lightcolor0;
 28: color = texture2D(diffTex, diffTexCoord.st);
 29: gl_FragColor = color * diff;
 30: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: uniform vec3 atmosphereRadius;
  8: uniform float mieCoeff;
  9: uniform float mieH;
 10: uniform float mieK;
 11: uniform vec3 rayleighCoeff;
 12: uniform float rayleighH;
 13: uniform vec3 scatterCoeffSum;
 14: uniform vec3 invScatterCoeffSum;
 15: uniform vec3 extinctionCoeff;
 16: varying vec3 scatteredColor0;
 17: vec3 eyeDir = normalize(eyePosition - gl_Vertex.xyz);
 18: float NV = dot(gl_Normal, eyeDir);
 19: varying vec3 scatterEx;
 20: varying vec3 eyeDir_obj;
 21:
 22: void main(void)
 23: {
 24: float NL;
 25: {
 26:     float rq = dot(eyePosition, eyeDir);
 27:     float qq = dot(eyePosition, eyePosition) - atmosphereRadius.y;
 28:     float d = sqrt(rq * rq - qq);
 29:     vec3 atmEnter = eyePosition + min(0.0, (-rq + d)) * eyeDir;
 30:     vec3 atmLeave = gl_Vertex.xyz;
 31:     vec3 atmSamplePoint = (atmEnter + atmLeave) * 0.5;
 32:     vec3 atmSamplePointSun = atmEnter * 0.5 + atmLeave * 0.5;
 33:     rq = dot(atmSamplePointSun, light0_direction);
 34:     qq = dot(atmSamplePointSun, atmSamplePointSun) - atmosphereRadius.y;
 35:     d = sqrt(rq * rq - qq);
 36:     float distSun = -rq + d;
 37:     float distAtm = length(atmEnter - atmLeave);
 38:     float density = 0.0;
 39:     atmSamplePoint = atmEnter * 0.333 + atmLeave * 0.667;
 40:     float h = max(0.0, length(atmSamplePoint) - atmosphereRadius.z);
 41:     density += exp(-h * mieH);
 42:     atmSamplePoint = atmEnter * 0.667 + atmLeave * 0.333;
 43:     h = max(0.0, length(atmSamplePoint) - atmosphereRadius.z);
 44:     density += exp(-h * mieH);
 45:     vec3 sunColor = exp(-extinctionCoeff * density * distSun);
 46:     vec3 ex = exp(-extinctionCoeff * density * distAtm);
 47:     scatterEx = ex;
 48:     scatteredColor0 = sunColor * (1.0 - exp(-scatterCoeffSum * density * distAtm));
 49: }
 50: eyeDir_obj = eyeDir;
 51: gl_Position = ftransform();
 52: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: varying vec3 scatterEx;
  3: varying vec3 eyeDir_obj;
  4: uniform float mieK;
  5: uniform float mieCoeff;
  6: uniform vec3  rayleighCoeff;
  7: uniform vec3  invScatterCoeffSum;
  8: uniform vec3 light0_direction;
  9: varying vec3 scatteredColor0;
 10:
 11: void main(void)
 12: {
 13: vec3 color = vec3(0.0, 0.0, 0.0);
 14: vec3 V = normalize(eyeDir_obj);
 15:     float cosTheta = dot(V, light0_direction);
 16:     float phMie = (1.0 - mieK * mieK) / ((1.0 - mieK * cosTheta) * (1.0 - mieK * cosTheta));
 17:     float phRayleigh = 1.0;
 18:     color += (phRayleigh * rayleighCoeff + phMie * mieCoeff) * invScatterCoeffSum * scatteredColor0;
 19:     gl_FragColor = vec4(color, dot(scatterEx, vec3(0.333, 0.333, 0.333)));
 20: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: uniform float textureOffset;
  9: uniform vec3 ambientColor;
 10: uniform float opacity;
 11: varying vec4 diff;
 12:
 13: void main(void)
 14: {
 15: float NL;
 16: diff = vec4(ambientColor, opacity);
 17: NL = max(0.0, dot(gl_Normal, light0_direction));
 18: diff.rgb += light0_diffuse * NL;
 19: diffTexCoord = gl_MultiTexCoord0.st + vec2(textureOffset, 0.0);
 20: gl_Position = ftransform();
 21: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: varying vec2 diffTexCoord;
  4: varying vec4 diff;
  5:
  6: void main(void)
  7: {
  8: vec4 color;
  9: color = texture2D(diffTex, diffTexCoord.st);
 10: gl_FragColor = color * diff;
 11: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: uniform float textureOffset;
  9: varying vec4 diffFactors;
 10: uniform float ringWidth;
 11: uniform float ringRadius;
 12: varying vec4 ringShadowTexCoord;
 13:
 14: void main(void)
 15: {
 16: float NL;
 17: NL = max(0.0, dot(gl_Normal, light0_direction));
 18: diffFactors.x = NL;
 19: diffTexCoord = gl_MultiTexCoord0.st + vec2(textureOffset, 0.0);
 20: vec3 ringShadowProj;
 21: ringShadowProj = gl_Vertex.xyz + light0_direction * max(0.0, gl_Vertex.y / -light0_direction.y);
 22: ringShadowTexCoord.x = (length(ringShadowProj) - ringRadius) * ringWidth;
 23: gl_Position = ftransform();
 24: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: varying vec2 diffTexCoord;
  4: uniform vec3 ambientColor;
  5: uniform float opacity;
  6: vec4 diff = vec4(ambientColor, opacity);
  7: varying vec4 diffFactors;
  8: uniform vec3 lightcolor0;
  9: uniform sampler2D ringTex;
 10: varying vec4 ringShadowTexCoord;
 11:
 12: void main(void)
 13: {
 14: vec4 color;
 15: float shadow;
 16: shadow = diffFactors.x;
 17: shadow *= (1.0 - texture2D(ringTex, vec2(ringShadowTexCoord.x, 0.0)).a);
 18: diff.rgb += shadow * lightcolor0;
 19: color = texture2D(diffTex, diffTexCoord.st);
 20: gl_FragColor = color * diff;
 21: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec4 diffFactors;
  8: varying vec2 diffTexCoord;
  9: varying vec3 position_obj;
 10: varying vec4 shadowDepths;
 11:
 12: void main(void)
 13: {
 14: vec3 eyeDir = normalize(eyePosition - gl_Vertex.xyz);
 15: diffFactors.x = (dot(light0_direction, eyeDir) + 1.0) * 0.5;
 16: diffTexCoord = gl_MultiTexCoord0.st;
 17: position_obj = gl_Vertex.xyz;
 18: shadowDepths.x = dot(gl_Vertex.xyz, light0_direction);
 19: gl_Position = ftransform();
 20: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform vec3 ambientColor;
  3: vec4 diff = vec4(ambientColor, 1.0);
  4: uniform vec3 lightcolor0;
  5: varying vec4 diffFactors;
  6: varying vec2 diffTexCoord;
  7: uniform sampler2D diffTex;
  8: varying vec3 position_obj;
  9: varying vec4 shadowDepths;
 10: uniform vec4 shadowTexGenS0_0;
 11: uniform vec4 shadowTexGenT0_0;
 12: uniform float shadowScale0_0;
 13: uniform float shadowBias0_0;
 14:
 15: void main(void)
 16: {
 17: vec4 color;
 18: float shadow;
 19: vec2 shadowCenter;
 20: float shadowR;
 21: shadow = 1.0;
 22: shadowCenter.s = dot(vec4(position_obj, 1.0), shadowTexGenS0_0) - 0.5;
 23: shadowCenter.t = dot(vec4(position_obj, 1.0), shadowTexGenT0_0) - 0.5;
 24: shadowR = clamp(dot(shadowCenter, shadowCenter) * shadowScale0_0 + shadowBias0_0, 0.0, 1.0);
 25: shadow *= sqrt(shadowR);
 26: shadow = min(1.0, shadow + step(0.0, shadowDepths.x));
 27: diff.rgb += (shadow * diffFactors.x) * lightcolor0;
 28: color = texture2D(diffTex, diffTexCoord.st);
 29: gl_FragColor = color * diff;
 30: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: uniform float textureOffset;
  9: varying vec4 diffFactors;
 10: varying vec3 position_obj;
 11:
 12: void main(void)
 13: {
 14: float NL;
 15: NL = max(0.0, dot(gl_Normal, light0_direction));
 16: diffFactors.x = NL;
 17: diffTexCoord = gl_MultiTexCoord0.st + vec2(textureOffset, 0.0);
 18: position_obj = gl_Vertex.xyz;
 19: gl_Position = ftransform();
 20: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: varying vec2 diffTexCoord;
  4: uniform vec3 ambientColor;
  5: uniform float opacity;
  6: vec4 diff = vec4(ambientColor, opacity);
  7: varying vec4 diffFactors;
  8: uniform vec3 lightcolor0;
  9: varying vec3 position_obj;
 10: uniform vec4 shadowTexGenS0_0;
 11: uniform vec4 shadowTexGenT0_0;
 12: uniform float shadowScale0_0;
 13: uniform float shadowBias0_0;
 14:
 15: void main(void)
 16: {
 17: vec4 color;
 18: float shadow;
 19: vec2 shadowCenter;
 20: float shadowR;
 21: shadow = diffFactors.x;
 22: shadowCenter.s = dot(vec4(position_obj, 1.0), shadowTexGenS0_0) - 0.5;
 23: shadowCenter.t = dot(vec4(position_obj, 1.0), shadowTexGenT0_0) - 0.5;
 24: shadowR = clamp(dot(shadowCenter, shadowCenter) * shadowScale0_0 + shadowBias0_0, 0.0, 1.0);
 25: shadow *= sqrt(shadowR);
 26: diff.rgb += shadow * lightcolor0;
 27: color = texture2D(diffTex, diffTexCoord.st);
 28: gl_FragColor = color * diff;
 29: }

Error compiling fragment shader:
(1) : error C0104: Unknown pre-processor directive #version
Vertex shader source:
  1: #version 110
  2: uniform vec3 light0_direction;
  3: uniform vec3 light0_diffuse;
  4: uniform vec3 light0_specular;
  5: uniform vec3 light0_halfVector;
  6: uniform vec3 eyePosition;
  7: varying vec2 diffTexCoord;
  8: uniform float textureOffset;
  9: uniform vec3 ambientColor;
 10: uniform float opacity;
 11: varying vec4 diff;
 12:
 13: void main(void)
 14: {
 15: float NL;
 16: diff = vec4(ambientColor, opacity);
 17: NL = max(0.0, dot(gl_Normal, light0_direction));
 18: diff.rgb += light0_diffuse * NL;
 19: diffTexCoord = gl_MultiTexCoord0.st;
 20: diffTexCoord.x += textureOffset;
 21: gl_Position = ftransform();
 22: }

Error compiling vertex shader:
(1) : error C0104: Unknown pre-processor directive #version
Fragment shader source:
  1: #version 110
  2: uniform sampler2D diffTex;
  3: varying vec2 diffTexCoord;
  4: varying vec4 diff;
  5:
  6: void main(void)
  7: {
  8: vec4 color;
  9: color = texture2D(diffTex, diffTexCoord.st);
 10: gl_FragColor = color * diff;
 11: }


NB: This is the shaders.log from the main Celestia directory. There is no file of that name on the Windows Desktop.

[Adirondack]

I'm pretty sure that an update of your graphics drivers will help!
Recent drivers for 6600 GT is ForceWare 169.21.
http://www.nvidia.com/object/winxp_169.21_whql.html

Adirondack

[selden]

Yup. The #version directive was implemented quite some time ago.

Be sure to deinstall the old drivers using the Windows Control Panel and reboot after you've done that. Otherwise the new drivers will not install properly. They won't complain but will not work properly, which may be the cause of your current problem.

[Adirondack]

See topic How to update your ForceWare graphics drivers on Windows <- click

Adirondack

[AndreasJ]

Thanks again. Installing that driver seems to've done the trick.

(Now I only wonder why, when I went to Nvidia's page before I went here, their diagnosis tool said there was no newer driver available for my card.)