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

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

@@ -1,146 +0,0 @@
-/* Copyright Torus Knot Software Ltd 2012
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
-Adapted by Matias N. Goldberg (Dark Sylinc) to GLSL based on the Cg file shadows.cg
-*/
-
-// Simple PCF 
-// Number of samples in one dimension (square for total samples)
-#define NUM_SHADOW_SAMPLES_1D 2.0
-#define SHADOW_FILTER_SCALE 1.0
-
-#define SHADOW_SAMPLES NUM_SHADOW_SAMPLES_1D*NUM_SHADOW_SAMPLES_1D
-
-vec4 offsetSample(vec4 uv, vec2 offset, float invMapSize)
-{
-	return vec4(uv.xy + offset * invMapSize * uv.w, uv.z, uv.w);
-}
-
-float calcDepthShadow(sampler2DShadow shadowMap, vec4 uv, float invShadowMapSize)
-{
-	// 4-sample PCF
-	
-	float shadow = 0.0;
-	float offset = (NUM_SHADOW_SAMPLES_1D/2.0 - 0.5) * SHADOW_FILTER_SCALE;
-	for (float y = -offset; y <= offset; y += SHADOW_FILTER_SCALE)
-		for (float x = -offset; x <= offset; x += SHADOW_FILTER_SCALE)
-		{
-			float depth = shadow2DProj(shadowMap, offsetSample(uv, vec2(x, y), invShadowMapSize)).x;
-			if (depth >= 1.0 || depth >= uv.z)
-				shadow += 1.0;
-		}
-
-	shadow /= SHADOW_SAMPLES;
-
-	return shadow;
-}
-
-
-float calcSimpleShadow(sampler2DShadow shadowMap, vec4 shadowMapPos)
-{
-	return shadow2DProj(shadowMap, shadowMapPos).x;
-}
-
-float calcPSSMDepthShadow(sampler2DShadow shadowMap0, sampler2DShadow shadowMap1, sampler2DShadow shadowMap2, 
-						   vec4 lsPos0, vec4 lsPos1, vec4 lsPos2,
-						   float invShadowmapSize0, float invShadowmapSize1, float invShadowmapSize2,
-						   vec4 pssmSplitPoints, float camDepth)
-{
-
-	float shadow;
-	vec4 splitColour;
-	// calculate shadow
-	if (camDepth <= pssmSplitPoints.y)
-	{
-		splitColour = vec4(0.3, 0.0, 0, 0);
-		shadow = calcDepthShadow(shadowMap0, lsPos0, invShadowmapSize0);
-	}
-	else if (camDepth <= pssmSplitPoints.z)
-	{
-		splitColour = vec4(0, 0.3, 0, 0);
-		shadow = calcDepthShadow(shadowMap1, lsPos1, invShadowmapSize1);
-	}
-	else
-	{
-		splitColour = vec4(0.0, 0.0, 0.3, 0);
-		shadow = calcDepthShadow(shadowMap2, lsPos2, invShadowmapSize2);
-	}
-
-	return shadow;
-}
-
-float calcPSSMSimpleShadow(sampler2DShadow shadowMap0, sampler2DShadow shadowMap1, sampler2DShadow shadowMap2, 
-						   vec4 lsPos0, vec4 lsPos1, vec4 lsPos2,
-						   vec4 pssmSplitPoints, float camDepth)
-{
-
-	float shadow;
-	vec4 splitColour;
-	// calculate shadow
-	if (camDepth <= pssmSplitPoints.y)
-	{
-		splitColour = vec4(0.3, 0.0, 0, 0);
-		shadow = calcSimpleShadow(shadowMap0, lsPos0);
-	}
-	else if (camDepth <= pssmSplitPoints.z)
-	{
-		splitColour = vec4(0, 0.3, 0, 0);
-		shadow = calcSimpleShadow(shadowMap1, lsPos1);
-	}
-	else
-	{
-		splitColour = vec4(0.0, 0.0, 0.3, 0);
-		shadow = calcSimpleShadow(shadowMap2, lsPos2);
-	}
-
-	return shadow;
-}
-
-
-
-vec3 calcPSSMDebugShadow(sampler2DShadow shadowMap0, sampler2DShadow shadowMap1, sampler2DShadow shadowMap2, 
-						   vec4 lsPos0, vec4 lsPos1, vec4 lsPos2,
-						   float invShadowmapSize0, float invShadowmapSize1, float invShadowmapSize2,
-						   vec4 pssmSplitPoints, float camDepth)
-{
-
-	vec4 splitColour;
-	// calculate shadow
-	if (camDepth <= pssmSplitPoints.y)
-	{
-		//splitColour = vec4(0.3, 0.0, 0, 0);
-		//splitColour = lsPos0 / lsPos0.w;
-		splitColour.rgb = shadow2DProj(shadowMap0, lsPos0).xxx;
-	}
-	else if (camDepth <= pssmSplitPoints.z)
-	{
-		//splitColour = vec4(0, 0.3, 0, 0);
-		//splitColour = lsPos1 / lsPos1.w;
-		splitColour.rgb = shadow2DProj(shadowMap1, lsPos1).xxx;
-	}
-	else
-	{
-		//splitColour = vec4(0.0, 0.0, 0.3, 0);
-		//splitColour = lsPos2 / lsPos2.w;
-		splitColour.rgb = shadow2DProj(shadowMap2, lsPos2).xxx;
-	}
-
-	return splitColour.rgb;
-}

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

