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

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

@@ -0,0 +1,358 @@
+import { ColorSpace } from '../constants.js';
+import { Matrix3 } from './Matrix3.js';
+import { Vector3 } from './Vector3.js';
+
+import { BufferAttribute } from '../core/BufferAttribute.js';
+import { InterleavedBufferAttribute } from '../core/InterleavedBufferAttribute.js';
+
+export { SRGBToLinear } from './ColorManagement.js';
+
+declare const _colorKeywords: {
+	aliceblue: 0xf0f8ff;
+	antiquewhite: 0xfaebd7;
+	aqua: 0x00ffff;
+	aquamarine: 0x7fffd4;
+	azure: 0xf0ffff;
+	beige: 0xf5f5dc;
+	bisque: 0xffe4c4;
+	black: 0x000000;
+	blanchedalmond: 0xffebcd;
+	blue: 0x0000ff;
+	blueviolet: 0x8a2be2;
+	brown: 0xa52a2a;
+	burlywood: 0xdeb887;
+	cadetblue: 0x5f9ea0;
+	chartreuse: 0x7fff00;
+	chocolate: 0xd2691e;
+	coral: 0xff7f50;
+	cornflowerblue: 0x6495ed;
+	cornsilk: 0xfff8dc;
+	crimson: 0xdc143c;
+	cyan: 0x00ffff;
+	darkblue: 0x00008b;
+	darkcyan: 0x008b8b;
+	darkgoldenrod: 0xb8860b;
+	darkgray: 0xa9a9a9;
+	darkgreen: 0x006400;
+	darkgrey: 0xa9a9a9;
+	darkkhaki: 0xbdb76b;
+	darkmagenta: 0x8b008b;
+	darkolivegreen: 0x556b2f;
+	darkorange: 0xff8c00;
+	darkorchid: 0x9932cc;
+	darkred: 0x8b0000;
+	darksalmon: 0xe9967a;
+	darkseagreen: 0x8fbc8f;
+	darkslateblue: 0x483d8b;
+	darkslategray: 0x2f4f4f;
+	darkslategrey: 0x2f4f4f;
+	darkturquoise: 0x00ced1;
+	darkviolet: 0x9400d3;
+	deeppink: 0xff1493;
+	deepskyblue: 0x00bfff;
+	dimgray: 0x696969;
+	dimgrey: 0x696969;
+	dodgerblue: 0x1e90ff;
+	firebrick: 0xb22222;
+	floralwhite: 0xfffaf0;
+	forestgreen: 0x228b22;
+	fuchsia: 0xff00ff;
+	gainsboro: 0xdcdcdc;
+	ghostwhite: 0xf8f8ff;
+	gold: 0xffd700;
+	goldenrod: 0xdaa520;
+	gray: 0x808080;
+	green: 0x008000;
+	greenyellow: 0xadff2f;
+	grey: 0x808080;
+	honeydew: 0xf0fff0;
+	hotpink: 0xff69b4;
+	indianred: 0xcd5c5c;
+	indigo: 0x4b0082;
+	ivory: 0xfffff0;
+	khaki: 0xf0e68c;
+	lavender: 0xe6e6fa;
+	lavenderblush: 0xfff0f5;
+	lawngreen: 0x7cfc00;
+	lemonchiffon: 0xfffacd;
+	lightblue: 0xadd8e6;
+	lightcoral: 0xf08080;
+	lightcyan: 0xe0ffff;
+	lightgoldenrodyellow: 0xfafad2;
+	lightgray: 0xd3d3d3;
+	lightgreen: 0x90ee90;
+	lightgrey: 0xd3d3d3;
+	lightpink: 0xffb6c1;
+	lightsalmon: 0xffa07a;
+	lightseagreen: 0x20b2aa;
+	lightskyblue: 0x87cefa;
+	lightslategray: 0x778899;
+	lightslategrey: 0x778899;
+	lightsteelblue: 0xb0c4de;
+	lightyellow: 0xffffe0;
+	lime: 0x00ff00;
+	limegreen: 0x32cd32;
+	linen: 0xfaf0e6;
+	magenta: 0xff00ff;
+	maroon: 0x800000;
+	mediumaquamarine: 0x66cdaa;
+	mediumblue: 0x0000cd;
+	mediumorchid: 0xba55d3;
+	mediumpurple: 0x9370db;
+	mediumseagreen: 0x3cb371;
+	mediumslateblue: 0x7b68ee;
+	mediumspringgreen: 0x00fa9a;
+	mediumturquoise: 0x48d1cc;
+	mediumvioletred: 0xc71585;
+	midnightblue: 0x191970;
+	mintcream: 0xf5fffa;
+	mistyrose: 0xffe4e1;
+	moccasin: 0xffe4b5;
+	navajowhite: 0xffdead;
+	navy: 0x000080;
+	oldlace: 0xfdf5e6;
+	olive: 0x808000;
+	olivedrab: 0x6b8e23;
+	orange: 0xffa500;
+	orangered: 0xff4500;
+	orchid: 0xda70d6;
+	palegoldenrod: 0xeee8aa;
+	palegreen: 0x98fb98;
+	paleturquoise: 0xafeeee;
+	palevioletred: 0xdb7093;
+	papayawhip: 0xffefd5;
+	peachpuff: 0xffdab9;
+	peru: 0xcd853f;
+	pink: 0xffc0cb;
+	plum: 0xdda0dd;
+	powderblue: 0xb0e0e6;
+	purple: 0x800080;
+	rebeccapurple: 0x663399;
+	red: 0xff0000;
+	rosybrown: 0xbc8f8f;
+	royalblue: 0x4169e1;
+	saddlebrown: 0x8b4513;
+	salmon: 0xfa8072;
+	sandybrown: 0xf4a460;
+	seagreen: 0x2e8b57;
+	seashell: 0xfff5ee;
+	sienna: 0xa0522d;
+	silver: 0xc0c0c0;
+	skyblue: 0x87ceeb;
+	slateblue: 0x6a5acd;
+	slategray: 0x708090;
+	slategrey: 0x708090;
+	snow: 0xfffafa;
+	springgreen: 0x00ff7f;
+	steelblue: 0x4682b4;
+	tan: 0xd2b48c;
+	teal: 0x008080;
+	thistle: 0xd8bfd8;
+	tomato: 0xff6347;
+	turquoise: 0x40e0d0;
+	violet: 0xee82ee;
+	wheat: 0xf5deb3;
+	white: 0xffffff;
+	whitesmoke: 0xf5f5f5;
+	yellow: 0xffff00;
+	yellowgreen: 0x9acd32;
+};
+
+export type ColorRepresentation = Color | string | number;
+
+export interface HSL {
+	h: number;
+	s: number;
+	l: number;
+}
+
+export interface RGB {
+	r: number;
+	g: number;
+	b: number;
+}
+
+/**
+ * Represents a color. See also {@link ColorUtils}.
+ *
+ * see {@link https://github.com/mrdoob/three.js/blob/master/src/math/Color.js|src/math/Color.js}
+ *
+ * @example
+ * const color = new THREE.Color( 0xff0000 );
+ */
+export class Color {
+	constructor(color?: ColorRepresentation);
+	constructor(r: number, g: number, b: number);
+
+	readonly isColor: true;
+
+	/**
+	 * Red channel value between 0 and 1. Default is 1.
+	 * @default 1
+	 */
+	r: number;
+
+	/**
+	 * Green channel value between 0 and 1. Default is 1.
+	 * @default 1
+	 */
+	g: number;
+
+	/**
+	 * Blue channel value between 0 and 1. Default is 1.
+	 * @default 1
+	 */
+	b: number;
+
+	set(...args: [color: ColorRepresentation] | [r: number, g: number, b: number]): this;
+
+	/**
+	 * Sets this color's {@link r}, {@link g} and {@link b} components from the x, y, and z components of the specified
+	 * {@link Vector3 | vector}.
+	 */
+	setFromVector3(vector: Vector3): this;
+
+	setScalar(scalar: number): Color;
+	setHex(hex: number, colorSpace?: ColorSpace): Color;
+
+	/**
+	 * Sets this color from RGB values.
+	 * @param r Red channel value between 0 and 1.
+	 * @param g Green channel value between 0 and 1.
+	 * @param b Blue channel value between 0 and 1.
+	 */
+	setRGB(r: number, g: number, b: number, colorSpace?: ColorSpace): Color;
+
+	/**
+	 * Sets this color from HSL values.
+	 * Based on MochiKit implementation by Bob Ippolito.
+	 *
+	 * @param h Hue channel value between 0 and 1.
+	 * @param s Saturation value channel between 0 and 1.
+	 * @param l Value channel value between 0 and 1.
+	 */
+	setHSL(h: number, s: number, l: number, colorSpace?: ColorSpace): Color;
+
+	/**
+	 * Sets this color from a CSS context style string.
+	 * @param contextStyle Color in CSS context style format.
+	 */
+	setStyle(style: string, colorSpace?: ColorSpace): Color;
+
+	/**
+	 * Sets this color from a color name.
+	 * Faster than {@link Color#setStyle .setStyle()} method if you don't need the other CSS-style formats.
+	 * @param style Color name in X11 format.
+	 */
+	setColorName(style: string, colorSpace?: ColorSpace): Color;
+
+	/**
+	 * Clones this color.
+	 */
+	clone(): this;
+
+	/**
+	 * Copies given color.
+	 * @param color Color to copy.
+	 */
+	copy(color: Color): this;
+
+	/**
+	 * Copies given color making conversion from sRGB to linear space.
+	 * @param color Color to copy.
+	 */
+	copySRGBToLinear(color: Color): Color;
+
+	/**
+	 * Copies given color making conversion from linear to sRGB space.
+	 * @param color Color to copy.
+	 */
+	copyLinearToSRGB(color: Color): Color;
+
+	/**
+	 * Converts this color from sRGB to linear space.
+	 */
+	convertSRGBToLinear(): Color;
+
+	/**
+	 * Converts this color from linear to sRGB space.
+	 */
+	convertLinearToSRGB(): Color;
+
+	/**
+	 * Returns the hexadecimal value of this color.
+	 */
+	getHex(colorSpace?: ColorSpace): number;
+
+	/**
+	 * Returns the string formated hexadecimal value of this color.
+	 */
+	getHexString(colorSpace?: ColorSpace): string;
+
+	getHSL(target: HSL, colorSpace?: ColorSpace): HSL;
+
+	getRGB(target: RGB, colorSpace?: ColorSpace): RGB;
+
+	/**
+	 * Returns the value of this color in CSS context style.
+	 * Example: rgb(r, g, b)
+	 */
+	getStyle(colorSpace?: ColorSpace): string;
+
+	offsetHSL(h: number, s: number, l: number): this;
+
+	add(color: Color): this;
+	addColors(color1: Color, color2: Color): this;
+	addScalar(s: number): this;
+
+	/**
+	 * Applies the transform {@link Matrix3 | m} to this color's RGB components.
+	 */
+	applyMatrix3(m: Matrix3): this;
+
+	sub(color: Color): this;
+	multiply(color: Color): this;
+	multiplyScalar(s: number): this;
+	lerp(color: Color, alpha: number): this;
+	lerpColors(color1: Color, color2: Color, alpha: number): this;
+	lerpHSL(color: Color, alpha: number): this;
+	equals(color: Color): boolean;
+
+	/**
+	 * Sets this color's red, green and blue value from the provided array or array-like.
+	 * @param array the source array or array-like.
+	 * @param offset (optional) offset into the array-like. Default is 0.
+	 */
+	fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
+
+	/**
+	 * Returns an array [red, green, blue], or copies red, green and blue into the provided array.
+	 * @param array (optional) array to store the color to. If this is not provided, a new array will be created.
+	 * @param offset (optional) optional offset into the array.
+	 * @return The created or provided array.
+	 */
+	toArray(array?: number[], offset?: number): number[];
+
+	/**
+	 * Copies red, green and blue into the provided array-like.
+	 * @param array array-like to store the color to.
+	 * @param offset (optional) optional offset into the array-like.
+	 * @return The provided array-like.
+	 */
+	toArray(xyz: ArrayLike<number>, offset?: number): ArrayLike<number>;
+
+	/**
+	 * This method defines the serialization result of Color.
+	 * @return The color as a hexadecimal value.
+	 */
+	toJSON(): number;
+
+	fromBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, index: number): this;
+
+	[Symbol.iterator](): Generator<number, void>;
+
+	/**
+	 * List of X11 color names.
+	 */
+	static NAMES: typeof _colorKeywords;
+}

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

