three-stdlib 2.35.6 → 2.35.8

package/effects/OutlineEffect.d.cts

@@ -0,0 +1,28 @@
+import type { Camera, Scene, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from 'three'
+
+export interface OutlineEffectParameters {
+  defaultThickness?: number | undefined
+  defaultColor?: number[] | undefined
+  defaultAlpha?: number | undefined
+  defaultKeepAlive?: boolean | undefined
+}
+
+export class OutlineEffect {
+  constructor(renderer: WebGLRenderer, parameters?: OutlineEffectParameters)
+  enabled: boolean
+  autoClear: boolean
+  domElement: HTMLElement
+  shadowMap: WebGLShadowMap
+
+  clear(color?: boolean, depth?: boolean, stencil?: boolean): void
+  getPixelRatio(): number
+  getSize(target: Vector2): Vector2
+  render(scene: Scene, camera: Camera): void
+  renderOutline(scene: Scene, camera: Camera): void
+  setRenderTarget(renderTarget: WebGLRenderTarget | null): void
+  setPixelRatio(value: number): void
+  setScissor(x: Vector4 | number, y?: number, width?: number, height?: number): void
+  setScissorTest(enable: boolean): void
+  setSize(width: number, height: number, updateStyle?: boolean): void
+  setViewport(x: Vector4 | number, y?: number, width?: number, height?: number): void
+}

package/effects/OutlineEffect.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Scene, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from 'three'
+import type { Camera, Scene, Vector2, Vector4, WebGLRenderer, WebGLRenderTarget, WebGLShadowMap } from 'three'
 
 export interface OutlineEffectParameters {
   defaultThickness?: number | undefined

package/effects/ParallaxBarrierEffect.d.cts

@@ -0,0 +1,8 @@
+import type { Camera, Scene, WebGLRenderer } from 'three'
+
+export class ParallaxBarrierEffect {
+  constructor(renderer: WebGLRenderer)
+
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/effects/ParallaxBarrierEffect.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Scene, WebGLRenderer } from 'three'
+import type { Camera, Scene, WebGLRenderer } from 'three'
 
 export class ParallaxBarrierEffect {
   constructor(renderer: WebGLRenderer)

package/effects/PeppersGhostEffect.d.cts

@@ -0,0 +1,10 @@
+import type { Camera, Scene, WebGLRenderer } from 'three'
+
+export class PeppersGhostEffect {
+  constructor(renderer: WebGLRenderer)
+  cameraDistance: number
+  reflectFromAbove: boolean
+
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/effects/PeppersGhostEffect.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Scene, WebGLRenderer } from 'three'
+import type { Camera, Scene, WebGLRenderer } from 'three'
 
 export class PeppersGhostEffect {
   constructor(renderer: WebGLRenderer)

package/effects/StereoEffect.d.cts

@@ -0,0 +1,9 @@
+import type { Camera, Scene, WebGLRenderer } from 'three'
+
+export class StereoEffect {
+  constructor(renderer: WebGLRenderer)
+
+  setEyeSeparation(eyeSep: number): void
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/effects/StereoEffect.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Scene, WebGLRenderer } from 'three'
+import type { Camera, Scene, WebGLRenderer } from 'three'
 
 export class StereoEffect {
   constructor(renderer: WebGLRenderer)

package/environments/RoomEnvironment.d.cts

@@ -0,0 +1,6 @@
+/**
+ * https://github.com/google/model-viewer/blob/master/packages/model-viewer/src/three-components/EnvironmentScene.ts
+ */
+import type * as THREE from 'three';
+declare function RoomEnvironment(): THREE.Scene;
+export { type RoomEnvironment };

package/environments/RoomEnvironment.d.ts

@@ -1,6 +1,6 @@
 /**
  * https://github.com/google/model-viewer/blob/master/packages/model-viewer/src/three-components/EnvironmentScene.ts
  */
-import * as THREE from 'three';
+import type * as THREE from 'three';
 declare function RoomEnvironment(): THREE.Scene;
-export { RoomEnvironment };
+export { type RoomEnvironment };

package/exporters/ColladaExporter.d.cts

@@ -0,0 +1,50 @@
+import type { Object3D } from 'three';
+/**
+ * https://github.com/gkjohnson/collada-exporter-js
+ *
+ * Usage:
+ *  const exporter = new ColladaExporter();
+ *
+ *  const data = exporter.parse(mesh);
+ *
+ * Format Definition:
+ *  https://www.khronos.org/collada/
+ */
+export interface ColladaExporterOptions {
+    author?: string;
+    textureDirectory?: string;
+    version?: string;
+}
+export interface ColladaExporterResult {
+    data: string;
+    textures: object[];
+}
+declare class ColladaExporter {
+    private options;
+    private geometryInfo;
+    private materialMap;
+    private imageMap;
+    private textures;
+    private libraryImages;
+    private libraryGeometries;
+    private libraryEffects;
+    private libraryMaterials;
+    private canvas;
+    private ctx;
+    private transMat;
+    private getFuncs;
+    constructor();
+    parse(object: Object3D, onDone: (res: ColladaExporterResult) => void, options?: ColladaExporterOptions): ColladaExporterResult | null;
+    private format;
+    private base64ToBuffer;
+    private imageToData;
+    private attrBufferToArray;
+    private subArray;
+    private getAttribute;
+    private getTransform;
+    private processGeometry;
+    private processTexture;
+    private processMaterial;
+    private processObject;
+}
+export { type ColladaExporter };

package/exporters/ColladaExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three';
+import type { Object3D } from 'three';
 /**
  * https://github.com/gkjohnson/collada-exporter-js
  *
@@ -47,4 +47,4 @@ declare class ColladaExporter {
     private processMaterial;
     private processObject;
 }
-export { ColladaExporter };
+export { type ColladaExporter };

package/exporters/DRACOExporter.d.cts

@@ -0,0 +1,36 @@
+import type * as THREE from 'three'
+
+declare class DRACOExporter {
+  // Encoder methods
+
+  public static MESH_EDGEBREAKER_ENCODING: number
+  public static MESH_SEQUENTIAL_ENCODING: number
+
+  // Geometry type
+
+  public static POINT_CLOUD: number
+  public static TRIANGULAR_MESH: number
+
+  // Attribute type
+  public static INVALID: number
+  public static POSITION: number
+  public static NORMAL: number
+  public static COLOR: number
+  public static TEX_COORD: number
+  public static GENERIC: number
+
+  public parse(
+    object: THREE.Mesh | THREE.Points,
+    options?: {
+      decodeSpeed?: number
+      encodeSpeed?: number
+      encoderMethod?: number
+      quantization?: [number, number, number, number, number]
+      exportUvs?: boolean
+      exportNormals?: boolean
+      exportColor?: boolean
+    },
+  ): Int8Array
+}
+
+export { type DRACOExporter }

package/exporters/DRACOExporter.d.ts

@@ -1,4 +1,4 @@
-import * as THREE from 'three'
+import type * as THREE from 'three'
 
 declare class DRACOExporter {
   // Encoder methods
@@ -33,4 +33,4 @@ declare class DRACOExporter {
   ): Int8Array
 }
 
-export { DRACOExporter }
+export { type DRACOExporter }

package/exporters/GLTFExporter.d.cts

@@ -0,0 +1,114 @@
+import type { Object3D, AnimationClip, Texture, Material, Mesh } from 'three'
+
+export interface GLTFExporterOptions {
+  /**
+   * Export position, rotation and scale instead of matrix per node. Default is false
+   */
+  trs?: boolean
+
+  /**
+   * Export only visible objects. Default is true.
+   */
+  onlyVisible?: boolean
+
+  /**
+   * Export just the attributes within the drawRange, if defined, instead of exporting the whole array. Default is true.
+   */
+  truncateDrawRange?: boolean
+
+  /**
+   * Export in binary (.glb) format, returning an ArrayBuffer. Default is false.
+   */
+  binary?: boolean
+
+  /**
+   * Export with images embedded into the glTF asset. Default is true.
+   */
+  embedImages?: boolean
+
+  /**
+   * Restricts the image maximum size (both width and height) to the given value. This option works only if embedImages is true. Default is Infinity.
+   */
+  maxTextureSize?: number
+
+  /**
+   * List of animations to be included in the export.
+   */
+  animations?: AnimationClip[]
+
+  /**
+   * Generate indices for non-index geometry and export with them. Default is false.
+   */
+  forceIndices?: boolean
+
+  /**
+   * Export custom glTF extensions defined on an object's userData.gltfExtensions property. Default is false.
+   */
+  includeCustomExtensions?: boolean
+}
+
+export class GLTFExporter {
+  constructor()
+
+  register(callback: (writer: GLTFWriter) => GLTFExporterPlugin): this
+  unregister(callback: (writer: GLTFWriter) => GLTFExporterPlugin): this
+
+  /**
+   * Generates a .gltf (JSON) or .glb (binary) output from the input (Scenes or Objects)
+   *
+   * @param input Scenes or objects to export. Valid options:
+   * - Export scenes
+   *   ```js
+   *   exporter.parse( scene1, ... )
+   *   exporter.parse( [ scene1, scene2 ], ... )
+   *   ```
+   * - Export objects (It will create a new Scene to hold all the objects)
+   *   ```js
+   *   exporter.parse( object1, ... )
+   *   exporter.parse( [ object1, object2 ], ... )
+   *   ```
+   * - Mix scenes and objects (It will export the scenes as usual but it will create a new scene to hold all the single objects).
+   *   ```js
+   *   exporter.parse( [ scene1, object1, object2, scene2 ], ... )
+   *   ```
+   * @param onDone Will be called when the export completes. The argument will be the generated glTF JSON or binary ArrayBuffer.
+   * @param onError Will be called if there are any errors during the gltf generation.
+   * @param options Export options
+   */
+  parse(
+    input: Object3D | Object3D[],
+    onDone: (gltf: ArrayBuffer | { [key: string]: any }) => void,
+    onError: (error: ErrorEvent) => void,
+    options?: GLTFExporterOptions,
+  ): void
+
+  parseAsync(input: Object3D | Object3D[], options?: GLTFExporterOptions): Promise<ArrayBuffer | { [key: string]: any }>
+}
+
+export class GLTFWriter {
+  constructor()
+
+  setPlugins(plugins: GLTFExporterPlugin[]): void
+
+  /**
+   * Parse scenes and generate GLTF output
+   *
+   * @param input Scene or Array of THREE.Scenes
+   * @param onDone Callback on completed
+   * @param options options
+   */
+  write(
+    input: Object3D | Object3D[],
+    onDone: (gltf: ArrayBuffer | { [key: string]: any }) => void,
+    options?: GLTFExporterOptions,
+  ): Promise<void>
+}
+
+export interface GLTFExporterPlugin {
+  writeTexture?: (map: Texture, textureDef: { [key: string]: any }) => void
+  writeMaterial?: (material: Material, materialDef: { [key: string]: any }) => void
+  writeMesh?: (mesh: Mesh, meshDef: { [key: string]: any }) => void
+  writeNode?: (object: Object3D, nodeDef: { [key: string]: any }) => void
+  beforeParse?: (input: Object3D | Object3D[]) => void
+  afterParse?: (input: Object3D | Object3D[]) => void
+}

package/exporters/GLTFExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, AnimationClip, Texture, Material, Mesh } from 'three'
+import type { Object3D, AnimationClip, Texture, Material, Mesh } from 'three'
 
 export interface GLTFExporterOptions {
   /**

package/exporters/MMDExporter.d.cts

@@ -0,0 +1,12 @@
+import type { SkinnedMesh } from 'three';
+/**
+ * Dependencies
+ *  - mmd-parser https://github.com/takahirox/mmd-parser
+ */
+declare class MMDExporter {
+    parseVpd(skin: SkinnedMesh, outputShiftJis: boolean, useOriginalBones: boolean): Uint8Array | string | null;
+    private u2sTable;
+    private unicodeToShiftjis;
+    private getBindBones;
+}
+export { type MMDExporter };

package/exporters/MMDExporter.d.ts

@@ -1,4 +1,4 @@
-import { SkinnedMesh } from 'three';
+import type { SkinnedMesh } from 'three';
 /**
  * Dependencies
  *  - mmd-parser https://github.com/takahirox/mmd-parser
@@ -9,4 +9,4 @@ declare class MMDExporter {
     private unicodeToShiftjis;
     private getBindBones;
 }
-export { MMDExporter };
+export { type MMDExporter };

package/exporters/OBJExporter.d.cts

@@ -0,0 +1,18 @@
+import type { Object3D } from 'three';
+declare class OBJExporter {
+    private output;
+    private indexVertex;
+    private indexVertexUvs;
+    private indexNormals;
+    private vertex;
+    private color;
+    private normal;
+    private uv;
+    private face;
+    constructor();
+    parse(object: Object3D): string;
+    private parseMesh;
+    private parseLine;
+    private parsePoints;
+}
+export { type OBJExporter };

package/exporters/OBJExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three';
+import type { Object3D } from 'three';
 declare class OBJExporter {
     private output;
     private indexVertex;
@@ -15,4 +15,4 @@ declare class OBJExporter {
     private parseLine;
     private parsePoints;
 }
-export { OBJExporter };
+export { type OBJExporter };

package/exporters/PLYExporter.d.cts

@@ -0,0 +1,23 @@
+import type { Object3D } from 'three';
+/**
+ * https://github.com/gkjohnson/ply-exporter-js
+ *
+ * Usage:
+ *  const exporter = new PLYExporter();
+ *
+ *  // second argument is a list of options
+ *  exporter.parse(mesh, data => console.log(data), { binary: true, excludeAttributes: [ 'color' ], littleEndian: true });
+ *
+ * Format Definition:
+ * http://paulbourke.net/dataformats/ply/
+ */
+export interface PLYExporterOptions {
+    binary?: boolean;
+    excludeAttributes?: string[];
+    littleEndian?: boolean;
+}
+declare class PLYExporter {
+    parse(object: Object3D, onDone: ((res: string) => void) | undefined, options: PLYExporterOptions): string | ArrayBuffer | null;
+    private traverseMeshes;
+}
+export { type PLYExporter };

package/exporters/PLYExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three';
+import type { Object3D } from 'three';
 /**
  * https://github.com/gkjohnson/ply-exporter-js
  *
@@ -20,4 +20,4 @@ declare class PLYExporter {
     parse(object: Object3D, onDone: ((res: string) => void) | undefined, options: PLYExporterOptions): string | ArrayBuffer | null;
     private traverseMeshes;
 }
-export { PLYExporter };
+export { type PLYExporter };

package/exporters/STLExporter.d.cts

@@ -0,0 +1,28 @@
+import type { Object3D } from 'three';
+export interface STLExporterOptionsBinary {
+    binary: true;
+}
+export interface STLExporterOptionsString {
+    binary?: false;
+}
+export interface STLExporterOptions {
+    binary?: boolean;
+}
+export declare class STLExporter {
+    private binary;
+    private output;
+    private offset;
+    private objects;
+    private triangles;
+    private vA;
+    private vB;
+    private vC;
+    private cb;
+    private ab;
+    private normal;
+    parse(scene: Object3D, options: STLExporterOptionsBinary): DataView;
+    parse(scene: Object3D, options?: STLExporterOptionsString): string;
+    private writeFace;
+    private writeNormal;
+    private writeVertex;
+}

package/exporters/STLExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three';
+import type { Object3D } from 'three';
 export interface STLExporterOptionsBinary {
     binary: true;
 }

package/exporters/USDZExporter.d.cts

@@ -0,0 +1,27 @@
+import type { Object3D } from 'three';
+declare class USDZExporter {
+    private readonly PRECISION;
+    private materials;
+    private textures;
+    private files;
+    constructor();
+    parse(scene: Object3D): Promise<Uint8Array>;
+    private imageToCanvas;
+    private buildHeader;
+    private buildUSDFileAsString;
+    private buildXform;
+    private buildMatrix;
+    private buildMatrixRow;
+    private buildMeshObject;
+    private buildMesh;
+    private buildMeshVertexCount;
+    private buildMeshVertexIndices;
+    private buildVector3Array;
+    private buildVector2Array;
+    private buildMaterials;
+    private buildMaterial;
+    private buildTexture;
+    private buildColor;
+    private buildVector2;
+}
+export { type USDZExporter };

package/exporters/USDZExporter.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three';
+import type { Object3D } from 'three';
 declare class USDZExporter {
     private readonly PRECISION;
     private materials;
@@ -24,4 +24,4 @@ declare class USDZExporter {
     private buildColor;
     private buildVector2;
 }
-export { USDZExporter };
+export { type USDZExporter };

package/geometries/BoxLineGeometry.d.cts

@@ -0,0 +1,12 @@
+import type { BufferGeometry } from 'three'
+
+export class BoxLineGeometry extends BufferGeometry {
+  constructor(
+    width?: number,
+    height?: number,
+    depth?: number,
+    widthSegments?: number,
+    heightSegments?: number,
+    depthSegments?: number,
+  )
+}

package/geometries/BoxLineGeometry.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry } from 'three'
+import type { BufferGeometry } from 'three'
 
 export class BoxLineGeometry extends BufferGeometry {
   constructor(

package/geometries/ConvexGeometry.d.cts

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

package/geometries/ConvexGeometry.d.ts

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

package/geometries/DecalGeometry.d.cts

@@ -0,0 +1,10 @@
+import type { BufferGeometry, Euler, Mesh, Vector3 } from 'three'
+
+export class DecalGeometry extends BufferGeometry {
+  constructor(mesh: Mesh, position: Vector3, orientation: Euler, size: Vector3)
+}
+
+export class DecalVertex {
+  constructor(position: Vector3, normal: Vector3)
+  clone(): this
+}

package/geometries/DecalGeometry.d.ts

@@ -1,4 +1,4 @@
-import { BufferGeometry, Euler, Mesh, Vector3 } from 'three'
+import type { BufferGeometry, Euler, Mesh, Vector3 } from 'three'
 
 export class DecalGeometry extends BufferGeometry {
   constructor(mesh: Mesh, position: Vector3, orientation: Euler, size: Vector3)

package/geometries/LightningStrike.d.cts

@@ -0,0 +1,108 @@
+import type { BufferGeometry, Vector3 } from 'three'
+
+export interface RandomGenerator {
+  random(): number
+  getSeed(): number
+  setSeed(seed: number): void
+}
+
+export interface LightningSegment {
+  iteration: number
+  pos0: Vector3
+  pos1: Vector3
+  linPos0: Vector3
+  linPos1: Vector3
+  up0: Vector3
+  up1: Vector3
+  radius0: number
+  radius1: number
+  fraction0: number
+  fraction1: number
+  positionVariationFactor: number
+}
+
+export interface LightningSubray {
+  seed: number
+  maxIterations: number
+  recursion: number
+  pos0: Vector3
+  pos1: Vector3
+  linPos0: Vector3
+  linPos1: Vector3
+  up0: Vector3
+  up1: Vector3
+  radius0: number
+  radius1: number
+  birthTime: number
+  deathTime: number
+  timeScale: number
+  roughness: number
+  straightness: number
+  propagationTimeFactor: number
+  vanishingTimeFactor: number
+  endPropagationTime: number
+  beginVanishingTime: number
+}
+
+export interface RayParameters {
+  sourceOffset?: Vector3
+  destOffset?: Vector3
+
+  timeScale?: number
+  roughness?: number
+  straightness?: number
+
+  up0?: Vector3
+  up1?: Vector3
+  radius0?: number
+  radius1?: number
+  radius0Factor?: number
+  radius1Factor?: number
+  minRadius?: number
+
+  isEternal?: boolean
+  birthTime?: number
+  deathTime?: number
+  propagationTimeFactor?: number
+  vanishingTimeFactor?: number
+  subrayPeriod?: number
+  subrayDutyCycle?: number
+
+  maxIterations?: number
+  isStatic?: boolean
+  ramification?: number
+  maxSubrayRecursion?: number
+  recursionProbability?: number
+  generateUVs?: boolean
+
+  randomGenerator?: RandomGenerator
+  noiseSeed?: number
+
+  onDecideSubrayCreation?: (segment: LightningSegment, lightningStrike: LightningStrike) => void
+  onSubrayCreation?: (
+    segment: LightningSegment,
+    parentSubray: LightningSubray,
+    childSubray: LightningSubray,
+    lightningStrike: LightningStrike,
+  ) => void
+}
+
+export class LightningStrike extends BufferGeometry {
+  constructor(rayParameters?: RayParameters)
+  copyParameters(dest?: RayParameters, source?: RayParameters): RayParameters
+
+  // Ray states
+  static readonly RAY_INITIALIZED: number
+  static readonly RAY_UNBORN: number
+  static readonly RAY_PROPAGATING: number
+  static readonly RAY_STEADY: number
+  static readonly RAY_VANISHING: number
+  static readonly RAY_EXTINGUISHED: number
+
+  state: number
+
+  update(time: number): void
+
+  copy(source: LightningStrike): this
+  clone(): this
+}