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

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

@@ -0,0 +1,218 @@
+import { ColorSpace, Combine, DepthPackingStrategies, GLSLVersion, Mapping, ShadowMapType, ToneMapping } from '../../constants.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Light } from '../../lights/Light.js';
+import { Material } from '../../materials/Material.js';
+import { Scene } from '../../scenes/Scene.js';
+import { IUniform } from '../shaders/UniformsLib.js';
+import { WebGLRenderer } from '../WebGLRenderer.js';
+import { WebGLBindingStates } from './WebGLBindingStates.js';
+import { WebGLCapabilities } from './WebGLCapabilities.js';
+import { WebGLClipping } from './WebGLClipping.js';
+import { WebGLCubeMaps } from './WebGLCubeMaps.js';
+import { WebGLExtensions } from './WebGLExtensions.js';
+import { WebGLLightsState } from './WebGLLights.js';
+import { WebGLProgram } from './WebGLProgram.js';
+
+export interface WebGLProgramParameters {
+	shaderID: string;
+	shaderType: string;
+	shaderName: string;
+
+	vertexShader: string;
+	fragmentShader: string;
+	defines: { [define: string]: string | number | boolean } | undefined;
+
+	customVertexShaderID: string | undefined;
+	customFragmentShaderID: string | undefined;
+
+	isRawShaderMaterial: boolean;
+	glslVersion: GLSLVersion | null | undefined;
+
+	precision: 'lowp' | 'mediump' | 'highp';
+
+	batching: boolean;
+	batchingColor: boolean;
+	instancing: boolean;
+	instancingColor: boolean;
+	instancingMorph: boolean;
+
+	supportsVertexTextures: boolean;
+	outputColorSpace: ColorSpace;
+	alphaToCoverage: boolean;
+
+	map: boolean;
+	matcap: boolean;
+	envMap: boolean;
+	envMapMode: Mapping | false;
+	envMapCubeUVHeight: number | null;
+	aoMap: boolean;
+	lightMap: boolean;
+	bumpMap: boolean;
+	normalMap: boolean;
+	displacementMap: boolean;
+	emissiveMap: boolean;
+
+	normalMapObjectSpace: boolean;
+	normalMapTangentSpace: boolean;
+
+	metalnessMap: boolean;
+	roughnessMap: boolean;
+
+	anisotropy: boolean;
+	anisotropyMap: boolean;
+
+	clearcoat: boolean;
+	clearcoatMap: boolean;
+	clearcoatNormalMap: boolean;
+	clearcoatRoughnessMap: boolean;
+
+	dispersion: boolean;
+
+	iridescence: boolean;
+	iridescenceMap: boolean;
+	iridescenceThicknessMap: boolean;
+
+	sheen: boolean;
+	sheenColorMap: boolean;
+	sheenRoughnessMap: boolean;
+
+	specularMap: boolean;
+	specularColorMap: boolean;
+	specularIntensityMap: boolean;
+
+	transmission: boolean;
+	transmissionMap: boolean;
+	thicknessMap: boolean;
+
+	gradientMap: boolean;
+
+	opaque: boolean;
+
+	alphaMap: boolean;
+	alphaTest: boolean;
+	alphaHash: boolean;
+
+	combine: Combine | undefined;
+
+	//
+
+	mapUv: string | false;
+	aoMapUv: string | false;
+	lightMapUv: string | false;
+	bumpMapUv: string | false;
+	normalMapUv: string | false;
+	displacementMapUv: string | false;
+	emissiveMapUv: string | false;
+
+	metalnessMapUv: string | false;
+	roughnessMapUv: string | false;
+
+	anisotropyMapUv: string | false;
+
+	clearcoatMapUv: string | false;
+	clearcoatNormalMapUv: string | false;
+	clearcoatRoughnessMapUv: string | false;
+
+	iridescenceMapUv: string | false;
+	iridescenceThicknessMapUv: string | false;
+
+	sheenColorMapUv: string | false;
+	sheenRoughnessMapUv: string | false;
+
+	specularMapUv: string | false;
+	specularColorMapUv: string | false;
+	specularIntensityMapUv: string | false;
+
+	transmissionMapUv: string | false;
+	thicknessMapUv: string | false;
+
+	alphaMapUv: string | false;
+
+	//
+
+	vertexTangents: boolean;
+	vertexColors: boolean;
+	vertexAlphas: boolean;
+	vertexUv1s: boolean;
+	vertexUv2s: boolean;
+	vertexUv3s: boolean;
+
+	pointsUvs: boolean;
+
+	fog: boolean;
+	useFog: boolean;
+	fogExp2: boolean;
+
+	flatShading: boolean;
+
+	sizeAttenuation: boolean;
+	logarithmicDepthBuffer: boolean;
+
+	skinning: boolean;
+
+	morphTargets: boolean;
+	morphNormals: boolean;
+	morphColors: boolean;
+	morphTargetsCount: number;
+	morphTextureStride: number;
+
+	numDirLights: number;
+	numPointLights: number;
+	numSpotLights: number;
+	numSpotLightMaps: number;
+	numRectAreaLights: number;
+	numHemiLights: number;
+
+	numDirLightShadows: number;
+	numPointLightShadows: number;
+	numSpotLightShadows: number;
+	numSpotLightShadowsWithMaps: number;
+
+	numLightProbes: number;
+
+	numClippingPlanes: number;
+	numClipIntersection: number;
+
+	dithering: boolean;
+
+	shadowMapEnabled: boolean;
+	shadowMapType: ShadowMapType;
+
+	toneMapping: ToneMapping;
+
+	decodeVideoTexture: boolean;
+
+	premultipliedAlpha: boolean;
+
+	doubleSided: boolean;
+	flipSided: boolean;
+
+	useDepthPacking: boolean;
+	depthPacking: DepthPackingStrategies | 0;
+
+	index0AttributeName: string | undefined;
+
+	extensionClipCullDistance: boolean;
+	extensionMultiDraw: boolean;
+
+	rendererExtensionParallelShaderCompile: boolean;
+
+	customProgramCacheKey: string;
+}
+
+export interface WebGLProgramParametersWithUniforms extends WebGLProgramParameters {
+	uniforms: { [uniform: string]: IUniform };
+}
+
+export class WebGLPrograms {
+	constructor(renderer: WebGLRenderer, cubemaps: WebGLCubeMaps, extensions: WebGLExtensions, capabilities: WebGLCapabilities, bindingStates: WebGLBindingStates, clipping: WebGLClipping);
+
+	programs: WebGLProgram[];
+
+	getParameters(material: Material, lights: WebGLLightsState, shadows: Light[], scene: Scene, object: Object3D): WebGLProgramParameters;
+
+	getProgramCacheKey(parameters: WebGLProgramParameters): string;
+	getUniforms(material: Material): { [uniform: string]: IUniform };
+	acquireProgram(parameters: WebGLProgramParametersWithUniforms, cacheKey: string): WebGLProgram;
+	releaseProgram(program: WebGLProgram): void;
+}

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

