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

package/three/src/nodes/lighting/LightsNode.d.ts

@@ -0,0 +1,22 @@
+import { Light } from "../../lights/Light.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import LightingNode from "./LightingNode.js";
+
+export default class LightsNode extends Node {
+    lightNodes: LightingNode[];
+
+    constructor(lightNodes?: LightingNode[]);
+
+    get hasLight(): boolean;
+    getLightNodeByHash(hash: string): LightingNode | null;
+
+    fromLights(lights: Light[]): this;
+
+    static setReference<T extends Light>(
+        lightClass: { new(): T },
+        lightNodeClass: { new(light: T): LightingNode },
+    ): void;
+}
+
+export const lights: (lights: Light[]) => ShaderNodeObject<LightsNode>;

package/three/src/nodes/lighting/PointLightNode.d.ts

@@ -0,0 +1,10 @@
+import { PointLight } from "../../lights/PointLight.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
+
+export default class PointLightNode extends AnalyticLightNode<PointLight> {
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: PointLight | null);
+}

package/three/src/nodes/lighting/RectAreaLightNode.d.ts

@@ -0,0 +1,21 @@
+import { RectAreaLight } from "../../lights/RectAreaLight.js";
+import { DataTexture } from "../../textures/DataTexture.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
+
+export interface RectAreaLightTexturesLib {
+    LTC_HALF_1: DataTexture;
+    LTC_HALF_2: DataTexture;
+
+    LTC_FLOAT_1: DataTexture;
+    LTC_FLOAT_2: DataTexture;
+}
+
+export default class RectAreaLightNode extends AnalyticLightNode<RectAreaLight> {
+    halfHeight: Node;
+    halfWidth: Node;
+
+    constructor(light?: RectAreaLight | null);
+
+    static setLTC(ltc: RectAreaLightTexturesLib): void;
+}

package/three/src/nodes/lighting/SpotLightNode.d.ts

@@ -0,0 +1,15 @@
+import { SpotLight } from "../../lights/SpotLight.js";
+import Node from "../core/Node.js";
+import AnalyticLightNode from "./AnalyticLightNode.js";
+
+export default class PointLightNode extends AnalyticLightNode<SpotLight> {
+    directionNode: Node;
+
+    coneCosNode: Node;
+    penumbraCosNode: Node;
+
+    cutoffDistanceNode: Node;
+    decayExponentNode: Node;
+
+    constructor(light?: SpotLight | null);
+}

package/three/src/nodes/loaders/NodeLoader.d.ts

@@ -0,0 +1,16 @@
+import { Loader } from "../../loaders/Loader.js";
+import { LoadingManager } from "../../loaders/LoadingManager.js";
+import { Texture } from "../../textures/Texture.js";
+import { Node } from "../Nodes.js";
+
+export interface NodeLoaderResult {
+    [hash: string]: Node;
+}
+
+export default class NodeLoader extends Loader<NodeLoaderResult> {
+    constructor(manager?: LoadingManager);
+
+    parseNodes(json: unknown): NodeLoaderResult;
+    parse(json: unknown): Node;
+    setTextures(textures: { [key: string]: Texture }): this;
+}

package/three/src/nodes/loaders/NodeMaterialLoader.d.ts

@@ -0,0 +1,8 @@
+import { MaterialLoader } from "../../loaders/MaterialLoader.js";
+import { NodeLoaderResult } from "./NodeLoader.js";
+
+export default class NodeMaterialLoader extends MaterialLoader {
+    nodes: NodeLoaderResult;
+
+    setNodes(value: NodeLoaderResult): this;
+}

package/three/src/nodes/loaders/NodeObjectLoader.d.ts

@@ -0,0 +1,10 @@
+import { ObjectLoader } from "../../loaders/ObjectLoader.js";
+import { Material } from "../../materials/Material.js";
+import { Texture } from "../../textures/Texture.js";
+import { NodeLoaderResult } from "./NodeLoader.js";
+
+export default class NodeObjectLoader extends ObjectLoader {
+    parseNodes(json: unknown, textures: { [key: string]: Texture }): NodeLoaderResult;
+
+    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
+}

package/three/src/nodes/materials/Line2NodeMaterial.d.ts

@@ -0,0 +1,53 @@
+import { LineDashedMaterialParameters } from "../../materials/LineDashedMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Texture } from "../../textures/Texture.js";
+import Node from "../core/Node.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    dashed?: boolean | undefined;
+}
+
+export default class Line2NodeMaterial extends NodeMaterial {
+    lights: boolean;
+
+    // Properties from LineDashedMaterial
+    readonly isLineDashedMaterial: true;
+    scale: number;
+    dashSize: number;
+    gapSize: number;
+
+    // Properties from LineBasicMaterial
+    readonly isLineBasicMaterial: true;
+    color: Color;
+    fog: boolean;
+    linewidth: number;
+    linecap: string;
+    linejoin: string;
+    map: Texture | null;
+
+    useAlphaToCoverage: boolean;
+    useColor: boolean;
+    useDash: boolean;
+    useWorldUnits: boolean;
+
+    dashOffset: number;
+    lineWidth: number;
+
+    lineColorNode: Node | null;
+
+    offsetNode: Node | null;
+    dashScaleNode: Node | null;
+    dashSizeNode: Node | null;
+    gapSizeNode: Node | null;
+
+    constructor(parameters?: Line2NodeMaterialParameters);
+
+    setupShaders(): void;
+
+    get worldUnits(): boolean;
+    set worldUnits(value: boolean);
+
+    get dashed(): boolean;
+    set dashed(value: boolean);
+}

