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

package/three/src/renderers/common/nodes/NodeUniform.d.ts

@@ -0,0 +1,68 @@
+import { Color } from "../../../math/Color.js";
+import { Matrix3 } from "../../../math/Matrix3.js";
+import { Matrix4 } from "../../../math/Matrix4.js";
+import { Vector2 } from "../../../math/Vector2.js";
+import { Vector3 } from "../../../math/Vector3.js";
+import { Vector4 } from "../../../math/Vector4.js";
+import NodeUniform from "../../../nodes/core/NodeUniform.js";
+import {
+    ColorUniform,
+    Matrix3Uniform,
+    Matrix4Uniform,
+    NumberUniform,
+    Vector2Uniform,
+    Vector3Uniform,
+    Vector4Uniform,
+} from "../Uniform.js";
+declare class NumberNodeUniform extends NumberUniform {
+    nodeUniform: NodeUniform<number>;
+    constructor(nodeUniform: NodeUniform<number>);
+    getValue(): number;
+}
+declare class Vector2NodeUniform extends Vector2Uniform {
+    nodeUniform: NodeUniform<Vector2>;
+    constructor(nodeUniform: NodeUniform<Vector2>);
+    getValue(): Vector2;
+}
+declare class Vector3NodeUniform extends Vector3Uniform {
+    nodeUniform: NodeUniform<Vector3>;
+    constructor(nodeUniform: NodeUniform<Vector3>);
+    getValue(): Vector3;
+}
+declare class Vector4NodeUniform extends Vector4Uniform {
+    nodeUniform: NodeUniform<Vector4>;
+    constructor(nodeUniform: NodeUniform<Vector4>);
+    getValue(): Vector4;
+}
+declare class ColorNodeUniform extends ColorUniform {
+    nodeUniform: NodeUniform<Color>;
+    constructor(nodeUniform: NodeUniform<Color>);
+    getValue(): Color;
+}
+declare class Matrix3NodeUniform extends Matrix3Uniform {
+    nodeUniform: NodeUniform<Matrix3>;
+    constructor(nodeUniform: NodeUniform<Matrix3>);
+    getValue(): Matrix3;
+}
+declare class Matrix4NodeUniform extends Matrix4Uniform {
+    nodeUniform: NodeUniform<Matrix4>;
+    constructor(nodeUniform: NodeUniform<Matrix4>);
+    getValue(): Matrix4;
+}
+export {
+    ColorNodeUniform,
+    Matrix3NodeUniform,
+    Matrix4NodeUniform,
+    NumberNodeUniform,
+    Vector2NodeUniform,
+    Vector3NodeUniform,
+    Vector4NodeUniform,
+};
+export type NodeUniformGPU =
+    | NumberNodeUniform
+    | Vector2NodeUniform
+    | Vector3NodeUniform
+    | Vector4NodeUniform
+    | ColorNodeUniform
+    | Matrix3NodeUniform
+    | Matrix4NodeUniform;

package/three/src/renderers/common/nodes/NodeUniformsGroup.d.ts

@@ -0,0 +1,10 @@
+import { UniformGroupNode, UniformNode } from "../../../nodes/Nodes.js";
+import UniformsGroup from "../UniformsGroup.js";
+declare class NodeUniformsGroup extends UniformsGroup {
+    id: number;
+    groupNode: UniformGroupNode;
+    readonly isNodeUniformsGroup: true;
+    constructor(name: string, groupNode: UniformGroupNode);
+    getNodes(): UniformNode<unknown>[];
+}
+export default NodeUniformsGroup;

package/three/src/renderers/common/nodes/Nodes.d.ts

