ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/share/OGRE/media/materials/programs/Ocean2HLSL_Cg.frag

@@ -1,85 +0,0 @@
-/*********************************************************************NVMH3****
-Copyright NVIDIA Corporation 2003
-TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
-*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
-BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
-WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
-BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
-ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
-BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-
-Comments:
-	Simple ocean shader with animated bump map and geometric waves
-	Based partly on "Effective Water Simulation From Physical Models", GPU Gems
-
-11 Aug 05: heavily modified by Jeff Doyle (nfz) for Ogre
-
-******************************************************************************/
-
-
-
-struct v2f {
-	float4 Position  : POSITION;  // in clip space
-	float3 rotMatrix1 : TEXCOORD0; // first row of the 3x3 transform from tangent to obj space
-	float3 rotMatrix2 : TEXCOORD1; // second row of the 3x3 transform from tangent to obj space
-	float3 rotMatrix3 : TEXCOORD2; // third row of the 3x3 transform from tangent to obj space
-
-	float2 bumpCoord0 : TEXCOORD3;
-	float2 bumpCoord1 : TEXCOORD4;
-	float2 bumpCoord2 : TEXCOORD5;
-
-	float3 eyeVector  : TEXCOORD6;
-};
-
-
-float4 main(v2f IN,
-			uniform sampler2D NormalMap,
-			uniform samplerCUBE EnvironmentMap,
-			uniform float4 deepColor,
-			uniform float4 shallowColor,
-			uniform float4 reflectionColor,
-			uniform float reflectionAmount,
-			uniform float reflectionBlur,
-			uniform float waterAmount,
-			uniform float fresnelPower,
-			uniform float fresnelBias,
-			uniform float hdrMultiplier
-			) : COLOR
-{
-	// sum normal maps
-	// sample from 3 different points so no texture repetition is noticeable
-    float4 t0 = tex2D(NormalMap, IN.bumpCoord0) * 2.0 - 1.0;
-    float4 t1 = tex2D(NormalMap, IN.bumpCoord1) * 2.0 - 1.0;
-    float4 t2 = tex2D(NormalMap, IN.bumpCoord2) * 2.0 - 1.0;
-    float3 N = t0.xyz + t1.xyz + t2.xyz;
-
-    float3x3 m; // tangent to world matrix
-    m[0] = IN.rotMatrix1;
-    m[1] = IN.rotMatrix2;
-    m[2] = IN.rotMatrix3;
-
-    N = normalize( mul( N, m ) );
-
-	// reflection
-    float3 E = normalize(IN.eyeVector);
-    float4 R;
-    R.xyz = reflect(E, N);
-    // Ogre conversion for cube map lookup
-    R.z = -R.z;
-    R.w = reflectionBlur;
-    float4 reflection = texCUBEbias(EnvironmentMap, R);
-    // cheap hdr effect
-    reflection.rgb *= (reflection.r + reflection.g + reflection.b) * hdrMultiplier;
-
-	// fresnel
-    float facing = 1.0 - max(dot(-E, N), 0);
-    float fresnel = saturate(fresnelBias + pow(facing, fresnelPower));
-
-    float4 waterColor = lerp(shallowColor, deepColor, facing) * waterAmount;
-
-    reflection = lerp(waterColor,  reflection * reflectionColor, fresnel) * reflectionAmount;
-    return waterColor + reflection;
-}

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

