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

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

@@ -1,189 +1,189 @@
-import { Color } from "../../math/Color.js";
-import { Matrix3 } from "../../math/Matrix3.js";
-import { Vector2 } from "../../math/Vector2.js";
+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;
+	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>;
-    };
+	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

@@ -1,5 +1,5 @@
-import { UniformsGroup } from "../../core/UniformsGroup.js";
-import { IUniform } from "./UniformsLib.js";
+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 };
@@ -7,8 +7,8 @@ export function mergeUniforms(uniforms: Array<{ [uniform: string]: IUniform }>):
 export function cloneUniformsGroups(src: UniformsGroup[]): UniformsGroup[];
 
 declare const UniformsUtils: {
-    clone: typeof cloneUniforms;
-    merge: typeof mergeUniforms;
+	clone: typeof cloneUniforms;
+	merge: typeof mergeUniforms;
 };
 
 export { UniformsUtils };

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

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

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

@@ -1,26 +1,20 @@
-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";
+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);
+	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;
+	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

@@ -1,21 +1,12 @@
-import { WebGLExtensions } from "./WebGLExtensions.js";
-import { WebGLInfo } from "./WebGLInfo.js";
+import { WebGLExtensions } from './WebGLExtensions.js';
+import { WebGLInfo } from './WebGLInfo.js';
 
 export class WebGLBufferRenderer {
-    constructor(
-        gl: WebGLRenderingContext,
-        extensions: WebGLExtensions,
-        info: WebGLInfo,
-    );
+	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;
+	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

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

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

@@ -1,26 +1,26 @@
-import { Camera } from "../../cameras/Camera.js";
-import { Material } from "../../materials/Material.js";
-import { Plane } from "../../math/Plane.js";
-import { WebGLProperties } from "./WebGLProperties.js";
+import { Camera } from '../../cameras/Camera.js';
+import { Material } from '../../materials/Material.js';
+import { Plane } from '../../math/Plane.js';
+import { WebGLProperties } from './WebGLProperties.js';
 
 export class WebGLClipping {
-    constructor(properties: WebGLProperties);
+	constructor(properties: WebGLProperties);
 
-    uniform: { value: any; needsUpdate: boolean };
+	uniform: { value: any; needsUpdate: boolean };
 
-    /**
-     * @default 0
-     */
-    numPlanes: number;
+	/**
+	 * @default 0
+	 */
+	numPlanes: number;
 
-    /**
-     * @default 0
-     */
-    numIntersection: number;
+	/**
+	 * @default 0
+	 */
+	numIntersection: number;
 
-    init(planes: any[], enableLocalClipping: boolean): boolean;
-    beginShadows(): void;
-    endShadows(): void;
-    setGlobalState(planes: Plane[], camera: Camera): void;
-    setState(material: Material, camera: Camera, useCache: boolean): void;
+	init(planes: any[], enableLocalClipping: boolean): boolean;
+	beginShadows(): void;
+	endShadows(): void;
+	setGlobalState(planes: Plane[], camera: Camera): void;
+	setState(material: Material, camera: Camera, useCache: boolean): void;
 }

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

@@ -1,8 +1,8 @@
-import { WebGLRenderer } from "../WebGLRenderer.js";
+import { WebGLRenderer } from '../WebGLRenderer.js';
 
 export class WebGLCubeMaps {
-    constructor(renderer: WebGLRenderer);
+	constructor(renderer: WebGLRenderer);
 
-    get(texture: any): any;
-    dispose(): void;
+	get(texture: any): any;
+	dispose(): void;
 }

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

@@ -1,9 +1,9 @@
-import { Texture } from "../../textures/Texture.js";
-import { WebGLRenderer } from "../WebGLRenderer.js";
+import { Texture } from '../../textures/Texture.js';
+import { WebGLRenderer } from '../WebGLRenderer.js';
 
 export class WebGLCubeUVMaps {
-    constructor(renderer: WebGLRenderer);
+	constructor(renderer: WebGLRenderer);
 
-    get<T>(texture: T): T extends Texture ? Texture : T;
-    dispose(): void;
+	get<T>(texture: T): T extends Texture ? Texture : T;
+	dispose(): void;
 }

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

@@ -1,7 +1,7 @@
 export class WebGLExtensions {
-    constructor(gl: WebGLRenderingContext);
+	constructor(gl: WebGLRenderingContext);
 
-    has(name: string): boolean;
-    init(): void;
-    get(name: string): any;
+	has(name: string): boolean;
+	init(): void;
+	get(name: string): any;
 }