@types/three 0.165.0 → 0.166.0

three/examples/jsm/renderers/webgpu/utils/WebGPUConstants.d.ts

@@ -0,0 +1,328 @@
+export enum GPUPrimitiveTopology {
+    PointList = "point-list",
+    LineList = "line-list",
+    LineStrip = "line-strip",
+    TriangleList = "triangle-list",
+    TriangleStrip = "triangle-strip",
+}
+
+export enum GPUCompareFunction {
+    Never = "never",
+    Less = "less",
+    Equal = "equal",
+    LessEqual = "less-equal",
+    Greater = "greater",
+    NotEqual = "not-equal",
+    GreaterEqual = "greater-equal",
+    Always = "always",
+}
+
+export enum GPUStoreOp {
+    Store = "store",
+    Discard = "discard",
+}
+
+export enum GPULoadOp {
+    Load = "load",
+    Clear = "clear",
+}
+
+export enum GPUFrontFace {
+    CCW = "ccw",
+    CW = "cw",
+}
+
+export enum GPUCullMode {
+    None = "none",
+    Front = "front",
+    Back = "back",
+}
+
+export enum GPUIndexFormat {
+    Uint16 = "uint16",
+    Uint32 = "uint32",
+}
+
+export enum GPUVertexFormat {
+    Uint8x2 = "uint8x2",
+    Uint8x4 = "uint8x4",
+    Sint8x2 = "sint8x2",
+    Sint8x4 = "sint8x4",
+    Unorm8x2 = "unorm8x2",
+    Unorm8x4 = "unorm8x4",
+    Snorm8x2 = "snorm8x2",
+    Snorm8x4 = "snorm8x4",
+    Uint16x2 = "uint16x2",
+    Uint16x4 = "uint16x4",
+    Sint16x2 = "sint16x2",
+    Sint16x4 = "sint16x4",
+    Unorm16x2 = "unorm16x2",
+    Unorm16x4 = "unorm16x4",
+    Snorm16x2 = "snorm16x2",
+    Snorm16x4 = "snorm16x4",
+    Float16x2 = "float16x2",
+    Float16x4 = "float16x4",
+    Float32 = "float32",
+    Float32x2 = "float32x2",
+    Float32x3 = "float32x3",
+    Float32x4 = "float32x4",
+    Uint32 = "uint32",
+    Uint32x2 = "uint32x2",
+    Uint32x3 = "uint32x3",
+    Uint32x4 = "uint32x4",
+    Sint32 = "sint32",
+    Sint32x2 = "sint32x2",
+    Sint32x3 = "sint32x3",
+    Sint32x4 = "sint32x4",
+}
+
+export enum GPUTextureFormat {
+    // 8-bit formats
+
+    R8Unorm = "r8unorm",
+    R8Snorm = "r8snorm",
+    R8Uint = "r8uint",
+    R8Sint = "r8sint",
+
+    // 16-bit formats
+
+    R16Uint = "r16uint",
+    R16Sint = "r16sint",
+    R16Float = "r16float",
+    RG8Unorm = "rg8unorm",
+    RG8Snorm = "rg8snorm",
+    RG8Uint = "rg8uint",
+    RG8Sint = "rg8sint",
+
+    // 32-bit formats
+
+    R32Uint = "r32uint",
+    R32Sint = "r32sint",
+    R32Float = "r32float",
+    RG16Uint = "rg16uint",
+    RG16Sint = "rg16sint",
+    RG16Float = "rg16float",
+    RGBA8Unorm = "rgba8unorm",
+    RGBA8UnormSRGB = "rgba8unorm-srgb",
+    RGBA8Snorm = "rgba8snorm",
+    RGBA8Uint = "rgba8uint",
+    RGBA8Sint = "rgba8sint",
+    BGRA8Unorm = "bgra8unorm",
+    BGRA8UnormSRGB = "bgra8unorm-srgb",
+    // Packed 32-bit formats
+    RGB9E5UFloat = "rgb9e5ufloat",
+    RGB10A2Unorm = "rgb10a2unorm",
+    RG11B10uFloat = "rgb10a2unorm",
+
+    // 64-bit formats
+
+    RG32Uint = "rg32uint",
+    RG32Sint = "rg32sint",
+    RG32Float = "rg32float",
+    RGBA16Uint = "rgba16uint",
+    RGBA16Sint = "rgba16sint",
+    RGBA16Float = "rgba16float",
+
+    // 128-bit formats
+
+    RGBA32Uint = "rgba32uint",
+    RGBA32Sint = "rgba32sint",
+    RGBA32Float = "rgba32float",
+
+    // Depth and stencil formats
+
+    Stencil8 = "stencil8",
+    Depth16Unorm = "depth16unorm",
+    Depth24Plus = "depth24plus",
+    Depth24PlusStencil8 = "depth24plus-stencil8",
+    Depth32Float = "depth32float",
+
+    // 'depth32float-stencil8' extension
+
+    Depth32FloatStencil8 = "depth32float-stencil8",
+
+    // BC compressed formats usable if 'texture-compression-bc' is both
+    // supported by the device/user agent and enabled in requestDevice.
+
+    BC1RGBAUnorm = "bc1-rgba-unorm",
+    BC1RGBAUnormSRGB = "bc1-rgba-unorm-srgb",
+    BC2RGBAUnorm = "bc2-rgba-unorm",
+    BC2RGBAUnormSRGB = "bc2-rgba-unorm-srgb",
+    BC3RGBAUnorm = "bc3-rgba-unorm",
+    BC3RGBAUnormSRGB = "bc3-rgba-unorm-srgb",
+    BC4RUnorm = "bc4-r-unorm",
+    BC4RSnorm = "bc4-r-snorm",
+    BC5RGUnorm = "bc5-rg-unorm",
+    BC5RGSnorm = "bc5-rg-snorm",
+    BC6HRGBUFloat = "bc6h-rgb-ufloat",
+    BC6HRGBFloat = "bc6h-rgb-float",
+    BC7RGBAUnorm = "bc7-rgba-unorm",
+    BC7RGBAUnormSRGB = "bc7-rgba-srgb",
+
+    // ETC2 compressed formats usable if 'texture-compression-etc2' is both
+    // supported by the device/user agent and enabled in requestDevice.
+
+    ETC2RGB8Unorm = "etc2-rgb8unorm",
+    ETC2RGB8UnormSRGB = "etc2-rgb8unorm-srgb",
+    ETC2RGB8A1Unorm = "etc2-rgb8a1unorm",
+    ETC2RGB8A1UnormSRGB = "etc2-rgb8a1unorm-srgb",
+    ETC2RGBA8Unorm = "etc2-rgba8unorm",
+    ETC2RGBA8UnormSRGB = "etc2-rgba8unorm-srgb",
+    EACR11Unorm = "eac-r11unorm",
+    EACR11Snorm = "eac-r11snorm",
+    EACRG11Unorm = "eac-rg11unorm",
+    EACRG11Snorm = "eac-rg11snorm",
+
+    // ASTC compressed formats usable if 'texture-compression-astc' is both
+    // supported by the device/user agent and enabled in requestDevice.
+
+    ASTC4x4Unorm = "astc-4x4-unorm",
+    ASTC4x4UnormSRGB = "astc-4x4-unorm-srgb",
+    ASTC5x4Unorm = "astc-5x4-unorm",
+    ASTC5x4UnormSRGB = "astc-5x4-unorm-srgb",
+    ASTC5x5Unorm = "astc-5x5-unorm",
+    ASTC5x5UnormSRGB = "astc-5x5-unorm-srgb",
+    ASTC6x5Unorm = "astc-6x5-unorm",
+    ASTC6x5UnormSRGB = "astc-6x5-unorm-srgb",
+    ASTC6x6Unorm = "astc-6x6-unorm",
+    ASTC6x6UnormSRGB = "astc-6x6-unorm-srgb",
+    ASTC8x5Unorm = "astc-8x5-unorm",
+    ASTC8x5UnormSRGB = "astc-8x5-unorm-srgb",
+    ASTC8x6Unorm = "astc-8x6-unorm",
+    ASTC8x6UnormSRGB = "astc-8x6-unorm-srgb",
+    ASTC8x8Unorm = "astc-8x8-unorm",
+    ASTC8x8UnormSRGB = "astc-8x8-unorm-srgb",
+    ASTC10x5Unorm = "astc-10x5-unorm",
+    ASTC10x5UnormSRGB = "astc-10x5-unorm-srgb",
+    ASTC10x6Unorm = "astc-10x6-unorm",
+    ASTC10x6UnormSRGB = "astc-10x6-unorm-srgb",
+    ASTC10x8Unorm = "astc-10x8-unorm",
+    ASTC10x8UnormSRGB = "astc-10x8-unorm-srgb",
+    ASTC10x10Unorm = "astc-10x10-unorm",
+    ASTC10x10UnormSRGB = "astc-10x10-unorm-srgb",
+    ASTC12x10Unorm = "astc-12x10-unorm",
+    ASTC12x10UnormSRGB = "astc-12x10-unorm-srgb",
+    ASTC12x12Unorm = "astc-12x12-unorm",
+    ASTC12x12UnormSRGB = "astc-12x12-unorm-srgb",
+}
+
+export enum GPUAddressMode {
+    ClampToEdge = "clamp-to-edge",
+    Repeat = "repeat",
+    MirrorRepeat = "mirror-repeat",
+}
+
+export enum GPUFilterMode {
+    Linear = "linear",
+    Nearest = "nearest",
+}
+
+export enum GPUBlendFactor {
+    Zero = "zero",
+    One = "one",
+    Src = "src",
+    OneMinusSrc = "one-minus-src",
+    SrcAlpha = "src-alpha",
+    OneMinusSrcAlpha = "one-minus-src-alpha",
+    Dst = "dst",
+    OneMinusDstColor = "one-minus-dst",
+    DstAlpha = "dst-alpha",
+    OneMinusDstAlpha = "one-minus-dst-alpha",
+    SrcAlphaSaturated = "src-alpha-saturated",
+    Constant = "constant",
+    OneMinusConstant = "one-minus-constant",
+}
+
+export enum GPUBlendOperation {
+    Add = "add",
+    Subtract = "subtract",
+    ReverseSubtract = "reverse-subtract",
+    Min = "min",
+    Max = "max",
+}
+
+export enum GPUColorWriteFlags {
+    None = 0,
+    Red = 0x1,
+    Green = 0x2,
+    Blue = 0x4,
+    Alpha = 0x8,
+    All = 0xF,
+}
+
+export enum GPUStencilOperation {
+    Keep = "keep",
+    Zero = "zero",
+    Replace = "replace",
+    Invert = "invert",
+    IncrementClamp = "increment-clamp",
+    DecrementClamp = "decrement-clamp",
+    IncrementWrap = "increment-wrap",
+    DecrementWrap = "decrement-wrap",
+}
+
+export enum GPUBufferBindingType {
+    Uniform = "uniform",
+    Storage = "storage",
+    ReadOnlyStorage = "read-only-storage",
+}
+
+export enum GPUStorageTextureAccess {
+    WriteOnly = "write-only",
+    ReadOnly = "read-only",
+    ReadWrite = "read-write",
+}
+
+export enum GPUSamplerBindingType {
+    Filtering = "filtering",
+    NonFiltering = "non-filtering",
+    Comparison = "comparison",
+}
+
+export enum GPUTextureSampleType {
+    Float = "float",
+    UnfilterableFloat = "unfilterable-float",
+    Depth = "depth",
+    SInt = "sint",
+    UInt = "uint",
+}
+
+export enum GPUTextureDimension {
+    OneD = "1d",
+    TwoD = "2d",
+    ThreeD = "3d",
+}
+
+export enum GPUTextureViewDimension {
+    OneD = "1d",
+    TwoD = "2d",
+    TwoDArray = "2d-array",
+    Cube = "cube",
+    CubeArray = "cube-array",
+    ThreeD = "3d",
+}
+
+export enum GPUTextureAspect {
+    All = "all",
+    StencilOnly = "stencil-only",
+    DepthOnly = "depth-only",
+}
+
+export enum GPUInputStepMode {
+    Vertex = "vertex",
+    Instance = "instance",
+}
+
+export enum GPUFeatureName {
+    DepthClipControl = "depth-clip-control",
+    Depth32FloatStencil8 = "depth32float-stencil8",
+    TextureCompressionBC = "texture-compression-bc",
+    TextureCompressionETC2 = "texture-compression-etc2",
+    TextureCompressionASTC = "texture-compression-astc",
+    TimestampQuery = "timestamp-query",
+    IndirectFirstInstance = "indirect-first-instance",
+    ShaderF16 = "shader-f16",
+    RG11B10UFloat = "rg11b10ufloat-renderable",
+    BGRA8UNormStorage = "bgra8unorm-storage",
+    Float32Filterable = "float32-filterable",
+}

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.165.0",
+    "version": "0.166.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -39,12 +39,12 @@
     },
     "scripts": {},
     "dependencies": {
-        "@tweenjs/tween.js": "~23.1.1",
+        "@tweenjs/tween.js": "~23.1.2",
         "@types/stats.js": "*",
         "@types/webxr": "*",
         "fflate": "~0.8.2",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "49d047af400101035815c93fc592aa882a686de2432be990ac9df6ee209b2854",
-    "typeScriptVersion": "4.7"
+    "typesPublisherContentHash": "edfaedac592c09ce630dbeba7c12eaa206916e9761f49db67f6e41ba87970203",
+    "typeScriptVersion": "4.8"
 }

