ogre-python 14.5.0__cp314-cp314-win_amd64.whl

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

@@ -0,0 +1,125 @@
+/*
+-----------------------------------------------------------------------------
+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_NormalMapLighting
+// Program Desc: Normal map lighting functions.
+// Program Type: Vertex/Pixel shader
+// Language: GLSL
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+void SGX_FetchNormal(in sampler2D s,
+				   in vec2 uv,
+				   out vec3 vOut)
+{
+	vOut = 2.0 * texture2D(s, uv).xyz - 1.0;
+}
+
+//-----------------------------------------------------------------------------
+void SGX_CalculateTBN(in vec3 vNormal,
+					  in vec4 vTangent,
+					  out mat3 TBN)
+{
+	vec3 vBinormal = cross(vNormal, vTangent.xyz) * vTangent.w;
+
+	// direction: from tangent space to world
+	TBN = mtxFromCols(vTangent.xyz, vBinormal, vNormal);
+}
+
+//-----------------------------------------------------------------------------
+void SGX_Generate_Parallax_Texcoord(in sampler2D normalHeightMap,
+						in vec2 texCoord,
+						in vec3 viewPos,
+						in float heightScale,
+						in mat3 TBN,
+						out f32vec2 newTexCoord)
+{
+	//Calculate eye direction
+	f32vec3 eyeVec = mul(-viewPos, TBN);
+	eyeVec = normalize(eyeVec);
+#ifndef TERRAIN_PARALLAX_MAPPING
+	eyeVec.y = -eyeVec.y; //Inverse y
+#endif
+
+	newTexCoord = texCoord;
+
+#ifndef POM_LAYER_COUNT
+	//Simple parallax mapping
+	float height = 1.0 - texture2D(normalHeightMap, newTexCoord).a;
+
+	#ifndef TERRAIN_PARALLAX_MAPPING
+		vec2 p = eyeVec.xy / eyeVec.z * (height * heightScale);
+	#else
+	    vec2 p = eyeVec.xy * (height * heightScale);
+	#endif
+
+    newTexCoord = newTexCoord - p;
+#else
+	// parallax occlusion mapping
+#ifdef POM_MAX_DISTANCE
+	if (abs(viewPos.z) > POM_MAX_DISTANCE)
+		return;
+#endif
+
+	//Configure steep mapping layering.
+	float layerDepth = 1.0 / float(POM_LAYER_COUNT);
+	float currentLayerDepth = 0.0;
+	vec2 parallaxShift = (eyeVec.xy) * heightScale;
+	vec2 deltaTexCoords = parallaxShift / float(POM_LAYER_COUNT);
+
+	float currentDepthMapValue = 1.0 - texture2D(normalHeightMap, newTexCoord).a;
+
+	//Loop through layers and break early if match found.
+	for (int currentLayerId = 0; currentLayerId < POM_LAYER_COUNT; currentLayerId++)
+	{
+		// shift texture coordinates along direction of P
+		newTexCoord -= deltaTexCoords;
+
+		// get depthmap value at current texture coordinates
+		currentDepthMapValue = 1.0 - texture2D(normalHeightMap, newTexCoord).a;
+
+		//Break if layer height matched
+		if (currentLayerDepth > currentDepthMapValue)
+			break;
+
+		// get depth of next layer
+		currentLayerDepth += layerDepth;
+	}
+
+	// get texture coordinates before collision (reverse operations)
+	vec2 prevTexCoords = newTexCoord + deltaTexCoords;
+
+	// get depth after and before collision for linear interpolation
+	float afterDepth  = currentDepthMapValue - currentLayerDepth;
+	float beforeDepth = (1.0 - texture2D(normalHeightMap, prevTexCoords).a) - currentLayerDepth + layerDepth;
+
+	// interpolation of texture coordinates
+	float weight = afterDepth / (afterDepth - beforeDepth);
+	newTexCoord = mix(newTexCoord, prevTexCoords, weight);
+#endif
+}

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

@@ -0,0 +1,183 @@
+/*
+-----------------------------------------------------------------------------
+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_Lighting
+// Program Desc: Per pixel lighting functions.
+// Program Type: Vertex/Pixel shader
+// Language: GLSL
+// Notes: Implements core functions for FFPLighting class.
+// based on lighting engine. 
+// See http://msdn.microsoft.com/en-us/library/bb147178.aspx
+//-----------------------------------------------------------------------------
+
+#include "RTSLib_Lighting.glsl"
+#ifdef HAVE_AREA_LIGHTS
+#include "RTSLib_LTC.glsl"
+#endif
+
+#ifdef USE_LINEAR_COLOURS
+#define FFP_SATURATE(x) x
+#else
+#define FFP_SATURATE(x) saturate(x)
+#endif
+
+#ifdef OGRE_HLSL
+void SGX_Flip_Backface_Normal(in float triArea, in float targetFlipped, inout vec3 normal)
+{
+#if OGRE_HLSL == 3
+	triArea *= -1.0;
+	triArea *= targetFlipped;
+#endif
+	if(triArea < 0.0)
+		normal *= -1.0;
+}
+#else
+void SGX_Flip_Backface_Normal(in bool frontFacing, in float targetFlipped, inout vec3 normal)
+{
+	if(!frontFacing)
+		normal *= -1.0;
+}
+#endif
+
+void evaluateLight(
+				in vec3 vNormal,
+				in f32vec3 vViewPos,
+				in vec4 vLightPos,
+				in vec4 vAttParams,
+				in vec4 vLightDirView,
+				in vec4 spotParams,
+				in vec4 vDiffuseColour,
+				inout vec3 vOutDiffuse
+#if defined(TVC_DIFFUSE) || defined(TVC_SPECULAR)
+				, in vec4 vInVertexColour
+#endif
+#ifdef USE_SPECULAR
+				, in vec4 vSpecularColour,
+				in float fSpecularPower,
+				inout vec3 vOutSpecular
+#endif
+#ifdef SHADOWLIGHT_COUNT
+				, in float shadowFactor
+#endif
+#ifdef HAVE_AREA_LIGHTS
+				, in sampler2D ltcLUT1,
+				in sampler2D ltcLUT2
+#endif
+				)
+{
+
+    vec3 vLightView = vLightPos.xyz;
+    float fLightD = 0.0;
+
+#ifdef TVC_DIFFUSE
+	vDiffuseColour *= vInVertexColour;
+#endif
+
+#ifdef HAVE_AREA_LIGHTS
+	if(spotParams.w == 2.0)
+	{
+		// rect area light
+		vec3 dcol = vDiffuseColour.rgb;
+#ifdef USE_SPECULAR
+#ifdef TVC_SPECULAR
+		vSpecularColour *= vInVertexColour;
+#endif
+		vec3 scol = vSpecularColour.rgb;
+#else
+		vec3 scol = vec3_splat(0.0);
+		float fSpecularPower = 0.0;
+#endif
+		float roughness = saturate(1.0 - fSpecularPower/128.0); // convert specular to roughness
+		roughness *= roughness; // perceptual to physical roughness
+		evaluateRectLight(ltcLUT1, ltcLUT2, roughness, normalize(vNormal), vViewPos, vLightPos.xyz, spotParams.xyz, vAttParams.xyz, scol, dcol);
+
+#ifdef SHADOWLIGHT_COUNT
+		dcol *= shadowFactor;
+		scol *= shadowFactor;
+#endif
+
+		// linear to gamma
+		dcol = pow(dcol, vec3_splat(1.0/2.2));
+		vOutDiffuse.rgb = FFP_SATURATE(vOutDiffuse.rgb + dcol);
+#ifdef USE_SPECULAR
+		scol = pow(scol, vec3_splat(1.0/2.2));
+		vOutSpecular.rgb = FFP_SATURATE(vOutSpecular.rgb + scol);
+#endif
+		return;
+	}
+#endif
+
+    if (vLightPos.w != 0.0)
+    {
+		f32vec3 tmp = vLightPos.xyz - vViewPos;
+        fLightD     = length(tmp);
+
+        if(fLightD > vAttParams.x)
+            return;
+
+		vLightView = tmp / fLightD; // normalize
+    }
+	else
+	{
+		vLightView = normalize(vLightView);
+	}
+
+	vec3 vNormalView = normalize(vNormal);
+	float nDotL		   = saturate(dot(vNormalView, vLightView));
+	
+	if (nDotL <= 0.0)
+		return;
+
+	float fAtten	   = getDistanceAttenuation(vAttParams.yzw, fLightD);
+
+#ifdef SHADOWLIGHT_COUNT
+	fAtten *= shadowFactor;
+#endif
+
+    if(spotParams.w != 0.0)
+    {
+        fAtten *= getAngleAttenuation(spotParams.xyz, vLightDirView.xyz, vLightView);
+    }
+
+	vOutDiffuse  += vDiffuseColour.rgb * nDotL * fAtten;
+	vOutDiffuse = FFP_SATURATE(vOutDiffuse);
+
+#ifdef USE_SPECULAR
+	f32vec3 vView       = -normalize(vViewPos);
+	f32vec3 vHalfWay    = normalize(vView + vLightView);
+	float32_t nDotH  = saturate(dot(vNormalView, vHalfWay));
+#ifdef TVC_SPECULAR
+	vSpecularColour *= vInVertexColour;
+#endif
+#ifdef NORMALISED
+	vSpecularColour *= (fSpecularPower + 8.0)/(8.0 * M_PI);
+#endif
+	vOutSpecular += vSpecularColour.rgb * pow(nDotH, fSpecularPower) * fAtten;
+	vOutSpecular = FFP_SATURATE(vOutSpecular);
+#endif
+}

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

@@ -0,0 +1,47 @@
+/*
+-----------------------------------------------------------------------------
+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.
+-----------------------------------------------------------------------------
+*/
+
+void SGX_TriplanarTexturing(in vec4 diffuse, in vec3 normal, in vec4 position, in sampler2D texFromX, in sampler2D texFromY, in sampler2D texFromZ, in vec3 parameters, out vec4 cOut)
+{
+	vec3 blendWeights = abs(normalize(normal));
+	blendWeights = blendWeights - parameters.y;
+	blendWeights = pow(max(blendWeights, vec3(0.0, 0.0, 0.0)), parameters.zzz);
+	float tot = (blendWeights.x + blendWeights.y + blendWeights.z);
+	blendWeights /= vec3(tot, tot, tot);
+	// Move the planar mapping a bit according to the normal length to avoid bad looking skirts.
+	float nLength = length(normal - 1.0);
+	vec2 coord1 = (position.yz + nLength) * parameters.x;
+	vec2 coord2 = (position.zx + nLength) * parameters.x;
+	vec2 coord3 = (position.xy + nLength) * parameters.x;
+	
+	vec4 col1 = texture2D(texFromX, coord1);
+	vec4 col2 = texture2D(texFromY, coord2);
+	vec4 col3 = texture2D(texFromZ, coord3);
+	cOut = diffuse * vec4(col1.xyz * blendWeights.x +
+		col2.xyz * blendWeights.y +
+		col3.xyz * blendWeights.z, 1);
+}

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

