ruby-ogre 0.0.1-x86-linux

data/deps/share/OGRE/media/materials/programs/OldMovieFP.cg

@@ -0,0 +1,55 @@
+sampler2D RT : register(s0);
+sampler2D SplotchesTx : register(s1);
+sampler1D Texture2 : register(s2);
+sampler1D SepiaTx : register(s3);
+
+float2 calcSpriteAddr(float2 texCoord, float DirtFrequency1, float period)
+{
+   return texCoord + tex1D(Texture2, period  * DirtFrequency1).xy;
+}
+
+float4 getSplotches(float2 spriteAddr)
+{
+   // get sprite address into paged texture coords space
+   spriteAddr = spriteAddr / 6.3f;
+   //spriteAddr = spriteAddr - frac(spriteAddr);
+   spriteAddr = spriteAddr - (spriteAddr /33.3f);
+
+   return tex2D(SplotchesTx, spriteAddr);
+}
+
+float4 OldMovie_ps (float4 pos : POSITION, 
+        float2 texCoord  : TEXCOORD0,
+				uniform float time_cycle_period,
+				uniform float flicker,
+				uniform float DirtFrequency,
+				uniform float3 luminance,
+				uniform float frameJitter,
+				uniform float lumiShift
+				) : COLOR
+{
+
+   // get sprite address
+   float2 spriteAddr = calcSpriteAddr(texCoord, DirtFrequency, time_cycle_period);
+
+    // add some dark and light splotches to the film
+   float4 splotches = getSplotches(spriteAddr);
+   float4 specs = 1.0f - getSplotches(spriteAddr / 3.0f);
+
+   // convert color to base luminance
+   float4 base = tex2D(RT, texCoord + float2(0, spriteAddr.y * frameJitter));
+   float lumi = dot(base.rgb, luminance);
+   // randomly shift luminance
+   lumi -= spriteAddr.x * lumiShift;
+   // tone map luminance
+   base.rgb = tex1D(SepiaTx, lumi ).rgb;
+
+   // calc flicker speed
+   float darken = frac(flicker * time_cycle_period);
+
+   // we want darken to cycle between 0.6 and 1.0
+   darken = abs(darken - 0.5f) * 0.4f + 0.6f;
+   // composite dirt onto film
+   return base * splotches * darken + specs;
+}
+

data/deps/share/OGRE/media/materials/programs/OldMovieFP.glsles

@@ -0,0 +1,58 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+varying vec2 uv0;
+varying vec2 uv1;
+
+uniform sampler2D RT;
+uniform sampler2D SplotchesTx;
+uniform sampler2D Texture2;
+uniform sampler2D SepiaTx;
+uniform float time_cycle_period;
+uniform float flicker;
+uniform float DirtFrequency;
+uniform vec3 luminance;
+uniform float frameJitter;
+uniform float lumiShift;
+
+vec2 calcSpriteAddr(vec2 texCoord, float DirtFrequency1, float period)
+{
+   return texCoord + texture2D(Texture2, vec2(period * DirtFrequency1, 0.0)).xy;
+}
+
+vec4 getSplotches(vec2 spriteAddr)
+{
+   // get sprite address into paged texture coords space
+   spriteAddr = spriteAddr / 6.3;
+   spriteAddr = spriteAddr - (spriteAddr / 33.3);
+
+   return texture2D(SplotchesTx, spriteAddr);
+}
+
+void main()
+{
+   // get sprite address
+   vec2 spriteAddr = calcSpriteAddr(uv0, DirtFrequency, time_cycle_period);
+
+   // add some dark and light splotches to the film
+   vec4 splotches = getSplotches(spriteAddr);
+   vec4 specs = 1.0 - getSplotches(spriteAddr / 3.0);
+
+   // convert color to base luminance
+   vec4 base = texture2D(RT, uv0 + vec2(0.0, spriteAddr.y * frameJitter));
+   float lumi = dot(base.rgb, luminance);
+   // randomly shift luminance
+   lumi -= spriteAddr.x * lumiShift;
+   // tone map luminance
+   base.rgb = texture2D(SepiaTx, vec2(lumi, 0.0)).rgb;
+
+   // calc flicker speed
+   float darken = fract(flicker * time_cycle_period);
+
+   // we want darken to cycle between 0.6 and 1.0
+   darken = abs(darken - 0.5) * 0.4 + 0.6;
+   // composite dirt onto film
+   gl_FragColor = base * splotches * darken + specs;
+}

data/deps/share/OGRE/media/materials/programs/OldTV.cg

