ogre-python 14.2.3__cp312-cp312-win_amd64.whl

ogre_python-14.2.3.data/data/Media/Main/Shadow.material

@@ -0,0 +1,85 @@
+// This file is part of the OGRE project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://www.ogre3d.org/licensing.
+
+material Ogre/TextureShadowCaster
+{
+    receive_shadows false
+    technique
+    {
+        pass
+        {
+            // Lighting has to be on, because we need shadow coloured objects
+            // Note that because we can't predict vertex programs, we'll have to
+            // bind light values to those, and so we bind White to ambient
+            // reflectance, and we'll set the ambient colour to the shadow colour
+            ambient 1 1 1
+            diffuse 0 0 0
+            specular 0 0 0 1
+            emissive 0 0 0
+            fog_override true none
+            // set depth bias in case this is used with PF_DEPTH
+            depth_bias -1 -1
+        }
+    }
+}
+
+material Ogre/StencilShadowModulationPass
+{
+    technique
+    {
+        pass
+        {
+            lighting off
+            scene_blend modulate
+            depth_write off
+            depth_check off
+            cull_hardware none
+
+            vertex_program_ref Ogre/ShadowBlendVP {}
+            fragment_program_ref Ogre/ShadowBlendFP {}
+            texture_unit {}
+        }
+    }
+}
+
+material Ogre/StencilShadowVolumes
+{
+    technique
+    {
+        pass
+        {
+            // program will be set dynamically to match light type
+            vertex_program_ref Ogre/ShadowExtrudeDirLightFinite
+            {
+                // however, the parameters here are shared between all programs
+                param_named_auto worldviewproj_matrix worldviewproj_matrix
+                param_named_auto light_position_object_space light_position_object_space 0
+                param_named_auto shadow_extrusion_distance shadow_extrusion_distance 0
+            }
+            fragment_program_ref Ogre/ShadowBlendFP {}
+        }
+    }
+}
+
+material Ogre/Debug/ShadowVolumes
+{
+    technique
+    {
+        pass
+        {
+            depth_write off
+            scene_blend add
+            cull_hardware none
+
+            // program will be set dynamically to match light type
+            vertex_program_ref Ogre/ShadowExtrudeDirLight
+            {
+                // however, the parameters here are shared between all programs
+                param_named_auto worldviewproj_matrix worldviewproj_matrix
+                param_named_auto light_position_object_space light_position_object_space 0
+            }
+            fragment_program_ref Ogre/ShadowBlendFP {}
+        }
+    }
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowBlend.frag

@@ -0,0 +1,11 @@
+#include <OgreUnifiedShader.h>
+
+OGRE_UNIFORMS(
+    uniform vec4 shadowColor;
+)
+
+MAIN_PARAMETERS
+MAIN_DECLARATION
+{
+    gl_FragColor = shadowColor;
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowBlend.vert

@@ -0,0 +1,12 @@
+#include <OgreUnifiedShader.h>
+
+OGRE_UNIFORMS(
+    uniform mat4 worldViewProj;
+)
+
+MAIN_PARAMETERS
+IN(vec4 vertex, POSITION)
+MAIN_DECLARATION
+{
+    gl_Position = mul(worldViewProj, vertex);
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowExtrudeDirLight.vert

@@ -0,0 +1,18 @@
+#include <OgreUnifiedShader.h>
+
+// Directional light extrude
+uniform mat4 worldviewproj_matrix;
+uniform vec4 light_position_object_space; // homogenous, object space
+
+MAIN_PARAMETERS
+IN(vec4 uv0, TEXCOORD0)
+IN(vec4 position, POSITION)
+MAIN_DECLARATION
+{
+    // Extrusion in object space
+    // Vertex unmodified if w==1, extruded if w==0
+    vec4 newpos =
+        (uv0.xxxx * (position + light_position_object_space)) - light_position_object_space;
+
+    gl_Position = mul(worldviewproj_matrix, newpos);
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowExtrudeDirLightFinite.vert

@@ -0,0 +1,22 @@
+#include <OgreUnifiedShader.h>
+
+// Directional light extrude - FINITE
+uniform mat4 worldviewproj_matrix;
+uniform vec4 light_position_object_space; // homogenous, object space
+uniform float shadow_extrusion_distance;  // how far to extrude
+
+MAIN_PARAMETERS
+IN(vec4 uv0, TEXCOORD0)
+IN(vec4 position, POSITION)
+MAIN_DECLARATION
+{
+    // Extrusion in object space
+    // Vertex unmodified if w==1, extruded if w==0
+    vec3 extrusionDir = - light_position_object_space.xyz;
+    extrusionDir = normalize(extrusionDir);
+
+    vec4 newpos = vec4(position.xyz +
+        ((1.0 - uv0.x) * shadow_extrusion_distance * extrusionDir), 1.0);
+
+    gl_Position = mul(worldviewproj_matrix, newpos);
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowExtrudePointLight.vert

@@ -0,0 +1,19 @@
+#include <OgreUnifiedShader.h>
+
+// Point light shadow volume extrude
+uniform mat4 worldviewproj_matrix;
+uniform vec4 light_position_object_space; // homogenous, object space
+
+MAIN_PARAMETERS
+IN(vec4 uv0, TEXCOORD0)
+IN(vec4 position, POSITION)
+MAIN_DECLARATION
+{
+    // Extrusion in object space
+    // Vertex unmodified if w==1, extruded if w==0
+    vec4 newpos =
+        (uv0.xxxx * light_position_object_space) +
+        vec4(position.xyz - light_position_object_space.xyz, 0.0);
+
+    gl_Position = mul(worldviewproj_matrix, newpos);
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowExtrudePointLightFinite.vert

@@ -0,0 +1,22 @@
+#include <OgreUnifiedShader.h>
+
+// Point light shadow volume extrude - FINITE
+uniform mat4 worldviewproj_matrix;
+uniform vec4 light_position_object_space; // homogenous, object space
+uniform float shadow_extrusion_distance; // how far to extrude
+
+MAIN_PARAMETERS
+IN(vec4 uv0, TEXCOORD0)
+IN(vec4 position, POSITION)
+MAIN_DECLARATION
+{
+    // Extrusion in object space
+    // Vertex unmodified if w==1, extruded if w==0
+    vec3 extrusionDir = position.xyz - light_position_object_space.xyz;
+    extrusionDir = normalize(extrusionDir);
+
+    vec4 newpos = vec4(position.xyz +
+        ((1.0 - uv0.x) * shadow_extrusion_distance * extrusionDir), 1.0);
+
+    gl_Position = mul(worldviewproj_matrix, newpos);
+}

ogre_python-14.2.3.data/data/Media/Main/ShadowVolumeExtude.program

@@ -0,0 +1,41 @@
+// This file is part of the OGRE project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at https://www.ogre3d.org/licensing.
+
+vertex_program Ogre/ShadowBlendVP glsl glsles hlsl glslang
+{
+    source ShadowBlend.vert
+    default_params
+    {
+        param_named_auto worldViewProj worldviewproj_matrix
+    }
+}
+
+fragment_program Ogre/ShadowBlendFP glsl glsles hlsl glslang
+{
+    source ShadowBlend.frag
+    default_params
+    {
+        param_named_auto shadowColor shadow_colour
+    }
+}
+
+vertex_program Ogre/ShadowExtrudePointLight glsl glsles hlsl
+{
+    source ShadowExtrudePointLight.vert
+}
+
+vertex_program Ogre/ShadowExtrudeDirLight glsl glsles hlsl
+{
+    source ShadowExtrudeDirLight.vert
+}
+
+vertex_program Ogre/ShadowExtrudePointLightFinite glsl glsles hlsl
+{
+    source ShadowExtrudePointLightFinite.vert
+}
+
+vertex_program Ogre/ShadowExtrudeDirLightFinite glsl glsles hlsl
+{
+    source ShadowExtrudeDirLightFinite.vert
+}

ogre_python-14.2.3.data/data/Media/RTShaderLib/FFPLib_AlphaTest.glsl

@@ -0,0 +1,45 @@
+//-----------------------------------------------------------------------------
+// Program Name: FFPLib_AlphaTest
+// Program Desc: Alpha test function.
+// Program Type: Vertex/Pixel shader
+// Language: GLSL
+//-----------------------------------------------------------------------------
+
+#define CMPF_ALWAYS_FAIL 0
+#define CMPF_ALWAYS_PASS 1
+#define CMPF_LESS 2
+#define CMPF_LESS_EQUAL 3
+#define CMPF_EQUAL 4
+#define CMPF_NOT_EQUAL 5
+#define CMPF_GREATER_EQUAL 6
+#define CMPF_GREATER 7
+
+bool Alpha_Func(in int func, in float alphaRef, in float alphaValue)
+{
+    // ES2 does not have switch
+    if(func == CMPF_ALWAYS_PASS)
+        return true;
+    else if(func == CMPF_LESS)
+        return alphaValue < alphaRef;
+    else if(func == CMPF_LESS_EQUAL)
+        return alphaValue <= alphaRef;
+    else if(func == CMPF_EQUAL)
+        return alphaValue == alphaRef;
+    else if(func == CMPF_NOT_EQUAL)
+        return alphaValue != alphaRef;
+    else if(func == CMPF_GREATER_EQUAL)
+        return alphaValue >= alphaRef;
+    else if(func == CMPF_GREATER)
+        return alphaValue > alphaRef;
+
+    // CMPF_ALWAYS_FAIL and default
+    return false;
+}
+
+
+void FFP_Alpha_Test(in float func, in float alphaRef, in vec4 texel)
+{
+    bool pass_ = Alpha_Func(int(func), alphaRef, texel.a);
+    if (!pass_)
+        discard;
+}

ogre_python-14.2.3.data/data/Media/RTShaderLib/FFPLib_Fog.glsl

@@ -0,0 +1,92 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org
+
+Copyright (c) 2000-2014 Torus Knot Software Ltd
+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.
+-----------------------------------------------------------------------------
+*/
+
+//-----------------------------------------------------------------------------
+// Program Name: FFPLib_Fog
+// Program Desc: Fog functions of the FFP.
+// Program Type: Vertex/Pixel shader
+// Language: GLSL
+// Notes: Implements core functions needed by FFPFog class.
+// Based on fog engine. 
+// See http://msdn.microsoft.com/en-us/library/bb173398.aspx
+// Vertex based fog: the w component of the out position is used
+// as the distance parameter to fog formulas. This is basically the z coordinate
+// in world space. See pixel fog under D3D docs. The fog factor is computed according 
+// to each formula, then clamped and output to the pixel shader.
+// Pixel based fog: the w component of the out position is passed to pixel shader
+// that computes the fog factor based on it.
+// Both techniques use the fog factor in the end of the pixel shader to blend
+// the output color with the fog color.
+//-----------------------------------------------------------------------------
+
+#define FOG_EXP    1
+#define FOG_EXP2   2
+#define FOG_LINEAR 3
+
+//-----------------------------------------------------------------------------
+void FFP_FogFactor(in float depth,
+				  in vec4 fogParams,				   
+				  out float oFogFactor)
+{
+	float distance  = abs(depth);
+
+#if FOG_TYPE == FOG_LINEAR
+	float fogFactor = (fogParams.z - distance) * fogParams.w;
+#elif FOG_TYPE == FOG_EXP
+	float x       = distance*fogParams.x;
+	float fogFactor = 1.0 / exp(x);
+#elif FOG_TYPE == FOG_EXP2
+	float x       = (distance*fogParams.x*distance*fogParams.x);
+	float fogFactor = 1.0 / exp(x);
+#endif
+
+	oFogFactor  = saturate(fogFactor);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_PixelFog_PositionDepth(in mat4 mWorld, 
+				   in vec3 cameraPos,
+				   in vec4 pos, 				   				   				   
+				   out vec3 oPosView,
+				   out float oDepth)
+{
+	vec4 vOutPos  = mul(mWorld, pos);
+	oPosView      = vOutPos.xyz - cameraPos;
+	oDepth        = length(oPosView);	
+}
+
+//-----------------------------------------------------------------------------
+void FFP_PixelFog(in float depth,
+				   in vec4 fogParams,				   
+				   in vec4 fogColor,
+				   in vec4 baseColor,
+				   out vec4 oColor)
+{
+	float fogFactor = 0.0;
+	FFP_FogFactor(depth, fogParams, fogFactor);
+	oColor = mix(fogColor, baseColor, fogFactor);
+}

ogre_python-14.2.3.data/data/Media/RTShaderLib/FFPLib_Texturing.glsl

@@ -0,0 +1,144 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org
+
+Copyright (c) 2000-2014 Torus Knot Software Ltd
+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.
+-----------------------------------------------------------------------------
+*/
+
+//-----------------------------------------------------------------------------
+// Program Name: FFPLib_Texturing
+// Program Desc: Texture functions of the FFP.
+// Program Type: Vertex/Pixel shader
+// Language: GLSL
+// Notes: Implements core functions for FFPTexturing class.
+// based on texturing operations needed by render system.
+// Implements texture coordinate processing:
+// see http://msdn.microsoft.com/en-us/library/bb206247.aspx
+// Implements texture blending operation:
+// see http://msdn.microsoft.com/en-us/library/bb206241.aspx
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+void FFP_TransformTexCoord(in mat4 m, in vec2 v, out vec2 vOut)
+{
+	vOut = mul(m, vec4(v, 0.0, 1.0)).xy;
+}
+//-----------------------------------------------------------------------------
+void FFP_TransformTexCoord(in mat4 m, in vec4 v, out vec2 vOut)
+{
+	vOut = mul(m, v).xy;
+}
+
+//-----------------------------------------------------------------------------
+void FFP_TransformTexCoord(in mat4 m, in vec3 v, out vec3 vOut)
+{
+	vOut = mul(m, vec4(v, 1.0)).xyz;
+}
+
+//-----------------------------------------------------------------------------
+void FFP_GenerateTexCoord_EnvMap_Normal(in mat3 mWorldIT,
+						   in vec3 vNormal,
+						   out vec3 vOut)
+{
+	vOut = normalize(mul(mWorldIT, vNormal));
+}
+
+//-----------------------------------------------------------------------------
+void FFP_GenerateTexCoord_EnvMap_Sphere(in 	mat4 mWorldView,
+										in 	mat3 mWorldIT,
+										in 	vec4 vPos,
+										in 	vec3 vNormal,
+										out vec2 vOut)
+{
+	vec3 normal = normalize( mul(mWorldIT, vNormal));
+	vec3 eyedir =  normalize(mul(mWorldView, vPos)).xyz;
+	vec3 r = reflect(eyedir, normal);
+	r.z += 1.0;
+	float two_p = 2.0 * length(r);
+	vOut = vec2(0.5 + r.x / two_p, 0.5 - r.y / two_p);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_GenerateTexCoord_EnvMap_Reflect(in mat4 mWorld, 
+							in mat4 mWorldIT, 
+						   in vec3 vCamPos,
+						   in vec3 vNormal,
+						   in vec4 vPos,						  
+						   out vec3 vOut)
+{
+	vec3 vWorldNormal = normalize(mul(mWorldIT, vec4(vNormal, 0.0)).xyz);
+	vec3 vWorldPos    = mul(mWorld, vPos).xyz;
+	vec3 vEyeDir  = normalize(vWorldPos - vCamPos);
+	
+	vec3 vReflect = reflect(vEyeDir, vWorldNormal);
+	vReflect.z *= -1.0;
+
+	vOut = vReflect;
+}
+
+//-----------------------------------------------------------------------------
+void FFP_AddSmooth(in float vIn0, in float vIn1, out float vOut)
+{
+	vOut = vIn0 + vIn1 - (vIn0 * vIn1);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_AddSmooth(in vec2 vIn0, in vec2 vIn1, out vec2 vOut)
+{
+	vOut = vIn0 + vIn1 - (vIn0 * vIn1);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_AddSmooth(in vec3 vIn0, in vec3 vIn1, out vec3 vOut)
+{
+	vOut = vIn0 + vIn1 - (vIn0 * vIn1);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_AddSmooth(in vec4 vIn0, in vec4 vIn1, out vec4 vOut)
+{
+	vOut = vIn0 + vIn1 - (vIn0 * vIn1);
+}
+//-----------------------------------------------------------------------------
+void FFP_DotProduct(in float vIn0, in float vIn1, out float vOut)
+{
+	vOut = dot(vIn0, vIn1);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_DotProduct(in vec2 vIn0, in vec2 vIn1, out vec2 vOut)
+{
+	vOut = vec2_splat(dot(vIn0, vIn1));
+}
+
+//-----------------------------------------------------------------------------
+void FFP_DotProduct(in vec3 vIn0, in vec3 vIn1, out vec3 vOut)
+{
+	vOut = vec3_splat(dot(vIn0, vIn1));
+}
+
+//-----------------------------------------------------------------------------
+void FFP_DotProduct(in vec4 vIn0, in vec4 vIn1, out vec4 vOut)
+{
+	vOut = vec4_splat(dot(vIn0, vIn1));
+}

ogre_python-14.2.3.data/data/Media/RTShaderLib/FFPLib_Transform.glsl

@@ -0,0 +1,100 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org
+
+Copyright (c) 2000-2014 Torus Knot Software Ltd
+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.
+-----------------------------------------------------------------------------
+*/
+
+//-----------------------------------------------------------------------------
+// Program Name: FFPLib_Transform
+// Program Desc: Transform functions of the FFP.
+// Program Type: Vertex shader
+// Language: GLSL
+// Notes: Implements core functions for FFPTransform class.
+// based on transform engine. 
+// See http://msdn.microsoft.com/en-us/library/bb206269.aspx
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+void FFP_Transform(in mat4 m, 
+				   in vec4 v, 
+				   out vec3 vOut)
+{
+	vOut = mul(m, v).xyz;
+}
+
+#ifdef OGRE_HLSL
+void FFP_Transform(in float3x4 m,
+				   in float4 v,
+				   out float3 vOut)
+{
+	vOut = mul(m, v);
+}
+
+//-----------------------------------------------------------------------------
+void FFP_Transform(in float3x4 m,
+				   in float3 v,
+				   out float3 vOut)
+{
+	vOut = mul((float3x3)m, v);
+}
+#elif !defined(OGRE_GLSLES) || OGRE_GLSLES > 100
+//-----------------------------------------------------------------------------
+void FFP_Transform(in mat3x4 m,
+				   in vec4 v,
+				   out vec3 vOut)
+{
+/* transpose non-square uniform matrix for correct row-major > column-major mapping
+ * to keep the indexing inside the shader so mat[0] returns the same data in both GLSL and HLSL
+ * although it will be the first row in HLSL and the first column in GLSL
+ */
+	vOut = v * m;
+}
+
+void FFP_Transform(in mat3x4 m,
+				   in vec3 v,
+				   out vec3 vOut)
+{
+	vOut = v * mat3(m);
+}
+#endif
+
+//-----------------------------------------------------------------------------
+void FFP_Transform(in mat4 m, 
+				   in vec3 v, 
+				   out vec3 vOut)
+{
+#ifdef OGRE_HLSL
+	vOut = mul((float3x3)m, v);
+#else
+	vOut = mat3(m) * v;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void FFP_DerivePointSize(in vec4 params,
+                         in float d,
+                         out float sz)
+{
+	sz = params.x/sqrt(params.y + params.z*d + params.w*d*d);
+}