@@ -0,0 +1,108 @@
+import { Camera } from "../../../cameras/Camera.js";
+import { Object3D } from "../../../core/Object3D.js";
+import { Material } from "../../../materials/Material.js";
+import { Color } from "../../../math/Color.js";
+import {
+    ComputeNode,
+    LightsNode,
+    Node,
+    NodeBuilder,
+    NodeFrame,
+    ShaderNodeObject,
+    UniformGroupNode,
+} from "../../../nodes/Nodes.js";
+import { Fog } from "../../../scenes/Fog.js";
+import { FogExp2 } from "../../../scenes/FogExp2.js";
+import { Scene } from "../../../scenes/Scene.js";
+import { CubeTexture } from "../../../textures/CubeTexture.js";
+import { Texture } from "../../../textures/Texture.js";
+import Backend from "../Backend.js";
+import ChainMap from "../ChainMap.js";
+import DataMap from "../DataMap.js";
+import Renderer from "../Renderer.js";
+import RenderObject from "../RenderObject.js";
+import NodeBuilderState from "./NodeBuilderState.js";
+import NodeUniformsGroup from "./NodeUniformsGroup.js";
+interface NodeUniformsGroupData {
+    renderId?: number | undefined;
+    frameId?: number | undefined;
+}
+interface RenderObjectData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface ComputeNodeData {
+    nodeBuilderState?: NodeBuilderState | undefined;
+}
+interface SceneData {
+    background?: Color | Texture | CubeTexture | undefined;
+    backgroundNode?: Node | undefined;
+    fog?: Fog | FogExp2 | undefined;
+    fogNode?: Node | undefined;
+    environment?: Texture | undefined;
+    environmentNode?: Node | undefined;
+}
+declare class Nodes extends DataMap<{
+    nodeUniformsGroup: {
+        key: NodeUniformsGroup;
+        value: NodeUniformsGroupData;
+    };
+    renderObject: {
+        key: RenderObject;
+        value: RenderObjectData;
+    };
+    computeNode: {
+        key: ComputeNode;
+        value: ComputeNodeData;
+    };
+    scene: {
+        key: Scene;
+        value: SceneData;
+    };
+}> {
+    renderer: Renderer;
+    backend: Backend;
+    nodeFrame: NodeFrame;
+    nodeBuilderCache: Map<string, NodeBuilderState>;
+    callHashCache: ChainMap<readonly [Scene, LightsNode], {
+        callId: number;
+        cacheKey: string;
+    }>;
+    groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
+        version?: number;
+    }>;
+    constructor(renderer: Renderer, backend: Backend);
+    updateGroup(nodeUniformsGroup: NodeUniformsGroup): boolean;
+    getForRenderCacheKey(renderObject: RenderObject): string;
+    getForRender(renderObject: RenderObject): NodeBuilderState;
+    delete(
+        object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
+    ): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+    getForCompute(computeNode: ComputeNode): NodeBuilderState;
+    _createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
+    getEnvironmentNode(scene: Scene): Node | null;
+    getBackgroundNode(scene: Scene): Node | null;
+    getFogNode(scene: Scene): Node | null;
+    getCacheKey(scene: Scene, lightsNode: LightsNode): string;
+    updateScene(scene: Scene): void;
+    get isToneMappingState(): boolean;
+    updateBackground(scene: Scene): void;
+    updateFog(scene: Scene): void;
+    updateEnvironment(scene: Scene): void;
+    getNodeFrame(
+        renderer?: Renderer,
+        scene?: Scene | null,
+        object?: Object3D | null,
+        camera?: Camera | null,
+        material?: Material | null,
+    ): NodeFrame;
+    getNodeFrameForRender(renderObject: RenderObject): NodeFrame;
+    getOutputCacheKey(): string;
+    hasOutputChange(outputTarget: Texture): boolean;
+    getOutputNode(outputTexture: Texture): ShaderNodeObject<Node>;
+    updateBefore(renderObject: RenderObject): void;
+    updateAfter(renderObject: RenderObject): void;
+    updateForCompute(computeNode: ComputeNode): void;
+    updateForRender(renderObject: RenderObject): void;
+    dispose(): void;
+}
+export default Nodes;

package/three/src/renderers/shaders/ShaderChunk.d.ts

