@nativescript/canvas-three 2.0.0-webgpu.26 → 2.0.0-webgpu.27

package/three/src/renderers/webgl/WebGLTextures.d.ts

@@ -0,0 +1,30 @@
+import { WebGLCapabilities } from "./WebGLCapabilities.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+import { WebGLProperties } from "./WebGLProperties.js";
+import { WebGLState } from "./WebGLState.js";
+import { WebGLUtils } from "./WebGLUtils.js";
+
+export class WebGLTextures {
+    constructor(
+        gl: WebGLRenderingContext,
+        extensions: WebGLExtensions,
+        state: WebGLState,
+        properties: WebGLProperties,
+        capabilities: WebGLCapabilities,
+        utils: WebGLUtils,
+        info: WebGLInfo,
+    );
+
+    allocateTextureUnit(): void;
+    resetTextureUnits(): void;
+    setTexture2D(texture: any, slot: number): void;
+    setTexture2DArray(texture: any, slot: number): void;
+    setTexture3D(texture: any, slot: number): void;
+    setTextureCube(texture: any, slot: number): void;
+    setupRenderTarget(renderTarget: any): void;
+    updateRenderTargetMipmap(renderTarget: any): void;
+    updateMultisampleRenderTarget(renderTarget: any): void;
+    safeSetTexture2D(texture: any, slot: number): void;
+    safeSetTextureCube(texture: any, slot: number): void;
+}

package/three/src/renderers/webgl/WebGLUniforms.d.ts

@@ -0,0 +1,12 @@
+import { WebGLProgram } from "./WebGLProgram.js";
+import { WebGLTextures } from "./WebGLTextures.js";
+
+export class WebGLUniforms {
+    constructor(gl: WebGLRenderingContext, program: WebGLProgram);
+
+    setValue(gl: WebGLRenderingContext, name: string, value: any, textures: WebGLTextures): void;
+    setOptional(gl: WebGLRenderingContext, object: any, name: string): void;
+
+    static upload(gl: WebGLRenderingContext, seq: any, values: any[], textures: WebGLTextures): void;
+    static seqWithValue(seq: any, values: any[]): any[];
+}

package/three/src/renderers/webgl/WebGLUniformsGroups.d.ts

@@ -0,0 +1,17 @@
+import { UniformsGroup } from "../../core/UniformsGroup.js";
+
+import { WebGLCapabilities } from "./WebGLCapabilities.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+import { WebGLProgram } from "./WebGLProgram.js";
+import { WebGLState } from "./WebGLState.js";
+
+export function WebGLUniformsGroups(
+    gl: WebGLRenderingContext,
+    info: WebGLInfo,
+    capabilities: WebGLCapabilities,
+    state: WebGLState,
+): {
+    dispose: () => void;
+    update: (uniformsGroup: UniformsGroup, program: WebGLProgram) => void;
+    bind: (uniformsGroup: UniformsGroup, program: WebGLProgram) => void;
+};

package/three/src/renderers/webgl/WebGLUtils.d.ts

@@ -0,0 +1,11 @@
+import { ColorSpace, CompressedPixelFormat, PixelFormat, TextureDataType } from "../../constants.js";
+import { WebGLExtensions } from "./WebGLExtensions.js";
+
+export class WebGLUtils {
+    constructor(
+        gl: WebGLRenderingContext | WebGL2RenderingContext,
+        extensions: WebGLExtensions,
+    );
+
+    convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, colorSpace?: ColorSpace): number | null;
+}

package/three/src/renderers/webgl-fallback/WebGLBackend.d.ts

@@ -0,0 +1,14 @@
+import { CoordinateSystem } from "../../constants.js";
+import Backend, { BackendParameters } from "../common/Backend.js";
+
+export interface WebGLBackendParameters extends BackendParameters {
+    trackTimestamp?: boolean | undefined;
+}
+
+export default class WebGLBackend extends Backend {
+    constructor(parameters?: BackendParameters);
+
+    get coordinateSystem(): CoordinateSystem;
+
+    getMaxAnisotropy(): number;
+}

package/three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -0,0 +1,21 @@
+import { CoordinateSystem } from "../../constants.js";
+import Backend, { BackendParameters } from "../common/Backend.js";
+
+export interface WebGPUBackendParameters extends BackendParameters {
+    alpha?: boolean | undefined;
+    antialias?: boolean | undefined;
+    sampleCount?: number | undefined;
+    trackTimestamp?: boolean | undefined;
+}
+
+export default class WebGPUBackend extends Backend {
+    readonly isWebGPUBackend: true;
+
+    constructor(parameters?: WebGPUBackendParameters);
+
+    get coordinateSystem(): CoordinateSystem;
+
+    // utils public
+
+    getMaxAnisotropy(): number;
+}