package/three/src/nodes/materials/LineBasicNodeMaterial.d.ts

@@ -0,0 +1,22 @@
+import { LineBasicMaterialParameters } from "../../materials/LineBasicMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Texture } from "../../textures/Texture.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {
+}
+
+export default class LineBasicNodeMaterial extends NodeMaterial {
+    readonly isLineBasicNodeMaterial: true;
+
+    // Properties from LineBasicMaterial
+    readonly isLineBasicMaterial: true;
+    color: Color;
+    fog: boolean;
+    linewidth: number;
+    linecap: string;
+    linejoin: string;
+    map: Texture | null;
+
+    constructor(parameters?: LineBasicNodeMaterialParameters);
+}

package/three/src/nodes/materials/Materials.d.ts

@@ -0,0 +1,15 @@
+export { default as Line2NodeMaterial } from "./Line2NodeMaterial.js";
+export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
+export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshMatcapNodeMaterial } from "./MeshMatcapNodeMaterial.js";
+export { default as MeshNormalNodeMaterial } from "./MeshNormalNodeMaterial.js";
+export { default as MeshPhongNodeMaterial } from "./MeshPhongNodeMaterial.js";
+export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.js";
+export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js";
+export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
+export { default as MeshToonNodeMaterial } from "./MeshToonNodeMaterial.js";
+export { addNodeMaterial, createNodeMaterialFromType, default as NodeMaterial } from "./NodeMaterial.js";
+export { default as PointsNodeMaterial } from "./PointsNodeMaterial.js";
+export { default as ShadowNodeMaterial } from "./ShadowNodeMaterial.js";
+export { default as SpriteNodeMaterial } from "./SpriteNodeMaterial.js";
+export { default as VolumeNodeMaterial } from "./VolumeNodeMaterial.js";

package/three/src/nodes/materials/MeshBasicNodeMaterial.d.ts