@@ -1,108 +0,0 @@
-/*********************************************************************NVMH3****
-Copyright NVIDIA Corporation 2003
-TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
-*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
-BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
-WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
-BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS)
-ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS
-BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
-
-Comments:
-	Simple ocean shader with animated bump map and geometric waves
-	Based partly on "Effective Water Simulation From Physical Models", GPU Gems
-
-11 Aug 05: heavily modified by Jeff Doyle (nfz) for Ogre
-
-******************************************************************************/
-
-struct a2v {
-	float4 Position : POSITION;   // in object space
-	float2 TexCoord : TEXCOORD0;
-};
-
-struct v2f {
-	float4 Position  : POSITION;  // in clip space
-	float3 rotMatrix1 : TEXCOORD0; // first row of the 3x3 transform from tangent to obj space
-	float3 rotMatrix2 : TEXCOORD1; // second row of the 3x3 transform from tangent to obj space
-	float3 rotMatrix3 : TEXCOORD2; // third row of the 3x3 transform from tangent to obj space
-
-	float2 bumpCoord0 : TEXCOORD3;
-	float2 bumpCoord1 : TEXCOORD4;
-	float2 bumpCoord2 : TEXCOORD5;
-
-	float3 eyeVector  : TEXCOORD6;
-};
-
-// wave functions
-
-struct Wave {
-  float freq;  // 2*PI / wavelength
-  float amp;   // amplitude
-  float phase; // speed * 2*PI / wavelength
-  float2 dir;
-};
-
-v2f main(a2v IN,
-		uniform float4x4 WorldViewProj,
-		uniform float3 eyePosition,
-		uniform float BumpScale,
-		uniform float2 textureScale,
-		uniform float2 bumpSpeed,
-		uniform float time,
-		uniform float waveFreq,
-		uniform float waveAmp
-        )
-{
-	v2f OUT;
-
-	#define NWAVES 2
-	Wave wave[NWAVES] = {
-		{ 1.0, 1.0, 0.5, float2(-1, 0) },
-		{ 2.0, 0.5, 1.7, float2(-0.7, 0.7) }
-	};
-
-    wave[0].freq = waveFreq;
-    wave[0].amp = waveAmp;
-
-    wave[1].freq = waveFreq * 3.0;
-    wave[1].amp = waveAmp * 0.33;
-
-    float4 P = IN.Position;
-
-	// sum waves
-	float ddx = 0.0, ddy = 0.0;
-	float deriv;
-	float angle;
-
-	// wave synthesis using two sine waves at different frequencies and phase shift
-	for(int i = 0; i<NWAVES; ++i)
-	{
-		angle = dot(wave[i].dir, P.xz) * wave[i].freq + time * wave[i].phase;
-		P.y += wave[i].amp * sin( angle );
-		// calculate derivate of wave function
-		deriv = wave[i].freq * wave[i].amp * cos(angle);
-		ddx -= deriv * wave[i].dir.x;
-		ddy -= deriv * wave[i].dir.y;
-	}
-
-	// compute the 3x3 transform from tangent space to object space
-	// first rows are the tangent and binormal scaled by the bump scale
-
-	OUT.rotMatrix1.xyz = BumpScale * normalize(float3(1, ddy, 0)); // Binormal
-	OUT.rotMatrix2.xyz = BumpScale * normalize(float3(0, ddx, 1)); // Tangent
-	OUT.rotMatrix3.xyz = normalize(float3(ddx, 1, ddy)); // Normal
-
-	OUT.Position = mul(WorldViewProj, P);
-
-	// calculate texture coordinates for normal map lookup
-	OUT.bumpCoord0.xy = IN.TexCoord*textureScale + time * bumpSpeed;
-	OUT.bumpCoord1.xy = IN.TexCoord*textureScale * 2.0 + time * bumpSpeed * 4.0;
-	OUT.bumpCoord2.xy = IN.TexCoord*textureScale * 4.0 + time * bumpSpeed * 8.0;
-
-	OUT.eyeVector = P.xyz - eyePosition; // eye position in vertex space
-	return OUT;
-}

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