@@ -1,42 +0,0 @@
-// Example GLSL program for skinning with two bone weights per vertex
-
-attribute vec4 vertex;
-attribute vec4 uv0;
-attribute vec4 blendIndices;
-attribute vec4 blendWeights;
-
-// 3x4 matrix, passed as vec4's for compatibility with GL 2.0
-// GL 2.0 supports 3x4 matrices
-// Support 24 bones ie 24*3, but use 72 since our parser can pick that out for sizing
-uniform vec4 worldMatrix3x4Array[72];
-uniform mat4 viewProjectionMatrix;
-uniform vec4 ambient;
-
-void main()
-{
-	vec3 blendPos = vec3(0,0,0);
-
-	for (int bone = 0; bone < 2; ++bone)
-	{
-		// perform matrix multiplication manually since no 3x4 matrices
-        // ATI GLSL compiler can't handle indexing an array within an array so calculate the inner index first
-	    int idx = int(blendIndices[bone]) * 3;
-        // ATI GLSL compiler can't handle unrolling the loop so do it manually
-        // ATI GLSL has better performance when mat4 is used rather than using individual dot product
-        // There is a bug in ATI mat4 constructor (Cat 7.2) when indexed uniform array elements are used as vec4 parameter so manually assign
-		mat4 worldMatrix;
-		worldMatrix[0] = worldMatrix3x4Array[idx];
-		worldMatrix[1] = worldMatrix3x4Array[idx + 1];
-		worldMatrix[2] = worldMatrix3x4Array[idx + 2];
-		worldMatrix[3] = vec4(0);
-		// now weight this into final 
-		blendPos += (vertex * worldMatrix).xyz * blendWeights[bone];
-	}
-
-	// apply view / projection to position
-	gl_Position = viewProjectionMatrix * vec4(blendPos, 1);
-	
-	gl_FrontSecondaryColor = vec4(0,0,0,0);
-	gl_FrontColor = ambient;
-	gl_TexCoord[0] = uv0;
-}

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

@@ -1,46 +0,0 @@
-#version 100
-
-precision highp int;
-precision highp float;
-
-/*
-  Two-weight-per-vertex hardware skinning, shadow caster pass
-*/
-
-attribute vec4 vertex;
-attribute vec4 uv0;
-attribute vec4 blendIndices;
-attribute vec4 blendWeights;
-
-// 3x4 matrix, passed as vec4's for compatibility with GL ES 2.0
-// Support 24 bones ie 24*3, but use 72 since our parser can pick that out for sizing
-uniform vec4 worldMatrix3x4Array[72];
-uniform mat4 viewProjectionMatrix;
-uniform vec4 ambient;
-
-varying vec4 colour;
-
-void main()
-{
-	vec3 blendPos = vec3(0.0);
-
-	for (int bone = 0; bone < 2; ++bone)
-	{
-		// Perform matrix multiplication manually since no 3x4 matrices
-	    int idx = int(blendIndices[bone]) * 3;
-
-        // Unroll the loop manually
-		mat4 worldMatrix;
-		worldMatrix[0] = worldMatrix3x4Array[idx];
-		worldMatrix[1] = worldMatrix3x4Array[idx + 1];
-		worldMatrix[2] = worldMatrix3x4Array[idx + 2];
-		worldMatrix[3] = vec4(0.0);
-		// Now weight this into final 
-		blendPos += (vertex * worldMatrix).xyz * blendWeights[bone];
-	}
-
-	// Apply view / projection to position
-	gl_Position = viewProjectionMatrix * vec4(blendPos, 1.0);
-
-	colour = ambient;
-}

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

