ruby-ogre 0.0.1-x86-linux

data/deps/share/OGRE/media/materials/programs/ShaderInstancing.vert

@@ -0,0 +1,117 @@
+//---------------------------------------------------------------------------
+//These materials/shaders are part of the NEW InstanceManager implementation
+//Written by Matias N. Goldberg ("dark_sylinc")
+//---------------------------------------------------------------------------
+#version 120
+
+//Vertex input
+attribute vec4 vertex;
+attribute vec3 normal;
+attribute vec3 tangent;
+attribute vec4 uv0;
+attribute vec4 blendIndices;
+attribute vec4 blendWeights;
+
+//Parameters
+uniform mat4 viewProjMatrix;
+//uniform mat4x3 worldMatrix3x4Array[80];
+#ifdef ST_DUAL_QUATERNION
+uniform vec4 worldDualQuaternion2x4Array[240];
+#else
+uniform vec4 worldMatrix3x4Array[240]; //240 = 80*3
+#endif
+
+
+#if (DEPTH_SHADOWCASTER || DEPTH_SHADOWRECEIVER)
+uniform vec4 depthRange;
+#endif
+
+#if DEPTH_SHADOWRECEIVER
+uniform mat4 texViewProjMatrix;
+#endif
+
+//Output
+#if DEPTH_SHADOWCASTER
+	varying vec2 depth;
+#else
+	varying vec2 _uv0;
+	varying vec3 oNormal;
+	varying vec3 oVPos;
+	#if DEPTH_SHADOWRECEIVER
+		varying vec4 oLightSpacePos;
+	#endif
+#endif
+
+vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ)
+{
+	vec3 blendPosition = position + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, position) + blendDQ[0].x*position);
+	vec3 trans = 2.0*(blendDQ[0].x*blendDQ[1].yzw - blendDQ[1].x*blendDQ[0].yzw + cross(blendDQ[0].yzw, blendDQ[1].yzw));
+	blendPosition += trans;
+
+	return blendPosition;
+}
+
+vec3 calculateBlendNormal(vec3 normal, mat2x4 blendDQ)
+{
+	return normal + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, normal) + blendDQ[0].x*normal);
+}
+
+//---------------------------------------------
+//Main Vertex Shader
+//---------------------------------------------
+void main(void)
+{
+vec4 worldPos;
+vec3 worldNorm;
+
+#ifdef ST_DUAL_QUATERNION
+	int idx = int(blendIndices[0]) * 2;
+	mat2x4 blendDQ;
+	blendDQ[0] = worldDualQuaternion2x4Array[idx];
+	blendDQ[1] = worldDualQuaternion2x4Array[idx + 1];
+#ifdef BONE_TWO_WEIGHTS
+	int idx2 = int(blendIndices[1]) * 2;
+	mat2x4 blendDQ2;
+ 	blendDQ2[0] = worldDualQuaternion2x4Array[idx2];
+	blendDQ2[1] = worldDualQuaternion2x4Array[idx2 + 1];
+
+	//Accurate antipodality handling. For speed increase, remove the following line
+	if (dot(blendDQ[0], blendDQ2[0]) < 0.0) blendDQ2 *= -1.0;
+	
+	//Blend the dual quaternions based on the weights
+	blendDQ *= blendWeights.x;
+	blendDQ += blendWeights.y*blendDQ2;
+	//Normalize the resultant dual quaternion
+	blendDQ /= length(blendDQ[0]);
+#endif
+	worldPos = vec4(calculateBlendPosition(vertex.xyz, blendDQ), 1.0);
+	worldNorm = calculateBlendNormal(normal, blendDQ);
+#else
+	mat4 worldMatrix;
+	int idx = int(blendIndices[0]) * 3;
+	worldMatrix[0] = worldMatrix3x4Array[idx];
+	worldMatrix[1] = worldMatrix3x4Array[idx + 1];
+	worldMatrix[2] = worldMatrix3x4Array[idx + 2];
+	worldMatrix[3] = vec4( 0, 0, 0, 1 );
+
+	worldPos		= vertex * worldMatrix;
+	worldNorm		= normal * mat3(worldMatrix);
+#endif
+
+	//Transform the position
+	gl_Position			= viewProjMatrix * worldPos;
+
+#if DEPTH_SHADOWCASTER
+	depth.x				= (gl_Position.z - depthRange.x) * depthRange.w;
+	depth.y				= depthRange.w;
+#else
+	_uv0		= uv0.xy;
+	oNormal		= worldNorm;
+	oVPos		= worldPos.xyz;
+
+	#if DEPTH_SHADOWRECEIVER
+		oLightSpacePos		= texViewProjMatrix * worldPos;
+		oLightSpacePos.z	= (oLightSpacePos.z - depthRange.x) * depthRange.w;
+	#endif
+#endif
+}

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