@@ -0,0 +1,143 @@
+// Renderers / Shaders /////////////////////////////////////////////////////////////////////
+export const ShaderChunk: {
+    alphahash_fragment: string;
+    alphahash_pars_fragment: string;
+    alphamap_fragment: string;
+    alphamap_pars_fragment: string;
+    alphatest_fragment: string;
+    alphatest_pars_fragment: string;
+    aomap_fragment: string;
+    aomap_pars_fragment: string;
+    batching_pars_vertex: string;
+    begin_vertex: string;
+    beginnormal_vertex: string;
+    bsdfs: string;
+    iridescence_fragment: string;
+    bumpmap_pars_fragment: string;
+    clipping_planes_fragment: string;
+    clipping_planes_pars_fragment: string;
+    clipping_planes_pars_vertex: string;
+    clipping_planes_vertex: string;
+    color_fragment: string;
+    color_pars_fragment: string;
+    color_pars_vertex: string;
+    color_vertex: string;
+    common: string;
+    cube_uv_reflection_fragment: string;
+    defaultnormal_vertex: string;
+    displacementmap_pars_vertex: string;
+    displacementmap_vertex: string;
+    emissivemap_fragment: string;
+    emissivemap_pars_fragment: string;
+    colorspace_fragment: string;
+    colorspace_pars_fragment: string;
+    envmap_fragment: string;
+    envmap_common_pars_fragment: string;
+    envmap_pars_fragment: string;
+    envmap_pars_vertex: string;
+    envmap_physical_pars_fragment: string;
+    envmap_vertex: string;
+    fog_vertex: string;
+    fog_pars_vertex: string;
+    fog_fragment: string;
+    fog_pars_fragment: string;
+    gradientmap_pars_fragment: string;
+    lightmap_pars_fragment: string;
+    lights_lambert_fragment: string;
+    lights_lambert_pars_fragment: string;
+    lights_pars_begin: string;
+    lights_toon_fragment: string;
+    lights_toon_pars_fragment: string;
+    lights_phong_fragment: string;
+    lights_phong_pars_fragment: string;
+    lights_physical_fragment: string;
+    lights_physical_pars_fragment: string;
+    lights_fragment_begin: string;
+    lights_fragment_maps: string;
+    lights_fragment_end: string;
+    logdepthbuf_fragment: string;
+    logdepthbuf_pars_fragment: string;
+    logdepthbuf_pars_vertex: string;
+    logdepthbuf_vertex: string;
+    map_fragment: string;
+    map_pars_fragment: string;
+    map_particle_fragment: string;
+    map_particle_pars_fragment: string;
+    metalnessmap_fragment: string;
+    metalnessmap_pars_fragment: string;
+    morphcolor_vertex: string;
+    morphnormal_vertex: string;
+    morphtarget_pars_vertex: string;
+    morphtarget_vertex: string;
+    normal_fragment_begin: string;
+    normal_fragment_maps: string;
+    normal_pars_fragment: string;
+    normal_pars_vertex: string;
+    normal_vertex: string;
+    normalmap_pars_fragment: string;
+    clearcoat_normal_fragment_begin: string;
+    clearcoat_normal_fragment_maps: string;
+    clearcoat_pars_fragment: string;
+    iridescence_pars_fragment: string;
+    opaque_fragment: string;
+    packing: string;
+    premultiplied_alpha_fragment: string;
+    project_vertex: string;
+    dithering_fragment: string;
+    dithering_pars_fragment: string;
+    roughnessmap_fragment: string;
+    roughnessmap_pars_fragment: string;
+    shadowmap_pars_fragment: string;
+    shadowmap_pars_vertex: string;
+    shadowmap_vertex: string;
+    shadowmask_pars_fragment: string;
+    skinbase_vertex: string;
+    skinning_pars_vertex: string;
+    skinning_vertex: string;
+    skinnormal_vertex: string;
+    specularmap_fragment: string;
+    specularmap_pars_fragment: string;
+    tonemapping_fragment: string;
+    tonemapping_pars_fragment: string;
+    transmission_fragment: string;
+    transmission_pars_fragment: string;
+    uv_pars_fragment: string;
+    uv_pars_vertex: string;
+    uv_vertex: string;
+    worldpos_vertex: string;
+
+    background_vert: string;
+    background_frag: string;
+    backgroundCube_vert: string;
+    backgroundCube_frag: string;
+    cube_vert: string;
+    cube_frag: string;
+    depth_vert: string;
+    depth_frag: string;
+    distanceRGBA_vert: string;
+    distanceRGBA_frag: string;
+    equirect_vert: string;
+    equirect_frag: string;
+    linedashed_vert: string;
+    linedashed_frag: string;
+    meshbasic_vert: string;
+    meshbasic_frag: string;
+    meshlambert_vert: string;
+    meshlambert_frag: string;
+    meshmatcap_vert: string;
+    meshmatcap_frag: string;
+    meshnormal_vert: string;
+    meshnormal_frag: string;
+    meshphong_vert: string;
+    meshphong_frag: string;
+    meshphysical_vert: string;
+    meshphysical_frag: string;
+    meshtoon_vert: string;
+    meshtoon_frag: string;
+    points_vert: string;
+    points_frag: string;
+    shadow_vert: string;
+    shadow_frag: string;
+    sprite_vert: string;
+    sprite_frag: string;
+};