@@ -1,61 +0,0 @@
-// Example GLSL program for skinning with two bone weights per vertex
-
-attribute vec4 vertex;
-attribute vec3 normal;
-attribute vec4 uv0;
-attribute vec4 blendIndices;
-attribute vec4 blendWeights;
-
-// 3x4 matrix, passed as vec4's for compatibility with GL 2.0
-// GL 2.0 supports 3x4 matrices
-// Support 24 bones ie 24*3, but use 72 since our parser can pick that out for sizing
-uniform vec4 worldMatrix3x4Array[72];
-uniform mat4 viewProjectionMatrix;
-uniform vec4 lightPos[2];
-uniform vec4 lightDiffuseColour[2];
-uniform vec4 ambient;
-uniform vec4 diffuse;
-
-void main()
-{
-	vec3 blendPos = vec3(0.0, 0.0, 0.0);
-	vec3 blendNorm = vec3(0.0, 0.0, 0.0);
-	
-	for (int bone = 0; bone < 2; ++bone)
-	{
-		// perform matrix multiplication manually since no 3x4 matrices
-        // ATI GLSL compiler can't handle indexing an array within an array so calculate the inner index first
-		int idx = int(blendIndices[bone]) * 3;
-        // ATI GLSL compiler can't handle unrolling the loop so do it manually
-        // ATI GLSL has better performance when mat4 is used rather than using individual dot product
-        // There is a bug in ATI mat4 constructor (Cat 7.2) when indexed uniform array elements are used as vec4 parameter so manually assign
-		mat4 worldMatrix;
-		worldMatrix[0] = worldMatrix3x4Array[idx];
-		worldMatrix[1] = worldMatrix3x4Array[idx + 1];
-		worldMatrix[2] = worldMatrix3x4Array[idx + 2];
-		worldMatrix[3] = vec4(0);
-		// now weight this into final 
-		float weight = blendWeights[bone];
-		blendPos += (vertex * worldMatrix).xyz * weight;
-		
-		mat3 worldRotMatrix = mat3(worldMatrix[0].xyz, worldMatrix[1].xyz, worldMatrix[2].xyz);
-		blendNorm += (normal * worldRotMatrix) * weight;
-	}
-
-	blendNorm = normalize(blendNorm);
-
-	// apply view / projection to position
-	gl_Position = viewProjectionMatrix * vec4(blendPos, 1.0);
-
-	// simple vertex lighting model
-	vec3 lightDir0 = normalize(
-		lightPos[0].xyz -  (blendPos * lightPos[0].w));
-	vec3 lightDir1 = normalize(
-		lightPos[1].xyz -  (blendPos * lightPos[1].w));
-		
-	gl_FrontColor = diffuse * (ambient + (clamp(dot(lightDir0, blendNorm), 0.0, 1.0) * lightDiffuseColour[0]) + 
-		(clamp(dot(lightDir1, blendNorm), 0.0, 1.0) * lightDiffuseColour[1]));	
-
-	gl_TexCoord[0] = uv0;
-	
-}

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

@@ -1,63 +0,0 @@
-#version 100
-
-precision highp int;
-precision highp float;
-
-// Example GLSL ES program for skinning with two bone weights per vertex
-
-attribute vec4 vertex;
-attribute vec4 uv0;
-attribute vec3 normal;
-attribute vec4 blendIndices;
-attribute vec4 blendWeights;
-
-varying vec4 colour;
-varying vec4 uv;
-
-// 3x4 matrix, passed as vec4's for compatibility with GL ES 2.0
-// Support 24 bones ie 24*3, but use 72 since our parser can pick that out for sizing
-uniform vec4 worldMatrix3x4Array[72];
-uniform mat4 viewProjectionMatrix;
-uniform vec4 lightPos[2];
-uniform vec4 lightDiffuseColour[2];
-uniform vec4 ambient;
-uniform vec4 diffuse;
-
-void main()
-{
-	vec3 blendPos = vec3(0.0);
-	vec3 blendNorm = vec3(0.0);
-	
-	for (int bone = 0; bone < 2; ++bone)
-	{
-		// perform matrix multiplication manually since no 3x4 matrices
-	    int idx = int(blendIndices[bone]) * 3;
-
-		mat4 worldMatrix;
-		worldMatrix[0] = worldMatrix3x4Array[idx];
-		worldMatrix[1] = worldMatrix3x4Array[idx + 1];
-		worldMatrix[2] = worldMatrix3x4Array[idx + 2];
-		worldMatrix[3] = vec4(0.0);
-		// now weight this into final 
-	    float weight = blendWeights[bone];
-		blendPos += (vertex * worldMatrix).xyz * weight;
-
-		mat3 worldRotMatrix = mat3(worldMatrix[0].xyz, worldMatrix[1].xyz, worldMatrix[2].xyz);
-		blendNorm += (normal * worldRotMatrix) * weight;
-	}
-
-	// apply view / projection to position
-	gl_Position = viewProjectionMatrix * vec4(blendPos, 1.0);
-
-	// simple vertex lighting model
-	vec3 lightDir0 = normalize(
-		lightPos[0].xyz -  (blendPos.xyz * lightPos[0].w));
-	vec3 lightDir1 = normalize(
-		lightPos[1].xyz -  (blendPos.xyz * lightPos[1].w));
-
-  
-	colour = diffuse * (ambient
-		+ clamp(dot(lightDir0, blendNorm), 0.0, 1.0) * lightDiffuseColour[0]
-		+ clamp(dot(lightDir1, blendNorm), 0.0, 1.0) * lightDiffuseColour[1]);
-    uv = uv0;
-}

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

