ruby-ogre 0.0.1-x86-linux

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

@@ -0,0 +1,116 @@
+// Vertex program for fresnel reflections / refractions
+void main_vp(
+		float4 pos			: POSITION,
+		float4 normal		: NORMAL,
+		float2 tex			: TEXCOORD0,
+		
+		out float4 oPos		: POSITION,
+		out float3 noiseCoord : TEXCOORD0,
+		out float4 projectionCoord : TEXCOORD1,
+		out float3 oEyeDir : TEXCOORD2, 
+		out float3 oNormal : TEXCOORD3, 
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float3 eyePosition, // object space
+		uniform float timeVal,
+		uniform float scale,  // the amount to scale the noise texture by
+		uniform float scroll, // the amount by which to scroll the noise
+		uniform float noise  // the noise perturb as a factor of the  time
+		)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// Projective texture coordinates, adjust for mapping
+	float4x4 scalemat = float4x4(0.5,   0,   0, 0.5, 
+	                               0,-0.5,   0, 0.5,
+								   0,   0, 0.5, 0.5,
+								   0,   0,   0,   1);
+	projectionCoord = mul(scalemat, oPos);
+	// Noise map coords
+	noiseCoord.xy = (tex + (timeVal * scroll)) * scale;
+	noiseCoord.z = noise * timeVal;
+
+	oEyeDir = normalize(pos.xyz - eyePosition); 
+	oNormal = normal.rgb; 
+	
+}
+
+// Fragment program for distorting a texture using a 3D noise texture
+void main_fp(
+		float4 pos			: POSITION,
+    float3 noiseCoord			: TEXCOORD0,
+		float4 projectionCoord		: TEXCOORD1,
+		float3 eyeDir				: TEXCOORD2,
+		float3 normal				: TEXCOORD3,
+		
+		out float4 col		: COLOR,
+		
+		uniform float4 tintColour,
+		uniform float noiseScale, 
+		uniform float fresnelBias,
+		uniform float fresnelScale,
+		uniform float fresnelPower,
+		uniform sampler2D noiseMap : register(s0),
+		uniform sampler2D reflectMap : register(s1),
+		uniform sampler2D refractMap : register(s2)
+		)
+{
+	// Do the tex projection manually so we can distort _after_
+	float2 final = projectionCoord.xy / projectionCoord.w;
+
+	// Noise
+	float3 noiseNormal = (tex2D(noiseMap, (noiseCoord.xy / 5)).rgb - 0.5).rbg * noiseScale;
+	final += noiseNormal.xz;
+
+	// Fresnel
+	//normal = normalize(normal + noiseNormal.xz);
+	float fresnel = fresnelBias + fresnelScale * pow(1 + dot(eyeDir, normal), fresnelPower);
+
+	// Reflection / refraction
+	float4 reflectionColour = tex2D(reflectMap, final);
+	float4 refractionColour = tex2D(refractMap, final) + tintColour;
+
+	// Final colour
+	col = lerp(refractionColour, reflectionColour, fresnel);
+
+
+}
+
+
+// Old version to match ATI PS 1.3 implementation
+void main_vp_old(
+		float4 pos			: POSITION,
+		float4 normal		: NORMAL,
+		float2 tex			: TEXCOORD0,
+		
+		out float4 oPos		: POSITION,
+		out float fresnel   : COLOR,
+		out float3 noiseCoord : TEXCOORD0,
+		out float4 projectionCoord : TEXCOORD1,
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float3 eyePosition, // object space
+		uniform float fresnelBias,
+		uniform float fresnelScale,
+		uniform float fresnelPower,
+		uniform float timeVal,
+		uniform float scale,  // the amount to scale the noise texture by
+		uniform float scroll, // the amount by which to scroll the noise
+		uniform float noise  // the noise perturb as a factor of the  time
+		)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// Projective texture coordinates, adjust for mapping
+	float4x4 scalemat = float4x4(0.5,   0,   0, 0.5, 
+	                               0,-0.5,   0, 0.5,
+								   0,   0, 0.5, 0.5,
+								   0,   0,   0,   1);
+	projectionCoord = mul(scalemat, oPos);
+	// Noise map coords
+	noiseCoord.xy = (tex + (timeVal * scroll)) * scale;
+	noiseCoord.z = noise * timeVal;
+
+	// calc fresnel factor (reflection coefficient)
+	float3 eyeDir = normalize(pos.xyz - eyePosition);
+	fresnel = fresnelBias + fresnelScale * pow(1 + dot(eyeDir, normal), fresnelPower);
+	
+}

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

