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

package/three/src/materials/MeshToonMaterial.d.ts

@@ -0,0 +1,178 @@
+import { NormalMapTypes } from '../constants.js';
+import { Color, ColorRepresentation } from '../math/Color.js';
+import { Vector2 } from '../math/Vector2.js';
+import { Texture } from '../textures/Texture.js';
+import { Material, MaterialParameters } from './Material.js';
+
+export interface MeshToonMaterialParameters extends MaterialParameters {
+	/** geometry color in hexadecimal. Default is 0xffffff. */
+	color?: ColorRepresentation | undefined;
+	opacity?: number | undefined;
+	gradientMap?: Texture | null | undefined;
+	map?: Texture | null | undefined;
+	lightMap?: Texture | null | undefined;
+	lightMapIntensity?: number | undefined;
+	aoMap?: Texture | null | undefined;
+	aoMapIntensity?: number | undefined;
+	emissive?: ColorRepresentation | undefined;
+	emissiveIntensity?: number | undefined;
+	emissiveMap?: Texture | null | undefined;
+	bumpMap?: Texture | null | undefined;
+	bumpScale?: number | undefined;
+	normalMap?: Texture | null | undefined;
+	normalMapType?: NormalMapTypes | undefined;
+	normalScale?: Vector2 | undefined;
+	displacementMap?: Texture | null | undefined;
+	displacementScale?: number | undefined;
+	displacementBias?: number | undefined;
+	alphaMap?: Texture | null | undefined;
+	wireframe?: boolean | undefined;
+	wireframeLinewidth?: number | undefined;
+	wireframeLinecap?: string | undefined;
+	wireframeLinejoin?: string | undefined;
+	fog?: boolean | undefined;
+}
+
+export class MeshToonMaterial extends Material {
+	constructor(parameters?: MeshToonMaterialParameters);
+
+	/**
+	 * Read-only flag to check if a given object is of type {@link MeshToonMaterial}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isMeshToonMaterial: true;
+
+	/**
+	 * @default 'MeshToonMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default { 'TOON': '' }
+	 */
+	defines: { [key: string]: any };
+
+	/**
+	 * @default new THREE.Color( 0xffffff )
+	 */
+	color: Color;
+
+	/**
+	 * @default null
+	 */
+	gradientMap: Texture | null;
+
+	/**
+	 * @default null
+	 */
+	map: Texture | null;
+
+	/**
+	 * @default null
+	 */
+	lightMap: Texture | null;
+
+	/**
+	 * @default 1
+	 */
+	lightMapIntensity: number;
+
+	/**
+	 * @default null
+	 */
+	aoMap: Texture | null;
+
+	/**
+	 * @default 1
+	 */
+	aoMapIntensity: number;
+
+	/**
+	 * @default new THREE.Color( 0x000000 )
+	 */
+	emissive: Color;
+
+	/**
+	 * @default 1
+	 */
+	emissiveIntensity: number;
+
+	/**
+	 * @default null
+	 */
+	emissiveMap: Texture | null;
+
+	/**
+	 * @default null
+	 */
+	bumpMap: Texture | null;
+
+	/**
+	 * @default 1
+	 */
+	bumpScale: number;
+
+	/**
+	 * @default null
+	 */
+	normalMap: Texture | null;
+
+	/**
+	 * @default THREE.TangentSpaceNormalMap
+	 */
+	normalMapType: NormalMapTypes;
+
+	/**
+	 * @default new THREE.Vector2( 1, 1 )
+	 */
+	normalScale: Vector2;
+
+	/**
+	 * @default null
+	 */
+	displacementMap: Texture | null;
+
+	/**
+	 * @default 1
+	 */
+	displacementScale: number;
+
+	/**
+	 * @default 0
+	 */
+	displacementBias: number;
+
+	/**
+	 * @default null
+	 */
+	alphaMap: Texture | null;
+
+	/**
+	 * @default false
+	 */
+	wireframe: boolean;
+
+	/**
+	 * @default 1
+	 */
+	wireframeLinewidth: number;
+
+	/**
+	 * @default 'round'
+	 */
+	wireframeLinecap: string;
+
+	/**
+	 * @default 'round'
+	 */
+	wireframeLinejoin: string;
+
+	/**
+	 * Whether the material is affected by fog. Default is true.
+	 * @default fog
+	 */
+	fog: boolean;
+
+	setValues(parameters: MeshToonMaterialParameters): void;
+}

package/three/src/materials/PointsMaterial.d.ts