@@ -1,65 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// shadowcasterfp.cg
-//
-// Hamilton Chong
-// (c) 2006
-//
-// This is an example fragment shader for shadow caster objects.  
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-
-// Define outputs from vertex shader.
-struct VertexOut
-{
-  float4 position   : POSITION;     // can't rely on access to this
-  float4 pos  	    : TEXCOORD0;    // position of fragment (in homogeneous coordinates)
-  float4 normal     : TEXCOORD1;    // un-normalized normal in object space
-  float4 modelPos   : TEXCOORD2;    // coordinates of model in object space at this point
-};
-
-struct FragmentOut
-{
-    float4 color  : COLOR0;
-};
-
-FragmentOut main( VertexOut        In,                     // fragment to process
-                  uniform float    uDepthOffset,           // offset amount (constant in eye space)
-                  uniform float4x4 uProjection             // projection matrix
-              )
-{
-    FragmentOut Out;
-
-    // compute the "normalized device coordinates" (no viewport applied yet)
-    float4 postproj = In.pos / In.pos.w;
-
-    // get the normalized normal of the geometry seen at this point
-    float4 normal = normalize(In.normal);
-
-
-    // -- Computing Depth Bias Quantities -----------------------------
-
-    // We now compute the change in z that would signify a push in the z direction
-    // by 1 unit in eye space.  Note that eye space z is related in a nonlinear way to
-    // screen space z, so this is not just a constant.  
-    // ddepth below is how much screen space z at this point would change for that push.
-    // NOTE: computation of ddepth likely differs from OpenGL's glPolygonOffset "unit"
-    //  computation, which is allowed to be vendor specific.
-    float4 dpwdz = mul(uProjection, float4(0.0, 0.0, 1.0, 0.0));
-    float4 dpdz = (dpwdz - (postproj * dpwdz.w)) / In.pos.w;
-    float  ddepth = abs(dpdz.z);
-
-    // -- End depth bias helper section --------------------------------   
-
-    // We now compute the depth of the fragment.  This is the actual depth value plus
-    // our depth bias.  The depth bias depends on how uncertain we are about the z value
-    // plus some constant push in the z direction.  The exact coefficients to use are
-    // up to you, but at least it should be somewhat intuitive now what the tradeoffs are.
-    float depthval = postproj.z /* + (0.5 * dzlen)*/ + (uDepthOffset * ddepth);
-    depthval = (0.5 * depthval) + 0.5; // put into [0,1] range instead of [-1,1] 
-
-    
-    Out.color = float4(depthval, depthval * depthval, depthval, 0.0);
-    return Out;
-}

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