@@ -0,0 +1,8 @@
+export class WebGLProperties {
+	constructor();
+
+	get(object: any): any;
+	remove(object: any): void;
+	update(object: any, key: any, value: any): any;
+	dispose(): void;
+}

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

@@ -0,0 +1,52 @@
+import { Camera } from '../../cameras/Camera.js';
+import { BufferGeometry } from '../../core/BufferGeometry.js';
+import { Object3D } from '../../core/Object3D.js';
+import { Material } from '../../materials/Material.js';
+import { Group } from '../../objects/Group.js';
+import { Scene } from '../../scenes/Scene.js';
+import { WebGLProgram } from './WebGLProgram.js';
+import { WebGLProperties } from './WebGLProperties.js';
+
+export interface RenderItem {
+	id: number;
+	object: Object3D;
+	geometry: BufferGeometry | null;
+	material: Material;
+	program: WebGLProgram;
+	groupOrder: number;
+	renderOrder: number;
+	z: number;
+	group: Group | null;
+}
+
+export class WebGLRenderList {
+	constructor(properties: WebGLProperties);
+
+	/**
+	 * @default []
+	 */
+	opaque: RenderItem[];
+
+	/**
+	 * @default []
+	 */
+	transparent: RenderItem[];
+
+	/**
+	 * @default []
+	 */
+	transmissive: RenderItem[];
+
+	init(): void;
+	push(object: Object3D, geometry: BufferGeometry | null, material: Material, groupOrder: number, z: number, group: Group | null): void;
+	unshift(object: Object3D, geometry: BufferGeometry | null, material: Material, groupOrder: number, z: number, group: Group | null): void;
+	sort(opaqueSort: (a: any, b: any) => number, transparentSort: (a: any, b: any) => number): void;
+	finish(): void;
+}
+
+export class WebGLRenderLists {
+	constructor(properties: WebGLProperties);
+
+	dispose(): void;
+	get(scene: Scene, renderCallDepth: number): WebGLRenderList;
+}

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

@@ -0,0 +1 @@
+export function WebGLShader(gl: WebGLRenderingContext, type: string, string: string): WebGLShader;

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