@@ -0,0 +1,36 @@
+import { Combine } from "../../constants.js";
+import { MeshBasicMaterialParameters } from "../../materials/MeshBasicMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Euler } from "../../math/Euler.js";
+import { Texture } from "../../textures/Texture.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {
+}
+
+export default class MeshBasicNodeMaterial extends NodeMaterial {
+    readonly isMeshBasicNodeMaterial: true;
+
+    // Properties from MeshBasicMaterial
+    readonly isMeshBasicMaterial: true;
+    color: Color;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    specularMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    envMapRotation: Euler;
+    combine: Combine;
+    reflectivity: number;
+    refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    fog: boolean;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshMatcapNodeMaterial.d.ts

@@ -0,0 +1,32 @@
+import { NormalMapTypes } from "../../constants.js";
+import { MeshMatcapMaterialParameters } from "../../materials/MeshMatcapMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {
+}
+
+export default class MeshMatcapNodeMaterial extends NodeMaterial {
+    readonly isMeshMatcapNodeMaterial: true;
+
+    // Properties from MeshMatcapMaterial
+    readonly isMeshMatcapMaterial: true;
+    color: Color;
+    matcap: Texture | null;
+    map: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    alphaMap: Texture | null;
+    flatShading: boolean;
+    fog: boolean;
+
+    constructor(paramters: MeshMatcapNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshNormalNodeMaterial.d.ts

@@ -0,0 +1,28 @@
+import { NormalMapTypes } from "../../constants.js";
+import { MeshNormalMaterialParameters } from "../../materials/MeshNormalMaterial.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {
+}
+
+export default class MeshNormalNodeMaterial extends NodeMaterial {
+    readonly isMeshNormalNodeMaterial: true;
+
+    // Properties from MeshNormalMaterial
+    readonly isMeshNormalMaterial: true;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    flatShading: boolean;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -0,0 +1,56 @@
+import { Combine, NormalMapTypes } from "../../constants.js";
+import { MeshPhongMaterialParameters } from "../../materials/MeshPhongMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Euler } from "../../math/Euler.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import Node from "../core/Node.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {
+}
+
+export default class MeshPhongNodeMaterial extends NodeMaterial {
+    readonly isMeshPhongNodeMaterial: true;
+
+    shininessNode: Node | null;
+    specularNode: Node | null;
+
+    // Properties from MeshPhongMaterial
+    readonly isMeshPhongMaterial: true;
+    color: Color;
+    specular: Color;
+    shininess: number;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    specularMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    envMapRotation: Euler;
+    combine: Combine;
+    reflectivity: number;
+    refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
+    metal: boolean;
+    fog: boolean;
+
+    constructor(parameters?: MeshPhongNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -0,0 +1,90 @@
+import { MeshPhysicalMaterialParameters } from "../../materials/MeshPhysicalMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import Node from "../core/Node.js";
+import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
+
+export interface MeshPhysicalNodeMaterialParameters
+    extends MeshStandardNodeMaterialParameters, MeshPhysicalMaterialParameters
+{
+}
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+    readonly isMeshPhysicalNodeMaterial: true;
+
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+    clearcoatNormalNode: Node | null;
+
+    sheenNode: Node | null;
+    sheenRoughnessNode: Node | null;
+
+    iridescenceNode: Node | null;
+    iridescenceIORNode: Node | null;
+    iridescenceThicknessNode: Node | null;
+
+    iorNode: Node | null;
+
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
+
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+    dispersionNode: Node | null;
+
+    anisotropyNode: Node | null;
+
+    // Properties from MeshPhysicalMaterial
+    readonly isMeshPhysicalMaterial: true;
+    anisotropyRotation: number;
+    anisotropyMap: Texture | null;
+    clearcoatMap: Texture | null;
+    clearcoatRoughness: number;
+    clearcoatRoughnessMap: Texture | null;
+    clearcoatNormalScale: Vector2;
+    clearcoatNormalMap: Texture | null;
+    ior: number;
+    get reflectivity(): number;
+    set reflectivity(reflectivity: number);
+    iridescenceMap: Texture | null;
+    iridescenceIOR: number;
+    iridescenceThicknessRange: [number, number];
+    iridescenceThicknessMap: Texture | null;
+    sheenColor: Color;
+    sheenColorMap: Texture | null;
+    sheenRoughness: number;
+    sheenRoughnessMap: Texture | null;
+    transmissionMap: Texture | null;
+    thickness: number;
+    thicknessMap: Texture | null;
+    attenuationDistance: number;
+    attenuationColor: Color;
+    specularIntensity: number;
+    specularIntensityMap: Texture | null;
+    specularColor: Color;
+    specularColorMap: Texture | null;
+    get anisotropy(): number;
+    set anisotropy(value: number);
+    get clearcoat(): number;
+    set clearcoat(value: number);
+    get iridescence(): number;
+    set iridescence(value: number);
+    get dispersion(): number;
+    set dispersion(value: number);
+    get sheen(): number;
+    set sheen(value: number);
+    get transmission(): number;
+    set transmission(value: number);
+
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+    get useClearcoat(): boolean;
+    get useIridescence(): boolean;
+    get useSheen(): boolean;
+    get useAnisotropy(): boolean;
+    get useTransmission(): boolean;
+    get useDispersion(): boolean;
+}

package/three/src/nodes/materials/MeshSSSNodeMaterial.d.ts

@@ -0,0 +1,16 @@
+import ConstNode from "../core/ConstNode.js";
+import Node from "../core/Node.js";
+import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
+
+export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
+    thicknessColorNode: Node | null;
+    thicknessDistortionNode: ConstNode<number>;
+    thicknessAmbientNode: ConstNode<number>;
+    thicknessAttenuationNode: ConstNode<number>;
+    thicknessPowerNode: ConstNode<number>;
+    thicknessScaleNode: ConstNode<number>;
+
+    constructor(parameters?: MeshPhysicalNodeMaterialParameters);
+
+    get useSSS(): boolean;
+}

package/three/src/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -0,0 +1,56 @@
+import { NormalMapTypes } from "../../constants.js";
+import { MeshStandardMaterialParameters } from "../../materials/MeshStandardMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Euler } from "../../math/Euler.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import Node from "../core/Node.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
+}
+
+export default class MeshStandardNodeMaterial extends NodeMaterial {
+    readonly isMeshStandardNodeMaterial: true;
+
+    emissiveNode: Node | null;
+
+    metalnessNode: Node | null;
+    roughnessNode: Node | null;
+
+    // Properties from MeshStandardMaterial
+    readonly isMeshStandardMaterial: true;
+    color: Color;
+    roughness: number;
+    metalness: number;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    roughnessMap: Texture | null;
+    metalnessMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    envMapRotation: Euler;
+    envMapIntensity: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    flatShading: boolean;
+    fog: boolean;
+
+    constructor(paramters?: MeshStandardNodeMaterialParameters);
+}

package/three/src/nodes/materials/MeshToonNodeMaterial.d.ts

@@ -0,0 +1,42 @@
+import { NormalMapTypes } from "../../constants.js";
+import { MeshToonMaterialParameters } from "../../materials/MeshToonMaterial.js";
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshToonNodeMaterialParameters extends NodeMaterialParameters, MeshToonMaterialParameters {
+}
+
+export default class MeshToonNodeMaterial extends NodeMaterial {
+    readonly isMeshToonNodeMaterial: true;
+
+    // Properties from MeshToonMaterial
+    readonly isMeshToonMaterial: true;
+    color: Color;
+    gradientMap: Texture | null;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    alphaMap: Texture | null;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+    fog: boolean;
+
+    constructor(paramters: MeshToonNodeMaterialParameters);
+}