three/src/Three.d.ts

@@ -71,6 +71,7 @@ export * as DataUtils from "./extras/DataUtils.js";
 export * from "./extras/ImageUtils.js";
 export * from "./extras/PMREMGenerator.js";
 export * from "./extras/ShapeUtils.js";
+export { TextureUtils } from "./extras/TextureUtils.js";
 /**
  * Geometries
  */

three/src/constants.d.ts

@@ -419,6 +419,11 @@ export const RGFormat: 1030;
  */
 export const RGIntegerFormat: 1031;
 
+/**
+ * {@link RGBIntegerFormat} discrads the alpha components and reads the red, green, and blue components.
+ */
+export const RGBIntegerFormat: 1032;
+
 /**
  * {@link RGBAIntegerFormat} reads the red, green, blue and alpha component
  * @remarks This is the default for {@link THREE.Texture}.
@@ -443,6 +448,7 @@ export type PixelFormat =
     | typeof RedIntegerFormat
     | typeof RGFormat
     | typeof RGIntegerFormat
+    | typeof RGBIntegerFormat
     | typeof RGBAIntegerFormat;
 
 /**

three/src/extras/ShapeUtils.d.ts

@@ -1,7 +1,4 @@
-export interface Vec2 {
-    x: number;
-    y: number;
-}
+import { Vector2Like } from "../math/Vector2.js";
 
 /**
  * A class containing utility functions for shapes.
@@ -9,20 +6,20 @@ export interface Vec2 {
  * @see {@link https://threejs.org/docs/index.html#api/en/extras/ShapeUtils | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/extras/ShapeUtils.js | Source}
  */