@@ -0,0 +1,61 @@
+import { Color, ColorRepresentation } from '../math/Color.js';
+import { Texture } from '../textures/Texture.js';
+import { Material, MaterialParameters } from './Material.js';
+
+export interface PointsMaterialParameters extends MaterialParameters {
+	color?: ColorRepresentation | undefined;
+	map?: Texture | null | undefined;
+	alphaMap?: Texture | null | undefined;
+	size?: number | undefined;
+	sizeAttenuation?: boolean | undefined;
+	fog?: boolean | undefined;
+}
+
+export class PointsMaterial extends Material {
+	constructor(parameters?: PointsMaterialParameters);
+
+	/**
+	 * Read-only flag to check if a given object is of type {@link PointsMaterial}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isPointsMaterial: true;
+
+	/**
+	 * @default 'PointsMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Color( 0xffffff )
+	 */
+	color: Color;
+
+	/**
+	 * @default null
+	 */
+	map: Texture | null;
+
+	/**
+	 * @default null
+	 */
+	alphaMap: Texture | null;
+
+	/**
+	 * @default 1
+	 */
+	size: number;
+
+	/**
+	 * @default true
+	 */
+	sizeAttenuation: boolean;
+
+	/**
+	 * Whether the material is affected by fog. Default is true.
+	 * @default fog
+	 */
+	fog: boolean;
+
+	setValues(parameters: PointsMaterialParameters): void;
+}

package/three/src/materials/RawShaderMaterial.d.ts

@@ -0,0 +1,14 @@
+import { ShaderMaterial, ShaderMaterialParameters } from './ShaderMaterial.js';
+
+export class RawShaderMaterial extends ShaderMaterial {
+	constructor(parameters?: ShaderMaterialParameters);
+
+	/**
+	 * Read-only flag to check if a given object is of type {@link RawShaderMaterial}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isRawShaderMaterial: true;
+
+	override readonly type: 'RawShaderMaterial';
+}

package/three/src/materials/ShaderMaterial.d.ts

@@ -0,0 +1,175 @@
+import { GLSLVersion } from '../constants.js';
+import { JSONMeta } from '../core/Object3D.js';
+import { UniformsGroup } from '../core/UniformsGroup.js';
+import { Matrix3, Matrix3Tuple } from '../math/Matrix3.js';
+import { Matrix4, Matrix4Tuple } from '../math/Matrix4.js';
+import { Vector2Tuple } from '../math/Vector2.js';
+import { Vector3Tuple } from '../math/Vector3.js';
+import { Vector4Tuple } from '../math/Vector4.js';
+import { IUniform } from '../renderers/shaders/UniformsLib.js';
+import { Material, MaterialJSON, MaterialParameters } from './Material.js';
+
+export interface ShaderMaterialParameters extends MaterialParameters {
+	uniforms?: { [uniform: string]: IUniform } | undefined;
+	uniformsGroups?: UniformsGroup[] | undefined;
+	vertexShader?: string | undefined;
+	fragmentShader?: string | undefined;
+	linewidth?: number | undefined;
+	wireframe?: boolean | undefined;
+	wireframeLinewidth?: number | undefined;
+	lights?: boolean | undefined;
+	clipping?: boolean | undefined;
+	fog?: boolean | undefined;
+	extensions?:
+		| {
+				clipCullDistance?: boolean | undefined;
+				multiDraw?: boolean | undefined;
+		  }
+		| undefined;
+	glslVersion?: GLSLVersion | undefined;
+}
+
+export type ShaderMaterialUniformJSON =
+	| {
+			type: 't';
+			value: string;
+	  }
+	| {
+			type: 'c';
+			value: number;
+	  }
+	| {
+			type: 'v2';
+			value: Vector2Tuple;
+	  }
+	| {
+			type: 'v3';
+			value: Vector3Tuple;
+	  }
+	| {
+			type: 'v4';
+			value: Vector4Tuple;
+	  }
+	| {
+			type: 'm3';
+			value: Matrix3Tuple;
+	  }
+	| {
+			type: 'm4';
+			value: Matrix4Tuple;
+	  }
+	| {
+			value: unknown;
+	  };
+
+export interface ShaderMaterialJSON extends MaterialJSON {
+	glslVersion: number | null;
+	uniforms: Record<string, ShaderMaterialUniformJSON>;
+
+	defines?: Record<string, unknown>;
+
+	vertexShader: string;
+	ragmentShader: string;
+
+	lights: boolean;
+	clipping: boolean;
+
+	extensions?: Record<string, boolean>;
+}
+
+export class ShaderMaterial extends Material {
+	constructor(parameters?: ShaderMaterialParameters);
+
+	/**
+	 * Read-only flag to check if a given object is of type {@link ShaderMaterial}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isShaderMaterial: true;
+
+	/**
+	 * @default 'ShaderMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default {}
+	 */
+	defines: { [key: string]: any };
+
+	/**
+	 * @default {}
+	 */
+	uniforms: { [uniform: string]: IUniform };
+
+	uniformsGroups: UniformsGroup[];
+
+	vertexShader: string;
+
+	fragmentShader: string;
+
+	/**
+	 * @default 1
+	 */
+	linewidth: number;
+
+	/**
+	 * @default false
+	 */
+	wireframe: boolean;
+
+	/**
+	 * @default 1
+	 */
+	wireframeLinewidth: number;
+
+	/**
+	 * @default false
+	 */
+	fog: boolean;
+
+	/**
+	 * @default false
+	 */
+	lights: boolean;
+
+	/**
+	 * @default false
+	 */
+	clipping: boolean;
+
+	/**
+	 * @default {
+	 *   clipCullDistance: false,
+	 *   multiDraw: false
+	 * }
+	 */
+	extensions: {
+		clipCullDistance: boolean;
+		multiDraw: boolean;
+	};
+
+	/**
+	 * @default { 'color': [ 1, 1, 1 ], 'uv': [ 0, 0 ], 'uv1': [ 0, 0 ] }
+	 */
+	defaultAttributeValues: any;
+
+	/**
+	 * @default undefined
+	 */
+	index0AttributeName: string | undefined;
+
+	/**
+	 * @default false
+	 */
+	uniformsNeedUpdate: boolean;
+
+	/**
+	 * @default null
+	 */
+	glslVersion: GLSLVersion | null;
+
+	setValues(parameters: ShaderMaterialParameters): void;
+
+	toJSON(meta?: JSONMeta): ShaderMaterialJSON;
+}

