ogre-python 14.5.0__cp314-cp314-win_amd64.whl

ogre_python-14.5.0.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.5.0.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.5.0.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.5.0.data/data/Media/RTShaderLib/FFPLib_Texturing.glsl

@@ -0,0 +1,150 @@
+/*
+-----------------------------------------------------------------------------
+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));
+}
+
+void TextureUVMix(in sampler2D tex, in vec2 uv, in vec4 params, out vec4 color)
+{
+	color = mix(texture2D(tex, uv), texture2D(tex, -vec2(uv.y, uv.x) * params.x), params.y);
+	ENABLE_LINEAR_COLOUR(color);
+}

ogre_python-14.5.0.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);
+}

ogre_python-14.5.0.data/data/Media/RTShaderLib/RTSLib_Colour.glsl

@@ -0,0 +1,16 @@
+// 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.
+// SPDX-License-Identifier: MIT
+
+#ifdef USE_LINEAR_COLOURS
+#define ENABLE_LINEAR_COLOUR(colour) colour.rgb = pow(colour.rgb, vec3_splat(2.2))
+#else
+#define ENABLE_LINEAR_COLOUR(colour)
+#endif
+
+#if defined(USE_LINEAR_COLOURS) && !defined(TARGET_CONSUMES_LINEAR)
+#define COLOUR_TRANSFER(colour) colour.rgb = pow(colour.rgb, vec3_splat(1.0/2.2))
+#else
+#define COLOUR_TRANSFER(colour)
+#endif

ogre_python-14.5.0.data/data/Media/RTShaderLib/RTSLib_IBL.glsl

@@ -0,0 +1,90 @@
+// This file is part of the OGRE project.
+// code adapted from Google Filament
+// SPDX-License-Identifier: Apache-2.0
+
+vec3 specularDFG(const PixelParams pixel) {
+    return mix(pixel.dfg.xxx, pixel.dfg.yyy, pixel.f0);
+}
+
+vec3 decodeDataForIBL(const vec4 data) {
+    return data.rgb;
+}
+
+vec3 Irradiance_RoughnessOne(samplerCube light_iblSpecular, const vec3 n, float iblRoughnessOneLevel) {
+    // note: lod used is always integer, hopefully the hardware skips tri-linear filtering
+    return decodeDataForIBL(textureCubeLod(light_iblSpecular, n, iblRoughnessOneLevel));
+}
+
+vec3 PrefilteredDFG_LUT(sampler2D light_iblDFG, float lod, float NoV) {
+    // coord = sqrt(linear_roughness), which is the mapping used by cmgen.
+    // OGRE Specific: y is flipped compared to Filament code
+    return texture2DLod(light_iblDFG, vec2(NoV, 1.0 - lod), 0.0).rgb;
+}
+
+float perceptualRoughnessToLod(float iblRoughnessOneLevel, float perceptualRoughness) {
+    // The mapping below is a quadratic fit for log2(perceptualRoughness)+iblRoughnessOneLevel when
+    // iblRoughnessOneLevel is 4. We found empirically that this mapping works very well for
+    // a 256 cubemap with 5 levels used. But also scales well for other iblRoughnessOneLevel values.
+    return iblRoughnessOneLevel * perceptualRoughness * (2.0 - perceptualRoughness);
+}
+
+vec3 prefilteredRadiance(samplerCube light_iblSpecular, const vec3 r, float perceptualRoughness, float iblRoughnessOneLevel) {
+    float lod = perceptualRoughnessToLod(iblRoughnessOneLevel, perceptualRoughness);
+    return decodeDataForIBL(textureCubeLod(light_iblSpecular, r, lod));
+}
+
+vec3 getSpecularDominantDirection(const vec3 n, const vec3 r, float roughness) {
+    return mix(r, n, roughness * roughness);
+}
+
+void evaluateIBL(inout PixelParams pixel,
+                 in vec3 vNormal,
+                 in vec3 viewPos,
+                 in mat4 invViewMat,
+                 in sampler2D dfgTex,
+                 in samplerCube iblEnvTex,
+                 in float iblRoughnessOneLevel,
+                 in float iblLuminance,
+                 inout vec3 color)
+{
+    vec3 shading_normal = normalize(vNormal);
+    vec3 shading_view = -normalize(viewPos);
+    float shading_NoV = clampNoV(abs(dot(shading_normal, shading_view)));
+
+    // the above is currently duplicated with CookTorrance
+
+    vec3 shading_reflected = reflect(-shading_view, shading_normal);
+
+    // Pre-filtered DFG term used for image-based lighting
+    pixel.dfg = PrefilteredDFG_LUT(dfgTex, pixel.perceptualRoughness, shading_NoV);
+
+    vec3 E = specularDFG(pixel);
+    vec3 r = getSpecularDominantDirection(shading_normal, shading_reflected, pixel.roughness);
+
+    // OGRE specific: convert r and n back to world space for texture sampling
+    r = normalize(mul(invViewMat, vec4(r, 0.0)).xyz);
+    r.z *= -1.0;
+    shading_normal = normalize(mul(invViewMat, vec4(shading_normal, 0.0)).xyz);
+
+    // specular layer
+    vec3 Fr = E * prefilteredRadiance(iblEnvTex, r, pixel.perceptualRoughness, iblRoughnessOneLevel);
+
+    vec3 diffuseIrradiance = Irradiance_RoughnessOne(iblEnvTex, shading_normal, iblRoughnessOneLevel);
+    vec3 Fd = pixel.diffuseColor * diffuseIrradiance * (1.0 - E);
+
+    Fr *= iblLuminance;
+    Fd *= iblLuminance;
+
+    // Combine all terms
+    // Note: iblLuminance is already premultiplied by the exposure
+#ifndef USE_LINEAR_COLOURS
+    color = pow(color, vec3_splat(2.2)); // gamma to linear
+#endif
+
+    color += Fr + Fd;
+
+#ifndef USE_LINEAR_COLOURS
+    color = pow(color, vec3_splat(1.0/2.2)); // linear to gamma
+    color = saturate(color);
+#endif
+}

ogre_python-14.5.0.data/data/Media/RTShaderLib/RTSLib_LTC.glsl

@@ -0,0 +1,114 @@
+// Real-Time Polygonal-Light Shading with Linearly Transformed Cosines
+// by Eric Heitz, Jonathan Dupuy, Stephen Hill and David Neubelt
+// code: https://github.com/selfshadow/ltc_code/
+// also: https://github.com/mrdoob/three.js/blob/master/src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl.js
+// adapted for Ogre by Pavel Rojtberg
+
+#define LUT_SIZE  64.0
+#define LUT_SCALE ((LUT_SIZE - 1.0)/LUT_SIZE)
+#define LUT_BIAS  (0.5/LUT_SIZE)
+
+vec3 IntegrateEdgeVec(vec3 v1, vec3 v2)
+{
+    float x = dot(v1, v2);
+    float y = abs(x);
+
+    float a = 0.8543985 + (0.4965155 + 0.0145206*y)*y;
+    float b = 3.4175940 + (4.1616724 + y)*y;
+    float v = a / b;
+
+    float theta_sintheta = (x > 0.0) ? v : 0.5*inversesqrt(max(1.0 - x*x, 1e-7)) - v;
+
+    return cross(v1, v2)*theta_sintheta;
+}
+
+float LTC_Evaluate(vec3 N, vec3 V, vec3 P, mat3 Minv, vec3 points[4], sampler2D ltc_2)
+{
+    vec3 dir = points[0] - P;
+    vec3 lightDir = cross(points[1] - points[0], points[3] - points[0]);
+    if(dot(dir, lightDir) < 0.0)
+        return 0.0;
+
+    // construct orthonormal basis around N
+    vec3 T1, T2;
+    T1 = normalize(V - N*dot(V, N));
+    T2 = cross(N, T1);
+
+    // rotate area light in (T1, T2, N) basis
+    Minv = mul(Minv, mtxFromRows(T1, T2, N));
+
+    // polygon
+    vec3 L[4];
+    L[0] = mul(Minv, points[0] - P);
+    L[1] = mul(Minv, points[1] - P);
+    L[2] = mul(Minv, points[2] - P);
+    L[3] = mul(Minv, points[3] - P);
+
+    // project rect onto sphere
+    L[0] = normalize(L[0]);
+    L[1] = normalize(L[1]);
+    L[2] = normalize(L[2]);
+    L[3] = normalize(L[3]);
+
+    vec3 vsum = vec3_splat(0.0);
+
+    vsum += IntegrateEdgeVec(L[0], L[1]);
+    vsum += IntegrateEdgeVec(L[1], L[2]);
+    vsum += IntegrateEdgeVec(L[2], L[3]);
+    vsum += IntegrateEdgeVec(L[3], L[0]);
+
+    float len = length(vsum);
+    float z = vsum.z/len;
+
+    // clipless approximation: tabulated horizon-clipped sphere
+    // visually better than alternatives, but produces artifacts at low roughness values
+    vec2 uv = vec2(z*0.5 + 0.5, len);
+    uv = uv*LUT_SCALE + LUT_BIAS;
+
+    float scale = texture2D(ltc_2, uv).w;
+    return len*scale;
+}
+
+void InitRectPoints(vec3 center, vec3 ex, vec3 ey, out vec3 points[4])
+{
+    points[0] = center - ex - ey;
+    points[1] = center + ex - ey;
+    points[2] = center + ex + ey;
+    points[3] = center - ex + ey;
+}
+
+void evaluateRectLight(sampler2D ltc_1, sampler2D ltc_2, float roughness, vec3 N, vec3 pos, vec3 lpos, vec3 halfwidth, vec3 halfheight,
+                       inout vec3 scol, inout vec3 dcol)
+{
+    vec3 points[4];
+    InitRectPoints(lpos, halfwidth, halfheight, points);
+
+    vec3 V = -normalize(pos);
+
+    float ndotv = saturate(dot(N, V));
+    vec2 uv = vec2(roughness, sqrt(1.0 - ndotv));
+    uv = uv*LUT_SCALE + LUT_BIAS;
+
+    vec4 t1 = texture2D(ltc_1, uv);
+
+    mat3 Minv = mtxFromCols(
+        vec3(t1.x, 0.0, t1.y),
+        vec3( 0.0, 1.0,  0.0),
+        vec3(t1.z, 0.0, t1.w)
+    );
+
+    float spec = LTC_Evaluate(N, V, pos, Minv, points, ltc_2);
+
+    // LTC Fresnel Approximation by Stephen Hill
+    // http://blog.selfshadow.com/publications/s2016-advances/s2016_ltc_fresnel.pdf
+    vec4 t2 = texture2D(ltc_2, uv);
+    scol = (scol*t2.x + (1.0 - scol)*t2.y)*spec;
+
+    mat3 Meye = mat3(
+        vec3(1.0, 0.0, 0.0),
+        vec3(0.0, 1.0, 0.0),
+        vec3(0.0, 0.0, 1.0)
+    );
+
+    dcol *= LTC_Evaluate(N, V, pos, Meye, points, ltc_2);
+}

ogre_python-14.5.0.data/data/Media/RTShaderLib/RTSLib_Lighting.glsl

@@ -0,0 +1,18 @@
+// 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.
+// SPDX-License-Identifier: MIT
+
+#define M_PI 3.14159265359
+
+float getDistanceAttenuation(const vec3 params, float distance)
+{
+    return 1.0 / (params.x + params.y * distance + params.z * distance * distance);
+}
+
+float getAngleAttenuation(const vec3 params, const vec3 lightDir, const vec3 toLight)
+{
+    float rho		= dot(-lightDir, toLight);
+    float fSpotE	= saturate((rho - params.y) / (params.x - params.y));
+    return pow(fSpotE, params.z);
+}

ogre_python-14.5.0.data/data/Media/RTShaderLib/RTSSamplers.material

@@ -0,0 +1,18 @@
+sampler Ogre/ShadowSampler
+{
+    tex_address_mode border
+    tex_border_colour 1 1 1 1
+    filtering linear linear none
+}
+
+sampler Ogre/DepthShadowSampler : Ogre/ShadowSampler
+{
+    compare_test on
+    comp_func less_equal
+}
+
+sampler Ogre/LtcLUTSampler
+{
+    filtering point linear point
+    tex_address_mode clamp
+}