@@ -1,84 +0,0 @@
-/* Bump mapping with Parallax offset vertex program 
-   In this program, we want to calculate the tangent space light end eye vectors 
-   which will get passed to the fragment program to produce the per-pixel bump map 
-   with parallax offset effect. 
-*/
-
-#include "Common.cg"
-
-float4 lightPosition;
-float3 eyePosition;
-float4x4 worldViewProj;
-
-float3 lightDiffuse;
-float3 lightSpecular;
-float4 scaleBias;
-sampler2D normalHeightMap;
-sampler2D diffuseMap;
-
-struct app2vertOffsetMapping
-{
-    float4 position	: POSITION;
-    float3 normal	: NORMAL;
-    float2 uv		: TEXCOORD0;
-    float3 tangent      : TANGENT;
-};
-
-struct vert2fragOffsetMapping
-{
-    float4 position     : POSITION;
-    float2 uv		: TEXCOORD0;
-    float3 lightDir     : TEXCOORD1;
-    float3 eyeDir       : TEXCOORD2;
-    float3 halfAngle    : TEXCOORD3;
-};
-
-/* Vertex program that moves light and eye vectors into texture tangent space at vertex */ 
-
-vert2fragOffsetMapping main_vp(app2vertOffsetMapping IN) 
-{
-    vert2fragOffsetMapping OUT;
-
-    // calculate output position 
-    OUT.position = mul(worldViewProj, IN.position); 
-
-    // pass the main uvs straight through unchanged 
-    OUT.uv = IN.uv; 
-
-    half3 lightDir = getLightDirection(lightPosition, IN.position);
-    half3 eyeDir = getEyeDirection(eyePosition, IN.position);
-    
-    // Form a rotation matrix out of the vectors 
-    half3x3 TBN = getTBNMatrix(IN.tangent, IN.normal); 
-    
-    // Transform the light vector according to this matrix 
-    OUT.lightDir = normalize(mul(TBN, lightDir)); 
-    OUT.eyeDir = normalize(mul(TBN, eyeDir)); 
-
-    OUT.halfAngle = normalize(OUT.eyeDir + OUT.lightDir);
-
-    return OUT;
-}
-
-outPixel main_fp(vert2fragOffsetMapping IN)
-{
-    outPixel OUT;
-
-    half displacement = getDisplacement(normalHeightMap, IN.uv, scaleBias.x, scaleBias.y);
-	
-    float3 uv2 = float3(IN.uv, 1);
-	
-    // calculate the new tex coord to use for normal and diffuse
-    float2 newTexCoord = ((IN.eyeDir * displacement) + uv2).xy;
-	
-    // get the new normal and diffuse values
-    half3 normal = getNormalMapVector(normalHeightMap, newTexCoord);
-    half3 diffuse = tex2D(diffuseMap, newTexCoord).xyz;
-	
-    half3 specular = getSpecularComponent(normal, IN.halfAngle, lightSpecular, 32);
-    half3 col = diffuse * getLightingComponent(normal, IN.lightDir, lightDiffuse) + specular;
-		
-    OUT.colour = float4(col, 1);
-
-    return OUT;
-}

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

