Oolite Bulletins

Code: Select all

// Texture Information from Oolite.
   uniform sampler2D      tex0; // Difuse and Specular Intensity map
   uniform sampler2D      tex1; // Effects map

// Uniforms from Oolite
   uniform float  uTime;
   uniform float  engine_power;

// Information from vertex shader.
   varying vec3         v_normal;   // Surface normal
   varying vec3         v_pos;      // Vertex/fragment position in eye space

// set the specExponent level (the specular highlight size, higher specExponent
// settings make the specular highlight smaller which makes the surface look 
// more glossy - good for glass & plastics
   const float    specExponent = 2.0;
   
// Cyan color exhaust glow
   vec4 cyanGlow(float level)
   {
      vec4 result;
      result.rgb = vec3(0.3, 0.6, 0.7) * level * 1.5;
      result.a = 1.0;
   
      return result;
   }

// Red/Orange color exhaust glow and engine heated metal
   vec4 redGlow(float level)
   {
      vec4 result;
      result.rgb = vec3(2.0, 0.5, 0.0) * level * 9.5;
      result.a = 1.0;
      return result;
   }   
   

// Irregular flickering function
   #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.1 + 0.9) * value;

      }

   #endif
   
// Calculate the contribution of a single light. Ought to be a function, but OS X's GLSlang implementation isn't sufficiently clever.
   #define LIGHT(idx) \
        { \
           vec3 lightVector   = normalize(gl_LightSource[idx].position.xyz); \
           vec3 reflection   = normalize(-reflect(lightVector, v_normal)); \
           diffuse += gl_FrontMaterial.diffuse * gl_LightSource[idx].diffuse * max(dot(v_normal, lightVector), 0.0); \
           specular += gl_LightSource[idx].diffuse * pow(max(dot(reflection, eyeVector), 0.0), specExponent); \
        }
   
   void main(void)
   {
   vec4 diffuse = vec4(0.0), specular = vec4(0.0);
   vec3 eyeVector = normalize(-v_pos);
 
// Load texture data
   vec2 texCoord = gl_TexCoord[0].st;
   vec4 diffuseMap = texture2D(tex0, texCoord);
    vec4 effectsMap = texture2D(tex1, texCoord);  
// calculate specular effects
   float specIntensity = diffuseMap.a;

   
/*   Light 0 is the "showroom" light, used in the demo screen and shipyard.
     Light 1 is the sun.
*/
   #ifdef OO_LIGHT_0_FIX
   LIGHT(0);
   #endif
   LIGHT(0);
   diffuse += gl_FrontMaterial.ambient * gl_LightModel.ambient;

   
// Calculate the basic ship colour & add in the specular effects 
   vec4 color = diffuse * diffuseMap + (diffuseMap * 3.0 * specular) * specIntensity; 
//add in the cyan engine glow around the rockets
 color += cyanGlow(effectsMap.r * Pulse(min(engine_power, 1.0), 1.0));
//add in the red heated metal glow around the exhaust 
   color += redGlow(effectsMap.b * diffuseMap.r * Pulse(min(engine_power, 1.0), 1.0)) * 0.5;

// add in the hull light glows
color += effectsMap.a * diffuseMap;

// Output final color
   gl_FragColor = vec4(color.rgb, 1.0);
   }

Code: Select all

LIGHT(0);

Code: Select all

LIGHT(1);

Code: Select all

// Irregular flickering function
   #ifdef OO_REDUCED_COMPLEXITY 
   #define Pulse(v, ts) ((v) * 0.95) 
   #define Blink_on_off(value) (1.0)
   #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.1 + 0.9) * value;
      }

// Hull Temperate heat glow effect
     vec4 TemperatureGlow(float level) 
     { 
        vec4 result = vec4(0); 
    
        result.r = level; 
        result.g = level * level * level; 
        result.b = max(level - 0.7, 0.0) * 2.0;
        result.a = 1.0; 
    
        return result;    
     } 
     
// Blink_on_off_function.
   float Blink_on_off(float value)
   {
   if (value < 0.90)
       value = 0.0;
   else value = 1.0;
   return (value);
   }     
     
// Cyan color exhaust glow effect
   vec4 cyanGlow(float level)
   {
      vec4 result;
      result.rgb = vec3(0.2, 0.7, 0.9) * level * 1.5;
      result.a = 1.0;
   
      return result;
   }     
     
// Red/Orange color heated metal effect
   vec4 redGlow(float level)
   {
      vec4 result;
      result.rgb = vec3(1.5, 0.55, 0.2) * level * 1.3;
      result.a = 1.0;
      return result;
   }
   
#endif