ogre-python 14.5.0__cp314-cp314-win_amd64.whl

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

@@ -0,0 +1,238 @@
+// This file is part of the OGRE project.
+// code adapted from Google Filament
+// SPDX-License-Identifier: Apache-2.0
+
+#include "RTSLib_Lighting.glsl"
+
+#ifdef HAVE_AREA_LIGHTS
+#include "RTSLib_LTC.glsl"
+#endif
+
+#ifdef OGRE_GLSLES
+    // min roughness such that (MIN_PERCEPTUAL_ROUGHNESS^4) > 0 in fp16 (i.e. 2^(-14/4), rounded up)
+    #define MIN_PERCEPTUAL_ROUGHNESS 0.089
+#else
+    #define MIN_PERCEPTUAL_ROUGHNESS 0.045
+#endif
+
+#define MEDIUMP_FLT_MAX    65504.0
+#define saturateMediump(x) min(x, MEDIUMP_FLT_MAX)
+
+#define MIN_N_DOT_V 1e-4
+
+struct PixelParams
+{
+    vec3 baseColor;
+    vec3 diffuseColor;
+    float perceptualRoughness;
+    float roughness;
+    vec3  f0;
+    vec3  dfg;
+    vec3  energyCompensation;
+};
+
+float clampNoV(float NoV) {
+    // Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
+    return max(NoV, MIN_N_DOT_V);
+}
+
+// Computes x^5 using only multiply operations.
+float pow5(float x) {
+    float x2 = x * x;
+    return x2 * x2 * x;
+}
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/diffusebrdf
+float Fd_Lambert() {
+    return 1.0 / M_PI;
+}
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/fresnel(specularf)
+vec3 F_Schlick(const vec3 f0, float f90, float VoH) {
+    // Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"
+    return f0 + (f90 - f0) * pow5(1.0 - VoH);
+}
+
+vec3 computeDiffuseColor(const vec3 baseColor, float metallic) {
+    return baseColor.rgb * (1.0 - metallic);
+}
+
+vec3 computeF0(const vec3 baseColor, float metallic, float reflectance) {
+    return baseColor.rgb * metallic + (reflectance * (1.0 - metallic));
+}
+
+float perceptualRoughnessToRoughness(float perceptualRoughness) {
+    return perceptualRoughness * perceptualRoughness;
+}
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/geometricshadowing(specularg)
+float V_SmithGGXCorrelated(float roughness, float NoV, float NoL) {
+    // Heitz 2014, "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs"
+    float a2 = roughness * roughness;
+    // TODO: lambdaV can be pre-computed for all the lights, it should be moved out of this function
+    float lambdaV = NoL * sqrt((NoV - a2 * NoV) * NoV + a2);
+    float lambdaL = NoV * sqrt((NoL - a2 * NoL) * NoL + a2);
+    float v = 0.5 / (lambdaV + lambdaL);
+    // a2=0 => v = 1 / 4*NoL*NoV   => min=1/4, max=+inf
+    // a2=1 => v = 1 / 2*(NoL+NoV) => min=1/4, max=+inf
+    // clamp to the maximum value representable in mediump
+    return saturateMediump(v);
+}
+
+// https://google.github.io/filament/Filament.md.html#materialsystem/specularbrdf/normaldistributionfunction(speculard)
+float D_GGX(float roughness, float32_t NoH, const vec3 h, const vec3 n) {
+    // Walter et al. 2007, "Microfacet Models for Refraction through Rough Surfaces"
+
+    // In mediump, there are two problems computing 1.0 - NoH^2
+    // 1) 1.0 - NoH^2 suffers floating point cancellation when NoH^2 is close to 1 (highlights)
+    // 2) NoH doesn't have enough precision around 1.0
+    // Both problem can be fixed by computing 1-NoH^2 in highp and providing NoH in highp as well
+
+    // However, we can do better using Lagrange's identity:
+    //      ||a x b||^2 = ||a||^2 ||b||^2 - (a . b)^2
+    // since N and H are unit vectors: ||N x H||^2 = 1.0 - NoH^2
+    // This computes 1.0 - NoH^2 directly (which is close to zero in the highlights and has
+    // enough precision).
+    // Overall this yields better performance, keeping all computations in mediump
+#ifdef OGRE_GLSLES
+    vec3 NxH = cross(n, h);
+    float oneMinusNoHSquared = dot(NxH, NxH);
+#else
+    float oneMinusNoHSquared = 1.0 - NoH * NoH;
+#endif
+
+    float a = NoH * roughness;
+    float k = roughness / (oneMinusNoHSquared + a * a);
+    float d = k * k * (1.0 / M_PI);
+    return saturateMediump(d);
+}
+
+vec3 evaluateLight(
+                in f32vec3 vNormal,
+                in vec3 viewPos,
+                in f32vec4 lightPos,
+                in vec3 lightColor,
+                in vec4 pointParams,
+                in vec4 vLightDirView,
+                in vec4 spotParams,
+                in PixelParams pixel)
+{
+    f32vec3 vLightView = lightPos.xyz;
+    float fLightD = 0.0;
+
+    if (lightPos.w != 0.0)
+    {
+        vLightView -= viewPos; // to light
+        fLightD     = length(vLightView);
+
+        if(fLightD > pointParams.x)
+            return vec3_splat(0.0);
+    }
+
+	vLightView		   = normalize(vLightView);
+
+	f32vec3 vNormalView = normalize(vNormal);
+	float NoL		 = saturate(dot(vNormalView, vLightView));
+
+    if(NoL <= 0.0)
+        return vec3_splat(0.0); // not lit by this light
+
+    // https://google.github.io/filament/Filament.md.html#toc5.6.2
+    float f90 = saturate(dot(pixel.f0, vec3_splat(50.0 * 0.33)));
+
+	vec3 vView       = -normalize(viewPos);
+
+    // https://google.github.io/filament/Filament.md.html#materialsystem/standardmodelsummary
+    vec3 h    = normalize(vView + vLightView);
+    float NoH = saturate(dot(vNormalView, h));
+    float NoV = clampNoV(abs(dot(vNormalView, vView)));
+
+    float V = V_SmithGGXCorrelated(pixel.roughness, NoV, NoL);
+    vec3 F  = F_Schlick(pixel.f0, f90, NoH);
+    float D = D_GGX(pixel.roughness, NoH, h, vNormalView);
+
+    vec3 Fr = (D * V) * F;
+    vec3 Fd = pixel.diffuseColor * Fd_Lambert();
+
+    // https://google.github.io/filament/Filament.md.html#materialsystem/improvingthebrdfs/energylossinspecularreflectance
+    vec3 color = NoL * lightColor * (Fr * pixel.energyCompensation + Fd);
+
+    color *= getDistanceAttenuation(pointParams.yzw, fLightD);
+
+    if(spotParams.w != 0.0)
+    {
+        color *= getAngleAttenuation(spotParams.xyz, vLightDirView.xyz, vLightView);
+    }
+
+    return color;
+}
+
+void PBR_MakeParams(in vec3 baseColor, in vec2 mrParam, inout PixelParams pixel)
+{
+    pixel.baseColor = baseColor;
+
+    float perceptualRoughness = mrParam.x;
+    // Clamp the roughness to a minimum value to avoid divisions by 0 during lighting
+    pixel.perceptualRoughness = clamp(perceptualRoughness, MIN_PERCEPTUAL_ROUGHNESS, 1.0);
+    // Remaps the roughness to a perceptually linear roughness (roughness^2)
+    pixel.roughness = perceptualRoughnessToRoughness(pixel.perceptualRoughness);
+
+    float metallic = saturate(mrParam.y);
+    pixel.f0 = computeF0(baseColor, metallic, 0.04); // using fixed IOR of 1.5 as per glTF spec
+    pixel.diffuseColor = computeDiffuseColor(baseColor, metallic);
+
+    pixel.dfg = vec3_splat(0.5); // use full f0 for energy compensation
+    pixel.energyCompensation = vec3_splat(0.0); // will be set later
+}
+
+#if LIGHT_COUNT > 0
+void PBR_Lights(
+#ifdef SHADOWLIGHT_COUNT
+                in float shadowFactor[SHADOWLIGHT_COUNT],
+#endif
+#ifdef HAVE_AREA_LIGHTS
+                in sampler2D ltcLUT1,
+                in sampler2D ltcLUT2,
+#endif
+                in vec3 vNormal,
+                in vec3 viewPos,
+                in vec4 ambient,
+                in f32vec4 lightPos[LIGHT_COUNT],
+                in f32vec4 lightColor[LIGHT_COUNT],
+                in f32vec4 pointParams[LIGHT_COUNT],
+                in f32vec4 vLightDirView[LIGHT_COUNT],
+                in f32vec4 spotParams[LIGHT_COUNT],
+                in PixelParams pixel,
+                inout vec3 vOutColour)
+{
+    // Energy compensation for multiple scattering in a microfacet model
+    // See "Multiple-Scattering Microfacet BSDFs with the Smith Model"
+    pixel.energyCompensation = 1.0 + pixel.f0 * (1.0 / pixel.dfg.y - 1.0);
+
+    for(int i = 0; i < LIGHT_COUNT; i++)
+    {
+#ifdef HAVE_AREA_LIGHTS
+        if(spotParams[i].w == 2.0)
+        {
+            // rect area light
+            vec3 dcol = pixel.diffuseColor;
+            vec3 scol = pixel.f0;
+            evaluateRectLight(ltcLUT1, ltcLUT2, pixel.roughness, normalize(vNormal), viewPos,
+                              lightPos[i].xyz, spotParams[i].xyz, pointParams[i].xyz, scol, dcol);
+            vOutColour += lightColor[i].xyz * (scol + dcol) * 4.0;
+            continue;
+        }
+#endif
+        vec3 lightVal = evaluateLight(vNormal, viewPos, lightPos[i], lightColor[i].xyz, pointParams[i], vLightDirView[i], spotParams[i],
+                        pixel);
+
+#ifdef SHADOWLIGHT_COUNT
+        if(i < SHADOWLIGHT_COUNT)
+            lightVal *= shadowFactor[i];
+#endif
+        vOutColour += lightVal;
+    }
+
+    vOutColour += pixel.baseColor * pow(ambient.rgb, vec3_splat(2.2));
+}
+#endif

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