@@ -0,0 +1,40 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform vec4 tintColour;
+uniform float noiseScale;
+uniform float fresnelBias;
+uniform float fresnelScale;
+uniform float fresnelPower;
+uniform sampler2D noiseMap;
+uniform sampler2D reflectMap;
+uniform sampler2D refractMap;
+
+varying vec3 noiseCoord;
+varying vec4 projectionCoord;
+varying vec3 eyeDir;
+varying vec3 oNormal;
+
+// Fragment program for distorting a texture using a 3D noise texture
+void main()
+{
+	// Do the tex projection manually so we can distort _after_
+	vec2 final = projectionCoord.xy / projectionCoord.w;
+
+	// Noise
+	vec3 noiseNormal = (texture2D(noiseMap, (noiseCoord.xy / 5.0)).rgb - 0.5).rbg * noiseScale;
+	final += noiseNormal.xz;
+
+	// Fresnel
+	//normal = normalize(normal + noiseNormal.xz);
+	float fresnel = fresnelBias + fresnelScale * pow(1.0 + dot(eyeDir, oNormal), fresnelPower);
+
+	// Reflection / refraction
+	vec4 reflectionColour = texture2D(reflectMap, final);
+	vec4 refractionColour = texture2D(refractMap, final) + tintColour;
+
+	// Final colour
+	gl_FragColor = mix(refractionColour, reflectionColour, fresnel);
+}

data/deps/share/OGRE/media/materials/programs/Example_FresnelPS.asm

@@ -0,0 +1,72 @@
+ps.1.4
+  // conversion from Cg generated ARB_fragment_program to ps.1.4 by NFZ
+  // command line args: -profile arbfp1 -entry main_fp
+  // program main_fp
+  // c0 : distortionRange
+  // c1 : tintColour
+  // testure 0 : noiseMap
+  // texture 1 : reflectMap
+  // texture 2 : refractMap
+  // v0.x : fresnel 
+  // t0.xyz : noiseCoord
+  // t1.xyw : projectionCoord 
+
+def c2, 2, 1, 0, 0
+
+  // Cg:	distort.x = tex3D(noiseMap, noiseCoord).x;
+  // arbfp1:	TEX R0.x, fragment.texcoord[0], texture[0], 3D;
+  // sample noise map using noiseCoord in TEX unit 0 
+
+texld r0, t0.xyz
+
+  // get projected texture coordinates from TEX coord 1
+  // will be used in phase 2
+
+texcrd r1.xy, t1_dw.xyw
+mov r1.z, c2.y
+
+  // Cg:	distort.y = tex3D(noiseMap, noiseCoord + yoffset).x;
+  // arbfp1:	ADD R1.xyz, fragment.texcoord[0], c1;
+  // arbfp1:	TEX R1.x, R1, texture[0], 3D;
+  // arbfp1:	MOV R0.y, R1.x;
+
+  // Cg:	distort = (distort * 2 - 1) * distortionRange;
+  // arbfp1:	MAD R0.xy, R0, c0.x, -c0.y;
+  // arbfp1:	MUL R0.xy, R0, u0.x;
+  // (distort * 2 - 1) same as 2*(distort -.5) so use _bx2
+
+
+  // Cg:	final = projectionCoord.xy / projectionCoord.w;
+  // Cg:	final += distort;
+  // arbfp1:	RCP R0.w, fragment.texcoord[1].w;
+  // arbfp1:	MAD R0.xy, fragment.texcoord[1], R0.w, R0;
+  // 	final = (distort *  projectionCoord.w) + projectionCoord.xy
+  // for ps.1.4 have to re-arrange things a bit to perturb projected texture coordinates
+
+mad r0.xyz, r0_bx2, c0.x, r1
+
+phase
+
+  // do dependent texture reads
+  // Cg:	reflectionColour = tex2D(reflectMap, final);
+  // arbfp1:	TEX R0, R0, texture[1], 2D;
+  // sampe reflectMap using dependent read : texunit 1 
+
+texld r1, r0.xyz
+
+  // Cg:	refractionColour = tex2D(refractMap, final) + tintColour;
+  // arbfp1:	TEX R1, R0, texture[2], 2D;
+  // sample refractMap : texunit 2 
+
+texld r2, r0.xyz
+
+  // adding tintColour that is in global c1
+  // arbfp1:	ADD R1, R1, u1;
+
+add r2, r2, c1
+
+  // Cg:	col = lerp(refractionColour, reflectionColour, fresnel);
+  // arbfp1:	ADD R0, R0, -R1;
+  // arbfp1:	MAD result.color, fragment.color.primary.x, R0, R1;
+
+lrp r0, v0.x, r1, r2

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