@@ -0,0 +1,23 @@
+sampler2D RT: register(s0);
+
+float4 sharpenEdges_fp( float4 pos : POSITION, float2 iTexCoord: TEXCOORD0, uniform float2 vTexelSize) : COLOR
+{
+
+	float2 usedTexelED[8] = {
+		-1, -1,
+		 0, -1,
+		 1, -1,
+		-1,  0,
+		 1,  0,
+		-1,  1,
+		 0,  1,
+	     1,  1,
+	};
+
+	float4 cAvgColor= 9 * tex2D (RT, iTexCoord);
+
+	for(int t=0; t<8; t++)
+		cAvgColor -= tex2D(RT, iTexCoord + vTexelSize * usedTexelED[t]);
+
+	return cAvgColor;
+}

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

@@ -0,0 +1,31 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform sampler2D RT;
+
+uniform vec2 vTexelSize;
+varying vec2 uv0;
+varying vec2 uv1;
+
+void main()
+{
+	vec2 usedTexelED[8];
+	usedTexelED[0] = vec2(-1, -1);
+	usedTexelED[1] = vec2(0, -1);
+	usedTexelED[2] = vec2(1, -1);
+	usedTexelED[3] = vec2(-1,  0);
+	usedTexelED[4] = vec2(1,  0);
+	usedTexelED[5] = vec2(-1,  1);
+	usedTexelED[6] = vec2(0,  1);
+	usedTexelED[7] = vec2(1,  1);
+
+    mediump vec4 tc = texture2D(RT, uv0);
+	vec4 cAvgColor = vec4(9.0 * tc);
+
+	for(int t=0; t<8; t++)
+		cAvgColor -= texture2D(RT, uv0 + vTexelSize * usedTexelED[t]);
+
+	gl_FragColor = cAvgColor;
+}

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

@@ -0,0 +1,16 @@
+#version 100
+precision mediump int;
+precision mediump float;
+
+attribute vec4 position;
+attribute vec3 normal;
+
+varying vec4 oUv0;
+
+uniform mat4 worldViewProj;
+
+void main()
+{
+	gl_Position = worldViewProj * position;
+	oUv0 = vec4(normal, 1.0);
+}

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

@@ -0,0 +1,16 @@
+#version 100
+precision mediump int;
+precision mediump float;
+
+attribute vec4 position;
+attribute vec3 tangent;
+
+varying vec4 oUv0;
+
+uniform mat4 worldViewProj;
+
+void main()
+{
+	gl_Position = worldViewProj * position;
+	oUv0 = vec4(tangent, 1.0);
+}

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

@@ -0,0 +1,12 @@
+#version 100
+precision mediump int;
+precision mediump float;
+
+varying vec2 ambientUV;
+
+// Basic fragment program to display UV
+void main()
+{
+	// wrap values using fract
+	gl_FragColor = vec4(fract(ambientUV.x), fract(ambientUV.y), 0.0, 1.0);
+}

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

@@ -0,0 +1,14 @@
+#version 100
+precision mediump int;
+precision mediump float;
+
+varying vec4 oUv0;
+
+// Basic fragment program to display 3d uv
+void main()
+{
+	vec3 n = normalize(oUv0.xyz);
+	gl_FragColor = vec4(n.x, n.y, n.z, 1.0);
+}
+
+

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

