Oolite Bulletins

Code: Select all

// Uniforms from Oolite
   uniform sampler2D    uColorMap;
   uniform sampler2D    uNormalMap;
   uniform sampler2D    uEffectsMap;

   uniform float  uTime;
   uniform float  timeElapsedSinceSpawn;
   uniform float  FadeTime; // Random value supplied by Oolite using 'randomFloat' (in the range 0.0 - 1.0)

// Info from the vertex shader
   varying vec2         vTexCoord;
   varying vec3         vEyeVector;   // These are all in tangent space
   varying vec3         vLight0Vector;
   varying vec3         vLight1Vector;
 
// Constants
   float kInitialHeat = 5.0;
   const float KspecExponent = 5.0;
   const float kSpecular = 0.4;

// Set up the total burntime
   float FadeTime2 = FadeTime * 100.0; // Multiply FadeTime by 100 to lengthen the burn time
   float  FadeFactor = kInitialHeat / FadeTime2;

// Irregular flickering function used to flicker the heated metal
   #ifdef OO_REDUCED_COMPLEXITY 
   #define Pulse(v, ts) ((v) * 0.95) 
   #else

     float Pulse(float value, float timeScale)
     {
        float t = uTime * timeScale;   

        float s0 = t;
        s0 -= floor(s0);
        float sum = abs( s0 - 0.5);
   
        float s1 = t * 0.7 - 0.05;
        s1 -= floor(s1);
        sum += abs(s1 - 0.5) - 0.25;
   
        float s2 = t * 1.3 - 0.3;
        s2 -= floor(s2);
        sum += abs(s2 - 0.5) - 0.25;
   
        float s3 = t * 5.09 - 0.6;
        s3 -= floor(s3);
        sum += abs(s3 - 0.5) - 0.25;

        return (sum * 0.4 + 0.9) * value;
      }

// Hot Glowing Metal Function.
   vec4 MetalGlow(float level)
   {
   vec4 result;
   result.rgb = vec3(2.0, 0.5, 0.25) * level;
   result.a = 1.0;
   return result;
   }
   
#endif

void Light(in vec3 lightVector, in vec3 normal, in vec4 lightColor, in vec3 eyeVector, 
           in float KspecExponent, inout vec4 totalDiffuse, inout vec4 totalSpecular)
{
   lightVector = normalize(lightVector);
   vec3 reflection = normalize(-reflect(lightVector, normal));
   
   totalDiffuse += gl_FrontMaterial.diffuse * 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, eyeVector, KspecExponent, diffuse, specular)

void main()
{
   vec3 eyeVector = normalize(vEyeVector);
   vec2 texCoord = vTexCoord;
   
   vec3 normal = normalize( texture2D(uNormalMap, texCoord).xyz - 0.5);
   normal = normalize(normal);

   vec4 colorMap = texture2D(uColorMap, texCoord);
   vec4 clipMap = texture2D(uEffectsMap, texCoord);
   vec4 diffuse = vec4(0.0), specular = vec4(0);

   float specIntensity = colorMap.a;

#ifdef OO_LIGHT_0_FIX
   LIGHT(0, normalize(vLight0Vector));
#endif
   LIGHT(0, normalize(vLight1Vector)); // change the 0 to 1 when saving the shader for oolite
   diffuse += gl_FrontMaterial.ambient * gl_LightSource[0].ambient;

/* Make the crinkly edge, use the red channel from the effects texture as a clipmap, 
   ramp up the intensity to eat away the polygon over time but stop it at FadeTime2 
   (FadeTime2 is the random float 'FadeTime' supplied by Oolite multiplied by 100) 
   This allows each fragment to burn for a random length of time */
   float BurnAway = clipMap.r * min(timeElapsedSinceSpawn, FadeTime2);  
   if (BurnAway > 0.9)  discard; 

// Calculate the lighting 
   vec4 color = diffuse * colorMap;
   color += colorMap * specular * 6.0 * specIntensity;   

// Add the glowing metal effect
   float metalTemperature = max(0.0, kInitialHeat - FadeFactor * timeElapsedSinceSpawn);
   float Heat = max(metalTemperature - 0.5, 0.0);
   Heat = Pulse(metalTemperature, 0.5);
   float FinalTemperature = BurnAway * (Heat + metalTemperature); 
   color += MetalGlow(FinalTemperature) * colorMap;

   gl_FragColor = color;
}

Code: Select all

{
	GLOBAL = {
	ENTER = ("pauseAI: 15.00"); 
	EXIT = (); 
	UPDATE = (becomeExplosion); 
	}; 
}