@@ -0,0 +1,172 @@
+/*
+-----------------------------------------------------------------------------
+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.
+-----------------------------------------------------------------------------
+*/
+
+//These functions are based on dqs.cg from http://isg.cs.tcd.ie/kavanl/dq/
+/* dqs.cg
+
+  Dual quaternion skinning vertex shaders (no shading computations)
+
+  Version 1.0.3, November 1st, 2007
+
+  Copyright (C) 2006-2007 University of Dublin, Trinity College, All Rights 
+  Reserved
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the author(s) be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Author: Ladislav Kavan, kavanl@cs.tcd.ie
+
+*/
+
+//-----------------------------------------------------------------------------
+// Program Name: SGXLib_DualQuaternion
+// Program Desc: Dual quaternion skinning functions.
+// Program Type: Vertex shader
+// Language: GLSL
+//-----------------------------------------------------------------------------
+
+#if defined(OGRE_HLSL) || defined(OGRE_CG)
+// this is technically wrong, thats why we dont put it into OgreUnifiedShader.h
+#define mat2x4 float2x4
+#define mat3x4 float3x4
+#endif
+
+//-----------------------------------------------------------------------------
+void SGX_BlendWeight(in float blendWgt, in mat2x4 dualQuaternion, out mat2x4 vOut)
+{
+	vOut = blendWgt*dualQuaternion;
+}
+
+//-----------------------------------------------------------------------------
+void SGX_BlendWeight(in float blendWgt, in mat3x4 scaleShearMatrix, out mat3x4 vOut)
+{
+	vOut = blendWgt*scaleShearMatrix;
+}
+
+//-----------------------------------------------------------------------------
+// Adjusts the sign of a dual quaternion depending on its orientation to the root dual quaternion
+void SGX_AntipodalityAdjustment(in mat2x4 dq0, in mat2x4 dq1,out mat2x4 dq2)
+{
+	//Accurate antipodality handling. For speed increase, remove the following line, 
+	//though, the results will only be valid for rotations less than 180 degrees.
+	dq2 = (dot(dq0[0], dq1[0]) < 0.0) ? dq1 * -1.0 : dq1;
+}
+
+//-----------------------------------------------------------------------------
+void SGX_CalculateBlendPosition(in vec3 position, in mat2x4 blendDQ, out vec4 vOut)
+{
+	vec3 blendPosition = position + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, position) + blendDQ[0].x*position);
+	vec3 trans = 2.0*(blendDQ[0].x*blendDQ[1].yzw - blendDQ[1].x*blendDQ[0].yzw + cross(blendDQ[0].yzw, blendDQ[1].yzw));
+	blendPosition += trans;
+
+	vOut = vec4(blendPosition, 1.0);
+}
+
+//-----------------------------------------------------------------------------
+void SGX_CalculateBlendNormal(in vec3 normal, in mat2x4 blendDQ, out vec3 vOut)
+{
+	vOut = normal + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, normal) + blendDQ[0].x*normal);
+}
+
+//-----------------------------------------------------------------------------
+void SGX_AdjointTransposeMatrix(in mat3x4 M, out mat3 vOut)
+{
+	mat3 atM;
+	atM[0][0] = M[2][2] * M[1][1] - M[1][2] * M[2][1];
+	atM[0][1] = M[1][2] * M[2][0] - M[1][0] * M[2][2];
+	atM[0][2] = M[1][0] * M[2][1] - M[2][0] * M[1][1];
+
+	atM[1][0] = M[0][2] * M[2][1] - M[2][2] * M[0][1];
+	atM[1][1] = M[2][2] * M[0][0] - M[0][2] * M[2][0];
+	atM[1][2] = M[2][0] * M[0][1] - M[0][0] * M[2][1];
+
+	atM[2][0] = M[1][2] * M[0][1] - M[0][2] * M[1][1];
+	atM[2][1] = M[1][0] * M[0][2] - M[1][2] * M[0][0];
+	atM[2][2] = M[0][0] * M[1][1] - M[1][0] * M[0][1];
+
+	vOut = atM;
+}
+
+//-----------------------------------------------------------------------------
+void blendBonesDQ(mat2x4 bones_dq[BONE_COUNT], vec4 indices, vec4 weights, out mat2x4 blendDQ)
+{
+	blendDQ = bones_dq[int(indices.x)] * weights.x;
+	mat2x4 dqi;
+#ifdef CORRECT_ANTIPODALITY
+	mat2x4 dq0 = blendDQ;
+#endif
+#if WEIGHT_COUNT > 1
+	dqi = bones_dq[int(indices.y)] * weights.y;
+#	ifdef CORRECT_ANTIPODALITY
+	SGX_AntipodalityAdjustment(dq0, dqi, dqi);
+#	endif
+	blendDQ += dqi;
+#endif
+#if WEIGHT_COUNT > 2
+	dqi = bones_dq[int(indices.z)] * weights.z;
+#	ifdef CORRECT_ANTIPODALITY
+	SGX_AntipodalityAdjustment(dq0, dqi, dqi);
+#	endif
+	blendDQ += dqi;
+#endif
+#if WEIGHT_COUNT > 3
+	dqi = bones_dq[int(indices.w)] * weights.w;
+#	ifdef CORRECT_ANTIPODALITY
+	SGX_AntipodalityAdjustment(dq0, dqi, dqi);
+#	endif
+	blendDQ += dqi;
+#endif
+
+	blendDQ /= length(blendDQ[0]); // normalise dual quaternion
+}
+
+void blendBonesMat3x4(mat3x4 bones_mat[BONE_COUNT], vec4 indices, vec4 weights, out mat3x4 blendMat)
+{
+	blendMat = bones_mat[int(indices.x)] * weights.x;
+#if WEIGHT_COUNT > 1
+	blendMat += bones_mat[int(indices.y)] * weights.y;
+#endif
+#if WEIGHT_COUNT > 2
+	blendMat += bones_mat[int(indices.z)] * weights.z;
+#endif
+#if WEIGHT_COUNT > 3
+	blendMat += bones_mat[int(indices.w)] * weights.w;
+#endif
+}

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

