@fps-games/engine 0.0.1-beta.5 → 0.0.1-beta.8

package/dist/babylon/renderer/shadows/planar-shadow-shaders.js

@@ -0,0 +1,316 @@
+import { Effect } from '@babylonjs/core/Materials/effect.js';
+export const PLANAR_SHADOW_SHADER_NAME = 'fpsPlanarShadow';
+export function registerPlanarShadowShaders() {
+    const vertexKey = `${PLANAR_SHADOW_SHADER_NAME}VertexShader`;
+    if (Effect.ShadersStore[vertexKey])
+        return;
+    Effect.ShadersStore[vertexKey] = `
+precision highp float;
+
+attribute vec3 position;
+
+#ifdef INSTANCES
+attribute vec4 world0;
+attribute vec4 world1;
+attribute vec4 world2;
+attribute vec4 world3;
+attribute float shadowVisibility;
+varying float v_shadowVisibility;
+#endif
+
+#ifdef ALPHA_CUTOUT
+attribute vec2 uv;
+attribute vec2 uv2;
+attribute vec2 uv3;
+attribute vec2 uv4;
+attribute vec2 uv5;
+attribute vec2 uv6;
+varying vec2 v_shadowAlphaUv;
+#ifdef ALPHA_CUTOUT_SECONDARY
+varying vec2 v_shadowAlphaUv2;
+#endif
+#endif
+
+#ifdef BONE
+attribute vec4 matricesIndices;
+attribute vec4 matricesWeights;
+#ifdef BONETEXTURE
+uniform sampler2D boneSampler;
+uniform float boneTextureWidth;
+#else
+uniform mat4 mBones[BonesPerMesh];
+#endif
+#ifdef BONES_VELOCITY_ENABLED
+attribute vec4 matricesIndicesExtra;
+attribute vec4 matricesWeightsExtra;
+#endif
+#endif
+
+uniform mat4 world;
+uniform mat4 viewProjection;
+uniform vec3 u_lightDir;
+uniform vec3 u_planeNormal;
+uniform vec3 u_shadowCenter;
+uniform float u_planeHeight;
+uniform float u_planeBias;
+uniform float u_footprintScale;
+uniform float u_shadowAlphaUvSet;
+uniform mat4 u_shadowAlphaMatrix;
+#ifdef ALPHA_CUTOUT_SECONDARY
+uniform float u_shadowAlphaUvSet2;
+uniform mat4 u_shadowAlphaMatrix2;
+#endif
+
+varying float v_t;
+
+mat4 resolvePlanarShadowWorld() {
+  #ifdef INSTANCES
+  mat4 instanceWorld = mat4(world0, world1, world2, world3);
+  #ifdef THIN_INSTANCES
+  return world * instanceWorld;
+  #else
+  return instanceWorld;
+  #endif
+  #else
+  return world;
+  #endif
+}
+
+#ifdef BONE
+#ifdef BONETEXTURE
+mat4 readMatrixFromRawSampler(sampler2D smp, float index) {
+  float offset = index * 4.0;
+  float dx = 1.0 / boneTextureWidth;
+  vec4 m0 = texture2D(smp, vec2(dx * (offset + 0.5), 0.));
+  vec4 m1 = texture2D(smp, vec2(dx * (offset + 1.5), 0.));
+  vec4 m2 = texture2D(smp, vec2(dx * (offset + 2.5), 0.));
+  vec4 m3 = texture2D(smp, vec2(dx * (offset + 3.5), 0.));
+  return mat4(m0, m1, m2, m3);
+}
+#endif
+#endif
+
+void main() {
+  #ifdef INSTANCES
+  v_shadowVisibility = shadowVisibility;
+  if (shadowVisibility < 0.5) {
+    v_t = -1.0;
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    return;
+  }
+  #endif
+
+  #ifdef ALPHA_CUTOUT
+  vec2 sourceAlphaUv = uv;
+  if (u_shadowAlphaUvSet > 4.5) sourceAlphaUv = uv6;
+  else if (u_shadowAlphaUvSet > 3.5) sourceAlphaUv = uv5;
+  else if (u_shadowAlphaUvSet > 2.5) sourceAlphaUv = uv4;
+  else if (u_shadowAlphaUvSet > 1.5) sourceAlphaUv = uv3;
+  else if (u_shadowAlphaUvSet > 0.5) sourceAlphaUv = uv2;
+  v_shadowAlphaUv = (u_shadowAlphaMatrix * vec4(sourceAlphaUv, 1.0, 0.0)).xy;
+  #ifdef ALPHA_CUTOUT_SECONDARY
+  vec2 sourceAlphaUv2 = uv;
+  if (u_shadowAlphaUvSet2 > 4.5) sourceAlphaUv2 = uv6;
+  else if (u_shadowAlphaUvSet2 > 3.5) sourceAlphaUv2 = uv5;
+  else if (u_shadowAlphaUvSet2 > 2.5) sourceAlphaUv2 = uv4;
+  else if (u_shadowAlphaUvSet2 > 1.5) sourceAlphaUv2 = uv3;
+  else if (u_shadowAlphaUvSet2 > 0.5) sourceAlphaUv2 = uv2;
+  v_shadowAlphaUv2 = (u_shadowAlphaMatrix2 * vec4(sourceAlphaUv2, 1.0, 0.0)).xy;
+  #endif
+  #endif
+
+  #ifdef FLAT_SHADOW
+  vec3 projPos = (resolvePlanarShadowWorld() * vec4(position, 1.0)).xyz;
+  v_t = 1.0;
+
+  vec4 clipPos = viewProjection * vec4(projPos, 1.0);
+  clipPos.z -= u_planeBias * 2e-4 * clipPos.w;
+
+  gl_Position = clipPos;
+  return;
+  #endif
+
+  #ifdef BONE
+  #ifdef BONETEXTURE
+  mat4 m0 = readMatrixFromRawSampler(boneSampler, matricesIndices.x);
+  mat4 m1 = readMatrixFromRawSampler(boneSampler, matricesIndices.y);
+  mat4 m2 = readMatrixFromRawSampler(boneSampler, matricesIndices.z);
+  mat4 m3 = readMatrixFromRawSampler(boneSampler, matricesIndices.w);
+  #else
+  mat4 m0 = mBones[int(matricesIndices.x)];
+  mat4 m1 = mBones[int(matricesIndices.y)];
+  mat4 m2 = mBones[int(matricesIndices.z)];
+  mat4 m3 = mBones[int(matricesIndices.w)];
+  #endif
+
+  mat4 influence = m0 * matricesWeights.x +
+                  m1 * matricesWeights.y +
+                  m2 * matricesWeights.z +
+                  m3 * matricesWeights.w;
+
+  #ifdef BONES_VELOCITY_ENABLED
+  #ifdef BONETEXTURE
+  mat4 m4 = readMatrixFromRawSampler(boneSampler, matricesIndicesExtra.x);
+  mat4 m5 = readMatrixFromRawSampler(boneSampler, matricesIndicesExtra.y);
+  mat4 m6 = readMatrixFromRawSampler(boneSampler, matricesIndicesExtra.z);
+  mat4 m7 = readMatrixFromRawSampler(boneSampler, matricesIndicesExtra.w);
+  #else
+  mat4 m4 = mBones[int(matricesIndicesExtra.x)];
+  mat4 m5 = mBones[int(matricesIndicesExtra.y)];
+  mat4 m6 = mBones[int(matricesIndicesExtra.z)];
+  mat4 m7 = mBones[int(matricesIndicesExtra.w)];
+  #endif
+
+  influence += m4 * matricesWeightsExtra.x +
+              m5 * matricesWeightsExtra.y +
+              m6 * matricesWeightsExtra.z +
+              m7 * matricesWeightsExtra.w;
+  #endif
+
+  mat4 finalWorld = resolvePlanarShadowWorld() * influence;
+  vec3 worldPos = (finalWorld * vec4(position, 1.0)).xyz;
+  #else
+  vec3 worldPos = (resolvePlanarShadowWorld() * vec4(position, 1.0)).xyz;
+  #endif
+
+  float denom = dot(u_planeNormal, u_lightDir);
+  if (abs(denom) < 1e-5) {
+    v_t = -1.0;
+    gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+    return;
+  }
+
+  float t = (u_planeHeight - dot(u_planeNormal, worldPos)) / denom;
+  v_t = t;
+
+  vec3 projPos = worldPos + u_lightDir * t;
+  projPos = u_shadowCenter + (projPos - u_shadowCenter) * u_footprintScale;
+  projPos += u_planeNormal * (u_planeBias * 0.002);
+
+  vec4 clipPos = viewProjection * vec4(projPos, 1.0);
+  clipPos.z -= u_planeBias * 2e-4 * clipPos.w;
+
+  gl_Position = clipPos;
+}
+`;
+    Effect.ShadersStore[`${PLANAR_SHADOW_SHADER_NAME}FragmentShader`] = `
+precision highp float;
+
+uniform vec4 u_shadowColor;
+uniform float u_shadowAlphaCutoff;
+uniform float u_shadowAlphaLevel;
+uniform float u_shadowAlphaChannelMode;
+uniform vec3 u_shadowAlphaLuminanceWeights;
+uniform sampler2D shadowAlphaSampler;
+#ifdef INSTANCES
+varying float v_shadowVisibility;
+#endif
+#ifdef ALPHA_CUTOUT_SECONDARY
+uniform float u_shadowAlphaLevel2;
+uniform float u_shadowAlphaChannelMode2;
+uniform vec3 u_shadowAlphaLuminanceWeights2;
+uniform sampler2D shadowAlphaSampler2;
+#endif
+varying float v_t;
+
+#ifdef ALPHA_CUTOUT
+varying vec2 v_shadowAlphaUv;
+#ifdef ALPHA_CUTOUT_SECONDARY
+varying vec2 v_shadowAlphaUv2;
+#endif
+#endif
+
+#ifdef ALPHA_CUTOUT
+float readShadowAlpha(sampler2D alphaSampler, vec2 alphaUv, float channelMode, vec3 luminanceWeights, float alphaLevel) {
+  vec4 alphaSample = texture2D(alphaSampler, alphaUv);
+  float sourceAlpha = alphaSample.a;
+  if (channelMode > 1.5) sourceAlpha = alphaSample.r;
+  else if (channelMode > 0.5) sourceAlpha = dot(alphaSample.rgb, luminanceWeights);
+  return sourceAlpha * alphaLevel;
+}
+#endif
+
+void main() {
+  #ifdef INSTANCES
+  if (v_shadowVisibility < 0.5) discard;
+  #endif
+  if (v_t < 0.0) discard;
+  #ifdef ALPHA_CUTOUT
+  float sourceAlpha = readShadowAlpha(
+    shadowAlphaSampler,
+    v_shadowAlphaUv,
+    u_shadowAlphaChannelMode,
+    u_shadowAlphaLuminanceWeights,
+    u_shadowAlphaLevel
+  );
+  #ifdef ALPHA_CUTOUT_SECONDARY
+  sourceAlpha *= readShadowAlpha(
+    shadowAlphaSampler2,
+    v_shadowAlphaUv2,
+    u_shadowAlphaChannelMode2,
+    u_shadowAlphaLuminanceWeights2,
+    u_shadowAlphaLevel2
+  );
+  #endif
+  if (sourceAlpha < u_shadowAlphaCutoff) discard;
+  #endif
+  gl_FragColor = u_shadowColor;
+}
+`;
+}
+export function getPlanarShadowShaderAttributes() {
+    return [
+        'position',
+        'uv',
+        'uv2',
+        'uv3',
+        'uv4',
+        'uv5',
+        'uv6',
+        'matricesIndices',
+        'matricesWeights',
+        'matricesIndicesExtra',
+        'matricesWeightsExtra',
+        'shadowVisibility',
+    ];
+}
+export function getPlanarShadowShaderUniforms() {
+    return [
+        'world',
+        'viewProjection',
+        'u_lightDir',
+        'u_planeNormal',
+        'u_shadowCenter',
+        'u_planeHeight',
+        'u_planeBias',
+        'u_footprintScale',
+        'u_shadowColor',
+        'u_shadowAlphaCutoff',
+        'u_shadowAlphaLevel',
+        'u_shadowAlphaChannelMode',
+        'u_shadowAlphaLuminanceWeights',
+        'u_shadowAlphaUvSet',
+        'u_shadowAlphaMatrix',
+        'u_shadowAlphaLevel2',
+        'u_shadowAlphaChannelMode2',
+        'u_shadowAlphaLuminanceWeights2',
+        'u_shadowAlphaUvSet2',
+        'u_shadowAlphaMatrix2',
+        'mBones',
+        'boneTextureWidth',
+    ];
+}
+export function getPlanarShadowShaderSamplers() {
+    return ['boneSampler', 'shadowAlphaSampler', 'shadowAlphaSampler2'];
+}
+export function getPlanarShadowSkeletonDefines(numBones, useTexture, hasExtraInfluence) {
+    const defines = ['BONE'];
+    if (useTexture)
+        defines.push('BONETEXTURE');
+    else
+        defines.push(`BonesPerMesh ${numBones}`);
+    if (hasExtraInfluence)
+        defines.push('BONES_VELOCITY_ENABLED');
+    return defines;
+}
+//# sourceMappingURL=planar-shadow-shaders.js.map