package/three/src/materials/ShadowMaterial.d.ts

@@ -0,0 +1,39 @@
+import { Color, ColorRepresentation } from '../math/Color.js';
+import { Material, MaterialParameters } from './Material.js';
+
+export interface ShadowMaterialParameters extends MaterialParameters {
+	color?: ColorRepresentation | undefined;
+	fog?: boolean | undefined;
+}
+
+export class ShadowMaterial extends Material {
+	constructor(parameters?: ShadowMaterialParameters);
+
+	/**
+	 * Read-only flag to check if a given object is of type {@link ShadowMaterial}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isShadowMaterial: true;
+
+	/**
+	 * @default 'ShadowMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Color( 0x000000 )
+	 */
+	color: Color;
+
+	/**
+	 * @default true
+	 */
+	transparent: boolean;
+
+	/**
+	 * Whether the material is affected by fog. Default is true.
+	 * @default fog
+	 */
+	fog: boolean;
+}

package/three/src/materials/SpriteMaterial.d.ts

@@ -0,0 +1,66 @@
+import { Color, ColorRepresentation } from '../math/Color.js';
+import { Texture } from '../textures/Texture.js';
+import { Material, MaterialParameters } from './Material.js';
+
+export interface SpriteMaterialParameters extends MaterialParameters {
+	color?: ColorRepresentation | undefined;
+	map?: Texture | null | undefined;
+	alphaMap?: Texture | null | undefined;
+	rotation?: number | undefined;
+	sizeAttenuation?: boolean | undefined;
+	fog?: boolean | undefined;
+}
+
+export class SpriteMaterial extends Material {
+	constructor(parameters?: SpriteMaterialParameters);
+	/**
+	 * Read-only flag to check if a given object is of type {@link SpriteMaterial}.
+	 * @remarks This is a _constant_ value
+	 * @defaultValue `true`
+	 */
+	readonly isSpriteMaterial: true;
+
+	/**
+	 * @default 'SpriteMaterial'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Color( 0xffffff )
+	 */
+	color: Color;
+
+	/**
+	 * @default null
+	 */
+	map: Texture | null;
+
+	/**
+	 * @default null
+	 */
+	alphaMap: Texture | null;
+
+	/**
+	 * @default 0
+	 */
+	rotation: number;
+
+	/**
+	 * @default true
+	 */
+	sizeAttenuation: boolean;
+
+	/**
+	 * @default true
+	 */
+	transparent: boolean;
+
+	/**
+	 * Whether the material is affected by fog. Default is true.
+	 * @default fog
+	 */
+	fog: boolean;
+
+	setValues(parameters: SpriteMaterialParameters): void;
+	copy(source: SpriteMaterial): this;
+}

package/three/src/math/Box2.d.ts

