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

package/three/src/loaders/LoadingManager.d.ts

@@ -0,0 +1,69 @@
+import { Loader } from "./Loader.js";
+
+export const DefaultLoadingManager: LoadingManager;
+
+/**
+ * Handles and keeps track of loaded and pending data.
+ */
+export class LoadingManager {
+    constructor(
+        onLoad?: () => void,
+        onProgress?: (url: string, loaded: number, total: number) => void,
+        onError?: (url: string) => void,
+    );
+
+    /**
+     * Will be called when loading of an item starts.
+     * @param url The url of the item that started loading.
+     * @param loaded The number of items already loaded so far.
+     * @param total The total amount of items to be loaded.
+     */
+    onStart?: ((url: string, loaded: number, total: number) => void) | undefined;
+
+    /**
+     * Will be called when all items finish loading.
+     * The default is a function with empty body.
+     */
+    onLoad: () => void;
+
+    /**
+     * Will be called for each loaded item.
+     * The default is a function with empty body.
+     * @param url The url of the item just loaded.
+     * @param loaded The number of items already loaded so far.
+     * @param total The total amount of items to be loaded.
+     */
+    onProgress: (url: string, loaded: number, total: number) => void;
+
+    /**
+     * Will be called when item loading fails.
+     * The default is a function with empty body.
+     * @param url The url of the item that errored.
+     */
+    onError: (url: string) => void;
+
+    /**
+     * If provided, the callback will be passed each resource URL before a request is sent.
+     * The callback may return the original URL, or a new URL to override loading behavior.
+     * This behavior can be used to load assets from .ZIP files, drag-and-drop APIs, and Data URIs.
+     * @param callback URL modifier callback. Called with url argument, and must return resolvedURL.
+     */
+    setURLModifier(callback?: (url: string) => string): this;
+
+    /**
+     * Given a URL, uses the URL modifier callback (if any) and returns a resolved URL.
+     * If no URL modifier is set, returns the original URL.
+     * @param url the url to load
+     */
+    resolveURL(url: string): string;
+
+    itemStart(url: string): void;
+    itemEnd(url: string): void;
+    itemError(url: string): void;
+
+    // handlers
+
+    addHandler(regex: RegExp, loader: Loader): this;
+    removeHandler(regex: RegExp): this;
+    getHandler(file: string): Loader | null;
+}

package/three/src/loaders/MaterialLoader.d.ts

@@ -0,0 +1,19 @@
+import { Material } from "../materials/Material.js";
+import { Texture } from "../textures/Texture.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class MaterialLoader extends Loader<Material> {
+    /**
+     * @default {}
+     */
+    textures: { [key: string]: Texture };
+
+    constructor(manager?: LoadingManager);
+
+    parse(json: unknown): Material;
+
+    setTextures(textures: { [key: string]: Texture }): this;
+
+    static createMaterialFromType(type: string): Material;
+}

package/three/src/loaders/ObjectLoader.d.ts

@@ -0,0 +1,35 @@
+import { AnimationClip } from "../animation/AnimationClip.js";
+import { BufferGeometry } from "../core/BufferGeometry.js";
+import { InstancedBufferGeometry } from "../core/InstancedBufferGeometry.js";
+import { Object3D } from "../core/Object3D.js";
+import { Material } from "../materials/Material.js";
+import { Source } from "../textures/Source.js";
+import { Texture } from "../textures/Texture.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+export class ObjectLoader extends Loader<Object3D> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: Object3D) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+
+    parse(json: unknown, onLoad?: (object: Object3D) => void): Object3D;
+    parseAsync(json: unknown): Promise<Object3D>;
+    parseGeometries(json: unknown): { [key: string]: InstancedBufferGeometry | BufferGeometry };
+    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
+    parseAnimations(json: unknown): { [key: string]: AnimationClip };
+    parseImages(json: unknown, onLoad?: () => void): { [key: string]: Source };
+    parseImagesAsync(json: unknown): Promise<{ [key: string]: Source }>;
+    parseTextures(json: unknown, images: { [key: string]: Source }): { [key: string]: Texture };
+    parseObject(
+        data: unknown,
+        geometries: { [key: string]: InstancedBufferGeometry | BufferGeometry },
+        materials: { [key: string]: Material },
+        animations: { [key: string]: AnimationClip },
+    ): Object3D;
+}

package/three/src/loaders/TextureLoader.d.ts

@@ -0,0 +1,18 @@
+import { Texture } from "../textures/Texture.js";
+import { Loader } from "./Loader.js";
+import { LoadingManager } from "./LoadingManager.js";
+
+/**
+ * Class for loading a texture.
+ * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
+ */
+export class TextureLoader extends Loader<Texture> {
+    constructor(manager?: LoadingManager);
+
+    load(
+        url: string,
+        onLoad?: (data: Texture) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): Texture;
+}

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

@@ -0,0 +1,60 @@
+import { Color, ColorRepresentation } from "../math/Color.js";
+import { Texture } from "../textures/Texture.js";
+import { Material, MaterialParameters } from "./Material.js";
+
+export interface LineBasicMaterialParameters extends MaterialParameters {
+    color?: ColorRepresentation | undefined;
+    fog?: boolean | undefined;
+    linewidth?: number | undefined;
+    linecap?: string | undefined;
+    linejoin?: string | undefined;
+}
+
+export class LineBasicMaterial extends Material {
+    constructor(parameters?: LineBasicMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link LineBasicMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLineBasicMaterial: true;
+
+    /**
+     * @default 'LineBasicMaterial'
+     */
+    type: string;
+
+    /**
+     * @default 0xffffff
+     */
+    color: Color;
+
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default true
+     */
+    fog: boolean;
+
+    /**
+     * @default 1
+     */
+    linewidth: number;
+
+    /**
+     * @default 'round'
+     */
+    linecap: string;
+
+    /**
+     * @default 'round'
+     */
+    linejoin: string;
+
+    /**
+     * Sets the color of the lines using data from a {@link Texture}.
+     */
+    map: Texture | null;
+
+    setValues(parameters: LineBasicMaterialParameters): void;
+}

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

@@ -0,0 +1,40 @@
+import { LineBasicMaterial, LineBasicMaterialParameters } from "./LineBasicMaterial.js";
+
+export interface LineDashedMaterialParameters extends LineBasicMaterialParameters {
+    scale?: number | undefined;
+    dashSize?: number | undefined;
+    gapSize?: number | undefined;
+}
+
+export class LineDashedMaterial extends LineBasicMaterial {
+    constructor(parameters?: LineDashedMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link LineDashedMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isLineDashedMaterial: true;
+
+    /**
+     * @default 'LineDashedMaterial'
+     */
+    type: string;
+
+    /**
+     * @default 1
+     */
+    scale: number;
+
+    /**
+     * @default 1
+     */
+    dashSize: number;
+
+    /**
+     * @default 1
+     */
+    gapSize: number;
+
+    setValues(parameters: LineDashedMaterialParameters): void;
+}