the 1.4prev9 bug report thread

[jdou]

Andrea,
With the 1.4.0 final version and NVIDIA driver 81.98, I have the same shadows problem You have.
But no longer red Earth

[ANDREA]

Andrea, With the 1.4.0 final version and NVIDIA driver 81.98, I have the same shadows problem You have. But no longer red Earth

Well jdou, so nVidia solved at least one of the many still living problems.
This makes me hope that tomorrow...
Meanwhile, Happy Xmas to all of you and your families.
Bye

Andrea

[symaski62]

"celestia.cfg"

#------------------------------------------------------------------------
# The following line is commented out by default.
#
# Celestia enables and disables certain rendering features based on
# the set of extensions supported by the installed OpenGL driver and 3D
# graphics hardware. With IgnoreGLExtensions, you may specify a list of
# extensions that Celestia will treat as unsupported. This is useful
# primarily for the developers of Celestia.
#------------------------------------------------------------------------
IgnoreGLExtensions [ "GL_ARB_vertex_program" ]

"#" oupss

:/ color error

Code: Select all

Vertex shader source:
  1: uniform struct {
  2:    vec3 direction;
  3:    vec3 diffuse;
  4:    vec3 specular;
  5:    vec3 halfVector;
  6: } lights[1];
  7: uniform float shininess;
  8: uniform vec3 ambientColor;
  9: varying vec4 diff;
 10: varying vec4 spec;
 11: varying vec2 diffTexCoord;
 12: varying vec2 nightTexCoord;
 13: varying float totalLight;
 14: uniform float textureOffset;
 15:
 16: void main(void)
 17: {
 18: float nDotVP;
 19: float nDotHV;
 20: diff = vec4(ambientColor, 1.0);
 21: spec = vec4(0.0, 0.0, 0.0, 0.0);
 22: totalLight = 0.0;
 23: nDotVP = max(0.0, dot(gl_Normal, lights[0].direction));
 24: nDotHV = max(0.0, dot(gl_Normal, lights[0].halfVector));
 25: diff.rgb += lights[0].diffuse * nDotVP;
 26: spec.rgb += lights[0].specular * (pow(nDotHV, shininess) * nDotVP);
 27: totalLight += nDotVP;
 28: totalLight = 1.0 - totalLight;
 29: totalLight = totalLight * totalLight * totalLight * totalLight;
 30: diffTexCoord = gl_MultiTexCoord0.st;
 31: diffTexCoord.x += textureOffset;
 32: nightTexCoord = gl_MultiTexCoord1.st;
 33: gl_Position = ftransform();
 34: }

Fragment shader source:
  1: varying vec4 diff;
  2: varying vec4 spec;
  3: varying vec2 diffTexCoord;
  4: uniform sampler2D diffTex;
  5: varying vec2 nightTexCoord;
  6: uniform sampler2D nightTex;
  7: varying float totalLight;
  8:
  9: void main(void)
 10: {
 11: vec4 color;
 12: color = texture2D(diffTex, diffTexCoord.st);
 13: gl_FragColor = color * diff + color.a * spec;
 14: gl_FragColor += texture2D(nightTex, nightTexCoord.st) * totalLight;
 15: }

Vertex shader source:
  1: uniform struct {
  2:    vec3 direction;
  3:    vec3 diffuse;
  4:    vec3 specular;
  5:    vec3 halfVector;
  6: } lights[1];
  7: uniform vec3 ambientColor;
  8: varying vec4 diff;
  9: varying vec2 diffTexCoord;
 10: uniform float textureOffset;
 11:
 12: void main(void)
 13: {
 14: float nDotVP;
 15: diff = vec4(ambientColor, 1.0);
 16: nDotVP = max(0.0, dot(gl_Normal, lights[0].direction));
 17: diff.rgb += lights[0].diffuse * nDotVP;
 18: diffTexCoord = gl_MultiTexCoord0.st;
 19: diffTexCoord.x += textureOffset;
 20: gl_Position = ftransform();
 21: }

