@nativescript/canvas-three 2.0.0-webgpu.3 → 2.0.0-webgpu.30

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,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';
+
+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,12 @@
+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;
+}

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

@@ -0,0 +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';
+
+export class WebGLClipping {
+	constructor(properties: WebGLProperties);
+
+	uniform: { value: any; needsUpdate: boolean };
+
+	/**
+	 * @default 0
+	 */
+	numPlanes: 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;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { BufferAttribute } from '../../core/BufferAttribute.js';
+import { BufferGeometry } from '../../core/BufferGeometry.js';
+import { Object3D } from '../../core/Object3D.js';
+import { WebGLAttributes } from './WebGLAttributes.js';
+import { WebGLInfo } from './WebGLInfo.js';
+
+export class WebGLGeometries {
+	constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes, info: WebGLInfo);
+
+	get(object: Object3D, geometry: BufferGeometry): BufferGeometry;
+	update(geometry: BufferGeometry): void;
+	getWireframeAttribute(geometry: BufferGeometry): BufferAttribute;
+}

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

@@ -0,0 +1,10 @@
+export class WebGLIndexedBufferRenderer {
+	constructor(gl: WebGLRenderingContext, extensions: any, info: any);
+
+	setMode: (value: any) => void;
+	setIndex: (index: 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/WebGLInfo.d.ts

@@ -0,0 +1,39 @@
+import { WebGLProgram } from './WebGLProgram.js';
+
+/**
+ * An object with a series of statistical information about the graphics board memory and the rendering process.
+ */
+export class WebGLInfo {
+	constructor(gl: WebGLRenderingContext);
+
+	/**
+	 * @default true
+	 */
+	autoReset: boolean;
+
+	/**
+	 * @default { geometries: 0, textures: 0 }
+	 */
+	memory: {
+		geometries: number;
+		textures: number;
+	};
+
+	/**
+	 * @default null
+	 */
+	programs: WebGLProgram[] | null;
+
+	/**
+	 * @default { frame: 0, calls: 0, triangles: 0, points: 0, lines: 0 }
+	 */
+	render: {
+		calls: number;
+		frame: number;
+		lines: number;
+		points: number;
+		triangles: number;
+	};
+	update(count: number, mode: number, instanceCount: number): void;
+	reset(): void;
+}

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

@@ -0,0 +1,49 @@
+import { WebGLExtensions } from './WebGLExtensions.js';
+
+export interface WebGLLightsState {
+	version: number;
+
+	hash: {
+		directionalLength: number;
+		pointLength: number;
+		spotLength: number;
+		rectAreaLength: number;
+		hemiLength: number;
+
+		numDirectionalShadows: number;
+		numPointShadows: number;
+		numSpotShadows: number;
+		numSpotMaps: number;
+
+		numLightProbes: number;
+	};
+
+	ambient: number[];
+	probe: any[];
+	directional: any[];
+	directionalShadow: any[];
+	directionalShadowMap: any[];
+	directionalShadowMatrix: any[];
+	spot: any[];
+	spotShadow: any[];
+	spotShadowMap: any[];
+	spotShadowMatrix: any[];
+	rectArea: any[];
+	point: any[];
+	pointShadow: any[];
+	pointShadowMap: any[];
+	pointShadowMatrix: any[];
+	hemi: any[];
+	numSpotLightShadowsWithMaps: number;
+	numLightProbes: number;
+}
+
+export class WebGLLights {
+	constructor(extensions: WebGLExtensions);
+
+	state: WebGLLightsState;
+
+	get(light: any): any;
+	setup(lights: any): void;
+	setupView(lights: any, camera: any): void;
+}

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

@@ -0,0 +1,6 @@
+export class WebGLObjects {
+	constructor(gl: WebGLRenderingContext, geometries: any, attributes: any, info: any);
+
+	update(object: any): any;
+	dispose(): void;
+}

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

@@ -0,0 +1,30 @@
+import { WebGLRenderer } from '../WebGLRenderer.js';
+import { WebGLUniforms } from './WebGLUniforms.js';
+
+export class WebGLProgram {
+	constructor(renderer: WebGLRenderer, cacheKey: string, parameters: object);
+
+	name: string;
+	id: number;
+	cacheKey: string; // unique identifier for this program, used for looking up compiled programs from cache.
+
+	/**
+	 * @default 1
+	 */
+	usedTimes: number;
+	program: any;
+	vertexShader: WebGLShader;
+	fragmentShader: WebGLShader;
+	/**
+	 * @deprecated Use {@link WebGLProgram#getUniforms getUniforms()} instead.
+	 */
+	uniforms: any;
+	/**
+	 * @deprecated Use {@link WebGLProgram#getAttributes getAttributes()} instead.
+	 */
+	attributes: any;
+
+	getUniforms(): WebGLUniforms;
+	getAttributes(): any;
+	destroy(): void;
+}