@@ -1,135 +0,0 @@
-/* Offset mapping including a shadow element and multiple lights in one pass */ 
-void integratedshadows_vp(float4 position   : POSITION, 
-              float3 normal      : NORMAL, 
-              float2 uv         : TEXCOORD0, 
-              float3 tangent     : TANGENT0, 
-              // outputs 
-              out float4 oPosition    : POSITION, 
-              out float2 oUv          : TEXCOORD0, 
-              out float3 oLightDir    : TEXCOORD1, // tangent space 
-             out float3 oEyeDir       : TEXCOORD2, // tangent space 
-			 out float3 oSpotDirection : TEXCOORD3, // tangent space
-              out float3 oLightDir1    : TEXCOORD4, // tangent space 
-              out float3 oSpotDirection1    : TEXCOORD5, // tangent space 
-			 out float4 oShadowUV1 : TEXCOORD6,
-			 out float4 oShadowUV2 : TEXCOORD7,
-              // parameters 
-              uniform float4 lightPosition, // object space 
-              uniform float4 lightPosition1, // object space 
-              uniform float3 eyePosition,   // object space 
- 			  uniform float3 spotDirection, // object space
- 			  uniform float3 spotDirection1, // object space
-              uniform float4x4 worldViewProj,
-			  uniform float4x4 worldMatrix,
-			  uniform float4x4 texViewProj1,
-			  uniform float4x4 texViewProj2) 
-{  
-   // calculate output position 
-   oPosition = mul(worldViewProj, position); 
-
-   float4 worldPos = mul(worldMatrix, position);
-   oShadowUV1 = mul(texViewProj1, worldPos);
-   oShadowUV2 = mul(texViewProj2, worldPos);
-   
-   
-
-   // pass the main uvs straight through unchanged 
-   oUv = uv; 
-
-   // calculate tangent space light vector 
-   // Get object space light direction 
-   float3 lightDir = normalize(lightPosition.xyz -  (position * lightPosition.w));
-   float3 lightDir1 = normalize(lightPosition1.xyz -  (position * lightPosition1.w));
-   float3 eyeDir = eyePosition - position.xyz; 
-    
-   // Calculate the binormal (NB we assume both normal and tangent are 
-   // already normalised) 
-   // NB looks like nvidia cross params are BACKWARDS to what you'd expect 
-   // this equates to NxT, not TxN 
-   float3 binormal = cross(tangent, normal); 
-    
-   // Form a rotation matrix out of the vectors 
-   float3x3 rotation = float3x3(tangent, binormal, normal); 
-    
-   // Transform the light vector according to this matrix 
-   lightDir = normalize(mul(rotation, lightDir)); 
-   lightDir1 = normalize(mul(rotation, lightDir1)); 
-   eyeDir = normalize(mul(rotation, eyeDir)); 
-
-   oLightDir = lightDir; 
-   oLightDir1 = lightDir1; 
-   oEyeDir = eyeDir; 
-   oSpotDirection = normalize(mul(rotation, -spotDirection));
-   oSpotDirection1 = normalize(mul(rotation, -spotDirection1));
-}
-
-// Expand a range-compressed vector
-float3 expand(float3 v)
-{
-	return (v - 0.5) * 2;
-}
-
-void integratedshadows_fp(
-	float2 uv : TEXCOORD0,
-	float3 lightDir : TEXCOORD1,
-	float3 eyeDir : TEXCOORD2,
-	float3 spotDir : TEXCOORD3,
-	float3 lightDir1 : TEXCOORD4,
-	float3 spotDir1 : TEXCOORD5,
-	float4 shadowUV1 : TEXCOORD6,
-	float4 shadowUV2 : TEXCOORD7,
-	uniform float3 lightDiffuse,
-	uniform float4 scaleBias,
-    uniform float4 spotParams,
-	uniform float3 lightDiffuse1,
-    uniform float4 spotParams1,
-	uniform sampler2D normalHeightMap : register(s0),
-	uniform sampler2D diffuseMap : register(s1),
-	uniform sampler2D shadowMap1 : register(s2),
-	uniform sampler2D shadowMap2 : register(s3),
-	out float4 oColour : COLOR)
-{
-	// get the height using the tex coords
-	float height = tex2D(normalHeightMap, uv).a;
-
-	// scale and bias factors	
-	float scale = scaleBias.x;
-	float bias = scaleBias.y;
-
-	// calculate displacement	
-	float displacement = (height * scale) + bias;
-	
-	float3 uv2 = float3(uv, 1);
-
-	float3 scaledEyeDir = eyeDir * displacement;
-	
-	// calculate the new tex coord to use for normal and diffuse
-	float2 newTexCoord = (scaledEyeDir + uv2).xy;
-	
-	// get the new normal and diffuse values
-	float3 normal = expand(tex2D(normalHeightMap, newTexCoord).xyz);
-	float3 diffuse = tex2D(diffuseMap, newTexCoord).xyz;
-	
-	float3 col1 = diffuse * saturate(dot(normal, lightDir)) * lightDiffuse;
-	// factor in spotlight angle
-	float rho = saturate(dot(spotDir, lightDir));
-	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
-	float spotFactor = pow(
-		saturate(rho - spotParams.y) / (spotParams.x - spotParams.y), spotParams.z);
-	col1 = col1 * spotFactor;
-	float3 col2 = diffuse * saturate(dot(normal, lightDir1)) * lightDiffuse1;
-	// factor in spotlight angle
-	rho = saturate(dot(spotDir1, lightDir1));
-	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
-	spotFactor = pow(
-		saturate(rho - spotParams1.y) / (spotParams1.x - spotParams1.y), spotParams1.z);
-	col2 = col2 * spotFactor;
-
-	// shadow textures
-	col1 = col1 * tex2Dproj(shadowMap1, shadowUV1);
-	col2 = col2 * tex2Dproj(shadowMap2, shadowUV2);
-
-	oColour = float4(col1 + col2, 1);
-
-}
-

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