Fragment shader source:
  1: varying vec4 diff;
  2: varying vec2 diffTexCoord;
  3: uniform sampler2D diffTex;
  4:
  5: void main(void)
  6: {
  7: vec4 color;
  8: color = texture2D(diffTex, diffTexCoord.st);
  9: gl_FragColor = color * diff;
 10: }

Vertex shader source:
  1: uniform struct {
  2:    vec3 direction;
  3:    vec3 diffuse;
  4:    vec3 specular;
  5:    vec3 halfVector;
  6: } lights[1];
  7: varying vec2 diffTexCoord;
  8: varying vec2 normTexCoord;
  9: varying vec3 lightDir0;
 10: uniform float textureOffset;
 11: attribute vec3 tangent;
 12:
 13: void main(void)
 14: {
 15: float nDotVP;
 16: nDotVP = max(0.0, dot(gl_Normal, lights[0].direction));
 17: vec3 bitangent = cross(gl_Normal, tangent);
 18: lightDir0.x = dot(tangent, lights[0].direction);
 19: lightDir0.y = dot(-bitangent, lights[0].direction);
 20: lightDir0.z = dot(gl_Normal, lights[0].direction);
 21: diffTexCoord = gl_MultiTexCoord0.st;
 22: diffTexCoord.x += textureOffset;
 23: normTexCoord = gl_MultiTexCoord1.st;
 24: gl_Position = ftransform();
 25: }

Fragment shader source:
  1: uniform vec3 ambientColor;
  2: vec4 diff = vec4(ambientColor, 1.0);
  3: uniform vec3 lightcolor0;
  4: varying vec2 diffTexCoord;
  5: uniform sampler2D diffTex;
  6: varying vec2 normTexCoord;
  7: varying vec3 lightDir0;
  8: uniform sampler2D normTex;
  9:
 10: void main(void)
 11: {
 12: vec4 color;
 13: vec3 n = texture2D(normTex, normTexCoord.st).xyz * vec3(2.0, 2.0, 2.0) - vec3(1.0, 1.0, 1.0);
 14: float l;
 15: l = max(0.0, dot(lightDir0, n)) * clamp(lightDir0.z * 8.0, 0.0, 1.0);
 16: diff.rgb += l * lightcolor0;
 17: color = texture2D(diffTex, diffTexCoord.st);
 18: gl_FragColor = color * diff;
 19: }

Vertex shader source:
  1: uniform struct {
  2:    vec3 direction;
  3:    vec3 diffuse;
  4:    vec3 specular;
  5:    vec3 halfVector;
  6: } lights[1];
  7: varying vec4 diffFactors;
  8: varying vec2 diffTexCoord;
  9: uniform float ringWidth;
 10: uniform float ringRadius;
 11: varying vec4 ringShadowTexCoord;
 12: uniform float textureOffset;
 13:
 14: void main(void)
 15: {
 16: float nDotVP;
 17: nDotVP = max(0.0, dot(gl_Normal, lights[0].direction));
 18: diffFactors.x = nDotVP;
 19: diffTexCoord = gl_MultiTexCoord0.st;
 20: diffTexCoord.x += textureOffset;
 21: vec3 ringShadowProj;
 22: ringShadowProj = gl_Vertex.xyz + lights[0].direction * max(0.0, gl_Vertex.y / -lights[0].direction.y);
 23: ringShadowTexCoord.x = length(ringShadowProj) * ringWidth - ringRadius;
 24: gl_Position = ftransform();
 25: }

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

