three-stdlib 2.15.1 → 2.15.2

package/csm/CSM.js

@@ -1,15 +1,12 @@
-import { Matrix4, Vector3, Box3, DirectionalLight, MathUtils, ShaderChunk, Vector2 } from 'three';
-import { CSMFrustum } from './CSMFrustum.js';
-import { CSMShader } from './CSMShader.js';
-
-const _cameraToLightMatrix = new Matrix4();
-
-const _lightSpaceFrustum = new CSMFrustum();
-
-const _center = new Vector3();
-
-const _bbox = new Box3();
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const CSMFrustum = require("./CSMFrustum.js");
+const CSMShader = require("./CSMShader.js");
+const _cameraToLightMatrix = new THREE.Matrix4();
+const _lightSpaceFrustum = new CSMFrustum.CSMFrustum();
+const _center = new THREE.Vector3();
+const _bbox = new THREE.Box3();
 const _uniformArray = [];
 const _logArray = [];
 class CSM {
@@ -18,30 +15,29 @@ class CSM {
     this.camera = data.camera;
     this.parent = data.parent;
     this.cascades = data.cascades || 3;
-    this.maxFar = data.maxFar || 100000;
-    this.mode = data.mode || 'practical';
+    this.maxFar = data.maxFar || 1e5;
+    this.mode = data.mode || "practical";
     this.shadowMapSize = data.shadowMapSize || 2048;
-    this.shadowBias = data.shadowBias || 0.000001;
-    this.lightDirection = data.lightDirection || new Vector3(1, -1, 1).normalize();
+    this.shadowBias = data.shadowBias || 1e-6;
+    this.lightDirection = data.lightDirection || new THREE.Vector3(1, -1, 1).normalize();
     this.lightIntensity = data.lightIntensity || 1;
     this.lightNear = data.lightNear || 1;
-    this.lightFar = data.lightFar || 2000;
+    this.lightFar = data.lightFar || 2e3;
     this.lightMargin = data.lightMargin || 200;
     this.customSplitsCallback = data.customSplitsCallback;
     this.fade = false;
-    this.mainFrustum = new CSMFrustum();
+    this.mainFrustum = new CSMFrustum.CSMFrustum();
     this.frustums = [];
     this.breaks = [];
     this.lights = [];
-    this.shaders = new Map();
+    this.shaders = /* @__PURE__ */ new Map();
     this.createLights();
     this.updateFrustums();
     this.injectInclude();
   }
-
   createLights() {
     for (let i = 0; i < this.cascades; i++) {
-      const light = new DirectionalLight(0xffffff, this.lightIntensity);
+      const light = new THREE.DirectionalLight(16777215, this.lightIntensity);
       light.castShadow = true;
       light.shadow.mapSize.width = this.shadowMapSize;
       light.shadow.mapSize.height = this.shadowMapSize;
@@ -53,46 +49,35 @@ class CSM {
       this.lights.push(light);
     }
   }
-
   initCascades() {
     const camera = this.camera;
     camera.updateProjectionMatrix();
     this.mainFrustum.setFromProjectionMatrix(camera.projectionMatrix, this.maxFar);
     this.mainFrustum.split(this.breaks, this.frustums);
   }
-
   updateShadowBounds() {
     const frustums = this.frustums;
-
     for (let i = 0; i < frustums.length; i++) {
       const light = this.lights[i];
       const shadowCam = light.shadow.camera;
-      const frustum = this.frustums[i]; // Get the two points that represent that furthest points on the frustum assuming
-      // that's either the diagonal across the far plane or the diagonal across the whole
-      // frustum itself.
-
+      const frustum = this.frustums[i];
       const nearVerts = frustum.vertices.near;
       const farVerts = frustum.vertices.far;
       const point1 = farVerts[0];
       let point2;
-
       if (point1.distanceTo(farVerts[2]) > point1.distanceTo(nearVerts[2])) {
         point2 = farVerts[2];
       } else {
         point2 = nearVerts[2];
       }
-
       let squaredBBWidth = point1.distanceTo(point2);
-
       if (this.fade) {
-        // expand the shadow extents by the fade margin if fade is enabled.
         const camera = this.camera;
         const far = Math.max(camera.far, this.maxFar);
         const linearDepth = frustum.vertices.far[0].z / (far - camera.near);
-        const margin = 0.25 * Math.pow(linearDepth, 2.0) * (far - camera.near);
+        const margin = 0.25 * Math.pow(linearDepth, 2) * (far - camera.near);
         squaredBBWidth += margin;
       }
-
       shadowCam.left = -squaredBBWidth / 2;
       shadowCam.right = squaredBBWidth / 2;
       shadowCam.top = squaredBBWidth / 2;
@@ -100,94 +85,72 @@ class CSM {
       shadowCam.updateProjectionMatrix();
     }
   }
-
   getBreaks() {
     const camera = this.camera;
     const far = Math.min(camera.far, this.maxFar);
     this.breaks.length = 0;
-
     switch (this.mode) {
-      case 'uniform':
+      case "uniform":
         uniformSplit(this.cascades, camera.near, far, this.breaks);
         break;
-
-      case 'logarithmic':
+      case "logarithmic":
         logarithmicSplit(this.cascades, camera.near, far, this.breaks);
         break;
-
-      case 'practical':
+      case "practical":
         practicalSplit(this.cascades, camera.near, far, 0.5, this.breaks);
         break;
-
-      case 'custom':
-        if (this.customSplitsCallback === undefined) console.error('CSM: Custom split scheme callback not defined.');
+      case "custom":
+        if (this.customSplitsCallback === void 0)
+          console.error("CSM: Custom split scheme callback not defined.");
         this.customSplitsCallback(this.cascades, camera.near, far, this.breaks);
         break;
     }
-
-    function uniformSplit(amount, near, far, target) {
+    function uniformSplit(amount, near, far2, target) {
       for (let i = 1; i < amount; i++) {
-        target.push((near + (far - near) * i / amount) / far);
+        target.push((near + (far2 - near) * i / amount) / far2);
       }
-
       target.push(1);
     }
-
-    function logarithmicSplit(amount, near, far, target) {
+    function logarithmicSplit(amount, near, far2, target) {
       for (let i = 1; i < amount; i++) {
-        target.push(near * (far / near) ** (i / amount) / far);
+        target.push(near * (far2 / near) ** (i / amount) / far2);
       }
-
       target.push(1);
     }
-
-    function practicalSplit(amount, near, far, lambda, target) {
+    function practicalSplit(amount, near, far2, lambda, target) {
       _uniformArray.length = 0;
       _logArray.length = 0;
-      logarithmicSplit(amount, near, far, _logArray);
-      uniformSplit(amount, near, far, _uniformArray);
-
+      logarithmicSplit(amount, near, far2, _logArray);
+      uniformSplit(amount, near, far2, _uniformArray);
       for (let i = 1; i < amount; i++) {
-        target.push(MathUtils.lerp(_uniformArray[i - 1], _logArray[i - 1], lambda));
+        target.push(THREE.MathUtils.lerp(_uniformArray[i - 1], _logArray[i - 1], lambda));
       }
-
       target.push(1);
     }
   }
-
   update() {
     const camera = this.camera;
     const frustums = this.frustums;
-
     for (let i = 0; i < frustums.length; i++) {
       const light = this.lights[i];
       const shadowCam = light.shadow.camera;
       const texelWidth = (shadowCam.right - shadowCam.left) / this.shadowMapSize;
       const texelHeight = (shadowCam.top - shadowCam.bottom) / this.shadowMapSize;
       light.shadow.camera.updateMatrixWorld(true);
-
       _cameraToLightMatrix.multiplyMatrices(light.shadow.camera.matrixWorldInverse, camera.matrixWorld);
-
       frustums[i].toSpace(_cameraToLightMatrix, _lightSpaceFrustum);
       const nearVerts = _lightSpaceFrustum.vertices.near;
       const farVerts = _lightSpaceFrustum.vertices.far;
-
       _bbox.makeEmpty();
-
       for (let j = 0; j < 4; j++) {
         _bbox.expandByPoint(nearVerts[j]);
-
         _bbox.expandByPoint(farVerts[j]);
       }
-
       _bbox.getCenter(_center);
-
       _center.z = _bbox.max.z + this.lightMargin;
       _center.x = Math.floor(_center.x / texelWidth) * texelWidth;
       _center.y = Math.floor(_center.y / texelHeight) * texelHeight;
-
       _center.applyMatrix4(light.shadow.camera.matrixWorld);
-
       light.position.copy(_center);
       light.target.position.copy(_center);
       light.target.position.x += this.lightDirection.x;
@@ -195,71 +158,54 @@ class CSM {
       light.target.position.z += this.lightDirection.z;
     }
   }
-
   injectInclude() {
-    ShaderChunk.lights_fragment_begin = CSMShader.lights_fragment_begin;
-    ShaderChunk.lights_pars_begin = CSMShader.lights_pars_begin;
+    THREE.ShaderChunk.lights_fragment_begin = CSMShader.CSMShader.lights_fragment_begin;
+    THREE.ShaderChunk.lights_pars_begin = CSMShader.CSMShader.lights_pars_begin;
   }
-
   setupMaterial(material) {
     material.defines = material.defines || {};
     material.defines.USE_CSM = 1;
     material.defines.CSM_CASCADES = this.cascades;
-
     if (this.fade) {
-      material.defines.CSM_FADE = '';
+      material.defines.CSM_FADE = "";
     }
-
     const breaksVec2 = [];
     const scope = this;
     const shaders = this.shaders;
-
-    material.onBeforeCompile = function (shader) {
+    material.onBeforeCompile = function(shader) {
       const far = Math.min(scope.camera.far, scope.maxFar);
       scope.getExtendedBreaks(breaksVec2);
-      shader.uniforms.CSM_cascades = {
-        value: breaksVec2
-      };
-      shader.uniforms.cameraNear = {
-        value: scope.camera.near
-      };
-      shader.uniforms.shadowFar = {
-        value: far
-      };
+      shader.uniforms.CSM_cascades = { value: breaksVec2 };
+      shader.uniforms.cameraNear = { value: scope.camera.near };
+      shader.uniforms.shadowFar = { value: far };
       shaders.set(material, shader);
     };
-
     shaders.set(material, null);
   }
-
   updateUniforms() {
     const far = Math.min(this.camera.far, this.maxFar);
     const shaders = this.shaders;
-    shaders.forEach(function (shader, material) {
+    shaders.forEach(function(shader, material) {
       if (shader !== null) {
         const uniforms = shader.uniforms;
         this.getExtendedBreaks(uniforms.CSM_cascades.value);
         uniforms.cameraNear.value = this.camera.near;
         uniforms.shadowFar.value = far;
       }
-
-      if (!this.fade && 'CSM_FADE' in material.defines) {
+      if (!this.fade && "CSM_FADE" in material.defines) {
         delete material.defines.CSM_FADE;
         material.needsUpdate = true;
-      } else if (this.fade && !('CSM_FADE' in material.defines)) {
-        material.defines.CSM_FADE = '';
+      } else if (this.fade && !("CSM_FADE" in material.defines)) {
+        material.defines.CSM_FADE = "";
         material.needsUpdate = true;
       }
     }, this);
   }
-
   getExtendedBreaks(target) {
     while (target.length < this.breaks.length) {
-      target.push(new Vector2());
+      target.push(new THREE.Vector2());
     }
-
     target.length = this.breaks.length;
-
     for (let i = 0; i < this.cascades; i++) {
       const amount = this.breaks[i];
       const prev = this.breaks[i - 1] || 0;
@@ -267,39 +213,32 @@ class CSM {
       target[i].y = amount;
     }
   }
-
   updateFrustums() {
     this.getBreaks();
     this.initCascades();
     this.updateShadowBounds();
     this.updateUniforms();
   }
-
   remove() {
     for (let i = 0; i < this.lights.length; i++) {
       this.parent.remove(this.lights[i]);
     }
   }
-
   dispose() {
     const shaders = this.shaders;
-    shaders.forEach(function (shader, material) {
+    shaders.forEach(function(shader, material) {
       delete material.onBeforeCompile;
       delete material.defines.USE_CSM;
       delete material.defines.CSM_CASCADES;
       delete material.defines.CSM_FADE;
-
       if (shader !== null) {
         delete shader.uniforms.CSM_cascades;
         delete shader.uniforms.cameraNear;
         delete shader.uniforms.shadowFar;
       }
-
       material.needsUpdate = true;
     });
     shaders.clear();
   }
-
 }
-
-export { CSM };
+exports.CSM = CSM;

package/csm/CSM.mjs

@@ -0,0 +1,244 @@
+import { Matrix4, Vector3, Box3, DirectionalLight, MathUtils, ShaderChunk, Vector2 } from "three";
+import { CSMFrustum } from "./CSMFrustum.mjs";
+import { CSMShader } from "./CSMShader.mjs";
+const _cameraToLightMatrix = new Matrix4();
+const _lightSpaceFrustum = new CSMFrustum();
+const _center = new Vector3();
+const _bbox = new Box3();
+const _uniformArray = [];
+const _logArray = [];
+class CSM {
+  constructor(data) {
+    data = data || {};
+    this.camera = data.camera;
+    this.parent = data.parent;
+    this.cascades = data.cascades || 3;
+    this.maxFar = data.maxFar || 1e5;
+    this.mode = data.mode || "practical";
+    this.shadowMapSize = data.shadowMapSize || 2048;
+    this.shadowBias = data.shadowBias || 1e-6;
+    this.lightDirection = data.lightDirection || new Vector3(1, -1, 1).normalize();
+    this.lightIntensity = data.lightIntensity || 1;
+    this.lightNear = data.lightNear || 1;
+    this.lightFar = data.lightFar || 2e3;
+    this.lightMargin = data.lightMargin || 200;
+    this.customSplitsCallback = data.customSplitsCallback;
+    this.fade = false;
+    this.mainFrustum = new CSMFrustum();
+    this.frustums = [];
+    this.breaks = [];
+    this.lights = [];
+    this.shaders = /* @__PURE__ */ new Map();
+    this.createLights();
+    this.updateFrustums();
+    this.injectInclude();
+  }
+  createLights() {
+    for (let i = 0; i < this.cascades; i++) {
+      const light = new DirectionalLight(16777215, this.lightIntensity);
+      light.castShadow = true;
+      light.shadow.mapSize.width = this.shadowMapSize;
+      light.shadow.mapSize.height = this.shadowMapSize;
+      light.shadow.camera.near = this.lightNear;
+      light.shadow.camera.far = this.lightFar;
+      light.shadow.bias = this.shadowBias;
+      this.parent.add(light);
+      this.parent.add(light.target);
+      this.lights.push(light);
+    }
+  }
+  initCascades() {
+    const camera = this.camera;
+    camera.updateProjectionMatrix();
+    this.mainFrustum.setFromProjectionMatrix(camera.projectionMatrix, this.maxFar);
+    this.mainFrustum.split(this.breaks, this.frustums);
+  }
+  updateShadowBounds() {
+    const frustums = this.frustums;
+    for (let i = 0; i < frustums.length; i++) {
+      const light = this.lights[i];
+      const shadowCam = light.shadow.camera;
+      const frustum = this.frustums[i];
+      const nearVerts = frustum.vertices.near;
+      const farVerts = frustum.vertices.far;
+      const point1 = farVerts[0];
+      let point2;
+      if (point1.distanceTo(farVerts[2]) > point1.distanceTo(nearVerts[2])) {
+        point2 = farVerts[2];
+      } else {
+        point2 = nearVerts[2];
+      }
+      let squaredBBWidth = point1.distanceTo(point2);
+      if (this.fade) {
+        const camera = this.camera;
+        const far = Math.max(camera.far, this.maxFar);
+        const linearDepth = frustum.vertices.far[0].z / (far - camera.near);
+        const margin = 0.25 * Math.pow(linearDepth, 2) * (far - camera.near);
+        squaredBBWidth += margin;
+      }
+      shadowCam.left = -squaredBBWidth / 2;
+      shadowCam.right = squaredBBWidth / 2;
+      shadowCam.top = squaredBBWidth / 2;
+      shadowCam.bottom = -squaredBBWidth / 2;
+      shadowCam.updateProjectionMatrix();
+    }
+  }
+  getBreaks() {
+    const camera = this.camera;
+    const far = Math.min(camera.far, this.maxFar);
+    this.breaks.length = 0;
+    switch (this.mode) {
+      case "uniform":
+        uniformSplit(this.cascades, camera.near, far, this.breaks);
+        break;
+      case "logarithmic":
+        logarithmicSplit(this.cascades, camera.near, far, this.breaks);
+        break;
+      case "practical":
+        practicalSplit(this.cascades, camera.near, far, 0.5, this.breaks);
+        break;
+      case "custom":
+        if (this.customSplitsCallback === void 0)
+          console.error("CSM: Custom split scheme callback not defined.");
+        this.customSplitsCallback(this.cascades, camera.near, far, this.breaks);
+        break;
+    }
+    function uniformSplit(amount, near, far2, target) {
+      for (let i = 1; i < amount; i++) {
+        target.push((near + (far2 - near) * i / amount) / far2);
+      }
+      target.push(1);
+    }
+    function logarithmicSplit(amount, near, far2, target) {
+      for (let i = 1; i < amount; i++) {
+        target.push(near * (far2 / near) ** (i / amount) / far2);
+      }
+      target.push(1);
+    }
+    function practicalSplit(amount, near, far2, lambda, target) {
+      _uniformArray.length = 0;
+      _logArray.length = 0;
+      logarithmicSplit(amount, near, far2, _logArray);
+      uniformSplit(amount, near, far2, _uniformArray);
+      for (let i = 1; i < amount; i++) {
+        target.push(MathUtils.lerp(_uniformArray[i - 1], _logArray[i - 1], lambda));
+      }
+      target.push(1);
+    }
+  }
+  update() {
+    const camera = this.camera;
+    const frustums = this.frustums;
+    for (let i = 0; i < frustums.length; i++) {
+      const light = this.lights[i];
+      const shadowCam = light.shadow.camera;
+      const texelWidth = (shadowCam.right - shadowCam.left) / this.shadowMapSize;
+      const texelHeight = (shadowCam.top - shadowCam.bottom) / this.shadowMapSize;
+      light.shadow.camera.updateMatrixWorld(true);
+      _cameraToLightMatrix.multiplyMatrices(light.shadow.camera.matrixWorldInverse, camera.matrixWorld);
+      frustums[i].toSpace(_cameraToLightMatrix, _lightSpaceFrustum);
+      const nearVerts = _lightSpaceFrustum.vertices.near;
+      const farVerts = _lightSpaceFrustum.vertices.far;
+      _bbox.makeEmpty();
+      for (let j = 0; j < 4; j++) {
+        _bbox.expandByPoint(nearVerts[j]);
+        _bbox.expandByPoint(farVerts[j]);
+      }
+      _bbox.getCenter(_center);
+      _center.z = _bbox.max.z + this.lightMargin;
+      _center.x = Math.floor(_center.x / texelWidth) * texelWidth;
+      _center.y = Math.floor(_center.y / texelHeight) * texelHeight;
+      _center.applyMatrix4(light.shadow.camera.matrixWorld);
+      light.position.copy(_center);
+      light.target.position.copy(_center);
+      light.target.position.x += this.lightDirection.x;
+      light.target.position.y += this.lightDirection.y;
+      light.target.position.z += this.lightDirection.z;
+    }
+  }
+  injectInclude() {
+    ShaderChunk.lights_fragment_begin = CSMShader.lights_fragment_begin;
+    ShaderChunk.lights_pars_begin = CSMShader.lights_pars_begin;
+  }
+  setupMaterial(material) {
+    material.defines = material.defines || {};
+    material.defines.USE_CSM = 1;
+    material.defines.CSM_CASCADES = this.cascades;
+    if (this.fade) {
+      material.defines.CSM_FADE = "";
+    }
+    const breaksVec2 = [];
+    const scope = this;
+    const shaders = this.shaders;
+    material.onBeforeCompile = function(shader) {
+      const far = Math.min(scope.camera.far, scope.maxFar);
+      scope.getExtendedBreaks(breaksVec2);
+      shader.uniforms.CSM_cascades = { value: breaksVec2 };
+      shader.uniforms.cameraNear = { value: scope.camera.near };
+      shader.uniforms.shadowFar = { value: far };
+      shaders.set(material, shader);
+    };
+    shaders.set(material, null);
+  }
+  updateUniforms() {
+    const far = Math.min(this.camera.far, this.maxFar);
+    const shaders = this.shaders;
+    shaders.forEach(function(shader, material) {
+      if (shader !== null) {
+        const uniforms = shader.uniforms;
+        this.getExtendedBreaks(uniforms.CSM_cascades.value);
+        uniforms.cameraNear.value = this.camera.near;
+        uniforms.shadowFar.value = far;
+      }
+      if (!this.fade && "CSM_FADE" in material.defines) {
+        delete material.defines.CSM_FADE;
+        material.needsUpdate = true;
+      } else if (this.fade && !("CSM_FADE" in material.defines)) {
+        material.defines.CSM_FADE = "";
+        material.needsUpdate = true;
+      }
+    }, this);
+  }
+  getExtendedBreaks(target) {
+    while (target.length < this.breaks.length) {
+      target.push(new Vector2());
+    }
+    target.length = this.breaks.length;
+    for (let i = 0; i < this.cascades; i++) {
+      const amount = this.breaks[i];
+      const prev = this.breaks[i - 1] || 0;
+      target[i].x = prev;
+      target[i].y = amount;
+    }
+  }
+  updateFrustums() {
+    this.getBreaks();
+    this.initCascades();
+    this.updateShadowBounds();
+    this.updateUniforms();
+  }
+  remove() {
+    for (let i = 0; i < this.lights.length; i++) {
+      this.parent.remove(this.lights[i]);
+    }
+  }
+  dispose() {
+    const shaders = this.shaders;
+    shaders.forEach(function(shader, material) {
+      delete material.onBeforeCompile;
+      delete material.defines.USE_CSM;
+      delete material.defines.CSM_CASCADES;
+      delete material.defines.CSM_FADE;
+      if (shader !== null) {
+        delete shader.uniforms.CSM_cascades;
+        delete shader.uniforms.cameraNear;
+        delete shader.uniforms.shadowFar;
+      }
+      material.needsUpdate = true;
+    });
+    shaders.clear();
+  }
+}
+export {
+  CSM
+};

package/csm/CSMFrustum.js

@@ -1,61 +1,50 @@
-import { Matrix4, Vector3 } from 'three';
-
-const inverseProjectionMatrix = new Matrix4();
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const inverseProjectionMatrix = new THREE.Matrix4();
 class CSMFrustum {
   constructor(data) {
     data = data || {};
     this.vertices = {
-      near: [new Vector3(), new Vector3(), new Vector3(), new Vector3()],
-      far: [new Vector3(), new Vector3(), new Vector3(), new Vector3()]
+      near: [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()],
+      far: [new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3()]
     };
-
-    if (data.projectionMatrix !== undefined) {
-      this.setFromProjectionMatrix(data.projectionMatrix, data.maxFar || 10000);
+    if (data.projectionMatrix !== void 0) {
+      this.setFromProjectionMatrix(data.projectionMatrix, data.maxFar || 1e4);
     }
   }
-
   setFromProjectionMatrix(projectionMatrix, maxFar) {
     const isOrthographic = projectionMatrix.elements[2 * 4 + 3] === 0;
-    inverseProjectionMatrix.copy(projectionMatrix).invert(); // 3 --- 0  vertices.near/far order
-    // |     |
-    // 2 --- 1
-    // clip space spans from [-1, 1]
-
+    inverseProjectionMatrix.copy(projectionMatrix).invert();
     this.vertices.near[0].set(1, 1, -1);
     this.vertices.near[1].set(1, -1, -1);
     this.vertices.near[2].set(-1, -1, -1);
     this.vertices.near[3].set(-1, 1, -1);
-    this.vertices.near.forEach(function (v) {
+    this.vertices.near.forEach(function(v) {
       v.applyMatrix4(inverseProjectionMatrix);
     });
     this.vertices.far[0].set(1, 1, 1);
     this.vertices.far[1].set(1, -1, 1);
     this.vertices.far[2].set(-1, -1, 1);
     this.vertices.far[3].set(-1, 1, 1);
-    this.vertices.far.forEach(function (v) {
+    this.vertices.far.forEach(function(v) {
       v.applyMatrix4(inverseProjectionMatrix);
       const absZ = Math.abs(v.z);
-
       if (isOrthographic) {
-        v.z *= Math.min(maxFar / absZ, 1.0);
+        v.z *= Math.min(maxFar / absZ, 1);
       } else {
-        v.multiplyScalar(Math.min(maxFar / absZ, 1.0));
+        v.multiplyScalar(Math.min(maxFar / absZ, 1));
       }
     });
     return this.vertices;
   }
-
   split(breaks, target) {
     while (breaks.length > target.length) {
       target.push(new CSMFrustum());
     }
-
     target.length = breaks.length;
-
     for (let i = 0; i < breaks.length; i++) {
       const cascade = target[i];
-
       if (i === 0) {
         for (let j = 0; j < 4; j++) {
           cascade.vertices.near[j].copy(this.vertices.near[j]);
@@ -65,7 +54,6 @@ class CSMFrustum {
           cascade.vertices.near[j].lerpVectors(this.vertices.near[j], this.vertices.far[j], breaks[i - 1]);
         }
       }
-
       if (i === breaks.length - 1) {
         for (let j = 0; j < 4; j++) {
           cascade.vertices.far[j].copy(this.vertices.far[j]);
@@ -77,14 +65,11 @@ class CSMFrustum {
       }
     }
   }
-
   toSpace(cameraMatrix, target) {
     for (let i = 0; i < 4; i++) {
       target.vertices.near[i].copy(this.vertices.near[i]).applyMatrix4(cameraMatrix);
       target.vertices.far[i].copy(this.vertices.far[i]).applyMatrix4(cameraMatrix);
     }
   }
-
 }
-
-export { CSMFrustum };
+exports.CSMFrustum = CSMFrustum;