three-stdlib 2.8.2 → 2.8.6

package/{BufferGeometryUtils-582025b8.js → BufferGeometryUtils-1a7a235c.js}

@@ -485,7 +485,8 @@ function computeMorphedAttributes(object) {
 
     const morphInfluences = object.morphTargetInfluences;
 
-    if (material.morphTargets && morphAttribute && morphInfluences) {
+    if ( // @ts-expect-error
+    material.morphTargets && morphAttribute && morphInfluences) {
       _morphA.set(0, 0, 0);
 
       _morphB.set(0, 0, 0);

package/animation/MMDAnimationHelper.d.ts

@@ -14,34 +14,34 @@ import { CCDIKSolver } from './CCDIKSolver';
 import { MMDPhysics } from './MMDPhysics';
 
 export interface MMDAnimationHelperParameter {
-    sync?: boolean;
-    afterglow?: number;
-    resetPhysicsOnLoop?: boolean;
+    sync?: boolean | undefined;
+    afterglow?: number | undefined;
+    resetPhysicsOnLoop?: boolean | undefined;
 }
 
 export interface MMDAnimationHelperAddParameter {
-    animation?: AnimationClip | AnimationClip[];
-    physics?: boolean;
-    warmup?: number;
-    unitStep?: number;
-    maxStepNum?: number;
-    gravity?: number;
-    delayTime?: number;
+    animation?: AnimationClip | AnimationClip[] | undefined;
+    physics?: boolean | undefined;
+    warmup?: number | undefined;
+    unitStep?: number | undefined;
+    maxStepNum?: number | undefined;
+    gravity?: number | undefined;
+    delayTime?: number | undefined;
 }
 
 export interface MMDAnimationHelperPoseParameter {
-    resetPose?: boolean;
-    ik?: boolean;
-    grant?: boolean;
+    resetPose?: boolean | undefined;
+    ik?: boolean | undefined;
+    grant?: boolean | undefined;
 }
 
 export interface MMDAnimationHelperMixer {
     looped: boolean;
-    mixer?: AnimationMixer;
+    mixer?: AnimationMixer | undefined;
     ikSolver: CCDIKSolver;
     grantSolver: GrantSolver;
-    physics?: MMDPhysics;
-    duration?: number;
+    physics?: MMDPhysics | undefined;
+    duration?: number | undefined;
 }
 
 export class MMDAnimationHelper {
@@ -77,7 +77,7 @@ export class MMDAnimationHelper {
 }
 
 export interface AudioManagerParameter {
-    delayTime?: number;
+    delayTime?: number | undefined;
 }
 
 export class AudioManager {

package/animation/MMDPhysics.d.ts

@@ -1,9 +1,9 @@
 import { Bone, Euler, Matrix4, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three';
 
 export interface MMDPhysicsParameter {
-    unitStep?: number;
-    maxStepNum?: number;
-    gravity?: Vector3;
+    unitStep?: number | undefined;
+    maxStepNum?: number | undefined;
+    gravity?: Vector3 | undefined;
 }
 
 export class MMDPhysics {

package/csm/CSM.d.ts

@@ -1,36 +1,61 @@
+import { Camera, Vector3, DirectionalLight, Material, Vector2, Object3D } from 'three';
+
+export enum CMSMode {
+    practical = 'practical',
+    uniform = 'uniform',
+    logarithmic = 'logarithmic',
+    custom = 'custom',
+}
+
+export interface CMSParameters {
+    camera?: Camera;
+    parent?: Object3D;
+    cascades?: number;
+    maxFar?: number;
+    mode?: CMSMode;
+    shadowMapSize?: number;
+    shadowBias?: number;
+    lightDirection?: Vector3;
+    lightIntensity?: number;
+    lightNear?: number;
+    lightFar?: number;
+    lightMargin?: number;
+    customSplitsCallback?: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
+}
+
 export class CSM {
-    constructor(data: any);
-    camera: any;
-    parent: any;
-    cascades: any;
-    maxFar: any;
-    mode: any;
-    shadowMapSize: any;
-    shadowBias: any;
-    lightDirection: any;
-    lightIntensity: any;
-    lightNear: any;
-    lightFar: any;
-    lightMargin: any;
-    customSplitsCallback: any;
+    constructor(data?: CMSParameters);
+    camera: Camera;
+    parent: Object3D;
+    cascades: number;
+    maxFar: number;
+    mode: CMSMode;
+    shadowMapSize: number;
+    shadowBias: number;
+    lightDirection: Vector3;
+    lightIntensity: number;
+    lightNear: number;
+    lightFar: number;
+    lightMargin: number;
+    customSplitsCallback: (cascades: number, cameraNear: number, cameraFar: number, breaks: number[]) => void;
     fade: boolean;
-    mainFrustum: Frustum;
-    frustums: any[];
-    breaks: any[];
-    lights: any[];
-    shaders: Map<any, any>;
+    mainFrustum: CSMFrustrum;
+    frustums: CSMFrustrum[];
+    breaks: number[];
+    lights: DirectionalLight[];
+    shaders: Map<unknown, string>;
     createLights(): void;
     initCascades(): void;
     updateShadowBounds(): void;
     getBreaks(): void;
     update(): void;
     injectInclude(): void;
-    setupMaterial(material: any): void;
+    setupMaterial(material: Material): void;
     updateUniforms(): void;
-    getExtendedBreaks(target: any): void;
+    getExtendedBreaks(target: Vector2[]): void;
     updateFrustums(): void;
     remove(): void;
     dispose(): void;
 }
 
-import Frustum from './Frustum.js';
+import CSMFrustrum from './CSMFrustum.js';

package/csm/CSMHelper.d.ts

@@ -1,13 +1,26 @@
-export class CSMHelper {
-    constructor(csm: any);
-    csm: any;
+import {
+    Box3Helper,
+    BufferGeometry,
+    Group,
+    LineBasicMaterial,
+    LineSegments,
+    Mesh,
+    MeshBasicMaterial,
+    PlaneGeometry,
+} from 'three';
+
+import { CSM } from './CSM';
+
+export class CSMHelper<TCSM extends CSM = CSM> extends Group {
+    constructor(csm: TCSM);
+    csm: TCSM;
     displayFrustum: boolean;
     displayPlanes: boolean;
     displayShadowBounds: boolean;
-    frustumLines: any;
-    cascadeLines: any[];
-    cascadePlanes: any[];
-    shadowLines: any[];
+    frustumLines: LineSegments<BufferGeometry, LineBasicMaterial>;
+    cascadeLines: Box3Helper[];
+    cascadePlanes: Array<Mesh<PlaneGeometry, MeshBasicMaterial>>;
+    shadowLines: Box3Helper[];
     updateVisibility(): void;
     update(): void;
 }

package/effects/OutlineEffect.d.ts

@@ -1,10 +1,10 @@
 import { Camera, Scene, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from 'three';
 
 export interface OutlineEffectParameters {
-    defaultThickness?: number;
-    defaultColor?: number[];
-    defaultAlpha?: number;
-    defaultKeepAlive?: boolean;
+    defaultThickness?: number | undefined;
+    defaultColor?: number[] | undefined;
+    defaultAlpha?: number | undefined;
+    defaultKeepAlive?: boolean | undefined;
 }
 
 export class OutlineEffect {

package/effects/OutlineEffect.js

@@ -185,7 +185,10 @@ const OutlineEffect = function (renderer, parameters) {
     material.uniforms.outlineAlpha.value = originalMaterial.opacity;
 
     if (outlineParameters !== undefined) {
-      if (outlineParameters.thickness !== undefined) material.uniforms.outlineThickness.value = outlineParameters.thickness;
+      if (outlineParameters.thickness !== undefined) {
+        material.uniforms.outlineThickness.value = outlineParameters.thickness;
+      }
+
       if (outlineParameters.color !== undefined) material.uniforms.outlineColor.value.fromArray(outlineParameters.color);
       if (outlineParameters.alpha !== undefined) material.uniforms.outlineAlpha.value = outlineParameters.alpha;
     }
@@ -216,7 +219,10 @@ const OutlineEffect = function (renderer, parameters) {
       }
 
       material.transparent = outlineParameters.alpha !== undefined && outlineParameters.alpha < 1.0 ? true : originalMaterial.transparent;
-      if (outlineParameters.keepAlive !== undefined) cache[originalMaterial.uuid].keepAlive = outlineParameters.keepAlive;
+
+      if (outlineParameters.keepAlive !== undefined) {
+        cache[originalMaterial.uuid].keepAlive = outlineParameters.keepAlive;
+      }
     } else {
       material.transparent = originalMaterial.transparent;
       material.visible = originalMaterial.visible;

package/exporters/GLTFExporter.js

@@ -1902,29 +1902,24 @@ class GLTFMaterialsVolumeExtension {
 
   writeMaterial(material, materialDef) {
     if (!(material instanceof MeshPhysicalMaterial && // @ts-expect-error
-    material.isMeshPhysicalMaterial) || // @ts-expect-error
-    material.thickness === 0) {
+    material.isMeshPhysicalMaterial) || material.thickness === 0) {
       return;
     }
 
     const writer = this.writer;
     const extensionsUsed = writer.extensionsUsed;
     const extensionDef = {};
-    extensionDef.thickness = // @ts-expect-error
-    material.thickness; // @ts-expect-error
+    extensionDef.thickness = material.thickness;
 
     if (material.thicknessMap) {
       const thicknessMapDef = {
-        index: writer.processTexture( // @ts-expect-error
-        material.thicknessMap)
+        index: writer.processTexture(material.thicknessMap)
       };
-      writer.applyTextureTransform(thicknessMapDef, // @ts-expect-error
-      material.thicknessMap);
+      writer.applyTextureTransform(thicknessMapDef, material.thicknessMap);
       extensionDef.thicknessTexture = thicknessMapDef;
     }
 
-    extensionDef.attenuationDistance = //@ts-expect-error
-    material.attenuationDistance;
+    extensionDef.attenuationDistance = material.attenuationDistance;
     extensionDef.attenuationColor = //@ts-expect-error
     material.attenuationTint.toArray();
     materialDef.extensions = materialDef.extensions || {};

package/geometries/ConvexGeometry.d.ts

@@ -1,5 +1,5 @@
 import { BufferGeometry, Vector3 } from 'three';
 
 export class ConvexGeometry extends BufferGeometry {
-    constructor(points: Vector3[]);
+    constructor(points?: Vector3[]);
 }

package/geometries/ParametricGeometries.d.ts

@@ -1,8 +1,10 @@
-import { Curve, ParametricGeometry, Vector3 } from 'three';
+import { Curve, Vector3 } from 'three';
+
+import { ParametricGeometry } from './ParametricGeometry';
 
 export namespace ParametricGeometries {
     function klein(v: number, u: number, target: Vector3): Vector3;
-    function plane(width: number, height: number, target: Vector3): Vector3;
+    function plane(width: number, height: number): (u: number, v: number, target: Vector3) => Vector3;
     function mobius(u: number, t: number, target: Vector3): Vector3;
     function mobius3d(u: number, t: number, target: Vector3): Vector3;
 

package/helpers/RectAreaLightHelper.d.ts

@@ -1,10 +1,10 @@
-import { Color, Line, RectAreaLight } from 'three';
+import { Line, RectAreaLight, ColorRepresentation } from 'three';
 
 export class RectAreaLightHelper extends Line {
-    constructor(light: RectAreaLight, color?: Color | string | number);
+    constructor(light: RectAreaLight, color?: ColorRepresentation);
 
     light: RectAreaLight;
-    color: Color | string | number | undefined;
+    color: ColorRepresentation | undefined;
 
     dispose(): void;
 }