package/three/src/renderers/shaders/ShaderLib.d.ts

@@ -0,0 +1,29 @@
+import { IUniform } from "./UniformsLib.js";
+
+export interface ShaderLibShader {
+    uniforms: { [uniform: string]: IUniform };
+    vertexShader: string;
+    fragmentShader: string;
+}
+
+declare const ShaderLib: {
+    [name: string]: ShaderLibShader;
+    basic: ShaderLibShader;
+    lambert: ShaderLibShader;
+    phong: ShaderLibShader;
+    standard: ShaderLibShader;
+    matcap: ShaderLibShader;
+    points: ShaderLibShader;
+    dashed: ShaderLibShader;
+    depth: ShaderLibShader;
+    normal: ShaderLibShader;
+    sprite: ShaderLibShader;
+    background: ShaderLibShader;
+    cube: ShaderLibShader;
+    equirect: ShaderLibShader;
+    distanceRGBA: ShaderLibShader;
+    shadow: ShaderLibShader;
+    physical: ShaderLibShader;
+};
+
+export { ShaderLib };

package/three/src/renderers/shaders/UniformsLib.d.ts

@@ -0,0 +1,189 @@
+import { Color } from "../../math/Color.js";
+import { Matrix3 } from "../../math/Matrix3.js";
+import { Vector2 } from "../../math/Vector2.js";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export interface IUniform<TValue = any> {
+    value: TValue;
+}
+
+export const UniformsLib: {
+    common: {
+        diffuse: IUniform<Color>;
+        opacity: IUniform<number>;
+        map: IUniform<unknown>;
+        mapTransform: IUniform<Matrix3>;
+        alphaMap: IUniform<unknown>;
+        alphaMapTransform: IUniform<Matrix3>;
+        alphaTest: IUniform<number>;
+    };
+    specularmap: {
+        specularMap: IUniform<unknown>;
+        specularMapTransform: IUniform<Matrix3>;
+    };
+    envmap: {
+        envMap: IUniform<unknown>;
+        envMapRotation: IUniform<Matrix3>;
+        flipEnvMap: IUniform<number>;
+        reflectivity: IUniform<number>;
+        ior: IUniform<number>;
+        refractRatio: IUniform<number>;
+    };
+    aomap: {
+        aoMap: IUniform<unknown>;
+        aoMapIntensity: IUniform<number>;
+        aoMapTransform: IUniform<Matrix3>;
+    };
+    lightmap: {
+        lightMap: IUniform<number>;
+        lightMapIntensity: IUniform<number>;
+        lightMapTransform: IUniform<Matrix3>;
+    };
+    bumpmap: {
+        bumpMap: IUniform<unknown>;
+        bumpMapTransform: IUniform<Matrix3>;
+        bumpScale: IUniform<number>;
+    };
+    normalmap: {
+        normalMap: IUniform<unknown>;
+        normalMapTransform: IUniform<Matrix3>;
+        normalScale: IUniform<Vector2>;
+    };
+    displacementmap: {
+        displacementMap: IUniform<unknown>;
+        displacementMapTransform: IUniform<Matrix3>;
+        displacementScale: IUniform<number>;
+        displacementBias: IUniform<number>;
+    };
+    emissivemap: {
+        emissiveMap: IUniform<unknown>;
+        emissiveMapTransform: IUniform<Matrix3>;
+    };
+    metalnessmap: {
+        metalnessMap: IUniform<unknown>;
+        metalnessMapTransform: IUniform<Matrix3>;
+    };
+    roughnessmap: {
+        roughnessMap: IUniform<unknown>;
+        roughnessMapTransform: IUniform<Matrix3>;
+    };
+    gradientmap: {
+        gradientMap: IUniform<unknown>;
+    };
+    fog: {
+        fogDensity: IUniform<number>;
+        fogNear: IUniform<number>;
+        fogFar: IUniform<number>;
+        fogColor: IUniform<Color>;
+    };
+    lights: {
+        ambientLightColor: IUniform<unknown[]>;
+        lightProbe: IUniform<unknown[]>;
+        directionalLights: {
+            value: unknown[];
+            properties: {
+                direction: {};
+                color: {};
+            };
+        };
+        directionalLightShadows: {
+            value: unknown[];
+            properties: {
+                shadowIntensity: number;
+                shadowBias: {};
+                shadowNormalBias: {};
+                shadowRadius: {};
+                shadowMapSize: {};
+            };
+        };
+        directionalShadowMap: IUniform<unknown[]>;
+        directionalShadowMatrix: IUniform<unknown[]>;
+        spotLights: {
+            value: unknown[];
+            properties: {
+                color: {};
+                position: {};
+                direction: {};
+                distance: {};
+                coneCos: {};
+                penumbraCos: {};
+                decay: {};
+            };
+        };
+        spotLightShadows: {
+            value: unknown[];
+            properties: {
+                shadowIntensity: number;
+                shadowBias: {};
+                shadowNormalBias: {};
+                shadowRadius: {};
+                shadowMapSize: {};
+            };
+        };
+        spotLightMap: IUniform<unknown[]>;
+        spotShadowMap: IUniform<unknown[]>;
+        spotLightMatrix: IUniform<unknown[]>;
+        pointLights: {
+            value: unknown[];
+            properties: {
+                color: {};
+                position: {};
+                decay: {};
+                distance: {};
+            };
+        };
+        pointLightShadows: {
+            value: unknown[];
+            properties: {
+                shadowIntensity: number;
+                shadowBias: {};
+                shadowNormalBias: {};
+                shadowRadius: {};
+                shadowMapSize: {};
+                shadowCameraNear: {};
+                shadowCameraFar: {};
+            };
+        };
+        pointShadowMap: IUniform<unknown[]>;
+        pointShadowMatrix: IUniform<unknown[]>;
+        hemisphereLights: {
+            value: unknown[];
+            properties: {
+                direction: {};
+                skycolor: {};
+                groundColor: {};
+            };
+        };
+        rectAreaLights: {
+            value: unknown[];
+            properties: {
+                color: {};
+                position: {};
+                width: {};
+                height: {};
+            };
+        };
+        ltc_1: IUniform<unknown>;
+        ltc_2: IUniform<unknown>;
+    };
+    points: {
+        diffuse: IUniform<Color>;
+        opacity: IUniform<number>;
+        size: IUniform<number>;
+        scale: IUniform<number>;
+        map: IUniform<unknown>;
+        alphaMap: IUniform<unknown>;
+        alphaTest: IUniform<number>;
+        uvTransform: IUniform<Matrix3>;
+    };
+    sprite: {
+        diffuse: IUniform<Color>;
+        opacity: IUniform<number>;
+        center: IUniform<Vector2>;
+        rotation: IUniform<number>;
+        map: IUniform<unknown>;
+        mapTransform: IUniform<Matrix3>;
+        alphaMap: IUniform<unknown>;
+        alphaTest: IUniform<number>;
+    };
+};

