three-stdlib 2.35.6 → 2.35.8

package/_polyfill/constants.d.cts

@@ -0,0 +1 @@
+export declare const version: number;

package/_polyfill/uv1.d.cts

@@ -0,0 +1,5 @@
+/** uv2 renamed to uv1 in r125
+ *
+ * https://github.com/mrdoob/three.js/pull/25943
+*/
+export declare const UV1: string;

package/animation/AnimationClipCreator.d.cts

@@ -0,0 +1,12 @@
+import type { AnimationClip, Vector3 } from 'three'
+
+export interface AnimationClipCreator {
+  CreateRotationAnimation(period: number, axis: string): AnimationClip
+  CreateScaleAxisAnimation(period: number, axis: string): AnimationClip
+  CreateShakeAnimation(duration: number, shakeScale: Vector3): AnimationClip
+  CreatePulsationAnimation(duration: number, pulseScale: number): AnimationClip
+  CreateVisibilityAnimation(duration: number): AnimationClip
+  CreateMaterialColorAnimation(duration: number, colors: number[]): AnimationClip
+}
+
+export const AnimationClipCreator: AnimationClipCreator

package/animation/AnimationClipCreator.d.ts

@@ -1,4 +1,4 @@
-import { AnimationClip, Vector3 } from 'three'
+import type { AnimationClip, Vector3 } from 'three'
 
 export interface AnimationClipCreator {
   CreateRotationAnimation(period: number, axis: string): AnimationClip

package/animation/CCDIKSolver.d.cts

@@ -0,0 +1,30 @@
+import type { Object3D, SkinnedMesh, Vector3 } from 'three'
+
+// tslint:disable-next-line:interface-name
+export interface IKS {
+  effector: number
+  iteration: number
+  links: Array<{
+    enabled: boolean
+    index: number
+    limitation?: Vector3
+    rotationMin?: Vector3
+    rotationMax?: Vector3
+  }>
+  minAngle: number
+  maxAngle: number
+  target: number
+}
+
+export class CCDIKSolver {
+  constructor(mesh: SkinnedMesh, iks: IKS[])
+
+  update(): this
+  updateOne(iks: IKS): this
+  createHelper(): CCDIKHelper
+}
+
+export class CCDIKHelper extends Object3D {
+  constructor(mesh: SkinnedMesh, iks?: IKS[], sphereSize?: number)
+  dispose(): void
+}

package/animation/CCDIKSolver.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, SkinnedMesh, Vector3 } from 'three'
+import type { Object3D, SkinnedMesh, Vector3 } from 'three'
 
 // tslint:disable-next-line:interface-name
 export interface IKS {

package/animation/MMDAnimationHelper.d.cts

@@ -0,0 +1,93 @@
+import type { AnimationClip, Audio, Camera, Object3D, Quaternion, SkinnedMesh, Bone, AnimationMixer } from 'three'
+
+import type { CCDIKSolver } from './CCDIKSolver.d.cts'
+import type { MMDPhysics } from './MMDPhysics.d.cts'
+
+export interface MMDAnimationHelperParameter {
+  sync?: boolean | undefined
+  afterglow?: number | undefined
+  resetPhysicsOnLoop?: boolean | undefined
+}
+
+export interface MMDAnimationHelperAddParameter {
+  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 | undefined
+  ik?: boolean | undefined
+  grant?: boolean | undefined
+}
+
+export interface MMDAnimationHelperMixer {
+  looped: boolean
+  mixer?: AnimationMixer | undefined
+  ikSolver: CCDIKSolver
+  grantSolver: GrantSolver
+  physics?: MMDPhysics | undefined
+  duration?: number | undefined
+}
+
+export class MMDAnimationHelper {
+  constructor(params?: MMDAnimationHelperParameter)
+  meshes: SkinnedMesh[]
+  camera: Camera | null
+  cameraTarget: Object3D
+  audio: Audio
+  audioManager: AudioManager
+  configuration: {
+    sync: boolean
+    afterglow: number
+    resetPhysicsOnLoop: boolean
+  }
+  enabled: {
+    animation: boolean
+    ik: boolean
+    grant: boolean
+    physics: boolean
+    cameraAnimation: boolean
+  }
+  objects: WeakMap<SkinnedMesh | Camera | AudioManager, MMDAnimationHelperMixer>
+  onBeforePhysics: (mesh: SkinnedMesh) => void
+  sharedPhysics: boolean
+  masterPhysics: null
+
+  add(object: SkinnedMesh | Camera | Audio, params?: MMDAnimationHelperAddParameter): this
+  remove(object: SkinnedMesh | Camera | Audio): this
+  update(delta: number): this
+  pose(mesh: SkinnedMesh, vpd: object, params?: MMDAnimationHelperPoseParameter): this
+  enable(key: string, enabled: boolean): this
+  createGrantSolver(mesh: SkinnedMesh): GrantSolver
+}
+
+export interface AudioManagerParameter {
+  delayTime?: number | undefined
+}
+
+export class AudioManager {
+  constructor(audio: Audio, params?: AudioManagerParameter)
+  audio: Audio
+  elapsedTime: number
+  currentTime: number
+  delayTime: number
+  audioDuration: number
+  duration: number
+
+  control(delta: number): this
+}
+
+export class GrantSolver {
+  constructor(mesh: SkinnedMesh, grants: object[])
+  mesh: SkinnedMesh
+  grants: object[]
+
+  update(): this
+  updateOne(gran: object[]): this
+  addGrantRotation(bone: Bone, q: Quaternion, ratio: number): this
+}

package/animation/MMDAnimationHelper.d.ts

@@ -1,7 +1,7 @@
-import { AnimationClip, Audio, Camera, Object3D, Quaternion, SkinnedMesh, Bone, AnimationMixer } from 'three'
+import type { AnimationClip, Audio, Camera, Object3D, Quaternion, SkinnedMesh, Bone, AnimationMixer } from 'three'
 
-import { CCDIKSolver } from './CCDIKSolver'
-import { MMDPhysics } from './MMDPhysics'
+import type { CCDIKSolver } from './CCDIKSolver.d.ts'
+import type { MMDPhysics } from './MMDPhysics.d.ts'
 
 export interface MMDAnimationHelperParameter {
   sync?: boolean | undefined

package/animation/MMDPhysics.d.cts

@@ -0,0 +1,119 @@
+import type { Bone, Euler, Matrix4, MeshBasicMaterial, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three'
+
+export interface MMDPhysicsParameter {
+  unitStep?: number | undefined
+  maxStepNum?: number | undefined
+  gravity?: Vector3 | undefined
+}
+
+export class MMDPhysics {
+  constructor(mesh: SkinnedMesh, rigidBodyParams: object[], constraintParams?: object[], params?: MMDPhysicsParameter)
+  manager: ResourceManager
+  mesh: SkinnedMesh
+  unitStep: number
+  maxStepNum: number
+  gravity: Vector3
+  world: null
+  bodies: RigidBody[]
+  constraints: Constraint[]
+
+  update(delta: number): this
+  reset(): this
+  warmup(cycles: number): this
+  setGravity(gravity: Vector3): this
+  createHelper(): MMDPhysicsHelper
+}
+
+export class ResourceManager {
+  constructor()
+  threeVector3s: Vector3[]
+  threeMatrix4s: Matrix4[]
+  threeQuaternions: Quaternion[]
+  threeEulers: Euler[]
+  transforms: object[]
+  quaternions: object[]
+  vector3s: object[]
+
+  allocThreeVector3(): void
+  freeThreeVector3(v: Vector3): void
+  allocThreeMatrix4(): void
+  freeThreeMatrix4(m: Matrix4): void
+  allocThreeQuaternion(): void
+  freeThreeQuaternion(q: Quaternion): void
+  allocThreeEuler(): void
+  freeThreeEuler(e: Euler): void
+  allocTransform(): void
+  freeTransform(t: object): void
+  allocQuaternion(): void
+  freeQuaternion(q: object): void
+  allocVector3(): void
+  freeVector3(v: object): void
+  setIdentity(): void
+  getBasis(t: object): object
+  getBasisAsMatrix3(t: object): object
+  getOrigin(t: object): object
+  setOrigin(t: object, v: object): void
+  copyOrigin(t1: object, t2: object): void
+  setBasis(t: object, q: object): void
+  setBasisFromMatrix3(t: object, m: object): void
+  setOriginFromArray3(t: object, a: number[]): void
+  setOriginFromThreeVector3(t: object, v: Vector3): void
+  setBasisFromArray3(t: object, a: number[]): void
+  setBasisFromThreeQuaternion(t: object, a: Quaternion): void
+  multiplyTransforms(t1: object, t2: object): object
+  inverseTransform(t: object): object
+  multiplyMatrices3(m1: object, m2: object): object
+  addVector3(v1: object, v2: object): object
+  dotVectors3(v1: object, v2: object): number
+  rowOfMatrix3(m: object, i: number): object
+  columnOfMatrix3(m: object, i: number): object
+  negativeVector3(v: object): object
+  multiplyMatrix3ByVector3(m: object, v: object): object
+  transposeMatrix3(m: object): object
+  quaternionToMatrix3(q: object): object
+  matrix3ToQuaternion(m: object): object
+}
+
+export class RigidBody {
+  constructor(mesh: SkinnedMesh, world: object, params: object, manager: ResourceManager)
+  mesh: SkinnedMesh
+  world: object
+  params: object
+  manager: ResourceManager
+
+  body: object
+  bone: Bone
+  boneOffsetForm: object
+  boneOffsetFormInverse: object
+
+  reset(): this
+  updateFromBone(): this
+  updateBone(): this
+}
+
+export class Constraint {
+  constructor(
+    mesh: SkinnedMesh,
+    world: object,
+    bodyA: RigidBody,
+    bodyB: RigidBody,
+    params: object,
+    manager: ResourceManager,
+  )
+
+  mesh: SkinnedMesh
+  world: object
+  bodyA: RigidBody
+  bodyB: RigidBody
+  params: object
+  manager: ResourceManager
+}
+
+export class MMDPhysicsHelper extends Object3D {
+  mesh: SkinnedMesh
+  physics: MMDPhysics
+  materials: [MeshBasicMaterial, MeshBasicMaterial, MeshBasicMaterial]
+
+  constructor(mesh: SkinnedMesh, physics: MMDPhysics)
+  dispose(): void
+}

package/animation/MMDPhysics.d.ts

@@ -1,4 +1,4 @@
-import { Bone, Euler, Matrix4, MeshBasicMaterial, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three'
+import type { Bone, Euler, Matrix4, MeshBasicMaterial, Object3D, Quaternion, SkinnedMesh, Vector3 } from 'three'
 
 export interface MMDPhysicsParameter {
   unitStep?: number | undefined

package/cameras/CinematicCamera.d.cts

@@ -0,0 +1,34 @@
+import type { PerspectiveCamera, ShaderMaterial, Scene, WebGLRenderer, OrthographicCamera, WebGLRenderTarget } from 'three'
+
+import type { BokehShader2Uniforms } from './../shaders/BokehShader2.d.cts'
+
+export class CinematicCamera extends PerspectiveCamera {
+  constructor(fov: number, aspect: number, near: number, far: number)
+
+  postprocessing: {
+    enabled: boolean
+    scene: Scene
+    camera: OrthographicCamera
+    rtTextureDepth: WebGLRenderTarget
+    rtTextureColor: WebGLRenderTarget
+    bokeh_uniforms: BokehShader2Uniforms
+  }
+  shaderSettings: {
+    rings: number
+    samples: number
+  }
+  materialDepth: ShaderMaterial
+  coc: number
+  aperture: number
+  fNumber: number
+  hyperFocal: number
+  filmGauge: number
+
+  linearize(depth: number): number
+  smoothstep(near: number, far: number, depth: number): number
+  saturate(x: number): number
+  focusAt(focusDistance: number): void
+  initPostProcessing(): void
+  renderCinematic(scene: Scene, renderer: WebGLRenderer): void
+  setLens(focalLength: number, frameHeight?: number, fNumber?: number, coc?: number): void
+}

package/cameras/CinematicCamera.d.ts

@@ -1,6 +1,6 @@
-import { PerspectiveCamera, ShaderMaterial, Scene, WebGLRenderer, OrthographicCamera, WebGLRenderTarget } from 'three'
+import type { PerspectiveCamera, ShaderMaterial, Scene, WebGLRenderer, OrthographicCamera, WebGLRenderTarget } from 'three'
 
-import { BokehShader2Uniforms } from './../shaders/BokehShader2'
+import type { BokehShader2Uniforms } from './../shaders/BokehShader2.d.ts'
 
 export class CinematicCamera extends PerspectiveCamera {
   constructor(fov: number, aspect: number, near: number, far: number)