@navaramap/three-csm 0.0.0

package/dist/index.umd.cjs

@@ -0,0 +1,306 @@
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports,require("three")):typeof define==`function`&&define.amd?define([`exports`,`three`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e.NavaraThreeCSM={},e.three))})(this,function(e,t){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var n=new t.Color(16777215),r=class extends t.Object3D{mainLight;cascadedLights;direction=new t.Vector3(-1,-1,-1);constructor(e,n){super();let r=new t.DirectionalLight(e,n);r.castShadow=!0,this.mainLight=r,this.cascadedLights=[r],this.add(r),this.add(r.target)}setCount(e){e=Math.max(1,e);let t=this.cascadedLights.length;if(e===t)return this;if(e>t){let r=this.mainLight;for(let i=t;i<e;++i){let e=r.clone();e.color.copy(n),this.add(e),this.add(e.target),this.cascadedLights[i]=e}}else for(let n=e;n<t;++n){let e=this.cascadedLights[n];e.dispose(),this.remove(e.target),this.remove(e)}return this.cascadedLights.length=e,this}dispose(){for(let e=0;e<this.cascadedLights.length;++e)this.cascadedLights[e].dispose()}copy(e,t){super.copy(e,!1),this.cascadedLights.length=0,this.clear();for(let t of e.cascadedLights){let e=t.clone();this.add(e),this.add(e.target),this.cascadedLights.push(e)}return this}},i=`Invariant failed`;function a(e,t){if(!e)throw Error(i)}var o=class e{near=[new t.Vector3,new t.Vector3,new t.Vector3,new t.Vector3];far=[new t.Vector3,new t.Vector3,new t.Vector3,new t.Vector3];constructor(e,t){e!=null&&t!=null&&this.setFromCamera(e,t)}clone(){return new e().copy(this)}copy(e){for(let t=0;t<4;++t)this.near[t].copy(e.near[t]),this.far[t].copy(e.far[t]);return this}setFromCamera(e,t){let n=e.isOrthographicCamera===!0,r=e.projectionMatrixInverse;this.near[0].set(1,1,-1),this.near[1].set(1,-1,-1),this.near[2].set(-1,-1,-1),this.near[3].set(-1,1,-1);for(let e=0;e<4;++e)this.near[e].applyMatrix4(r);this.far[0].set(1,1,1),this.far[1].set(1,-1,1),this.far[2].set(-1,-1,1),this.far[3].set(-1,1,1);for(let e=0;e<4;++e){let i=this.far[e];i.applyMatrix4(r);let a=Math.abs(i.z);n?i.z*=Math.min(t/a,1):i.multiplyScalar(Math.min(t/a,1))}return this}split(t,n=[]){for(let r=0;r<t.length;++r){let i=n[r]??=new e;if(r===0)for(let e=0;e<4;++e)i.near[e].copy(this.near[e]);else for(let e=0;e<4;++e)i.near[e].lerpVectors(this.near[e],this.far[e],t[r-1]);if(r===t.length-1)for(let e=0;e<4;++e)i.far[e].copy(this.far[e]);else for(let e=0;e<4;++e)i.far[e].lerpVectors(this.near[e],this.far[e],t[r])}return n.length=t.length,n}applyMatrix4(e){for(let t=0;t<4;++t)this.near[t].applyMatrix4(e),this.far[t].applyMatrix4(e);return this}},s=`// Based on the following work:
+// https://github.com/StrandedKitty/three-csm/tree/master/src
+// https://github.com/mrdoob/three.js/tree/r169/examples/jsm/csm
+
+void cascadedFadedLights() {
+  directionalLight = directionalLights[0];
+  getDirectionalLightInfo(directionalLight, directLight);
+
+  float clipDepth = vViewPosition.z / (csmFar - csmNear);
+  bool lastCascade;
+  vec2 cascade;
+  float cascadeCenter;
+  float closestEdge;
+  float margin;
+  float shadow = 1.0;
+  float nextShadow = 1.0;
+
+  #pragma unroll_loop_start
+  for (int i = 0; i < NUM_DIR_LIGHTS; i++) {
+    #if UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+    #if UNROLLED_LOOP_INDEX < CSM_CASCADE_COUNT
+
+    lastCascade = UNROLLED_LOOP_INDEX == CSM_CASCADE_COUNT - 1;
+    cascade = csmCascades[i];
+    cascadeCenter = (cascade.x + cascade.y) * 0.5;
+    closestEdge = clipDepth < cascadeCenter ? cascade.x : cascade.y;
+    margin = 0.25 * pow(closestEdge, 2.0);
+    cascade += margin * vec2(-0.5, 0.5);
+
+    if (clipDepth >= cascade.x && (clipDepth < cascade.y || lastCascade)) {
+      directionalLightShadow = directionalLightShadows[i];
+      float prevShadow = nextShadow;
+      nextShadow =
+        directLight.visible && receiveShadow
+          ? getShadow(
+            directionalShadowMap[i],
+            directionalLightShadow.shadowMapSize,
+            directionalLightShadow.shadowIntensity,
+            directionalLightShadow.shadowBias,
+            directionalLightShadow.shadowRadius,
+            vDirectionalShadowCoord[i]
+          )
+          : 1.0;
+
+      shadow = mix(
+        prevShadow,
+        nextShadow,
+        saturate(min(clipDepth - cascade.x, cascade.y - clipDepth) / margin)
+      );
+    }
+    #endif // UNROLLED_LOOP_INDEX < CSM_CASCADE_COUNT
+    #endif // UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+  }
+  #pragma unroll_loop_end
+
+  // No loop here: all cascaded lights are in fact one light only.
+  directLight.color *= shadow;
+  RE_Direct(
+    directLight,
+    geometryPosition,
+    geometryNormal,
+    geometryViewDir,
+    geometryClearcoatNormal,
+    material,
+    reflectedLight
+  );
+
+  // The rest of directional lights.
+  #pragma unroll_loop_start
+  for (int i = 0; i < NUM_DIR_LIGHTS; i++) {
+    #if UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+    #if UNROLLED_LOOP_INDEX >= CSM_CASCADE_COUNT
+    directionalLight = directionalLights[i];
+    getDirectionalLightInfo(directionalLight, directLight);
+
+    directionalLightShadow = directionalLightShadows[i];
+    directLight.color *=
+      directLight.visible && receiveShadow
+        ? getShadow(
+          directionalShadowMap[i],
+          directionalLightShadow.shadowMapSize,
+          directionalLightShadow.shadowIntensity,
+          directionalLightShadow.shadowBias,
+          directionalLightShadow.shadowRadius,
+          vDirectionalShadowCoord[i]
+        )
+        : 1.0;
+
+    RE_Direct(
+      directLight,
+      geometryPosition,
+      geometryNormal,
+      geometryViewDir,
+      geometryClearcoatNormal,
+      material,
+      reflectedLight
+    );
+    #endif // UNROLLED_LOOP_INDEX >= CSM_CASCADE_COUNT
+    #endif // UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+  }
+  #pragma unroll_loop_end
+}
+`,c=`// Based on the following work:
+// https://github.com/StrandedKitty/three-csm/tree/master/src
+// https://github.com/mrdoob/three.js/tree/r169/examples/jsm/csm
+
+void cascadedLights() {
+  directionalLight = directionalLights[0];
+  getDirectionalLightInfo(directionalLight, directLight);
+
+  float clipDepth = vViewPosition.z / (csmFar - csmNear);
+  vec2 cascade;
+
+  #pragma unroll_loop_start
+  for (int i = 0; i < NUM_DIR_LIGHTS; i++) {
+    #if UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+    #if UNROLLED_LOOP_INDEX < CSM_CASCADE_COUNT
+    cascade = csmCascades[i];
+    directionalLightShadow = directionalLightShadows[i];
+    if (clipDepth >= cascade.x && clipDepth < cascade.y) {
+      directLight.color *=
+        directLight.visible && receiveShadow
+          ? getShadow(
+            directionalShadowMap[i],
+            directionalLightShadow.shadowMapSize,
+            directionalLightShadow.shadowIntensity,
+            directionalLightShadow.shadowBias,
+            directionalLightShadow.shadowRadius,
+            vDirectionalShadowCoord[i]
+          )
+          : 1.0;
+    }
+    #endif // UNROLLED_LOOP_INDEX < CSM_CASCADE_COUNT
+    #endif // UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+  }
+  #pragma unroll_loop_end
+
+  // No loop here: all cascaded lights are in fact one light only.
+  RE_Direct(
+    directLight,
+    geometryPosition,
+    geometryNormal,
+    geometryViewDir,
+    geometryClearcoatNormal,
+    material,
+    reflectedLight
+  );
+
+  // The rest of directional lights.
+  #pragma unroll_loop_start
+  for (int i = 0; i < NUM_DIR_LIGHTS; i++) {
+    #if UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+    #if UNROLLED_LOOP_INDEX >= CSM_CASCADE_COUNT
+    directionalLight = directionalLights[i];
+    getDirectionalLightInfo(directionalLight, directLight);
+
+    directionalLightShadow = directionalLightShadows[i];
+    directLight.color *=
+      directLight.visible && receiveShadow
+        ? getShadow(
+          directionalShadowMap[i],
+          directionalLightShadow.shadowMapSize,
+          directionalLightShadow.shadowIntensity,
+          directionalLightShadow.shadowBias,
+          directionalLightShadow.shadowRadius,
+          vDirectionalShadowCoord[i]
+        )
+        : 1.0;
+
+    RE_Direct(
+      directLight,
+      geometryPosition,
+      geometryNormal,
+      geometryViewDir,
+      geometryClearcoatNormal,
+      material,
+      reflectedLight
+    );
+    #endif // UNROLLED_LOOP_INDEX >= CSM_CASCADE_COUNT
+    #endif // UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+  }
+  #pragma unroll_loop_end
+}
+`,l=`// Based on the following work:
+// https://github.com/StrandedKitty/three-csm/tree/master/src
+// https://github.com/mrdoob/three.js/tree/r169/examples/jsm/csm
+
+void cascadedLightsWithoutShadows() {
+  // No loop here: all cascaded lights are in fact one light only.
+  getDirectionalLightInfo(directionalLights[0], directLight);
+  RE_Direct(
+    directLight,
+    geometryPosition,
+    geometryNormal,
+    geometryViewDir,
+    geometryClearcoatNormal,
+    material,
+    reflectedLight
+  );
+
+  // The rest of directional lights.
+  #pragma unroll_loop_start
+  for (int i = CSM_CASCADE_COUNT; i < NUM_DIR_LIGHTS; i++) {
+    directionalLight = directionalLights[i];
+    getDirectionalLightInfo(directionalLight, directLight);
+
+    RE_Direct(
+      directLight,
+      geometryPosition,
+      geometryNormal,
+      geometryViewDir,
+      geometryClearcoatNormal,
+      material,
+      reflectedLight
+    );
+  }
+  #pragma unroll_loop_end
+}
+`,u=`// Default shader.
+// See: https://github.com/mrdoob/three.js/blob/r169/src/renderers/shaders/ShaderChunk/lights_fragment_begin.glsl.js#L136
+
+void defaultLights() {
+  #pragma unroll_loop_start
+  for (int i = 0; i < NUM_DIR_LIGHTS; i++) {
+    directionalLight = directionalLights[i];
+    getDirectionalLightInfo(directionalLight, directLight);
+
+    #if defined(USE_SHADOWMAP) && UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS
+    directionalLightShadow = directionalLightShadows[i];
+    directLight.color *=
+      directLight.visible && receiveShadow
+        ? getShadow(
+          directionalShadowMap[i],
+          directionalLightShadow.shadowMapSize,
+          directionalLightShadow.shadowIntensity,
+          directionalLightShadow.shadowBias,
+          directionalLightShadow.shadowRadius,
+          vDirectionalShadowCoord[i]
+        )
+        : 1.0;
+    #endif
+
+    RE_Direct(
+      directLight,
+      geometryPosition,
+      geometryNormal,
+      geometryViewDir,
+      geometryClearcoatNormal,
+      material,
+      reflectedLight
+    );
+  }
+  #pragma unroll_loop_end
+}
+`,d=`void nonShadowCastingLights() {
+  #pragma unroll_loop_start
+  for (int i = NUM_DIR_LIGHT_SHADOWS; i < NUM_DIR_LIGHTS; i++) {
+    directionalLight = directionalLights[i];
+    getDirectionalLightInfo(directionalLight, directLight);
+
+    RE_Direct(
+      directLight,
+      geometryPosition,
+      geometryNormal,
+      geometryViewDir,
+      geometryClearcoatNormal,
+      material,
+      reflectedLight
+    );
+  }
+  #pragma unroll_loop_end
+}
+`,f=`
+  #include <lights_pars_begin>
+
+  #ifdef CSM
+    uniform vec2 csmCascades[CSM_CASCADE_COUNT];
+    uniform float csmNear;
+    uniform float csmFar;
+  #endif // CSM
+`;function p(e){return e.replace(/^\s*void\s+\w+\s*\(\s*\)\s*/m,``)}var m=`
+  #if NUM_DIR_LIGHTS > 0 && defined(RE_Direct)
+    DirectionalLight directionalLight;
+    #if defined(USE_SHADOWMAP) && NUM_DIR_LIGHT_SHADOWS > 0
+      DirectionalLightShadow directionalLightShadow;
+    #endif
+
+    #ifdef CSM
+      #ifdef USE_SHADOWMAP
+        #ifdef CSM_FADE
+          ${p(s)}
+        #else
+          ${p(c)}
+        #endif // CSM_FADE
+      #elif NUM_DIR_LIGHT_SHADOWS > 0
+        ${p(l)}
+      #endif // USE_SHADOWMAP
+
+      #if NUM_DIR_LIGHTS > NUM_DIR_LIGHT_SHADOWS
+        ${p(d)}
+      #endif
+    #else
+      ${p(u)}
+    #endif // CSM
+  #endif // NUM_DIR_LIGHTS > 0 && defined(RE_Direct)
+`;function h({source:e,startLine:t,endLine:n,replacement:r}){let i=`\n${t}\n`,a=e.indexOf(i);if(a<0)return e;let o=`\n${n}\n`,s=e.indexOf(o,a+i.length);return s<0?e:e.slice(0,a+1)+r+e.slice(s+o.length-1)}function g(e){return e.replace(`#include <lights_pars_begin>`,f).replace(`#include <lights_fragment_begin>`,h({source:t.ShaderChunk.lights_fragment_begin,startLine:`#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )`,endLine:`#endif`,replacement:m}))}var _=class{map=new Map;setup(e,t){if(this.map.has(e))return e;e.userData.defines??={},e.userData.defines.CSM=1,e.userData.defines.CSM_CASCADE_COUNT=t.cascadeCount,t.fade&&(e.userData.defines.CSM_FADE=1);let n={};this.map.set(e,n);let r=e=>{n.parameters=e;let r=t.cascades,i=t.mainCamera.near,a=Math.min(t.mainCamera.far,t.far),o=e.uniforms;o.csmCascades={value:r},o.csmNear={value:i},o.csmFar={value:a},e.fragmentShader=g(e.fragmentShader)},i=e.onBeforeCompile.bind(e),a=e.customProgramCacheKey.bind(e);Object.prototype.hasOwnProperty.call(e,`hasOwnProperty`)&&(n.originalHandler=i),e.customProgramCacheKey=()=>i.toString()+a(),e.onBeforeCompile=(...t)=>{let[n]=t;n.defines??={},Object.assign(n.defines,e.userData.defines),i.apply(e,t),r(...t)};let o=()=>{this.map.delete(e),e.removeEventListener(`dispose`,o)};return e.addEventListener(`dispose`,o),e}update(e){let t=e.cascadeCount,n=e.fade,r=e.cascades,i=e.mainCamera.near,a=Math.min(e.mainCamera.far,e.far);for(let[e,o]of this.map.entries()){let s=e.userData.defines;if(s!=null){let r=!1;s.CSM_FADE!=null!==n&&(n?s.CSM_FADE=1:delete s.CSM_FADE,r=!0),s.CSM_CASCADE_COUNT!==t&&(s.CSM_CASCADE_COUNT=t,r=!0),r&&(e.needsUpdate=!0)}let c=o.parameters?.uniforms;c!=null&&(c.csmCascades.value=r,c.csmNear.value=i,c.csmFar.value=a)}}rollback(e){let t=this.map.get(e);return t==null?e:this.rollbackToState(e,t)}rollbackToState(e,{parameters:t,originalHandler:n}){return t!=null&&(delete t.uniforms.csmCascades,delete t.uniforms.csmNear,delete t.uniforms.csmFar),n==null?delete e.onBeforeCompile:e.onBeforeCompile=n,e.userData.defines!=null&&(delete e.userData.defines.CSM,delete e.userData.defines.CSM_CASCADE_COUNT,delete e.userData.defines.CSM_FADE),e.needsUpdate=!0,this.map.delete(e),e}dispose(){for(let[e,t]of this.map)this.rollbackToState(e,t);this.map.clear()}};Math.PI/180,180/Math.PI;function v(e,t,n){return(1-n)*e+n*t}var y={uniform:(e,t,n,r,i=[])=>{for(let r=0;r<e;++r)i[r]=(t+(n-t)*(r+1)/e)/n;return i.length=e,i},logarithmic:(e,t,n,r,i=[])=>{for(let r=0;r<e;++r)i[r]=t*(n/t)**((r+1)/e)/n;return i.length=e,i},practical:(e,t,n,r=.5,i=[])=>{for(let a=0;a<e;++a)i[a]=v((t+(n-t)*(a+1)/e)/n,t*(n/t)**((a+1)/e)/n,r);return i.length=e,i}},b=y;function x(e,t,n,r,i,a=[]){return y[e](t,n,r,i,a)}var S=new t.Vector3,C=new t.Vector3,w=new t.Matrix4,T=new t.Matrix4,E=new o,D=new t.Box3,O={cascadeCount:4,mapSize:2048,far:5e3,mode:`practical`,lambda:.5,margin:200,fade:!0,disableLastCascadeCutoff:!1},k=class{mainCamera;needsUpdateFrusta=!0;directionalLights=new r;materialStates=new _;mainFrustum=new o;cascadedFrusta=[];splits=[];cascades=[];_far;_mode;_lambda;_margin;_fade;_disableLastCascadeCutoff;constructor(e,t){this.mainCamera=e;let{cascadeCount:n,mapSize:r,far:i,mode:a,lambda:o,margin:s,fade:c,disableLastCascadeCutoff:l}={...O,...t};this._far=i,this._mode=a,this._lambda=o,this._margin=s,this._fade=c,this._disableLastCascadeCutoff=l,this.cascadeCount=n,this.mapSize=r}dispose(){this.materialStates.dispose(),this.directionalLights.dispose()}setupMaterial(e){return this.materialStates.setup(e,this)}rollbackMaterial(e){return this.materialStates.rollback(e)}setupMaterials(e){for(let t=0;t<e.length;++t)this.materialStates.setup(e[t],this);return()=>{for(let t=0;t<e.length;++t)this.materialStates.rollback(e[t])}}updateCascades(){let e=this.cascadeCount,n=this.splits;x(this.mode,e,this.mainCamera.near,Math.min(this.mainCamera.far,this.far),this.lambda,n),this.mainFrustum.setFromCamera(this.mainCamera,this.far),this.mainFrustum.split(n,this.cascadedFrusta);let r=this.cascades;for(let i=0;i<e;++i)(r[i]??(r[i]=new t.Vector2)).set(n[i-1]??0,n[i]??0);this.disableLastCascadeCutoff&&(r[e-1].y=1/0),r.length=e}getFrustumRadius(e){let t=e.near,n=e.far,r=Math.max(n[0].distanceTo(n[2]),n[0].distanceTo(t[2]));if(this.fade){let e=this.mainCamera,t=e.near,i=Math.min(e.far,this.far),a=n[0].z/(i-t);r+=.25*a**2*(i-t)}return r*.5}updateShadowBounds(){let e=this.cascadedFrusta,t=this.directionalLights.cascadedLights;a(e.length===t.length);for(let n=0;n<e.length;++n){let e=this.getFrustumRadius(this.cascadedFrusta[n]),r=t[n].shadow.camera;r.left=-e,r.right=e,r.top=e,r.bottom=-e,r.near=0,r.far=e*2+this.margin,r.updateProjectionMatrix()}}updateFrusta(){this.updateCascades(),this.updateShadowBounds(),this.materialStates.update(this)}update(){this.needsUpdateFrusta&&(this.needsUpdateFrusta=!1,this.updateFrusta());let e=this.directionalLights,n=S.copy(e.direction).normalize(),r=w.lookAt(new t.Vector3,n,t.Object3D.DEFAULT_UP),i=T.multiplyMatrices(T.copy(r).invert(),this.mainCamera.matrixWorld),a=this.margin,o=this.mapSize,s=this.cascadedFrusta,c=e.cascadedLights;for(let e=0;e<s.length;++e){let{near:t,far:l}=E.copy(s[e]).applyMatrix4(i),u=D.makeEmpty();for(let e=0;e<4;e++)u.expandByPoint(t[e]),u.expandByPoint(l[e]);let d=u.getCenter(C);d.z=u.max.z+a;let f=c[e],{left:p,right:m,top:h,bottom:g}=f.shadow.camera,_=(m-p)/o,v=(h-g)/o;d.x=Math.round(d.x/_)*_,d.y=Math.round(d.y/v)*v,d.applyMatrix4(r),f.position.copy(d),f.target.position.copy(d),f.target.position.add(n)}}get cascadeCount(){return this.directionalLights.cascadedLights.length}set cascadeCount(e){e!==this.cascadeCount&&(this.directionalLights.setCount(e),this.needsUpdateFrusta=!0)}get mapSize(){return this.directionalLights.mainLight.shadow.mapSize.width}set mapSize(e){if(e!==this.mapSize){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n){let r=t[n].shadow;r.mapSize.width=e,r.mapSize.height=e,r.map!=null&&(r.map.dispose(),r.map=null)}}}get far(){return this._far}set far(e){e!==this._far&&(this._far=e,this.needsUpdateFrusta=!0)}get mode(){return this._mode}set mode(e){e!==this._mode&&(this._mode=e,this.needsUpdateFrusta=!0)}get lambda(){return this._lambda}set lambda(e){e!==this._lambda&&(this._lambda=e,this.needsUpdateFrusta=!0)}get margin(){return this._margin}set margin(e){e!==this._margin&&(this._margin=e,this.needsUpdateFrusta=!0)}get fade(){return this._fade}set fade(e){e!==this._fade&&(this._fade=e,this.needsUpdateFrusta=!0)}get disableLastCascadeCutoff(){return this._disableLastCascadeCutoff}set disableLastCascadeCutoff(e){e!==this._disableLastCascadeCutoff&&(this._disableLastCascadeCutoff=e,this.needsUpdateFrusta=!0)}get intensity(){return this.directionalLights.mainLight.intensity}set intensity(e){if(e!==this.intensity){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n)t[n].intensity=e}}get shadowIntensity(){return this.directionalLights.mainLight.shadow.intensity}set shadowIntensity(e){if(e!==this.shadowIntensity){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n)t[n].shadow.intensity=e}}get color(){return this.directionalLights.mainLight.color}set color(e){e!==this.color&&this.directionalLights.mainLight.color.copy(e)}get bias(){return this.directionalLights.mainLight.shadow.bias}set bias(e){if(e!==this.bias){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n)t[n].shadow.bias=e}}get normalBias(){return this.directionalLights.mainLight.shadow.normalBias}set normalBias(e){if(e!==this.normalBias){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n)t[n].shadow.normalBias=e}}get radius(){return this.directionalLights.mainLight.shadow.radius}set radius(e){if(e!==this.radius){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n)t[n].shadow.radius=e}}get blurSamples(){return this.directionalLights.mainLight.shadow.blurSamples}set blurSamples(e){if(e!==this.blurSamples){let t=this.directionalLights.cascadedLights;for(let n=0;n<t.length;++n)t[n].shadow.blurSamples=e}}};e.CSMHelper=class extends t.Group{csm;displayFrustum=!0;displayPlanes=!0;displayShadowBounds=!0;frustumLines;cascadeLines=[];cascadePlanes=[];shadowLines=[];constructor(e){super(),this.csm=e;let n=new Uint16Array([0,1,1,2,2,3,3,0,4,5,5,6,6,7,7,4,0,4,1,5,2,6,3,7]),r=new Float32Array(24),i=new t.BufferGeometry;i.setIndex(new t.BufferAttribute(n,1)),i.setAttribute(`position`,new t.BufferAttribute(r,3,!1));let a=new t.LineSegments(i,new t.LineBasicMaterial);this.add(a),this.frustumLines=a}updateVisibility(){let e=this.displayFrustum,t=this.displayPlanes,n=this.displayShadowBounds,r=this.frustumLines,i=this.cascadeLines,a=this.cascadePlanes,o=this.shadowLines;for(let r=0,s=i.length;r<s;r++){let s=i[r],c=a[r],l=o[r];s.visible=e,c.visible=e&&t,l.visible=n}r.visible=e}update(){let e=this.csm,n=e.mainCamera,r=e.cascadeCount,i=e.mainFrustum,a=e.cascadedFrusta,o=e.directionalLights.cascadedLights,s=this.frustumLines.geometry.getAttribute(`position`),c=this.cascadeLines,l=this.cascadePlanes,u=this.shadowLines;for(this.position.copy(n.position),this.quaternion.copy(n.quaternion),this.scale.copy(n.scale),this.updateMatrixWorld(!0);c.length>r;){let e=c.pop(),t=l.pop(),n=u.pop();e&&this.remove(e),t&&this.remove(t),n&&this.remove(n)}for(;c.length<r;){let e=new t.Box3Helper(new t.Box3,new t.Color(16777215)),n=new t.MeshBasicMaterial({transparent:!0,opacity:.1,depthWrite:!1,side:t.DoubleSide}),r=new t.Mesh(new t.PlaneGeometry,n),i=new t.Group,a=new t.Box3Helper(new t.Box3,new t.Color(16776960));i.add(a),this.add(e),this.add(r),this.add(i),c.push(e),l.push(r),u.push(i)}for(let e=0;e<r;e++){let t=a[e],n=o[e].shadow.camera,r=t.far,i=c[e],s=l[e],d=u[e],f=d.children[0];i.box.min.copy(r[2]),i.box.max.copy(r[0]),i.box.max.z+=1e-4,s.position.addVectors(r[0],r[2]),s.position.multiplyScalar(.5),s.scale.subVectors(r[0],r[2]),s.scale.z=1e-4,this.remove(d),d.position.copy(n.position),d.quaternion.copy(n.quaternion),d.scale.copy(n.scale),d.updateMatrixWorld(!0),this.attach(d),f.box.min.set(n.bottom,n.left,-n.far),f.box.max.set(n.top,n.right,-n.near)}let d=i.near,f=i.far;s.setXYZ(0,f[0].x,f[0].y,f[0].z),s.setXYZ(1,f[3].x,f[3].y,f[3].z),s.setXYZ(2,f[2].x,f[2].y,f[2].z),s.setXYZ(3,f[1].x,f[1].y,f[1].z),s.setXYZ(4,d[0].x,d[0].y,d[0].z),s.setXYZ(5,d[3].x,d[3].y,d[3].z),s.setXYZ(6,d[2].x,d[2].y,d[2].z),s.setXYZ(7,d[1].x,d[1].y,d[1].z),s.needsUpdate=!0}},e.CascadedDirectionalLights=r,e.CascadedShadowMaps=k,e.cascadedShadowMapsOptionsDefaults=O,e.frustumSplitFunctions=b,e.overrideFragmentShaderForCSM=g,e.splitFrustum=x});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@navaramap/three-csm",
+  "type": "module",
+  "version": "0.0.0",
+  "main": "dist/index.umd.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "src",
+    "dist"
+  ],
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reearth/navara.git",
+    "directory": "web/navara_three_csm"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "three": ">=0.183.0"
+  },
+  "devDependencies": {
+    "@types/three": "0.185.1",
+    "three": "0.185.1"
+  },
+  "scripts": {
+    "build": "tsc && vite build --watch=false",
+    "build:dev": "vite build --mode development",
+    "build:dev:watch": "pnpm build:dev --watch",
+    "test": "vitest --passWithNoTests --watch=false",
+    "lint": "eslint . --fix",
+    "lint:check": "eslint .",
+    "format": "prettier --write --ignore-path ../../.gitignore --ignore-path ../../.prettierignore .",
+    "format:check": "prettier --check --ignore-path ../../.gitignore --ignore-path ../../.prettierignore ."
+  }
+}