package/three/src/renderers/shaders/UniformsUtils.d.ts

@@ -0,0 +1,14 @@
+import { UniformsGroup } from "../../core/UniformsGroup.js";
+import { IUniform } from "./UniformsLib.js";
+
+export function cloneUniforms<T extends { [uniform: string]: IUniform }>(uniformsSrc: T): T;
+export function mergeUniforms(uniforms: Array<{ [uniform: string]: IUniform }>): { [uniform: string]: IUniform };
+
+export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
+
+declare const UniformsUtils: {
+    clone: typeof cloneUniforms;
+    merge: typeof mergeUniforms;
+};
+
+export { UniformsUtils };

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

@@ -0,0 +1,21 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { GLBufferAttribute } from "../../core/GLBufferAttribute.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
+
+export class WebGLAttributes {
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
+
+    get(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute):
+        | {
+            buffer: WebGLBuffer;
+            type: number;
+            bytesPerElement: number;
+            version: number;
+            size: number;
+        }
+        | undefined;
+
+    remove(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute): void;
+
+    update(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute, bufferType: number): void;
+}

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

@@ -0,0 +1,26 @@
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Material } from "../../materials/Material.js";
+import { WebGLAttributes } from "./WebGLAttributes.js";
+import { WebGLProgram } from "./WebGLProgram.js";
+
+export class WebGLBindingStates {
+    constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes);
+
+    setup(
+        object: Object3D,
+        material: Material,
+        program: WebGLProgram,
+        geometry: BufferGeometry,
+        index: BufferAttribute,
+    ): void;
+    reset(): void;
+    resetDefaultState(): void;
+    dispose(): void;
+    releaseStatesOfGeometry(): void;
+    releaseStatesOfProgram(): void;
+    initAttributes(): void;
+    enableAttribute(attribute: number): void;
+    disableUnusedAttributes(): void;
+}

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