@@ -0,0 +1,198 @@
+/*
+-----------------------------------------------------------------------------
+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: SGXLib_IntegratedPSSM
+// Program Desc: Integrated PSSM functions.
+// Program Type: Vertex/Pixel shader
+// Language: GLSL
+//-----------------------------------------------------------------------------
+
+#ifdef PSSM_ARRAY_TEXTURE
+#   ifdef PSSM_SAMPLE_CMP
+    #define SAMPLER_TYPE sampler2DArrayShadow
+#   else
+    #define SAMPLER_TYPE sampler2DArray
+#   endif
+#define PSSM_LAYER_ARG(x) x,
+#else
+#   ifdef PSSM_SAMPLE_CMP
+    #define SAMPLER_TYPE sampler2DShadow
+#   else
+    #define SAMPLER_TYPE sampler2D
+#   endif
+#define PSSM_LAYER_ARG(x)
+#endif
+
+// default to 2x2 PCF
+#ifndef PCF_XSAMPLES
+#define PCF_XSAMPLES 2.0
+#endif
+
+//-----------------------------------------------------------------------------
+#ifdef SHADOWLIGHT_COUNT
+void SGX_ApplyShadowFactor_Modulative(in vec4 ambient,
+					  in float fShadowFactor[SHADOWLIGHT_COUNT],
+					  inout vec4 diffCol
+#ifdef USE_SPECULAR
+					  , inout vec4 specCol
+#endif
+					  )
+{
+	float shadowFactor = fShadowFactor[0];
+	for(int i = 1; i < SHADOWLIGHT_COUNT; ++i)
+		shadowFactor *= fShadowFactor[i];
+
+	diffCol.rgb = mix(ambient.rgb, diffCol.rgb, shadowFactor);
+
+#ifdef USE_SPECULAR
+	specCol.rgb *= shadowFactor;
+#endif
+}
+#endif
+//-----------------------------------------------------------------------------
+#ifdef PSSM_SAMPLE_COLOUR
+void SGX_ShadowPCF4(in SAMPLER_TYPE shadowMap, in vec4 shadowMapPos, in vec2 invTexSize, PSSM_LAYER_ARG(in float layer) out float c)
+{
+#	ifdef PSSM_ARRAY_TEXTURE
+	c = texture2DArray(shadowMap, vec3(shadowMapPos.xy/shadowMapPos.w, layer)).x;
+#	else
+	c = texture2DProj(shadowMap, shadowMapPos).x;
+#	endif
+}
+#else
+float sampleDepth(in SAMPLER_TYPE shadowMap, vec2 uv, PSSM_LAYER_ARG(in float layer) float depth)
+{
+#ifdef PSSM_ARRAY_TEXTURE
+	// we can assume PSSM_SAMPLE_CMP is always defined when using array textures
+	return shadow2D(shadowMap, vec4(uv, layer, depth));
+#elif defined(PSSM_SAMPLE_CMP)
+#	if defined(OGRE_GLSL) && OGRE_GLSL < 130
+	return shadow2D(shadowMap, vec3(uv, depth)).r;
+#	else
+	return shadow2D(shadowMap, vec3(uv, depth));
+#	endif
+#else
+	return (depth <= texture2D(shadowMap, uv).r) ? 1.0 : 0.0;
+#endif
+}
+void SGX_ShadowPCF4(in SAMPLER_TYPE shadowMap, in f32vec4 shadowMapPos, in vec2 invTexSize, PSSM_LAYER_ARG(in float layer) out float c)
+{
+	shadowMapPos = shadowMapPos / shadowMapPos.w;
+#if !defined(OGRE_REVERSED_Z) && !defined(OGRE_HLSL) && !defined(VULKAN)
+	shadowMapPos.z = shadowMapPos.z * 0.5 + 0.5; // convert -1..1 to 0..1
+#endif
+	vec2 uv = shadowMapPos.xy;
+
+    // depth must be clamped to support floating-point depth formats. This is to avoid comparing a
+    // value from the depth texture (which is never greater than 1.0) with a greater-than-one
+    // comparison value (which is possible with floating-point formats).
+	float depth = clamp(shadowMapPos.z, 0.0, 1.0);
+
+	c = 0.0;
+	float scale = 1.0;
+	float offset = (PCF_XSAMPLES / 2.0 - 0.5) * scale;
+	for (float y = -offset; y <= offset; y += scale)
+		for (float x = -offset; x <= offset; x += scale)
+			c += sampleDepth(shadowMap, uv + invTexSize * vec2(x, y), PSSM_LAYER_ARG(layer) depth);
+
+	c /= PCF_XSAMPLES * PCF_XSAMPLES;
+}
+#endif
+
+//-----------------------------------------------------------------------------
+void SGX_ComputeShadowFactor_PSSM3(in float32_t fDepth,
+							in vec4 vSplitPoints,	
+							in vec4 lightPosition0,
+							in SAMPLER_TYPE shadowMap0,
+							in vec2 invShadowMapSize0,
+							#if PSSM_NUM_SPLITS > 2
+							in vec4 lightPosition1,
+							in SAMPLER_TYPE shadowMap1,
+							in vec2 invShadowMapSize1,
+							#endif
+							#if PSSM_NUM_SPLITS > 3
+							in vec4 lightPosition2,
+							in SAMPLER_TYPE shadowMap2,
+							in vec2 invShadowMapSize2,
+							#endif
+							in vec4 lightPosition3,
+							in SAMPLER_TYPE shadowMap3,
+							in vec2 invShadowMapSize3,
+							out float oShadowFactor
+							#ifdef DEBUG_PSSM
+							, out vec4 oDiffuse
+							#endif
+							)
+{
+#if !defined(OGRE_REVERSED_Z) && !defined(OGRE_HLSL) && !defined(VULKAN)
+	vSplitPoints = vSplitPoints * 0.5 + 0.5; // convert -1..1 to 0..1
+#endif
+
+#ifdef OGRE_REVERSED_Z
+	vSplitPoints = vec4_splat(1.0) - vSplitPoints;
+	fDepth = 1.0 - fDepth;
+#endif
+
+	if (fDepth  <= vSplitPoints.x)
+	{
+		SGX_ShadowPCF4(shadowMap0, lightPosition0, invShadowMapSize0, PSSM_LAYER_ARG(0.0) oShadowFactor);
+#ifdef DEBUG_PSSM
+        oDiffuse.r += 1.0;
+#endif
+	}
+#if PSSM_NUM_SPLITS > 2
+	else if (fDepth <= vSplitPoints.y)
+	{
+		SGX_ShadowPCF4(shadowMap1, lightPosition1, invShadowMapSize1, PSSM_LAYER_ARG(1.0) oShadowFactor);
+#ifdef DEBUG_PSSM
+        oDiffuse.g += 1.0;
+#endif
+	}
+#endif
+#if PSSM_NUM_SPLITS > 3
+	else if (fDepth <= vSplitPoints.z)
+	{
+        SGX_ShadowPCF4(shadowMap2, lightPosition2, invShadowMapSize2, PSSM_LAYER_ARG(2.0) oShadowFactor);
+#ifdef DEBUG_PSSM
+		oDiffuse.r += 1.0;
+        oDiffuse.g += 1.0;
+#endif
+	}
+#endif
+	else if (fDepth <= vSplitPoints.w)
+	{
+		SGX_ShadowPCF4(shadowMap3, lightPosition3, invShadowMapSize3, PSSM_LAYER_ARG(float(PSSM_NUM_SPLITS - 1)) oShadowFactor);
+#ifdef DEBUG_PSSM
+        oDiffuse.b += 1.0;
+#endif
+	}
+	else
+	{
+		// behind far distance
+		oShadowFactor = 1.0;
+	}
+}