@@ -1,69 +0,0 @@
-uniform vec4 lightDiffuse;
-uniform vec4 scaleBias;
-uniform vec4 spotParams;
-uniform vec4 lightDiffuse1;
-uniform vec4 spotParams1;
-
-uniform sampler2D normalHeightMap;
-uniform sampler2D diffuseMap;
-uniform sampler2D shadowMap1;
-uniform sampler2D shadowMap2;
-
-
-
-varying vec3 tangentEyeDir;
-varying vec3 tangentLightDir[2];
-varying vec3 tangentSpotDir[2];
-varying vec4 shadowUV[2];
-
-
-// Expand a range-compressed vector
-vec3 expand(vec3 v)
-{
-	return (v - 0.5) * 2.0;
-}
-
-
-void main()
-{
-	// get the height using the tex coords
-	float height = texture2D(normalHeightMap, gl_TexCoord[0].xy).a;
-	// scale and bias factors	
-	float scale = scaleBias.x;
-	float bias = scaleBias.y;
-
-	// calculate displacement	
-	float displacement = (height * scale) + bias;
-	//float displacement = (height * 0.04) - 0.02;
-	
-	vec3 scaledEyeDir = tangentEyeDir * displacement;
-	
-	// calculate the new tex coord to use for normal and diffuse
-	vec2 newTexCoord = (scaledEyeDir + gl_TexCoord[0].xyz).xy;
-	
-	// get the new normal and diffuse values
-	vec3 normal = expand(texture2D(normalHeightMap, newTexCoord).xyz);
-	vec4 diffuse = texture2D(diffuseMap, newTexCoord);
-	
-	vec4 col1 = diffuse * clamp(dot(normal, tangentLightDir[0]),0.0,1.0) * lightDiffuse;
-	// factor in spotlight angle
-	float rho = clamp(dot(tangentSpotDir[0], tangentLightDir[0]),0.0,1.0);
-	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
-	float spotFactor = pow(
-		clamp(rho - spotParams.y,0.0,1.0) / (spotParams.x - spotParams.y), spotParams.z);
-	col1 = col1 * spotFactor;
-	vec4 col2 = diffuse * clamp(dot(normal, tangentLightDir[1]),0.0,1.0) * lightDiffuse1;
-	// factor in spotlight angle
-	rho = clamp(dot(tangentSpotDir[1], tangentLightDir[1]),0.0,1.0);
-	// factor = (rho - cos(outer/2) / cos(inner/2) - cos(outer/2)) ^ falloff
-	spotFactor = pow(
-		clamp(rho - spotParams1.y,0.0,1.0) / (spotParams1.x - spotParams1.y), spotParams1.z);
-	col2 = col2 * spotFactor;
-
-	// shadow textures
-	col1 = col1 * texture2DProj(shadowMap1, shadowUV[0]);
-	col2 = col2 * texture2DProj(shadowMap2, shadowUV[1]);
-
-	gl_FragColor = col1 + col2;
-
-}