@@ -0,0 +1,39 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+attribute vec4 uv0;
+attribute vec4 position;
+attribute vec3 normal;
+
+uniform mat4 worldViewProjMatrix;
+uniform vec3 eyePosition; // object space
+uniform float timeVal;
+uniform float scale;  // the amount to scale the noise texture by
+uniform float scroll; // the amount by which to scroll the noise
+uniform float noise;  // the noise perturb as a factor of the time
+
+varying vec3 noiseCoord;
+varying vec4 projectionCoord;
+varying vec3 eyeDir;
+varying vec3 oNormal;
+
+// Vertex program for fresnel reflections / refractions
+void main()
+{
+	gl_Position = worldViewProjMatrix * position;
+	// Projective texture coordinates, adjust for mapping
+	mat4 scalemat = mat4(0.5, 0.0, 0.0, 0.0, 
+                         0.0, -0.5, 0.0, 0.0,
+                         0.0, 0.0, 0.5, 0.0,
+                         0.5, 0.5, 0.5, 1.0);
+	projectionCoord = scalemat * gl_Position;
+
+	// Noise map coords
+	noiseCoord.xy = (uv0.xy + (timeVal * scroll)) * scale;
+	noiseCoord.z = noise * timeVal;
+
+	eyeDir = normalize(position.xyz - eyePosition); 
+	oNormal = normal.rgb;
+}

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

@@ -0,0 +1,28 @@
+
+void generalPurposeProjection_vp(
+		float4 pos			: POSITION,
+		
+		out float4 oPos		: POSITION,
+		out float4 texCoord : TEXCOORD0,
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float4x4 worldMatrix,
+		uniform float4x4 texViewProjMatrix)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// multiply position by world matrix, then by projective view/proj
+	float4 newpos = mul(worldMatrix, pos);
+	texCoord = mul(texViewProjMatrix, newpos);
+	
+}
+
+void generalPurposeProjection_fp(
+		float4 texCoord		: TEXCOORD0,
+		out float4 col		: COLOR,
+		uniform sampler2D texMap)
+{
+	col = tex2Dproj(texMap, texCoord);
+
+}
+		
+

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

@@ -0,0 +1,56 @@
+
+void generalPurposeProjection_vp(
+		float4 pos			: POSITION,
+		
+		out float4 oPos		: POSITION,
+		out float4 texCoord : TEXCOORD0,
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float4x4 worldMatrix,
+		uniform float4x4 texViewProjMatrix)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// multiply position by world matrix, then by projective view/proj
+	float4 newpos = mul(worldMatrix, pos);
+	texCoord = mul(texViewProjMatrix, newpos);
+	
+}
+
+void generalPurposeProjection_fp(
+		float4 texCoord		: TEXCOORD0,
+		out float4 col		: COLOR,
+		uniform sampler2D texMap)
+{
+	col = tex2Dproj(texMap, texCoord);
+
+}
+		
+
+
+void generalPurposeProjection_vp(
+		float4 pos			: POSITION,
+		
+		out float4 oPos		: POSITION,
+		out float4 texCoord : TEXCOORD0,
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float4x4 worldMatrix,
+		uniform float4x4 texViewProjMatrix)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// multiply position by world matrix, then by projective view/proj
+	float4 newpos = mul(worldMatrix, pos);
+	texCoord = mul(texViewProjMatrix, newpos);
+	
+}
+
+void generalPurposeProjection_fp(
+		float4 texCoord		: TEXCOORD0,
+		out float4 col		: COLOR,
+		uniform sampler2D texMap)
+{
+	col = tex2Dproj(texMap, texCoord);
+
+}
+		
+

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

@@ -0,0 +1,26 @@
+
+void generalPurposeProjection_vp(
+		float4 pos			: POSITION,
+		
+		out float4 oPos		: POSITION,
+		out float4 texCoord : TEXCOORD0,
+
+		uniform float4x4 worldViewProjMatrix,
+		uniform float4x4 worldMatrix,
+		uniform float4x4 texViewProjMatrix)
+{
+	oPos = mul(worldViewProjMatrix, pos);
+	// multiply position by world matrix, then by projective view/proj
+	float4 newpos = mul(worldMatrix, pos);
+	texCoord = mul(texViewProjMatrix, newpos);
+}
+
+void generalPurposeProjection_fp(
+		float4 texCoord		: TEXCOORD0,
+		out float4 col		: COLOR,
+		uniform sampler2D texMap)
+{
+	col = tex2Dproj(texMap, texCoord);
+}
+		
+