@@ -0,0 +1,19 @@
+// 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
+
+float weight(float z, float a)
+{
+    // from https://casual-effects.blogspot.com/2015/03/implemented-weighted-blended-order.html
+    return clamp(pow(min(1.0, a * 10.0) + 0.01, 3.0) * 1e8 * pow(1.0 - z * 0.9, 3.0), 1e-2, 3e3);
+}
+
+void SGX_WBOIT(float depth, inout vec4 accum, out vec4 revealage)
+{
+    vec4 colour = accum;
+    // Weighted Blended Order-Independent Transparency, Listing 4
+    float w = weight(depth, colour.a);
+    accum = vec4(colour.rgb * w * colour.a, colour.a);
+    revealage = vec4_splat(colour.a * w);
+}

ogre_python-14.5.0.data/data/Media/Terrain/TerrainSurface.glsl

@@ -0,0 +1,91 @@
+// 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
+
+#include "RTSLib_Colour.glsl"
+
+void transformToTS(in vec3 TSnormal, in mat3 normalMatrix, inout vec3 normal)
+{
+    // derive the tangent space basis
+    // we do this in the pixel shader because we don't have per-vertex normals
+    // because of the LOD, we use a normal map
+    // tangent is always +x or -z in object space depending on alignment
+#ifdef TERRAIN_ALIGN_Y_Z
+    vec3 tangent = vec3(0, 0, -1);
+#else
+    vec3 tangent = vec3(1, 0, 0);
+#endif
+    normal = normalize(normal);
+    tangent = normalize(mul(normalMatrix, tangent));
+    vec3 binormal = cross(tangent, normal);
+    // note, now we need to re-cross to derive tangent again because it wasn't orthonormal
+    tangent = cross(normal, binormal);
+    // derive final matrix
+    mat3 TBN = mtxFromCols(tangent, binormal, normal);
+
+    normal = mul(TBN, TSnormal);
+}
+
+void getShadowFactor(in sampler2D lightmap, in vec2 uv, inout float shadowFactor)
+{
+    float lmShadow = texture2D(lightmap, uv).x;
+    shadowFactor = min(shadowFactor, lmShadow);
+}
+
+#define MIN_BLEND_WEIGHT 0.0039 // 1/255
+
+void blendTerrainLayer(in float blendWeight, in f32vec2 uv0, in float uvMul,
+#ifdef TERRAIN_PARALLAX_MAPPING
+                    in vec3 viewPos, in float scaleBias, in mat3 TBN,
+#endif
+#ifdef TERRAIN_NORMAL_MAPPING
+                    in sampler2D normtex, inout vec3 normal,
+#endif
+                    in sampler2D difftex, inout vec4 diffuseSpec)
+{
+    if(blendWeight < MIN_BLEND_WEIGHT)
+        return;
+
+    // generate UV
+    vec2 uv = mod(uv0 * uvMul, 1.0);
+
+#ifdef TERRAIN_PARALLAX_MAPPING
+    SGX_Generate_Parallax_Texcoord(normtex, uv, viewPos, scaleBias, TBN, uv);
+#endif
+
+    // sample diffuse texture
+    vec4 diffuseSpecTex = texture2D(difftex, uv);
+    ENABLE_LINEAR_COLOUR(diffuseSpecTex);
+    // apply to common
+    diffuseSpec = mix(diffuseSpec, diffuseSpecTex, blendWeight);
+
+#ifdef TERRAIN_NORMAL_MAPPING
+    vec3 TSnormal;
+    // access TS normal map
+    SGX_FetchNormal(normtex, uv, TSnormal);
+    // Partial Derivative Blending https://blog.selfshadow.com/publications/blending-in-detail/
+    normal = normalize(vec3(mix(normal.xy*TSnormal.z, TSnormal.xy*normal.z, blendWeight), TSnormal.z*normal.z));
+#endif
+}
+
+//-----------------------------------------------------------------------------
+void SGX_CalculateTerrainTBN(in vec3 normal, in mat3 normalMatrix, out mat3 TBN)
+{
+    // derive the tangent space basis
+    // we do this in the pixel shader because we don't have per-vertex normals
+    // because of the LOD, we use a normal map
+    // tangent is always +x or -z in object space depending on alignment
+	#ifdef TERRAIN_ALIGN_Y_Z
+		vec3 tangent = vec3(0, 0, -1);
+	#else
+		vec3 tangent = vec3(1, 0, 0);
+	#endif
+    normal = normalize(normal);
+    tangent = normalize(mul(normalMatrix, tangent));
+    vec3 binormal = cross(tangent, normal);
+    // note, now we need to re-cross to derive tangent again because it wasn't orthonormal
+    tangent = cross(normal, binormal);
+    // derive final matrix
+    TBN = mtxFromCols(tangent, binormal, normal);
+}