@@ -1,132 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////////
-//
-// varianceshadowcasterfp.glsles
-//
-// Hamilton Chong
-// (c) 2006
-// GLSL ES by David Rogers
-//
-// This is an example fragment shader for shadow caster objects.  
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-
-// Define outputs from vertex shader.
-struct VertexOut
-{
-  float4 position   : POSITION;     // can't rely on access to this
-  float4 pos  	    : TEXCOORD0;    // position of fragment (in homogeneous coordinates)
-  float4 normal     : TEXCOORD1;    // un-normalized normal in object space
-  float4 modelPos   : TEXCOORD2;    // coordinates of model in object space at this point
-};
-
-struct FragmentOut
-{
-    float4 color  : COLOR0;
-};
-
-FragmentOut main( VertexOut        In,                     // fragment to process
-                  uniform float    uDepthOffset,           // offset amount (constant in eye space)
-                  uniform float4x4 uProjection             // projection matrix
-              )
-{
-    FragmentOut Out;
-
-    // compute the "normalized device coordinates" (no viewport applied yet)
-    float4 postproj = In.pos / In.pos.w;
-
-    // get the normalized normal of the geometry seen at this point
-    float4 normal = normalize(In.normal);
-
-
-    // -- Computing Depth Bias Quantities -----------------------------
-
-    // We now compute the change in z that would signify a push in the z direction
-    // by 1 unit in eye space.  Note that eye space z is related in a nonlinear way to
-    // screen space z, so this is not just a constant.  
-    // ddepth below is how much screen space z at this point would change for that push.
-    // NOTE: computation of ddepth likely differs from OpenGL's glPolygonOffset "unit"
-    //  computation, which is allowed to be vendor specific.
-    float4 dpwdz = mul(uProjection, float4(0.0, 0.0, 1.0, 0.0));
-    float4 dpdz = (dpwdz - (postproj * dpwdz.w)) / In.pos.w;
-    float  ddepth = abs(dpdz.z);
-
-    // -- End depth bias helper section --------------------------------   
-
-    // We now compute the depth of the fragment.  This is the actual depth value plus
-    // our depth bias.  The depth bias depends on how uncertain we are about the z value
-    // plus some constant push in the z direction.  The exact coefficients to use are
-    // up to you, but at least it should be somewhat intuitive now what the tradeoffs are.
-    float depthval = postproj.z /* + (0.5 * dzlen)*/ + (uDepthOffset * ddepth);
-    depthval = (0.5 * depthval) + 0.5; // put into [0,1] range instead of [-1,1] 
-
-    
-    Out.color = float4(depthval, depthval * depthval, depthval, 0.0);
-    return Out;
-}
-/////////////////////////////////////////////////////////////////////////////////
-//
-// varianceshadowcasterfp.glsles
-//
-// Hamilton Chong
-// (c) 2006
-// GLSL ES by David Rogers
-//
-// This is an example fragment shader for shadow caster objects.  
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-
-// Define outputs from vertex shader.
-struct VertexOut
-{
-  float4 position   : POSITION;     // can't rely on access to this
-  float4 pos  	    : TEXCOORD0;    // position of fragment (in homogeneous coordinates)
-  float4 normal     : TEXCOORD1;    // un-normalized normal in object space
-  float4 modelPos   : TEXCOORD2;    // coordinates of model in object space at this point
-};
-
-struct FragmentOut
-{
-    float4 color  : COLOR0;
-};
-
-FragmentOut main( VertexOut        In,                     // fragment to process
-                  uniform float    uDepthOffset,           // offset amount (constant in eye space)
-                  uniform float4x4 uProjection             // projection matrix
-              )
-{
-    FragmentOut Out;
-
-    // compute the "normalized device coordinates" (no viewport applied yet)
-    float4 postproj = In.pos / In.pos.w;
-
-    // get the normalized normal of the geometry seen at this point
-    float4 normal = normalize(In.normal);
-
-
-    // -- Computing Depth Bias Quantities -----------------------------
-
-    // We now compute the change in z that would signify a push in the z direction
-    // by 1 unit in eye space.  Note that eye space z is related in a nonlinear way to
-    // screen space z, so this is not just a constant.  
-    // ddepth below is how much screen space z at this point would change for that push.
-    // NOTE: computation of ddepth likely differs from OpenGL's glPolygonOffset "unit"
-    //  computation, which is allowed to be vendor specific.
-    float4 dpwdz = mul(uProjection, float4(0.0, 0.0, 1.0, 0.0));
-    float4 dpdz = (dpwdz - (postproj * dpwdz.w)) / In.pos.w;
-    float  ddepth = abs(dpdz.z);
-
-    // -- End depth bias helper section --------------------------------   
-
-    // We now compute the depth of the fragment.  This is the actual depth value plus
-    // our depth bias.  The depth bias depends on how uncertain we are about the z value
-    // plus some constant push in the z direction.  The exact coefficients to use are
-    // up to you, but at least it should be somewhat intuitive now what the tradeoffs are.
-    float depthval = postproj.z /* + (0.5 * dzlen)*/ + (uDepthOffset * ddepth);
-    depthval = (0.5 * depthval) + 0.5; // put into [0,1] range instead of [-1,1] 
-
-    
-    Out.color = float4(depthval, depthval * depthval, depthval, 0.0);
-    return Out;
-}