@@ -0,0 +1,21 @@
+import { WebGLExtensions } from "./WebGLExtensions.js";
+import { WebGLInfo } from "./WebGLInfo.js";
+
+export class WebGLBufferRenderer {
+    constructor(
+        gl: WebGLRenderingContext,
+        extensions: WebGLExtensions,
+        info: WebGLInfo,
+    );
+
+    setMode: (value: any) => void;
+    render: (start: any, count: number) => void;
+    renderInstances: (start: any, count: number, primcount: number) => void;
+    renderMultiDraw: (starts: Int32Array, counts: Int32Array, drawCount: number) => void;
+    renderMultiDrawInstances: (
+        starts: Int32Array,
+        counts: Int32Array,
+        drawCount: number,
+        primcount: Int32Array,
+    ) => void;
+}

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

@@ -0,0 +1,35 @@
+import { PixelFormat, TextureDataType } from "../../constants.js";
+
+export interface WebGLCapabilitiesParameters {
+    precision?: string | undefined;
+    logarithmicDepthBuffer?: boolean | undefined;
+}
+
+export class WebGLCapabilities {
+    constructor(gl: WebGLRenderingContext, extensions: any, parameters: WebGLCapabilitiesParameters);
+
+    readonly isWebGL2: boolean;
+
+    getMaxAnisotropy: () => number;
+    getMaxPrecision: (precision: string) => string;
+
+    textureFormatReadable: (textureFormat: PixelFormat) => boolean;
+    textureTypeReadable: (textureType: TextureDataType) => boolean;
+
+    precision: string;
+    logarithmicDepthBuffer: boolean;
+
+    maxTextures: number;
+    maxVertexTextures: number;
+    maxTextureSize: number;
+    maxCubemapSize: number;
+
+    maxAttributes: number;
+    maxVertexUniforms: number;
+    maxVaryings: number;
+    maxFragmentUniforms: number;
+
+    vertexTextures: boolean;
+
+    maxSamples: number;
+}