ogre_python-14.5.0.data/data/Media/Terrain/TerrainTransforms.glsl

@@ -0,0 +1,36 @@
+/**
+ * @param delta: lodDelta, lodThreshold (vertex attribute)
+ * @param lodMorph: morph amount, morph targetLOD (uniform)
+ */
+void applyLODMorph(vec2 delta, vec2 lodMorph, inout float height
+#ifdef TERRAIN_DEBUG
+, out vec2 lodInfo
+#endif
+)
+{
+    // determine whether to apply the LOD morph to this vertex
+    // we store the deltas against all vertices so we only want to apply
+    // the morph to the ones which would disappear.
+    // If we subtract
+    // the lodThreshold from the targetLOD, and arrange to only morph if the
+    // result is negative (it will only be -1 in fact, since after that
+    // the vertex will never be indexed), we will achieve our aim.
+    // sign(lodThreshold - targetLOD) == -1 is to morph
+
+    // this will either be 1 (morph) or 0 (don't morph)
+    float toMorph = -min(0.0, sign(delta.y - lodMorph.y));
+    height += delta.x * toMorph * lodMorph.x;
+
+#ifdef TERRAIN_DEBUG
+    // LOD level (-1 since value is target level, we want to display actual)
+    lodInfo.x = (lodMorph.y - 1) / NUM_LODS;
+    // LOD morph
+    lodInfo.y = toMorph * lodMorph.x;
+#endif
+}
+
+void expandVertex(mat4 idxToObjectSpace, float baseUVScale, vec2 idx, float height, out vec4 position, out vec2 uv)
+{
+    position = mul(idxToObjectSpace, vec4(idx, height, 1));
+    uv = vec2(idx.x * baseUVScale, 1.0 - idx.y * baseUVScale);
+}