package/src/CSMHelper.ts

@@ -0,0 +1,199 @@
+// TODO
+
+// Based on the following work:
+// https://github.com/StrandedKitty/three-csm/tree/master/src
+// https://github.com/mrdoob/three.js/tree/r169/examples/jsm/csm
+
+import {
+  Box3,
+  Box3Helper,
+  BufferAttribute,
+  BufferGeometry,
+  Color,
+  DoubleSide,
+  Group,
+  LineBasicMaterial,
+  LineSegments,
+  Mesh,
+  MeshBasicMaterial,
+  PlaneGeometry,
+} from "three";
+
+import { type CascadedShadowMaps } from "./CascadedShadowMaps";
+
+export class CSMHelper extends Group {
+  private readonly csm: CascadedShadowMaps;
+  public displayFrustum = true;
+  public displayPlanes = true;
+  public displayShadowBounds = true;
+  private frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>;
+  private cascadeLines: Box3Helper[] = [];
+  private cascadePlanes: Mesh[] = [];
+  private shadowLines: Group[] = [];
+
+  public constructor(csm: CascadedShadowMaps) {
+    super();
+    this.csm = csm;
+
+    const indices = new Uint16Array([
+      0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7,
+    ]);
+    const positions = new Float32Array(24);
+    const frustumGeometry = new BufferGeometry();
+    frustumGeometry.setIndex(new BufferAttribute(indices, 1));
+    frustumGeometry.setAttribute(
+      "position",
+      new BufferAttribute(positions, 3, false),
+    );
+    const frustumLines = new LineSegments(
+      frustumGeometry,
+      new LineBasicMaterial(),
+    );
+    this.add(frustumLines);
+
+    this.frustumLines = frustumLines;
+  }
+
+  public updateVisibility() {
+    const displayFrustum = this.displayFrustum;
+    const displayPlanes = this.displayPlanes;
+    const displayShadowBounds = this.displayShadowBounds;
+
+    const frustumLines = this.frustumLines;
+    const cascadeLines = this.cascadeLines;
+    const cascadePlanes = this.cascadePlanes;
+    const shadowLines = this.shadowLines;
+    for (let i = 0, l = cascadeLines.length; i < l; i++) {
+      const cascadeLine = cascadeLines[i];
+      const cascadePlane = cascadePlanes[i];
+      const shadowLineGroup = shadowLines[i];
+
+      cascadeLine.visible = displayFrustum;
+      cascadePlane.visible = displayFrustum && displayPlanes;
+      shadowLineGroup.visible = displayShadowBounds;
+    }
+
+    frustumLines.visible = displayFrustum;
+  }
+
+  public update() {
+    const csm = this.csm;
+    const camera = csm.mainCamera;
+    const cascadeCount = csm.cascadeCount;
+    const mainFrustum = csm.mainFrustum;
+    const frusta = csm.cascadedFrusta;
+    const lights = csm.directionalLights.cascadedLights;
+
+    const frustumLines = this.frustumLines;
+    const frustumLinePositions = frustumLines.geometry.getAttribute("position");
+    const cascadeLines = this.cascadeLines;
+    const cascadePlanes = this.cascadePlanes;
+    const shadowLines = this.shadowLines;
+
+    this.position.copy(camera.position);
+    this.quaternion.copy(camera.quaternion);
+    this.scale.copy(camera.scale);
+    this.updateMatrixWorld(true);
+
+    while (cascadeLines.length > cascadeCount) {
+      const cascadeLine = cascadeLines.pop();
+      const cascadePlane = cascadePlanes.pop();
+      const shadowLine = shadowLines.pop();
+      if (cascadeLine) {
+        this.remove(cascadeLine);
+      }
+      if (cascadePlane) {
+        this.remove(cascadePlane);
+      }
+      if (shadowLine) {
+        this.remove(shadowLine);
+      }
+    }
+
+    while (cascadeLines.length < cascadeCount) {
+      const cascadeLine = new Box3Helper(new Box3(), new Color(0xffffff));
+      const planeMat = new MeshBasicMaterial({
+        transparent: true,
+        opacity: 0.1,
+        depthWrite: false,
+        side: DoubleSide,
+      });
+      const cascadePlane = new Mesh(new PlaneGeometry(), planeMat);
+      const shadowLineGroup = new Group();
+      const shadowLine = new Box3Helper(new Box3(), new Color(0xffff00));
+      shadowLineGroup.add(shadowLine);
+
+      this.add(cascadeLine);
+      this.add(cascadePlane);
+      this.add(shadowLineGroup);
+
+      cascadeLines.push(cascadeLine);
+      cascadePlanes.push(cascadePlane);
+      shadowLines.push(shadowLineGroup);
+    }
+
+    for (let i = 0; i < cascadeCount; i++) {
+      const frustum = frusta[i];
+      const light = lights[i];
+      const shadowCam = light.shadow.camera;
+      const farVerts = frustum.far;
+
+      const cascadeLine = cascadeLines[i];
+      const cascadePlane = cascadePlanes[i];
+      const shadowLineGroup = shadowLines[i];
+      const shadowLine = shadowLineGroup.children[0] as Box3Helper;
+
+      cascadeLine.box.min.copy(farVerts[2]);
+      cascadeLine.box.max.copy(farVerts[0]);
+      cascadeLine.box.max.z += 1e-4;
+
+      cascadePlane.position.addVectors(farVerts[0], farVerts[2]);
+      cascadePlane.position.multiplyScalar(0.5);
+      cascadePlane.scale.subVectors(farVerts[0], farVerts[2]);
+      cascadePlane.scale.z = 1e-4;
+
+      this.remove(shadowLineGroup);
+      shadowLineGroup.position.copy(shadowCam.position);
+      shadowLineGroup.quaternion.copy(shadowCam.quaternion);
+      shadowLineGroup.scale.copy(shadowCam.scale);
+      shadowLineGroup.updateMatrixWorld(true);
+      this.attach(shadowLineGroup);
+
+      shadowLine.box.min.set(shadowCam.bottom, shadowCam.left, -shadowCam.far);
+      shadowLine.box.max.set(shadowCam.top, shadowCam.right, -shadowCam.near);
+    }
+
+    const nearVerts = mainFrustum.near;
+    const farVerts = mainFrustum.far;
+    frustumLinePositions.setXYZ(0, farVerts[0].x, farVerts[0].y, farVerts[0].z);
+    frustumLinePositions.setXYZ(1, farVerts[3].x, farVerts[3].y, farVerts[3].z);
+    frustumLinePositions.setXYZ(2, farVerts[2].x, farVerts[2].y, farVerts[2].z);
+    frustumLinePositions.setXYZ(3, farVerts[1].x, farVerts[1].y, farVerts[1].z);
+
+    frustumLinePositions.setXYZ(
+      4,
+      nearVerts[0].x,
+      nearVerts[0].y,
+      nearVerts[0].z,
+    );
+    frustumLinePositions.setXYZ(
+      5,
+      nearVerts[3].x,
+      nearVerts[3].y,
+      nearVerts[3].z,
+    );
+    frustumLinePositions.setXYZ(
+      6,
+      nearVerts[2].x,
+      nearVerts[2].y,
+      nearVerts[2].z,
+    );
+    frustumLinePositions.setXYZ(
+      7,
+      nearVerts[1].x,
+      nearVerts[1].y,
+      nearVerts[1].z,
+    );
+    frustumLinePositions.needsUpdate = true;
+  }
+}