package/three/src/renderers/webgpu/WebGPURenderer.d.ts

@@ -0,0 +1,10 @@
+import Renderer, { RendererParameters } from "../common/Renderer.js";
+import { WebGPUBackendParameters } from "./WebGPUBackend.js";
+
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+    forceWebGL?: boolean | undefined;
+}
+
+export default class WebGPURenderer extends Renderer {
+    constructor(parameters?: WebGPURendererParameters);
+}

package/three/src/renderers/webgpu/nodes/WGSLNodeBuilder.d.ts

@@ -0,0 +1,125 @@
+import CodeNode from "../../../nodes/code/CodeNode.js";
+import { NodeShaderStage } from "../../../nodes/core/constants.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import NodeUniform from "../../../nodes/core/NodeUniform.js";
+import NodeVar from "../../../nodes/core/NodeVar.js";
+import StructTypeNode from "../../../nodes/core/StructTypeNode.js";
+import { ShaderNode } from "../../../nodes/shadernode/ShaderNode.js";
+import { Texture } from "../../../textures/Texture.js";
+import NodeUniformsGroup from "../../common/nodes/NodeUniformsGroup.js";
+
+type BuiltinStage = NodeShaderStage | "attribute" | "output";
+interface BuiltinType {
+    name: string;
+    property: string;
+    type: string;
+}
+
+export default class WGSLNodeBuilder extends NodeBuilder {
+    builtins: { [key in BuiltinStage]: Map<string, BuiltinType> };
+    uniformGroups: { [key in NodeShaderStage]: NodeUniformsGroup };
+
+    needsColorSpaceToLinear(texture: Texture): boolean;
+    _generateTextureSample(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    _generateVideoSample(textureProperty: string, uvSnippet: string, shaderStage: NodeShaderStage): string;
+    _generateTextureSampleLevel(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        levelSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureLod(texture: Texture, textureProperty: string, uvSnippet: string, levelSnippet: string): string;
+    generateTextureLoad(
+        texture: Texture,
+        textureProperty: string,
+        uvIndexSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureStore(
+        texture: Texture,
+        textureProperty: string,
+        uvIndexSnippet: string,
+        valueSnippet: string,
+    ): string;
+    isUnfilterable(texture: Texture): boolean;
+    generateTexture(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureGrad(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        gradSnippet: string[],
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureCompare(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        compareSnippet: String,
+        shaderStage: NodeShaderStage,
+    ): string;
+    generateTextureLevel(
+        texture: Texture,
+        textureProperty: string,
+        uvSnippet: string,
+        levelSnippet: string,
+        depthSnippet: string | null,
+        shaderStage: NodeShaderStage,
+    ): string;
+
+    getPropertyName<TValue>(node: NodeVar | NodeUniform<TValue>, shaderStage: NodeShaderStage): string;
+
+    getOutputStructName(): string;
+
+    _getUniformGroupCount(shaderStage: NodeShaderStage): number;
+
+    getFunctionOperator(op: string): string | null;
+    // getStorageAccess(node: StorageTextureNode | StorageBufferNode): string;
+
+    getBuiltin(name: string, property: string, type: string, shaderStage: BuiltinStage): string;
+    getVertexIndex(): string;
+    getInstanceIndex(): string;
+    getDrawIndex(): null;
+
+    buildFunctionCode(shaderNode: ShaderNode): string;
+
+    getFragDepth(): string;
+    getFragCoord(): string;
+    getFrontFacing(): string;
+
+    getBuiltins(shaderStage: BuiltinStage): string;
+    getAttributes(shaderStage: NodeShaderStage): string;
+
+    getStructMembers(struct: StructTypeNode): string;
+    getStructs(shaderStage: NodeShaderStage): string;
+
+    getVar(type: string, name: string): string;
+    getVars(shaderStage: NodeShaderStage): string;
+    getVaryings(shaderStage: NodeShaderStage): string;
+    getUniforms(shaderStage: NodeShaderStage): string;
+    buildCode(): void;
+    getMethod(method: string, output?: string | null): string;
+
+    _getWGSLMethod(method: string): CodeNode | string;
+    _include(name: string): CodeNode;
+    _getWGSLVertexCode(shaderData: { [key: string]: string }): string;
+    _getWGSLFragmentCode(shaderData: { [key: string]: string }): string;
+    _getWGSLComputeCode(shaderData: { [key: string]: string }, workgroupSize: string): string;
+    _getWGSLStruct(name: string, vars: string): string;
+    _getWGSLStructBinding(name: string, vars: string, access: string, binding: number, group: number): string;
+}

package/three/src/renderers/webgpu/nodes/WGSLNodeFunction.d.ts

@@ -0,0 +1,6 @@
+import NodeFunction from "../../../nodes/core/NodeFunction.js";
+
+export default class WGSLNodeFunction extends NodeFunction {
+    constructor(source: string);
+    getCode(name?: string): string;
+}

package/three/src/renderers/webgpu/nodes/WGSLNodeParser.d.ts

@@ -0,0 +1,6 @@
+import NodeParser from "../../../nodes/core/NodeParser.js";
+import WGSLNodeFunction from "./WGSLNodeFunction.js";
+
+export default class WGSLNodeParser extends NodeParser {
+    parseFunction(source: string): WGSLNodeFunction;
+}

package/three/src/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",
+}

package/three/src/renderers/webxr/WebXRController.d.ts

@@ -0,0 +1,63 @@
+import { Object3DEventMap } from "../../core/Object3D.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Group } from "../../objects/Group.js";
+
+export type XRControllerEventType = XRSessionEventType | XRInputSourceEventType | "disconnected" | "connected";
+
+export class XRJointSpace extends Group {
+    readonly jointRadius: number | undefined;
+}
+
+export type XRHandJoints = Record<XRHandJoint, XRJointSpace>;
+
+export interface XRHandInputState {
+    pinching: boolean;
+}
+
+export interface WebXRSpaceEventMap extends Object3DEventMap {
+    select: { data: XRInputSource };
+    selectstart: { data: XRInputSource };
+    selectend: { data: XRInputSource };
+    squeeze: { data: XRInputSource };
+    squeezestart: { data: XRInputSource };
+    squeezeend: { data: XRInputSource };
+
+    connected: { data: XRInputSource };
+    disconnected: { data: XRInputSource };
+
+    pinchend: { handedness: XRHandedness; target: WebXRController }; // This Event break the THREE.EventDispatcher contract, replacing the target to the wrong instance.
+    pinchstart: { handedness: XRHandedness; target: WebXRController }; // This Event break the THREE.EventDispatcher contract, replacing the target to the wrong instance.
+
+    move: {};
+}
+
+export class XRHandSpace extends Group<WebXRSpaceEventMap> {
+    readonly joints: Partial<XRHandJoints>;
+    readonly inputState: XRHandInputState;
+}
+
+export class XRTargetRaySpace extends Group<WebXRSpaceEventMap> {
+    hasLinearVelocity: boolean;
+    readonly linearVelocity: Vector3;
+    hasAngularVelocity: boolean;
+    readonly angularVelocity: Vector3;
+}
+
+export class XRGripSpace extends Group<WebXRSpaceEventMap> {
+    hasLinearVelocity: boolean;
+    readonly linearVelocity: Vector3;
+    hasAngularVelocity: boolean;
+    readonly angularVelocity: Vector3;
+}
+
+export class WebXRController {
+    constructor();
+
+    getHandSpace(): XRHandSpace;
+    getTargetRaySpace(): XRTargetRaySpace;
+    getGripSpace(): XRGripSpace;
+    dispatchEvent(event: { type: XRControllerEventType; data?: XRInputSource }): this;
+    connect(inputSource: XRInputSource): this;
+    disconnect(inputSource: XRInputSource): this;
+    update(inputSource: XRInputSource, frame: XRFrame, referenceSpace: XRReferenceSpace): this;
+}

package/three/src/renderers/webxr/WebXRDepthSensing.d.ts

@@ -0,0 +1,22 @@
+import { Mesh } from "../../objects/Mesh.js";
+import { Texture } from "../../textures/Texture.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
+import { WebXRArrayCamera } from "./WebXRManager.js";
+
+export class WebXRDepthSensing {
+    texture: Texture | null;
+    mesh: Mesh | null;
+
+    depthNear: number;
+    depthFar: number;
+
+    constructor();
+
+    init(renderer: WebGLRenderer, depthData: XRWebGLDepthInformation, renderState: XRRenderState): void;
+
+    getMesh(cameraXR: WebXRArrayCamera): Mesh | null;
+
+    reset(): void;
+
+    getDepthTexture(): Texture | null;
+}