GLSL Shader bug - HD3000 Win7 64bit driver 8.15.10.2671

Hi,

Caveat - I'm not the author of the code below, and neither do I fully understand it. However what I do know is that the HD3000 fails to produce the expected output, whilst other hardware (including my old XP laptop with an ATI x700 OpenGL 2.1 card, and the authors OpenGL 4.1 Nvidia card) does. The part of the code that does not seem to be processed as expected is designed to place and rotate a decal texture on a 3d models base texture. The placement works, the rotation value (defined as a float (Decal1_Rotation) is picked up and bound to the model correctly, but the value passed to the shader appears to be ignored. No errors are reported to the host application.

// Constants

const float KspecExponent = 5.0;

const vec3 kLampColorNoAlert = vec3(0);

const vec3 kLampColorYellowAlert = vec3(0.9926, 0.9686, 0.7325);

const vec3 kLampColorRedAlert = vec3(1.0, 0.1, 0.0);

// Uniforms from Oolite

   uniform float  uTime;

   uniform float  hull_heat_level;

   uniform float  engine_power;

   uniform vec4   PaintColor1; // used with paintmask map to tint diffuse texture

   uniform vec4   PaintColor2; // used with paintmask map to tint diffuse texture

   uniform vec4   Decal1_Scale_and_Position; // position & scale settings for decal 1

   uniform float  Decal1_Rotation;  // rotation settings for decal 1

// Irregular flickering function

   #ifdef OO_REDUCED_COMPLEXITY

   #define Pulse(v, ts) ((v) * 0.95)

   #define Blink_on_off(value) (1.0)

   #else

// Hull Temperate heat glow effect

// Blink_on_off_function.

   float Blink_on_off(float timeScale)

   {

   float result = step(0.5, sin(uTime * timeScale));

   return 0.5 + result;

// Cyan color exhaust glow effect

   vec3 cyanGlow(float level)

   {

// Red/Orange color heated metal effect

   vec3 redGlow(float level)

   {

   }

#endif

void Light(in vec3 lightVector, in vec3 normal, in vec3 lightColor, in vec3 eyeVector,

{

   lightVector = normalize(lightVector);

   vec3 reflection = normalize(-reflect(lightVector, normal));

   totalDiffuse += gl_FrontMaterial.diffuse.rgb * lightColor * max(dot(normal, lightVector), 0.0);

   totalSpecular += lightColor * pow(max(dot(reflection, eyeVector), 0.0), KspecExponent);

}

#define LIGHT(idx, vector) Light(vector, normal, gl_LightSource[idx].diffuse.rgb, eyeVector, KspecExponent, diffuse, specular)

#ifndef OO_REDUCED_COMPLEXITY

// function to read in the colour map then scale and position the decal map onto it.

/*

   "the_decaliser" - this function scales & positions the decal image using data passed

   to it from the main shader

*/ 

vec4 the_decaliser(vec4 Your_Decal_Settings, float Your_decal_Rotation)

{

// Setup the basic texture co-ords for the decals

   vec2 decal_TexCoord = vTexCoord;

   decal_TexCoord -= vec2(Your_Decal_Settings.s, Your_Decal_Settings.t - (0.5 / Your_Decal_Settings.p));

// Orientate & scale the decal 

   float decal_s = sin(Your_decal_Rotation);

   float decal_c = cos(Your_decal_Rotation);

   decal_TexCoord *= mat2(decal_c, decal_s, -decal_s, decal_c);

   decal_TexCoord += vec2(0.5 / Your_Decal_Settings.p);

   decal_TexCoord *= vec2(Your_Decal_Settings.p, Your_Decal_Settings.p);

// Get texture values.

   vec4 decal_Tex = texture2D(uDecalMap, decal_TexCoord);

// Modify the Decals texture co-oords

   decal_TexCoord.s += 1.0;

   decal_Tex *= step(1.0, decal_TexCoord.s) *

// Use the Alpha in the decal as a transparency mask so you can 'cutout' your decal from it's background

   float alpha = decal_Tex.a;

// Return the scaled, position & rotated decal, it's mixed into the colour texture further on in the shader .

   return alpha * decal_Tex;

#endif 

void main()

{

   vec3 eyeVector = normalize(vEyeVector);

   vec2 texCoord = vTexCoord;

   vec3 normal = normalize(texture2D(uNormalMap, vTexCoord).rgb - 0.5);

   vec3 colorMap = texture2D(uColorMap, texCoord).rgb;

   vec4 effectsMap = texture2D(uEffectsMap, texCoord);

   vec3 diffuse = vec3(0.0), specular = vec3(0);

   float specIntensity = texture2D(uColorMap, texCoord).a;

   float glowMap = texture2D(uNormalMap, texCoord).a;

   vec3  LampColor = vec3(0.9926, 0.9686, 0.7325);

#ifdef OO_LIGHT_0_FIX

   LIGHT(0, normalize(vLight0Vector));

#endif

   LIGHT(1, normalize(vLight1Vector));

   diffuse += gl_FrontMaterial.ambient.rgb * gl_LightModel.ambient.rgb;

#ifndef OO_REDUCED_COMPLEXITY

// Full Shader Mode - Repaint the hull

   colorMap += effectsMap.g * PaintColor1.rgb;

   colorMap += effectsMap.a * PaintColor2.rgb;

// Full Shader Mode - Apply the decals

   vec4 decals = the_decaliser(Decal1_Scale_and_Position, Decal1_Rotation);

// mix the decals into the texture using the decal alpha as a mask

   vec3 color = mix(colorMap, decals.rgb, decals.a) * diffuse;

// Calculate the lighting for full shader mode

   color += color * specular * specIntensity * 2.5;

#endif

// Calculate the lighting for simple shader mode

#ifdef OO_REDUCED_COMPLEXITY   

   vec3 color = diffuse * colorMap;

   color += colorMap * specular *  specIntensity * 2.5;

// Add in simple shader hull lights

   color += LampColor * glowMap;   

#endif

// these next glow effects are only available in full shader mode  

#ifndef OO_REDUCED_COMPLEXITY

// check Alert Level, Adjust Lamp Colour Accordingly

   if (alertlevel > 0)

   else

// Damage Calculator

float tempvar = float(damage_amount);

float DamageAmount = mod(tempvar, 100.0) / 100.0;

vec3 Lampglow = LampColor * glowMap * Pulse(2.0, 1.0) * (1.0  - DamageAmount); 

vec3 Cyanglow = cyanGlow(effectsMap.b * Pulse(min(engine_power, 1.0), 1.0));

vec3 Redglow =  redGlow(effectsMap.r * Pulse(min(engine_power, 1.0), 1.0));

color += mix(Lampglow + Cyanglow + Redglow, 

// Add the all over hull temperature glow. Full Shader mode only

   float hullHeat = max(hull_heat_level - 0.5, 0.0) * 2.0;

   hullHeat = Pulse(hullHeat * hullHeat, 0.1);

   color += TemperatureGlow(hullHeat);

#endif  

   gl_FragColor = vec4(color.rgb, 1.0);

}