package/src/CascadedDirectionalLights.ts

@@ -0,0 +1,80 @@
+import {
+  Color,
+  DirectionalLight,
+  Object3D,
+  Vector3,
+  type ColorRepresentation,
+} from "three";
+
+const DEFAULT_LIGHT_COLOR = new Color(0xffffff);
+
+export class CascadedDirectionalLights extends Object3D {
+  readonly mainLight: DirectionalLight;
+  readonly cascadedLights: DirectionalLight[];
+
+  // For convenience and stability of the values, because CascadedShadowMaps
+  // modifies the positions of lights and their targets.
+  // i.e. position.copy(direction).multiplyScalar(-1).add(target.position)
+  direction = new Vector3(-1, -1, -1);
+
+  constructor(color?: ColorRepresentation, intensity?: number) {
+    super();
+    const light = new DirectionalLight(color, intensity);
+    light.castShadow = true;
+    this.mainLight = light;
+    this.cascadedLights = [light];
+    this.add(light);
+    this.add(light.target);
+  }
+
+  setCount(value: number): this {
+    value = Math.max(1, value);
+    const count = this.cascadedLights.length;
+    if (value === count) {
+      return this;
+    }
+    if (value > count) {
+      const mainLight = this.mainLight;
+      for (let i = count; i < value; ++i) {
+        const light = mainLight.clone(); // Clones the shadow parameters as well.
+        // Avoid accumulating that lighting color.
+        light.color.copy(DEFAULT_LIGHT_COLOR);
+        this.add(light);
+        this.add(light.target);
+        this.cascadedLights[i] = light;
+      }
+    } else {
+      for (let i = value; i < count; ++i) {
+        const light = this.cascadedLights[i];
+        light.dispose();
+        this.remove(light.target);
+        this.remove(light);
+      }
+    }
+    this.cascadedLights.length = value;
+    return this;
+  }
+
+  dispose(): void {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < this.cascadedLights.length; ++i) {
+      this.cascadedLights[i].dispose();
+    }
+  }
+
+  copy(source: this, _recursive?: boolean): this {
+    super.copy(source, false);
+
+    this.cascadedLights.length = 0;
+    this.clear();
+
+    for (const l of source.cascadedLights) {
+      const cloned = l.clone();
+      this.add(cloned);
+      this.add(cloned.target);
+      this.cascadedLights.push(cloned);
+    }
+
+    return this;
+  }
+}