data/deps/share/OGRE/media/materials/programs/Example_TextureArrayPS.asm

@@ -0,0 +1,10 @@
+!!NVfp4.0                                        
+TEMP texcoord, c0, c1, frac;                     
+MOV texcoord, fragment.texcoord[0];              
+FLR texcoord.z, texcoord;                        
+TEX c0, texcoord, texture[0], ARRAY2D;           
+ADD texcoord.z, texcoord, { 0, 0, 1, 0 };        
+TEX c1, texcoord, texture[0], ARRAY2D;           
+FRC frac.x, fragment.texcoord[0].z;              
+LRP result.color, frac.x, c1, c0;                
+END

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

@@ -0,0 +1,17 @@
+#version 120
+#extension GL_EXT_texture_array : enable
+
+uniform sampler2DArray TextureArrayTex;
+varying vec3 oUv;
+
+void main(void)
+{
+	vec3 texcoord;
+	texcoord = oUv;
+	texcoord.z = floor(texcoord.z);
+    vec4 c0 = texture2DArray(TextureArrayTex, texcoord);
+	texcoord.z += 1.0;
+    vec4 c1 = texture2DArray(TextureArrayTex, texcoord);
+
+	gl_FragColor = mix(c0, c1, fract(oUv.z));
+}

data/deps/share/OGRE/media/materials/programs/Example_TextureArrayPS.hlsl4

@@ -0,0 +1,33 @@
+
+Texture2DArray g_txTextures    : TextureArray;
+
+//--------------------------------------------------------------------------------------
+
+SamplerState g_samAniso
+{
+    Filter = ANISOTROPIC;
+    AddressU = Wrap;
+    AddressV = Wrap;
+};
+
+//--------------------------------------------------------------------------------------
+
+struct VS_OUTPUT {
+    float4 Position : SV_Position;
+    float3 TextureUV : TEXCOORD0;
+};
+
+//--------------------------------------------------------------------------------------
+
+float4 textureArray_p ( VS_OUTPUT In ) : SV_Target
+{
+	int numberOfTextures = 20;
+	float3 texcoord;
+	texcoord = In.TextureUV;
+	texcoord.z = floor(texcoord.z);
+    float4 c0 = g_txTextures.Sample(g_samAniso, texcoord);
+	texcoord.z += 1;
+    float4 c1 = g_txTextures.Sample(g_samAniso, texcoord);
+
+	return lerp(c0, c1, frac(In.TextureUV.z));
+}

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

@@ -0,0 +1,14 @@
+
+
+void textureArray_v(float4 position : POSITION,
+						  float3 uv		  : TEXCOORD0,
+						  
+						  out float4 oPosition : POSITION,
+						  out float3 oUv	   : TEXCOORD0,
+
+						  uniform float4x4 worldViewProj)
+{
+	oPosition = mul(worldViewProj, position);
+	oUv = uv;
+}
+

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

@@ -0,0 +1,11 @@
+#version 120
+
+varying vec3 oUv;
+
+uniform mat4 worldViewProj;
+
+void main(void)
+{
+	gl_Position = worldViewProj * gl_Vertex;
+	oUv = gl_MultiTexCoord0.xyz;
+}

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

@@ -0,0 +1,9 @@
+sampler2D RT : register(s0);
+sampler2D NormalMap : register(s1);
+
+float4 main_ps(float4 pos : POSITION, float2 iTexCoord : TEXCOORD0) : COLOR
+{
+	float4 normal = 2 * (tex2D(NormalMap, iTexCoord * 2.5) - 0.5);
+
+	return tex2D(RT, iTexCoord + normal.xy * 0.05);
+}

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

@@ -0,0 +1,15 @@
+#version 100
+
+precision mediump int;
+precision mediump float;
+
+uniform sampler2D RT;
+uniform sampler2D NormalMap;
+varying vec2 uv;
+
+void main()
+{
+	vec4 normal = 2.0 * (texture2D(NormalMap, uv * 2.5) - 0.5);
+
+	gl_FragColor = texture2D(RT, uv + normal.xy * 0.05);
+}