ogre_python-14.5.0.data/data/bin/plugins.cfg

@@ -0,0 +1,27 @@
+# Defines plugins to load
+
+# Define plugin folder
+PluginFolder=.
+
+# Define plugins
+# Plugin=RenderSystem_Direct3D9
+ Plugin=RenderSystem_Direct3D11
+ Plugin=RenderSystem_GL
+ Plugin=RenderSystem_GL3Plus
+ Plugin=RenderSystem_GLES2
+# Plugin=RenderSystem_Metal
+ Plugin=RenderSystem_Tiny
+ Plugin=RenderSystem_Vulkan
+ Plugin=Plugin_ParticleFX
+# Plugin=Plugin_BSPSceneManager
+# Plugin=Plugin_CgProgramManager
+ Plugin=Plugin_GLSLangProgramManager
+# Plugin=Codec_EXR
+ Plugin=Codec_STBI
+# Plugin=Codec_RsImage
+# Plugin=Codec_FreeImage
+# Plugin=Plugin_PCZSceneManager
+# Plugin=Plugin_OctreeZone
+ Plugin=Plugin_OctreeSceneManager
+ Plugin=Plugin_DotScene
+ Plugin=Codec_Assimp

ogre_python-14.5.0.data/data/bin/resources.cfg

@@ -0,0 +1,12 @@
+# Ogre Core Resources
+[OgreInternal]
+FileSystem=../Media/Main
+FileSystem=../Media/RTShaderLib
+FileSystem=../Media/Terrain/
+
+# Resources required by OgreBites::Trays
+[Essential]
+Zip=../Media/packs/SdkTrays.zip
+Zip=../Media/packs/profiler.zip
+
+