@@ -0,0 +1,23 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform mat4 worldViewProj;
+attribute vec4 vertex;
+varying vec2 uv0;
+varying vec2 uv1;
+varying vec4 pos;
+
+void main()
+{
+	// Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    gl_Position = worldViewProj * vertex;
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+	vec2 inPos = sign(vertex.xy);
+
+    // Convert to image-space
+    uv0 = (vec2(inPos.x, -inPos.y) + 1.0) * 0.5;
+    uv1 = uv0;
+}

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

@@ -0,0 +1,23 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform mat4 worldViewProj;
+attribute vec4 vertex;
+varying vec2 uv0;
+varying vec2 uv1;
+varying vec4 pos;
+
+void main()
+{
+	// Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    gl_Position = worldViewProj * vertex;
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+	vec2 inPos = sign(vertex.xy);
+
+    // Convert to image-space
+    uv0 = (vec2(inPos.x, -inPos.y) + 1.0) * 0.5;
+    uv1 = inPos.xy;
+}

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

@@ -0,0 +1,25 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform mat4 worldViewProj;
+attribute vec4 vertex;
+varying vec2 uv0;
+varying vec2 uv1;
+varying vec2 uv2;
+varying vec4 pos;
+
+void main()
+{
+	// Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    gl_Position = worldViewProj * vertex;
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+	vec2 inPos = sign(vertex.xy);
+
+    // Convert to image-space
+    uv0 = (vec2(inPos.x, -inPos.y) + 1.0) * 0.5;
+    uv1 = uv0;
+    uv2 = uv0;
+}

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

@@ -0,0 +1,27 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform mat4 worldViewProj;
+attribute vec4 vertex;
+varying vec2 uv0;
+varying vec2 uv1;
+varying vec2 uv2;
+varying vec2 uv3;
+varying vec4 pos;
+
+void main()
+{
+	// Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    gl_Position = worldViewProj * vertex;
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+	vec2 inPos = sign(vertex.xy);
+
+    // Convert to image-space
+    uv0 = (vec2(inPos.x, -inPos.y) + 1.0) * 0.5;
+    uv1 = uv0;
+    uv2 = uv0;
+    uv3 = uv0;
+}

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

@@ -0,0 +1,113 @@
+void StdQuad_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+
+    uniform float4x4 worldViewProj
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+}
+
+void StdQuad_Tex2_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+    out float2 uv1 : TEXCOORD1,
+
+    uniform float4x4 worldViewProj
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+    uv1 = uv0;
+}
+
+void StdQuad_Tex2a_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+    out float2 uv1 : TEXCOORD1,
+
+    uniform float4x4 worldViewProj
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+    uv1 = inPos.xy;
+}
+
+void StdQuad_Tex3_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+    out float2 uv1 : TEXCOORD1,
+    out float2 uv2 : TEXCOORD2,
+
+    uniform float4x4 worldViewProj
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+    uv1 = uv0;
+    uv2 = uv0;
+}
+
+void StdQuad_Tex4_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+    out float2 uv1 : TEXCOORD1,
+    out float2 uv2 : TEXCOORD2,
+    out float2 uv3 : TEXCOORD3,
+
+    uniform float4x4 worldViewProj
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+    uv1 = uv0;
+    uv2 = uv0;
+    uv3 = uv0;
+}

data/deps/share/OGRE/media/materials/programs/StdQuad_vp.glsl

@@ -0,0 +1,11 @@
+varying vec2 uv;
+
+void main()                    
+{
+	gl_Position = ftransform();
+	
+	vec2 inPos = sign(gl_Vertex.xy);
+	
+	uv = (vec2(inPos.x, -inPos.y) + 1.0)/2.0;
+}
+

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

@@ -0,0 +1,17 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform mat4 worldViewProj;
+attribute vec4 vertex;
+varying vec2 uv;
+
+void main()
+{
+    gl_Position = worldViewProj * vertex;
+  	
+	vec2 inPos = sign(vertex.xy);
+	
+	uv = (vec2(inPos.x, -inPos.y) + 1.0) / 2.0;
+}

