ogre-python 14.2.3__cp312-cp312-win_amd64.whl

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

@@ -0,0 +1,88 @@
+// 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
+
+    color = pow(color, vec3_splat(2.2)); // gamma to linear
+
+    color += Fr + Fd;
+
+    // linear to gamma
+    color = pow(color, vec3_splat(1.0/2.2));
+    color = saturate(color);
+}

ogre_python-14.2.3.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.2.3.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.2.3.data/data/Media/RTShaderLib/RTSSamplers.material

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

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

@@ -0,0 +1,246 @@
+// 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, float 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 vec3 vNormal,
+                in vec3 viewPos,
+                in vec4 lightPos,
+                in vec3 lightColor,
+                in vec4 pointParams,
+                in vec4 vLightDirView,
+                in vec4 spotParams,
+                in PixelParams pixel)
+{
+    vec3 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);
+
+	vec3 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)
+{
+    baseColor = pow(baseColor, vec3_splat(2.2));
+    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);
+    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 vec4 lightPos[LIGHT_COUNT],
+                in vec4 lightColor[LIGHT_COUNT],
+                in vec4 pointParams[LIGHT_COUNT],
+                in vec4 vLightDirView[LIGHT_COUNT],
+                in vec4 spotParams[LIGHT_COUNT],
+                in PixelParams pixel,
+                inout vec3 vOutColour)
+{
+    vOutColour = pow(vOutColour, vec3_splat(2.2)); // gamma to linear
+
+    // 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));
+
+    // linear to gamma
+    vOutColour = pow(vOutColour, vec3_splat(1.0/2.2));
+
+    vOutColour = saturate(vOutColour);
+}
+#endif

ogre_python-14.2.3.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
+}