@@ -0,0 +1,48 @@
+import { Vector2 } from './Vector2.js';
+
+// Math //////////////////////////////////////////////////////////////////////////////////
+
+export class Box2 {
+	constructor(min?: Vector2, max?: Vector2);
+
+	/**
+	 * @default new THREE.Vector2( + Infinity, + Infinity )
+	 */
+	min: Vector2;
+
+	/**
+	 * @default new THREE.Vector2( - Infinity, - Infinity )
+	 */
+	max: Vector2;
+
+	set(min: Vector2, max: Vector2): Box2;
+	setFromPoints(points: Vector2[]): Box2;
+	setFromCenterAndSize(center: Vector2, size: Vector2): Box2;
+	clone(): this;
+	copy(box: Box2): this;
+	makeEmpty(): Box2;
+	isEmpty(): boolean;
+	getCenter(target: Vector2): Vector2;
+	getSize(target: Vector2): Vector2;
+	expandByPoint(point: Vector2): Box2;
+	expandByVector(vector: Vector2): Box2;
+	expandByScalar(scalar: number): Box2;
+	containsPoint(point: Vector2): boolean;
+	containsBox(box: Box2): boolean;
+	getParameter(point: Vector2, target: Vector2): Vector2;
+	intersectsBox(box: Box2): boolean;
+	clampPoint(point: Vector2, target: Vector2): Vector2;
+	distanceToPoint(point: Vector2): number;
+	intersect(box: Box2): Box2;
+	union(box: Box2): Box2;
+	translate(offset: Vector2): Box2;
+	equals(box: Box2): boolean;
+	/**
+	 * @deprecated Use {@link Box2#isEmpty .isEmpty()} instead.
+	 */
+	empty(): any;
+	/**
+	 * @deprecated Use {@link Box2#intersectsBox .intersectsBox()} instead.
+	 */
+	isIntersectionBox(b: any): any;
+}

package/three/src/math/Box3.d.ts

@@ -0,0 +1,66 @@
+import { BufferAttribute } from '../core/BufferAttribute.js';
+import { Object3D } from '../core/Object3D.js';
+import { Matrix4 } from './Matrix4.js';
+import { Plane } from './Plane.js';
+import { Sphere } from './Sphere.js';
+import { Triangle } from './Triangle.js';
+import { Vector3 } from './Vector3.js';
+
+export class Box3 {
+	constructor(min?: Vector3, max?: Vector3);
+
+	/**
+	 * @default new THREE.Vector3( + Infinity, + Infinity, + Infinity )
+	 */
+	min: Vector3;
+
+	/**
+	 * @default new THREE.Vector3( - Infinity, - Infinity, - Infinity )
+	 */
+	max: Vector3;
+	readonly isBox3: true;
+
+	set(min: Vector3, max: Vector3): this;
+	setFromArray(array: ArrayLike<number>): this;
+	setFromBufferAttribute(bufferAttribute: BufferAttribute): this;
+	setFromPoints(points: Vector3[]): this;
+	setFromCenterAndSize(center: Vector3, size: Vector3): this;
+	setFromObject(object: Object3D, precise?: boolean): this;
+	clone(): this;
+	copy(box: Box3): this;
+	makeEmpty(): this;
+	isEmpty(): boolean;
+	getCenter(target: Vector3): Vector3;
+	getSize(target: Vector3): Vector3;
+	expandByPoint(point: Vector3): this;
+	expandByVector(vector: Vector3): this;
+	expandByScalar(scalar: number): this;
+	expandByObject(object: Object3D, precise?: boolean): this;
+	containsPoint(point: Vector3): boolean;
+	containsBox(box: Box3): boolean;
+	getParameter(point: Vector3, target: Vector3): Vector3;
+	intersectsBox(box: Box3): boolean;
+	intersectsSphere(sphere: Sphere): boolean;
+	intersectsPlane(plane: Plane): boolean;
+	intersectsTriangle(triangle: Triangle): boolean;
+	clampPoint(point: Vector3, target: Vector3): Vector3;
+	distanceToPoint(point: Vector3): number;
+	getBoundingSphere(target: Sphere): Sphere;
+	intersect(box: Box3): this;
+	union(box: Box3): this;
+	applyMatrix4(matrix: Matrix4): this;
+	translate(offset: Vector3): this;
+	equals(box: Box3): boolean;
+	/**
+	 * @deprecated Use {@link Box3#isEmpty .isEmpty()} instead.
+	 */
+	empty(): any;
+	/**
+	 * @deprecated Use {@link Box3#intersectsBox .intersectsBox()} instead.
+	 */
+	isIntersectionBox(b: any): any;
+	/**
+	 * @deprecated Use {@link Box3#intersectsSphere .intersectsSphere()} instead.
+	 */
+	isIntersectionSphere(s: any): any;
+}