@@ -0,0 +1,42 @@
+
+
+sampler Image: register(s0);
+sampler Rand: register(s1);
+sampler Noise: register(s2);
+
+float4 OldTV_ps(float2 pos: TEXCOORD1, float2 img: TEXCOORD0,
+    uniform float distortionFreq: register(c3),
+    uniform float distortionScale: register(c4),
+    uniform float distortionRoll: register(c5),
+    uniform float interference: register(c7),
+    uniform float frameLimit: register(c8),
+    uniform float frameShape: register(c0),
+    uniform float frameSharpness: register(c1),
+    uniform float time_0_X: register(c2),
+    uniform float sin_time_0_X: register(c6)
+
+) : COLOR {
+   // Define a frame shape
+   float f = (1 - pos.x * pos.x) * (1 - pos.y * pos.y);
+   float frame = saturate(frameSharpness * (pow(f, frameShape) - frameLimit));
+
+   // Interference ... just a texture filled with rand()
+   float rand = tex3D(Rand, float3(1.5 * pos, time_0_X)) - 0.2;
+
+   // Some signed noise for the distortion effect
+   float noisy = tex3D(Noise, float3(0, 0.5 * pos.y, 0.1 * time_0_X)) - 0.5;
+
+   // Repeat a 1 - x^2 (0 < x < 1) curve and roll it with sinus.
+   float dst = frac(pos.y * distortionFreq + distortionRoll * sin_time_0_X);
+   dst *= (1 - dst);
+   // Make sure distortion is highest in the center of the image
+   dst /= 1 + distortionScale * abs(pos.y);
+
+   // ... and finally distort
+   img.x += distortionScale * noisy * dst;
+   float4 image = tex2D(Image, img);
+
+   // Combine frame, distorted image and interference
+   return frame * (interference * rand + image);
+}
+

data/deps/share/OGRE/media/materials/programs/ParticleGS.cg