Vertex shader source:
  1: uniform struct {
  2:    vec3 direction;
  3:    vec3 diffuse;
  4:    vec3 specular;
  5:    vec3 halfVector;
  6: } lights[1];
  7: uniform vec3 eyePosition;
  8: varying vec4 diffFactors;
  9: varying vec2 diffTexCoord;
 10: uniform vec4 shadowTexGenS0_0;
 11: uniform vec4 shadowTexGenT0_0;
 12: varying vec3 shadowTexCoord0_0;
 13:
 14: void main(void)
 15: {
 16: float nDotVP;
 17: vec3 eyeDir = normalize(eyePosition - gl_Vertex.xyz);
 18: diffFactors.x = (dot(lights[0].direction, eyeDir) + 1.0) * 0.5;
 19: diffTexCoord = gl_MultiTexCoord0.st;
 20: shadowTexCoord0_0.x = dot(gl_Vertex, shadowTexGenS0_0);
 21: shadowTexCoord0_0.y = dot(gl_Vertex, shadowTexGenT0_0);
 22: shadowTexCoord0_0.z = dot(gl_Vertex.xyz, lights[0].direction);
 23: gl_Position = ftransform();
 24: }

Fragment shader source:
  1: uniform vec3 ambientColor;
  2: vec4 diff = vec4(ambientColor, 1.0);
  3: uniform vec3 lightcolor0;
  4: varying vec4 diffFactors;
  5: varying vec2 diffTexCoord;
  6: uniform sampler2D diffTex;
  7: varying vec3 shadowTexCoord0_0;
  8: uniform float shadowScale0_0;
  9: uniform float shadowBias0_0;
 10:
 11: void main(void)
 12: {
 13: vec4 color;
 14: float shadow;
 15: vec2 shadowCenter;
 16: float shadowR;
 17: shadow = 1.0;
 18: shadowCenter = shadowTexCoord0_0.st - vec2(0.5, 0.5);
 19: shadowR = clamp(dot(shadowCenter, shadowCenter) * shadowScale0_0 + shadowBias0_0, 0.0, 1.0);
 20: shadow *= sqrt(shadowR);
 21: shadow = min(1.0, shadow + step(0.0, shadowTexCoord0_0.z));
 22: diff.rgb += (shadow * diffFactors.x) * lightcolor0;
 23: color = texture2D(diffTex, diffTexCoord.st);
 24: gl_FragColor = color * diff;
 25: }

Vertex shader source:
  1: uniform struct {
  2:    vec3 direction;
  3:    vec3 diffuse;
  4:    vec3 specular;
  5:    vec3 halfVector;
  6: } lights[1];
  7: uniform float shininess;
  8: uniform vec3 ambientColor;
  9: varying vec4 diff;
 10: varying vec4 spec;
 11: varying vec2 diffTexCoord;
 12: varying vec2 specTexCoord;
 13: uniform float textureOffset;
 14:
 15: void main(void)
 16: {
 17: float nDotVP;
 18: float nDotHV;
 19: diff = vec4(ambientColor, 1.0);
 20: spec = vec4(0.0, 0.0, 0.0, 0.0);
 21: nDotVP = max(0.0, dot(gl_Normal, lights[0].direction));
 22: nDotHV = max(0.0, dot(gl_Normal, lights[0].halfVector));
 23: diff.rgb += lights[0].diffuse * nDotVP;
 24: spec.rgb += lights[0].specular * (pow(nDotHV, shininess) * nDotVP);
 25: diffTexCoord = gl_MultiTexCoord0.st;
 26: diffTexCoord.x += textureOffset;
 27: specTexCoord = gl_MultiTexCoord1.st;
 28: gl_Position = ftransform();
 29: }

Fragment shader source:
  1: varying vec4 diff;
  2: varying vec4 spec;
  3: varying vec2 diffTexCoord;
  4: uniform sampler2D diffTex;
  5: varying vec2 specTexCoord;
  6: uniform sampler2D specTex;
  7:
  8: void main(void)
  9: {
 10: vec4 color;
 11: color = texture2D(diffTex, diffTexCoord.st);
 12: gl_FragColor = color * diff + texture2D(specTex, specTexCoord.st) * spec;
 13: }