data/deps/share/OGRE/media/materials/programs/StdQuad_vp.hlsl

@@ -0,0 +1,20 @@
+void StdQuad_vp
+(
+    in float4 inPos : POSITION,
+
+    out float4 pos : POSITION,
+    out float2 uv0 : TEXCOORD0,
+
+    uniform float4x4 worldViewProj
+)
+{
+    // Use standardise transform, so work accord with render system specific (RS depth, requires texture flipping, etc)
+    pos = mul(worldViewProj, inPos);
+
+    // The input positions adjusted by texel offsets, so clean up inaccuracies
+    inPos.xy = sign(inPos.xy);
+
+    // Convert to image-space
+    uv0 = (float2(inPos.x, -inPos.y) + 1.0f) * 0.5f;
+}
+

data/deps/share/OGRE/media/materials/programs/Swizzle.gp

@@ -0,0 +1,39 @@
+!!NVgp4.0
+PRIMITIVE_IN TRIANGLES;
+PRIMITIVE_OUT TRIANGLE_STRIP;
+VERTICES_OUT 6;
+# cgc version 2.0.0015, build date May 15 2008
+# command line args: -profile gpu_gp
+# source file: gs_simple.cg
+#vendor NVIDIA Corporation
+#version 2.0.0.15
+#profile gpu_gp
+#program geometry_swizzle
+#semantic geometry_swizzle.position : POSITION
+#var float4 position.__data[0] : $vin.VERTEX[0].POSITION : HPOS[0][32] : 0 : 1
+#var float4 position.__data[1] : $vin.VERTEX[1].POSITION : HPOS[1][32] : 0 : 1
+#var float4 position.__data[2] : $vin.VERTEX[2].POSITION : HPOS[2][32] : 0 : 1
+ATTRIB vertex_position = vertex.position;
+TEMP RC, HC;
+MOV.F result.position, vertex[0].position;
+MOV.F result.color, {1, 0}.xyyx;
+EMIT;
+MOV.F result.position, vertex[1].position;
+MOV.F result.color, {1, 0}.xyyx;
+EMIT;
+MOV.F result.position, vertex[2].position;
+MOV.F result.color, {1, 0}.xyyx;
+EMIT;
+ENDPRIM;
+MOV.F result.position, vertex[0].position.yxzw;
+MOV.F result.color, {0, 1}.xxyy;
+EMIT;
+MOV.F result.position, vertex[1].position.yxzw;
+MOV.F result.color, {0, 1}.xxyy;
+EMIT;
+MOV.F result.position, vertex[2].position.yxzw;
+MOV.F result.color, {0, 1}.xxyy;
+EMIT;
+ENDPRIM;
+END
+# 20 instructions, 0 R-regs

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

@@ -0,0 +1,14 @@
+// Geometry pass-through program for colored triangles
+TRIANGLE void gs_swizzle(AttribArray<float4> position : POSITION)
+{
+  for (int i=0; i<position.length; i++) {
+    emitVertex(position[i], float4(1,0.9,0.8,0.7):COLOR0);
+  }
+  restartStrip();
+  for (int i=0; i<position.length; i++) {
+    float4 newPosition = position[i].yxzw;
+	newPosition.z += 20;
+	emitVertex(newPosition:POSITION, float4(0.3,0.4,0.5,0.6):COLOR0);
+  }
+  restartStrip();
+}

data/deps/share/OGRE/media/materials/programs/SwizzleGP.glsl