@@ -0,0 +1,37 @@
+import { ColorSpace, ColorSpacePrimaries, ColorSpaceTransfer, DisplayP3ColorSpace, LinearDisplayP3ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from '../constants.js';
+import { Color } from './Color.js';
+import { Vector3 } from './Vector3.js';
+
+export type WorkingColorSpace = typeof LinearSRGBColorSpace | typeof LinearDisplayP3ColorSpace;
+export type DefinedColorSpace = typeof LinearSRGBColorSpace | typeof SRGBColorSpace | typeof LinearDisplayP3ColorSpace | typeof DisplayP3ColorSpace;
+
+export interface ColorManagement {
+	/**
+	 * @default false
+	 */
+	enabled: boolean;
+
+	/**
+	 * @default LinearSRGBColorSpace
+	 */
+	get workingColorSpace(): WorkingColorSpace;
+	set workingColorSpace(colorSpace: WorkingColorSpace);
+
+	convert: (color: Color, sourceColorSpace: DefinedColorSpace, targetColorSpace: DefinedColorSpace) => Color;
+
+	fromWorkingColorSpace: (color: Color, targetColorSpace: DefinedColorSpace) => Color;
+
+	toWorkingColorSpace: (color: Color, sourceColorSpace: DefinedColorSpace) => Color;
+
+	getPrimaries: (colorSpace: DefinedColorSpace) => ColorSpacePrimaries;
+
+	getTransfer: (colorSpace: ColorSpace) => ColorSpaceTransfer;
+
+	getLuminanceCoefficients: (target: Vector3, colorSpace?: ColorSpace) => Vector3;
+}
+
+export const ColorManagement: ColorManagement;
+
+export function SRGBToLinear(c: number): number;
+
+export function LinearToSRGB(c: number): number;

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

@@ -0,0 +1,26 @@
+import { Vector3 } from './Vector3.js';
+
+export class Cylindrical {
+	constructor(radius?: number, theta?: number, y?: number);
+
+	/**
+	 * @default 1
+	 */
+	radius: number;
+
+	/**
+	 * @default 0
+	 */
+	theta: number;
+
+	/**
+	 * @default 0
+	 */
+	y: number;
+
+	clone(): this;
+	copy(other: Cylindrical): this;
+	set(radius: number, theta: number, y: number): this;
+	setFromVector3(vec3: Vector3): this;
+	setFromCartesianCoords(x: number, y: number, z: number): this;
+}

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

@@ -0,0 +1,50 @@
+import { Matrix4 } from './Matrix4.js';
+import { Quaternion } from './Quaternion.js';
+import { Vector3 } from './Vector3.js';
+
+export type EulerOrder = 'XYZ' | 'YXZ' | 'ZXY' | 'ZYX' | 'YZX' | 'XZY';
+
+export type EulerTuple = [x: number, y: number, z: number, order?: EulerOrder];
+
+export class Euler {
+	constructor(x?: number, y?: number, z?: number, order?: EulerOrder);
+
+	/**
+	 * @default 0
+	 */
+	x: number;
+
+	/**
+	 * @default 0
+	 */
+	y: number;
+
+	/**
+	 * @default 0
+	 */
+	z: number;
+
+	/**
+	 * @default THREE.Euler.DEFAULT_ORDER
+	 */
+	order: EulerOrder;
+	readonly isEuler: true;
+
+	_onChangeCallback: () => void;
+
+	set(x: number, y: number, z: number, order?: EulerOrder): Euler;
+	clone(): this;
+	copy(euler: Euler): this;
+	setFromRotationMatrix(m: Matrix4, order?: EulerOrder, update?: boolean): Euler;
+	setFromQuaternion(q: Quaternion, order?: EulerOrder, update?: boolean): Euler;
+	setFromVector3(v: Vector3, order?: EulerOrder): Euler;
+	reorder(newOrder: EulerOrder): Euler;
+	equals(euler: Euler): boolean;
+	fromArray(array: EulerTuple): Euler;
+	toArray(array?: Partial<EulerTuple>, offset?: number): EulerTuple;
+	_onChange(callback: () => void): this;
+
+	static DEFAULT_ORDER: 'XYZ';
+
+	[Symbol.iterator](): Generator<string | number, void>;
+}

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

@@ -0,0 +1,30 @@
+import { CoordinateSystem } from '../constants.js';
+import { Object3D } from '../core/Object3D.js';
+import { Sprite } from '../objects/Sprite.js';
+import { Box3 } from './Box3.js';
+import { Matrix4 } from './Matrix4.js';
+import { Plane } from './Plane.js';
+import { Sphere } from './Sphere.js';
+import { Vector3 } from './Vector3.js';
+
+/**
+ * Frustums are used to determine what is inside the camera's field of view. They help speed up the rendering process.
+ */
+export class Frustum {
+	constructor(p0?: Plane, p1?: Plane, p2?: Plane, p3?: Plane, p4?: Plane, p5?: Plane);
+
+	/**
+	 * Array of 6 vectors.
+	 */
+	planes: Plane[];
+
+	set(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
+	clone(): this;
+	copy(frustum: Frustum): this;
+	setFromProjectionMatrix(m: Matrix4, coordinateSystem?: CoordinateSystem): this;
+	intersectsObject(object: Object3D): boolean;
+	intersectsSprite(sprite: Sprite): boolean;
+	intersectsSphere(sphere: Sphere): boolean;
+	intersectsBox(box: Box3): boolean;
+	containsPoint(point: Vector3): boolean;
+}

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

@@ -0,0 +1,10 @@
+export abstract class Interpolant {
+	constructor(parameterPositions: any, sampleValues: any, sampleSize: number, resultBuffer?: any);
+
+	parameterPositions: any;
+	sampleValues: any;
+	valueSize: number;
+	resultBuffer: any;
+
+	evaluate(time: number): any;
+}

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

@@ -0,0 +1,29 @@
+import { Matrix4 } from './Matrix4.js';
+import { Vector3 } from './Vector3.js';
+
+export class Line3 {
+	constructor(start?: Vector3, end?: Vector3);
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
+	start: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
+	end: Vector3;
+
+	set(start?: Vector3, end?: Vector3): Line3;
+	clone(): this;
+	copy(line: Line3): this;
+	getCenter(target: Vector3): Vector3;
+	delta(target: Vector3): Vector3;
+	distanceSq(): number;
+	distance(): number;
+	at(t: number, target: Vector3): Vector3;
+	closestPointToPointParameter(point: Vector3, clampToLine?: boolean): number;
+	closestPointToPoint(point: Vector3, clampToLine: boolean, target: Vector3): Vector3;
+	applyMatrix4(matrix: Matrix4): Line3;
+	equals(line: Line3): boolean;
+}

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

@@ -0,0 +1,131 @@
+import { Quaternion } from './Quaternion.js';
+
+/**
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/math/MathUtils.js|src/math/MathUtils.js}
+ */
+
+export const DEG2RAD: number;
+
+export const RAD2DEG: number;
+
+export function generateUUID(): string;
+
+/**
+ * Clamps the x to be between a and b.
+ *
+ * @param value Value to be clamped.
+ * @param min Minimum value.
+ * @param max Maximum value.
+ */
+export function clamp(value: number, min: number, max: number): number;
+
+export function euclideanModulo(n: number, m: number): number;
+
+/**
+ * Linear mapping of x from range [a1, a2] to range [b1, b2].
+ *
+ * @param x Value to be mapped.
+ * @param a1 Minimum value for range A.
+ * @param a2 Maximum value for range A.
+ * @param b1 Minimum value for range B.
+ * @param b2 Maximum value for range B.
+ */
+export function mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number;
+
+export function inverseLerp(x: number, y: number, t: number): number;
+
+/**
+ * Returns a value linearly interpolated from two known points based
+ * on the given interval - t = 0 will return x and t = 1 will return y.
+ *
+ * @param x Start point.
+ * @param y End point.
+ * @param t interpolation factor in the closed interval [0, 1]
+ */
+export function lerp(x: number, y: number, t: number): number;
+
+/**
+ * Smoothly interpolate a number from x toward y in a spring-like
+ * manner using the dt to maintain frame rate independent movement.
+ *
+ * @param x Current point.
+ * @param y Target point.
+ * @param lambda A higher lambda value will make the movement more sudden, and a lower value will make the movement more gradual.
+ * @param dt Delta time in seconds.
+ */
+export function damp(x: number, y: number, lambda: number, dt: number): number;
+
+/**
+ * Returns a value that alternates between 0 and length.
+ *
+ * @param x The value to pingpong.
+ * @param length The positive value the export function will pingpong to. Default is 1.
+ */
+export function pingpong(x: number, length?: number): number;
+
+export function smoothstep(x: number, min: number, max: number): number;
+
+export function smootherstep(x: number, min: number, max: number): number;
+
+/**
+ * Random integer from low to high interval.
+ */
+export function randInt(low: number, high: number): number;
+
+/**
+ * Random float from low to high interval.
+ */
+export function randFloat(low: number, high: number): number;
+
+/**
+ * Random float from - range / 2 to range / 2 interval.
+ */
+export function randFloatSpread(range: number): number;
+
+/**
+ * Deterministic pseudo-random float in the interval [ 0, 1 ].
+ */
+export function seededRandom(seed?: number): number;
+
+export function degToRad(degrees: number): number;
+
+export function radToDeg(radians: number): number;
+
+export function isPowerOfTwo(value: number): boolean;
+
+export function ceilPowerOfTwo(value: number): number;
+
+export function floorPowerOfTwo(value: number): number;
+
+export function setQuaternionFromProperEuler(q: Quaternion, a: number, b: number, c: number, order: string): void;
+
+export function denormalize(value: number, array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array): number;
+
+export function normalize(value: number, array: Float32Array | Uint32Array | Uint16Array | Uint8Array | Int32Array | Int16Array | Int8Array): number;
+
+export const MathUtils: {
+	DEG2RAD: typeof DEG2RAD;
+	RAD2DEG: typeof RAD2DEG;
+	generateUUID: typeof generateUUID;
+	clamp: typeof clamp;
+	euclideanModulo: typeof euclideanModulo;
+	mapLinear: typeof mapLinear;
+	inverseLerp: typeof inverseLerp;
+	lerp: typeof lerp;
+	damp: typeof damp;
+	pingpong: typeof pingpong;
+	smoothstep: typeof smoothstep;
+	smootherstep: typeof smootherstep;
+	randInt: typeof randInt;
+	randFloat: typeof randFloat;
+	randFloatSpread: typeof randFloatSpread;
+	seededRandom: typeof seededRandom;
+	degToRad: typeof degToRad;
+	radToDeg: typeof radToDeg;
+	isPowerOfTwo: typeof isPowerOfTwo;
+	ceilPowerOfTwo: typeof ceilPowerOfTwo;
+	floorPowerOfTwo: typeof floorPowerOfTwo;
+	setQuaternionFromProperEuler: typeof setQuaternionFromProperEuler;
+	normalize: typeof normalize;
+	denormalize: typeof denormalize;
+};