-export namespace ShapeUtils {
+export class ShapeUtils {
     /**
      * Calculate area of a ( 2D ) contour polygon.
      */
-    function area(contour: Vec2[]): number;
+    static area(contour: readonly Vector2Like[]): number;
 
     /**
      * Note that this is a linear function so it is necessary to calculate separately for x, y components of a polygon.
      * @remarks Used internally by {@link THREE.Path | Path}, {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry}.
      */
-    function isClockWise(pts: Vec2[]): boolean;
+    static isClockWise(pts: readonly Vector2Like[]): boolean;
 
     /**
      * Used internally by {@link THREE.ExtrudeGeometry | ExtrudeGeometry} and {@link THREE.ShapeGeometry | ShapeGeometry} to calculate faces in shapes with holes.
      */
-    function triangulateShape(contour: Vec2[], holes: Vec2[][]): number[][];
+    static triangulateShape(contour: Vector2Like[], holes: Vector2Like[][]): number[][];
 }

three/src/extras/TextureUtils.d.ts

@@ -0,0 +1,42 @@
+import { CompressedPixelFormat, PixelFormat, TextureDataType } from "../constants.js";
+import { Texture } from "../textures/Texture.js";
+
+/**
+ * Scales the texture as large as possible within its surface without cropping or stretching the texture. The method
+ * preserves the original aspect ratio of the texture. Akin to CSS `object-fit: contain`.
+ */
+declare function contain(texture: Texture, aspect: number): Texture;
+
+/**
+ * Scales the texture to the smallest possible size to fill the surface, leaving no empty space. The method preserves
+ * the original aspect ratio of the texture. Akin to CSS `object-fit: cover`.
+ */
+declare function cover(texture: Texture, aspect: number): Texture;
+
+/**
+ * Configures the texture to the default transformation. Akin to CSS `object-fit: fill`.
+ */
+declare function fill(texture: Texture): Texture;
+
+/**
+ * Given the width, height, format, and type of a texture. Determines how many bytes must be used to represent the
+ * texture.
+ */
+declare function getByteLength(
+    width: number,
+    height: number,
+    format: PixelFormat | CompressedPixelFormat,
+    type: TextureDataType,
+): number;
+
+/**
+ * A class containing utility functions for textures.
+ */
+declare const TextureUtils: {
+    contain: typeof contain;
+    cover: typeof cover;
+    fill: typeof fill;
+    getByteLength: typeof getByteLength;
+};
+
+export { contain, cover, fill, getByteLength, TextureUtils };

three/src/lights/LightShadow.d.ts

@@ -24,6 +24,11 @@ export class LightShadow<TCamera extends Camera = Camera> {
      */
     camera: TCamera;
 
+    /**
+     * The intensity of the shadow. The default is `1`. Valid values are in the range `[0, 1]`.
+     */
+    intensity: number;
+
     /**
      * Shadow map bias, how much to add or subtract from the normalized depth when deciding whether a surface is in shadow.
      * @remark The Very tiny adjustments here (in the order of 0.0001) may help reduce artifacts in shadows.

three/src/materials/Material.d.ts

@@ -394,17 +394,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     set alphaTest(value: number);
 
-    onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
-
-    onBeforeRender(
-        renderer: WebGLRenderer,
-        scene: Scene,
-        camera: Camera,
-        geometry: BufferGeometry,
-        object: Object3D,
-        group: Group,
-    ): void;
-
     /**
      * An optional callback that is executed immediately before the shader program is compiled.
      * This function is called with the associated WebGL program parameters and renderer.
@@ -443,7 +432,10 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     copy(material: Material): this;
 
     /**
-     * This disposes the material. Textures of a material don't get disposed. These needs to be disposed by {@link Texture}.
+     * Frees the GPU-related resources allocated by this instance. Call this method whenever this instance is no longer
+     * used in your app.
+     *
+     * Material textures must be disposed of by the dispose() method of {@link Texture}.
      */
     dispose(): void;
 
@@ -453,4 +445,21 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @default false
      */
     set needsUpdate(value: boolean);
+
+    /**
+     * @deprecated onBuild() has been removed.
+     */
+    onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
+
+    /**
+     * @deprecated onBeforeRender() has been removed.
+     */
+    onBeforeRender(
+        renderer: WebGLRenderer,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        object: Object3D,
+        group: Group,
+    ): void;
 }

three/src/math/Vector4.d.ts

@@ -137,6 +137,12 @@ export class Vector4 {
      */
     setAxisAngleFromRotationMatrix(m: Matrix4): this;
 
+    /**
+     * Sets this vector to the position elements of the
+     * [transformation matrix]{@link https://en.wikipedia.org/wiki/Transformation_matrix} m.
+     */
+    setFromMatrixPosition(m: Matrix4): this;
+
     min(v: Vector4Like): this;
     max(v: Vector4Like): this;
     clamp(min: Vector4Like, max: Vector4Like): this;