@@ -0,0 +1,38 @@
+import { Camera } from '../../cameras/Camera.js';
+import { ShadowMapType } from '../../constants.js';
+import { Light } from '../../lights/Light.js';
+import { Scene } from '../../scenes/Scene.js';
+import { WebGLRenderer } from '../WebGLRenderer.js';
+import { WebGLCapabilities } from './WebGLCapabilities.js';
+import { WebGLObjects } from './WebGLObjects.js';
+
+export class WebGLShadowMap {
+	constructor(_renderer: WebGLRenderer, _objects: WebGLObjects, _capabilities: WebGLCapabilities);
+
+	/**
+	 * @default false
+	 */
+	enabled: boolean;
+
+	/**
+	 * @default true
+	 */
+	autoUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
+	needsUpdate: boolean;
+
+	/**
+	 * @default THREE.PCFShadowMap
+	 */
+	type: ShadowMapType;
+
+	render(shadowsArray: Light[], scene: Scene, camera: Camera): void;
+
+	/**
+	 * @deprecated Use {@link Material#shadowSide} instead.
+	 */
+	cullFace: any;
+}

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

@@ -0,0 +1,71 @@
+import { Blending, BlendingDstFactor, BlendingEquation, BlendingSrcFactor, CullFace, DepthModes } from '../../constants.js';
+import { Material } from '../../materials/Material.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { WebGLRenderTarget } from '../WebGLRenderTarget.js';
+
+export class WebGLColorBuffer {
+	constructor();
+
+	setMask(colorMask: boolean): void;
+	setLocked(lock: boolean): void;
+	setClear(r: number, g: number, b: number, a: number, premultipliedAlpha: boolean): void;
+	reset(): void;
+}
+
+export class WebGLDepthBuffer {
+	constructor();
+
+	setTest(depthTest: boolean): void;
+	setMask(depthMask: boolean): void;
+	setFunc(depthFunc: DepthModes): void;
+	setLocked(lock: boolean): void;
+	setClear(depth: number): void;
+	reset(): void;
+}
+
+export class WebGLStencilBuffer {
+	constructor();
+
+	setTest(stencilTest: boolean): void;
+	setMask(stencilMask: number): void;
+	setFunc(stencilFunc: number, stencilRef: number, stencilMask: number): void;
+	setOp(stencilFail: number, stencilZFail: number, stencilZPass: number): void;
+	setLocked(lock: boolean): void;
+	setClear(stencil: number): void;
+	reset(): void;
+}
+
+export class WebGLState {
+	constructor(gl: WebGLRenderingContext);
+
+	buffers: {
+		color: WebGLColorBuffer;
+		depth: WebGLDepthBuffer;
+		stencil: WebGLStencilBuffer;
+	};
+
+	enable(id: number): void;
+	disable(id: number): void;
+	bindFramebuffer(target: number, framebuffer: WebGLFramebuffer | null): void;
+	drawBuffers(renderTarget: WebGLRenderTarget | null, framebuffer: WebGLFramebuffer | null): void;
+	useProgram(program: any): boolean;
+	setBlending(blending: Blending, blendEquation?: BlendingEquation, blendSrc?: BlendingSrcFactor, blendDst?: BlendingDstFactor, blendEquationAlpha?: BlendingEquation, blendSrcAlpha?: BlendingSrcFactor, blendDstAlpha?: BlendingDstFactor, premultiplyAlpha?: boolean): void;
+	setMaterial(material: Material, frontFaceCW: boolean): void;
+	setFlipSided(flipSided: boolean): void;
+	setCullFace(cullFace: CullFace): void;
+	setLineWidth(width: number): void;
+	setPolygonOffset(polygonoffset: boolean, factor?: number, units?: number): void;
+	setScissorTest(scissorTest: boolean): void;
+	activeTexture(webglSlot: number): void;
+	bindTexture(webglType: number, webglTexture: any): void;
+	unbindTexture(): void;
+	// Same interface as https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/compressedTexImage2D
+	compressedTexImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, data: ArrayBufferView): void;
+	// Same interface as https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/texImage2D
+	texImage2D(target: number, level: number, internalformat: number, width: number, height: number, border: number, format: number, type: number, pixels: ArrayBufferView | null): void;
+	texImage2D(target: number, level: number, internalformat: number, format: number, type: number, source: any): void;
+	texImage3D(target: number, level: number, internalformat: number, width: number, height: number, depth: number, border: number, format: number, type: number, pixels: any): void;
+	scissor(scissor: Vector4): void;
+	viewport(viewport: Vector4): void;
+	reset(): void;
+}

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

@@ -0,0 +1,22 @@
+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,8 @@
+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,75 @@
+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;
+}