@@ -0,0 +1,324 @@
+//
+// Explanation of different particle types
+//
+#define PT_LAUNCHER 0 //Firework Launcher - launches a PT_SHELL every so many seconds
+#define PT_SHELL    1 //Unexploded shell - flies from the origin and explodes into many PT_EMBERXs
+#define PT_EMBER1   2 //basic particle - after it's emitted from the shell, it dies
+#define PT_EMBER2   3 //after it's emitted, it explodes again into many PT_EMBER1s
+#define PT_EMBER3   4 //just a differently colored ember1
+#define P_SHELLLIFE 3.0
+#define P_EMBER1LIFE 2.5
+#define P_EMBER2LIFE 1.5
+#define P_EMBER3LIFE 2.0
+
+//These two were originally shader params, but they caused runtime errors
+#define NUM_EMBER_1S 30
+#define NUM_EMBER_2S 15
+#define NUM_EMBER_3S 10
+//This one was originally a variant, but this also causes runtime errors
+//#define MAX_EMBER_2S 15.0
+
+//
+// Generic particle motion handler
+//
+
+void GSGenericHandler( float3 Pos, float3 Vel, float Timer, float Type,
+						float elapsedTime, 
+						float3 frameGravity)
+{
+    Pos += Vel * elapsedTime;
+    Vel += frameGravity;
+    Timer -= elapsedTime;
+	if (Pos.y > -100)
+	{
+		emitVertex( Pos : POSITION, Vel : TEXCOORD2, Timer : TEXCOORD0, Type : TEXCOORD1);
+	}
+}
+
+//
+// Sample a random direction from our random texture
+//
+float3 RandomDir(float fOffset, float globalTime, sampler1D randomTex)
+{
+    float tCoord = (globalTime + fOffset) / 300.0;
+    return tex1D(randomTex, tCoord).rgb;
+}
+
+//
+// Launcher type particle handler
+//
+void GSLauncherHandler( float3 Pos, float3 Vel, float Timer, float Type, 
+						float elapsedTime, 
+						float globalTime, 
+						sampler1D randomTex,
+						float secondsPerFirework)
+{
+    if(Timer <= 0)
+    {
+        float3 vRandom = normalize( RandomDir( Type, globalTime, randomTex) );
+		//Give it more of an up bias
+        vRandom = normalize(vRandom + float3(0,2.5,0)); 
+		
+		//time to emit a new SHELL
+        float3 outputPos = Pos + Vel*elapsedTime;
+        float3 outputVel = Vel + vRandom*35.0;
+        float  outputTimer = P_SHELLLIFE + vRandom.y*0.5;
+        float outputType = PT_SHELL;
+        emitVertex(outputPos : POSITION, outputVel : TEXCOORD2, outputTimer : TEXCOORD0, outputType : TEXCOORD1);
+        
+        //reset our timer
+        Timer = secondsPerFirework + vRandom.x*0.4;
+    }
+    else
+    {
+        Timer -= elapsedTime;
+    }
+    
+    //emit ourselves to keep us alive
+    emitVertex( Pos : POSITION, Vel : TEXCOORD2, Timer : TEXCOORD0, Type : TEXCOORD1);
+}
+
+//
+// Shell type particle handler
+//	
+void GSShellHandler( float3 Pos, float3 Vel, float Timer, float Type,
+					float elapsedTime, 
+					float globalTime, 
+					sampler1D randomTex,
+					float3 frameGravity)
+{
+    if(Timer <= 0)
+    {
+        float3 outputPos;
+		float3 outputVel;
+		float outputTimer;
+		float outputType;
+		
+        float3 vRandom = float3(0,0,0);
+        
+        //time to emit a series of new Ember1s  
+        for(int i=0; i<NUM_EMBER_1S; i++)
+        {
+            vRandom = normalize( RandomDir( Type+i, globalTime, randomTex ) );
+            outputPos = Pos + Vel*elapsedTime;
+            outputVel = Vel + vRandom*15.0;
+            outputTimer = P_EMBER1LIFE;
+            outputType = PT_EMBER1;
+            emitVertex(outputPos : POSITION, outputTimer : TEXCOORD0, outputType : TEXCOORD1, outputVel : TEXCOORD2);
+        }
+        
+        //find out how many Ember2s to emit
+		//Not doing this because it causes a runtime error
+		//int numEmber2s = abs(vRandom.x)*MAX_EMBER_2S;
+        for(int i=0; i<NUM_EMBER_2S; i++)
+        {
+            vRandom = normalize( RandomDir( Type, globalTime, randomTex) );
+            outputPos = Pos + Vel*elapsedTime;
+            outputVel = Vel + vRandom*10.0;
+            outputTimer = P_EMBER2LIFE + 0.4*vRandom.x;
+            outputType = PT_EMBER2;
+            emitVertex(outputPos : POSITION, outputVel : TEXCOORD2, outputTimer : TEXCOORD0, outputType : TEXCOORD1);
+        }
+        
+    }
+    else
+    {
+        GSGenericHandler(Pos, Vel, Timer, Type, elapsedTime, frameGravity );
+    }
+}
+
+//
+// Ember1 and Ember3 type particle handler
+//
+void GSEmber1Handler( float3 Pos, float3 Vel, float Timer, float Type,
+						float elapsedTime, 
+						float3 frameGravity)
+{
+    if(Timer > 0)
+    {
+        GSGenericHandler(Pos, Vel, Timer, Type, elapsedTime, frameGravity );
+    }
+}
+
+//
+// Ember2 type particle handler
+//
+void GSEmber2Handler( float3 Pos, float3 Vel, float Timer, float Type,
+						float elapsedTime, 
+						float globalTime, 
+						sampler1D randomTex,
+						float3 frameGravity)
+{
+    if(Timer <= 0)
+    {
+		float3 outputPos;
+		float3 outputVel;
+		float outputTimer;
+		float outputType;
+    
+        //time to emit a series of new Ember3s  
+        for(int i=0; i<NUM_EMBER_3S; i++)
+        {
+            outputPos = Pos + Vel*elapsedTime;
+            outputVel = Vel + normalize( RandomDir( Type + i, globalTime, randomTex ) )*10.0;
+            outputTimer = P_EMBER3LIFE;
+            outputType = PT_EMBER3;
+            emitVertex(outputPos : POSITION, outputVel : TEXCOORD2, outputTimer : TEXCOORD0, outputType : TEXCOORD1);
+        }
+    }
+    else
+    {
+         GSGenericHandler(Pos, Vel, Timer, Type, elapsedTime, frameGravity );
+    }
+}
+
+struct FireworkData
+{
+	float4 	Pos 	: POSITION;
+	float 	Timer 	: TEXCOORD0;
+    float 	Type 	: TEXCOORD1;
+	float3	Velocity : TEXCOORD2;
+};
+
+//The vertex shader that prepares the fireworks for display
+FireworkData GenerateParticles_VS(
+    in float4 		inPos : POSITION,	
+	in float 		inTimer : TEXCOORD0,
+	in float 		inType : TEXCOORD1,
+	in float3 		inVelocity : TEXCOORD2
+	)
+{
+	FireworkData output;
+	output.Pos = inPos;
+	output.Timer = inTimer;
+	output.Type = inType;
+	output.Velocity = inVelocity;
+	
+	return output;
+}
+
+POINT
+POINT_OUT
+void GenerateParticles_GS(
+	AttribArray<float3> Pos : POSITION,
+	AttribArray<float> Timer : TEXCOORD0,
+	AttribArray<float> Type : TEXCOORD1,
+	AttribArray<float3> Vel : TEXCOORD2,
+	
+	uniform sampler1D randomTex : TEXUNIT0,
+	uniform float3 frameGravity,
+	uniform float globalTime,
+	uniform float elapsedTime,
+	uniform float secondsPerFirework
+	)
+{
+	if( Type[0] == PT_LAUNCHER )
+        GSLauncherHandler( Pos[0], Vel[0], Timer[0], Type[0], 
+							elapsedTime, globalTime, randomTex, secondsPerFirework);
+	else if ( Type[0] == PT_SHELL )
+        GSShellHandler( Pos[0], Vel[0], Timer[0], Type[0], 
+							elapsedTime, globalTime, randomTex, frameGravity);
+	else if ( Type[0] == PT_EMBER1 ||
+              Type[0] == PT_EMBER3 )
+       GSEmber1Handler( Pos[0], Vel[0], Timer[0], Type[0], 
+							elapsedTime, frameGravity);
+    else if( Type[0] == PT_EMBER2 )
+        GSEmber2Handler( Pos[0], Vel[0], Timer[0], Type[0], 
+							elapsedTime, globalTime, randomTex, frameGravity);
+}
+
+struct ColoredFirework
+{
+	float3 	pos : POSITION;
+    float4 	color : COLOR;
+	float	radius : TEXCOORD0;
+};
+
+//The vertex shader that prepares the fireworks for display
+ColoredFirework DisplayParticles_VS
+(
+    in float3 		inPos : POSITION,
+	in float 		inTimer : TEXCOORD0,
+	in float 		inType : TEXCOORD1,
+	in float3 		inVelocity : TEXCOORD2
+	
+
+    //uniform float4x4 worldViewProj
+)
+{
+	ColoredFirework output;
+    //
+    // Pass the point through
+    //
+    output.pos = inPos; //Multiply by world matrix?
+    output.radius = 1.5;
+    
+    //  
+    // calculate the color
+    //
+    if( inType == PT_LAUNCHER )
+    {
+        output.color = float4(1,0.1,0.1,1);
+        output.radius = 1.0;
+    }
+    else if( inType == PT_SHELL )
+    {
+        output.color = float4(0.1,1,1,1);
+        output.radius = 1.0;
+    }
+    else if( inType == PT_EMBER1 )
+    {
+        output.color = float4(1,1,0.1,1);
+        output.color *= (inTimer / P_EMBER1LIFE );
+    }
+    else if( inType == PT_EMBER2 )
+    {
+        output.color = float4(1,0.1,1,1);
+    }
+    else if( inType == PT_EMBER3 )
+    {
+        output.color = float4(1,0.1,0.1,1);
+        output.color *= (inTimer / P_EMBER3LIFE );
+    }
+    
+    return output;
+}
+
+//The geometry shader that prepares the fireworks for display
+POINT 
+TRIANGLE_OUT 
+void DisplayParticles_GS( AttribArray<float3> Pos : POSITION,
+							AttribArray<float4> Color : COLOR,
+							AttribArray<float> Radius : TEXCOORD0,
+							
+							uniform float4x4 inverseView,
+							uniform float4x4 worldViewProj)
+{
+	//float3 g_positions[4] = { float3( -1, 1, 0 ), float3( 1, 1, 0 ), float3( -1, -1, 0 ), float3( 1, -1, 0 ) };
+	float3 g_positions[4] = { float3( -1, 1, 0 ), float3( -1, -1, 0 ), float3( 1, 1, 0 ), float3( 1, -1, 0 ) };
+    float2 g_texcoords[4] = { float2(0,1), float2(1,1), float2(0,0), float2(1,0) };
+	
+	
+	//
+    // Emit two new triangles
+    //
+    for(int i=0; i<4; i++)
+    {
+		float3 position = -g_positions[i]*Radius[0];
+        position = mul( (float3x3)inverseView, position ) + Pos[0];
+        float4 outPos = mul( worldViewProj, float4(position,1.0) );
+        
+        emitVertex(outPos : POSITION, Color[0] : COLOR0, g_texcoords[i] : TEXCOORD0);
+    }
+    restartStrip();
+}
+
+//The pixels shaders that colors the fireworks
+float4 DisplayParticles_PS(	float2 iTexCoord : TEXCOORD0,
+							float4 iColor : COLOR0,
+							uniform sampler diffuseTex : register(s0)) : COLOR
+{
+	return tex2D(diffuseTex, iTexCoord) * iColor;
+	//return float4(iTexCoord.x, iTexCoord.y, 0, 1) + iColor * 0.01;
+	//return float4(iTexCoord.xy, 0, 1) * 0.3 + tex2D(diffuseTex, iTexCoord) * 0.7 + iColor * 0.01;
+}