package/dist/babylon/renderer/shadows/planar-shadow-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"planar-shadow-shaders.js","sourceRoot":"","sources":["../../../../src/babylon/renderer/shadows/planar-shadow-shaders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAE7D,MAAM,CAAC,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;AAE3D,MAAM,UAAU,2BAA2B;IACzC,MAAM,SAAS,GAAG,GAAG,yBAAyB,cAAc,CAAC;IAC7D,IAAI,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC;QAAE,OAAO;IAE3C,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4LlC,CAAC;IAEA,MAAM,CAAC,YAAY,CAAC,GAAG,yBAAyB,gBAAgB,CAAC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+DrE,CAAC;AACF,CAAC;AAED,MAAM,UAAU,+BAA+B;IAC7C,OAAO;QACL,UAAU;QACV,IAAI;QACJ,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;QACL,iBAAiB;QACjB,iBAAiB;QACjB,sBAAsB;QACtB,sBAAsB;QACtB,kBAAkB;KACnB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,6BAA6B;IAC3C,OAAO;QACL,OAAO;QACP,gBAAgB;QAChB,YAAY;QACZ,eAAe;QACf,gBAAgB;QAChB,eAAe;QACf,aAAa;QACb,kBAAkB;QAClB,eAAe;QACf,qBAAqB;QACrB,oBAAoB;QACpB,0BAA0B;QAC1B,+BAA+B;QAC/B,oBAAoB;QACpB,qBAAqB;QACrB,qBAAqB;QACrB,2BAA2B;QAC3B,gCAAgC;QAChC,qBAAqB;QACrB,sBAAsB;QACtB,QAAQ;QACR,kBAAkB;KACnB,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,6BAA6B;IAC3C,OAAO,CAAC,aAAa,EAAE,oBAAoB,EAAE,qBAAqB,CAAC,CAAC;AACtE,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,QAAgB,EAChB,UAAmB,EACnB,iBAA0B;IAE1B,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,IAAI,UAAU;QAAE,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;;QACvC,OAAO,CAAC,IAAI,CAAC,gBAAgB,QAAQ,EAAE,CAAC,CAAC;IAC9C,IAAI,iBAAiB;QAAE,OAAO,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;IAC9D,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/babylon/renderer/shadows/planar-shadow-system.d.ts

@@ -0,0 +1,5 @@
+import { DirectionalLight } from '@babylonjs/core/Lights/directionalLight.js';
+import type { Scene } from '@babylonjs/core/scene.js';
+import { type PlanarShadowOptions, type PlanarShadowSystem } from './types.js';
+export declare function createPlanarShadowSystem(scene: Scene, directionalLight: DirectionalLight, options?: Partial<PlanarShadowOptions>): PlanarShadowSystem;
+//# sourceMappingURL=planar-shadow-system.d.ts.map

package/dist/babylon/renderer/shadows/planar-shadow-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planar-shadow-system.d.ts","sourceRoot":"","sources":["../../../../src/babylon/renderer/shadows/planar-shadow-system.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAa9E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAUtD,OAAO,EAIL,KAAK,mBAAmB,EAGxB,KAAK,kBAAkB,EAExB,MAAM,YAAY,CAAC;AAuGpB,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,KAAK,EACZ,gBAAgB,EAAE,gBAAgB,EAClC,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACzC,kBAAkB,CAEpB"}