@@ -0,0 +1,40 @@
+#version 120																				
+#extension GL_EXT_geometry_shader4 : enable													
+
+uniform vec4 origColor;																		
+uniform vec4 cloneColor;																	
+
+void main(void)																				
+{																							
+
+	//increment variable																	
+	int i;																					
+
+	/////////////////////////////////////////////////////////////							
+	//This example has two parts															
+	//	step a) draw the primitive pushed down the pipeline									
+	//		 there are gl_Vertices # of vertices											
+	//		 put the vertex value into gl_Position											
+	//		 use EmitVertex => 'create' a new vertex										
+	// 		use EndPrimitive to signal that you are done creating a primitive!				
+	//	step b) create a new piece of geometry (I.E. WHY WE ARE USING A GEOMETRY SHADER!)	
+	//		I just do the same loop, but swizzle the x and y values							
+	//	result => the line we want to draw, and the same line, but along the other axis		
+
+	//Pass-thru!																			
+	for(i=0; i< gl_VerticesIn; i++){														
+		gl_Position = gl_PositionIn[i];														
+		gl_FrontColor = origColor;															
+		EmitVertex();																		
+	}																						
+	EndPrimitive();																			
+	//New piece of geometry!  We just swizzle the x and y terms								
+	for(i=0; i< gl_VerticesIn; i++){														
+		gl_Position = gl_PositionIn[i];														
+		gl_Position.xy = gl_Position.yx;													
+		gl_FrontColor = cloneColor;															
+		EmitVertex();																		
+	}																						
+	EndPrimitive();																			
+
+}

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

@@ -0,0 +1,80 @@
+#version 120																				
+#extension GL_EXT_geometry_shader4 : enable													
+
+uniform vec4 origColor;																		
+uniform vec4 cloneColor;																	
+
+void main(void)																				
+{																							
+
+	//increment variable																	
+	int i;																					
+
+	/////////////////////////////////////////////////////////////							
+	//This example has two parts															
+	//	step a) draw the primitive pushed down the pipeline									
+	//		 there are gl_Vertices # of vertices											
+	//		 put the vertex value into gl_Position											
+	//		 use EmitVertex => 'create' a new vertex										
+	// 		use EndPrimitive to signal that you are done creating a primitive!				
+	//	step b) create a new piece of geometry (I.E. WHY WE ARE USING A GEOMETRY SHADER!)	
+	//		I just do the same loop, but swizzle the x and y values							
+	//	result => the line we want to draw, and the same line, but along the other axis		
+
+	//Pass-thru!																			
+	for(i=0; i< gl_VerticesIn; i++){														
+		gl_Position = gl_PositionIn[i];														
+		gl_FrontColor = origColor;															
+		EmitVertex();																		
+	}																						
+	EndPrimitive();																			
+	//New piece of geometry!  We just swizzle the x and y terms								
+	for(i=0; i< gl_VerticesIn; i++){														
+		gl_Position = gl_PositionIn[i];														
+		gl_Position.xy = gl_Position.yx;													
+		gl_FrontColor = cloneColor;															
+		EmitVertex();																		
+	}																						
+	EndPrimitive();																			
+
+}
+#version 120																				
+#extension GL_EXT_geometry_shader4 : enable													
+
+uniform vec4 origColor;																		
+uniform vec4 cloneColor;																	
+
+void main(void)																				
+{																							
+
+	//increment variable																	
+	int i;																					
+
+	/////////////////////////////////////////////////////////////							
+	//This example has two parts															
+	//	step a) draw the primitive pushed down the pipeline									
+	//		 there are gl_Vertices # of vertices											
+	//		 put the vertex value into gl_Position											
+	//		 use EmitVertex => 'create' a new vertex										
+	// 		use EndPrimitive to signal that you are done creating a primitive!				
+	//	step b) create a new piece of geometry (I.E. WHY WE ARE USING A GEOMETRY SHADER!)	
+	//		I just do the same loop, but swizzle the x and y values							
+	//	result => the line we want to draw, and the same line, but along the other axis		
+
+	//Pass-thru!																			
+	for(i=0; i< gl_VerticesIn; i++){														
+		gl_Position = gl_PositionIn[i];														
+		gl_FrontColor = origColor;															
+		EmitVertex();																		
+	}																						
+	EndPrimitive();																			
+	//New piece of geometry!  We just swizzle the x and y terms								
+	for(i=0; i< gl_VerticesIn; i++){														
+		gl_Position = gl_PositionIn[i];														
+		gl_Position.xy = gl_Position.yx;													
+		gl_FrontColor = cloneColor;															
+		EmitVertex();																		
+	}																						
+	EndPrimitive();																			
+
+}