u-space 0.0.0-alpha.1

package/dist/plugins/u-manager/license/decryptUtils.d.ts

@@ -0,0 +1,5 @@
+import type { ILicense, ITreeData } from '../types';
+export declare function decryptWithDebugKey(license: ILicense): ITreeData[];
+export declare function decryptWithKey(license: ILicense, key: string): ITreeData[];
+export declare function decodeToBytes(input: string): Int8Array<ArrayBuffer>;
+export declare function decodeString(encodedStr: string): string;

package/dist/plugins/u-manager/loaders/AnimationsLoader.d.ts

@@ -0,0 +1,59 @@
+import { EventDispatcher, Loader, type Object3D } from 'three/webgpu';
+import { type AnimationModeType, type Tween, type Viewer } from 'u-space';
+export declare class AnimationsLoader extends Loader {
+    constructor();
+    loadAsync(): Promise<IAnimations[]>;
+}
+export interface IKeyframe {
+    id: string;
+    uuid: string;
+    x: number;
+    y: number;
+    z: number;
+    scaleX: number;
+    scaleY: number;
+    scaleZ: number;
+    rotationX: number;
+    rotationY: number;
+    rotationZ: number;
+    easing: AnimationModeType;
+    mode: string;
+    delay: number;
+    duration: number;
+    repeat: number;
+    yoyo: boolean;
+}
+/**
+ * 动画
+ */
+export interface IAnimations {
+    id: string;
+    sid: string;
+    modelId: string;
+    name: string;
+    keyframes: IKeyframe[];
+}
+export declare class AnimationsParser extends EventDispatcher<TAnimationsPlayerEventMap> {
+    viewer: Viewer;
+    target: Object3D;
+    tweenSet: Set<TTweenType>;
+    _initialTransformSymbol: symbol;
+    constructor(viewer: Viewer, target: Object3D);
+    initTransform(defaultTransform?: TTweenSource): TTweenSource;
+    getInitialTransform(): TTweenSource | undefined;
+    play(frames: IKeyframe[]): Promise<void>;
+    stop(): void;
+    reset(): void;
+    dispose(): void;
+}
+export type TTweenSource = Pick<IKeyframe, 'x' | 'y' | 'z' | 'rotationX' | 'rotationY' | 'rotationZ' | 'scaleX' | 'scaleY' | 'scaleZ'>;
+export type TTweenType = Tween<TTweenSource>;
+export type TAnimationsPlayerEventMap = {
+    update: {
+        source: TTweenSource;
+        tween: TTweenType;
+    };
+    start: {
+        tween: TTweenType;
+    };
+};

package/dist/plugins/u-manager/loaders/BaseFileLoader.d.ts

@@ -0,0 +1,5 @@
+import { FileLoader as FileLoaderClass, Loader } from 'three/webgpu';
+export declare class BaseFileLoader extends FileLoaderClass {
+    constructor(loader: Loader<any, any>);
+    loadAsync<T = any>(url: string): Promise<T>;
+}

package/dist/plugins/u-manager/loaders/PropertiesLoader.d.ts

@@ -0,0 +1,12 @@
+import { Loader } from 'three/webgpu';
+export declare class PropertiesLoader extends Loader {
+    constructor();
+    loadAsync(): Promise<IProperties[]>;
+}
+export interface IProperties {
+    modelId: string;
+    group: string;
+    key: string;
+    value: string | null;
+    label: string | null;
+}

package/dist/plugins/u-manager/loaders/SceneLoader.d.ts

@@ -0,0 +1,15 @@
+import { Group, Loader } from 'three/webgpu';
+import { type Viewer } from 'u-space';
+export interface SceneLoaderOptions {
+}
+export declare class SceneLoader extends Loader<unknown, SceneLoaderOptions> {
+    #private;
+    viewer: Viewer;
+    key: string;
+    cachedIds: Set<string>;
+    constructor(viewer: Viewer);
+    setKey(key: string): this;
+    loadAsync(options?: SceneLoaderOptions): Promise<Group<import("three").Object3DEventMap>>;
+    clearCache(): void;
+    dispose(): void;
+}

package/dist/plugins/u-manager/loaders/TopologiesLoader.d.ts

@@ -0,0 +1,10 @@
+import { Loader } from 'three/webgpu';
+import { Topology } from 'u-space';
+import type { ITopologyPath } from '../types';
+export declare class TopologyParser {
+    parse(data: ITopologyPath): Topology;
+}
+export declare class TopologiesLoader extends Loader {
+    constructor();
+    loadAsync(): Promise<Topology[]>;
+}

package/dist/plugins/u-manager/loaders/VisionsLoader.d.ts

@@ -0,0 +1,26 @@
+import { Loader } from 'three/webgpu';
+import type { IVector3, Viewer } from 'u-space';
+export declare class VisionsLoader extends Loader {
+    constructor();
+    loadAsync(): Promise<IVisionsData>;
+}
+export declare class VisionsParser {
+    viewer: Viewer;
+    constructor(viewer: Viewer);
+    flyToPrimary(visions: IVisions[], enableTransition?: boolean): Promise<boolean>;
+    flyTo(vision: IVisions, enableTransition?: boolean): Promise<void>;
+}
+export interface IVisions {
+    id: string;
+    uuid: string;
+    nodeId: string;
+    name: string;
+    code?: any;
+    camera: 'O' | 'P';
+    position: IVector3;
+    rotation: IVector3;
+    target: IVector3;
+    zoom: number;
+    primary: boolean;
+}
+export type IVisionsData = Record<string, IVisions[]>;

package/dist/plugins/u-manager/types.d.ts

@@ -0,0 +1,84 @@
+import { type IVector3 } from 'u-space';
+export interface IMetadata {
+    platformVersion: number;
+    version: number;
+    name: string;
+    projectId: string;
+    sceneId: string;
+    cover: string | null;
+    flatModel: string;
+    treeModel: string;
+    resource: string;
+    exportTime: number;
+    authority: 'TRIAL' | 'OFFICIAL';
+    encryptWith: 'DEBUG' | 'SCENE' | 'COMPANY' | null;
+    environment: string | null;
+    previewSettings: string | null;
+    gisSettings: IGisSettings | null;
+}
+export interface IGisSettings {
+    enabled: boolean;
+    longitude: number;
+    latitude: number;
+    altitude: number;
+}
+export interface ITreeData {
+    id: string;
+    pid: string | null;
+    sid: string;
+    name: string;
+    path: string | null;
+    renderType: 'GROUP' | '3D' | 'STUB' | 'POLYGON' | 'CIRCLE' | 'WATER_SURFACE' | 'DECAL' | 'AREA' | 'FLOOR' | 'ROOM' | 'GS';
+    deviceCode: string | null;
+    matrix: number[];
+    familyId: string | null;
+    children: ITreeData[];
+    visible: boolean;
+    shape?: {
+        height?: number;
+        radius?: number;
+        depth?: number;
+        points?: IVector3[];
+    };
+    boundingBox?: number[];
+    extra?: {
+        [key: string]: any;
+    };
+}
+export interface ILicense {
+    sign: string;
+    content: string;
+    version: number;
+}
+export interface ITopologyPath {
+    id: string;
+    name: string;
+    position: IVector3;
+    rotation: IVector3;
+    scale: IVector3;
+    nodes: ITopologyNode[];
+    type: 'network';
+    linkWidth?: number;
+    linkColor?: [string];
+    nodeRadius?: number;
+    nodeColor?: string;
+    imgUrl?: string;
+    animation?: {
+        duration: 0;
+    };
+}
+export interface ITopologyNode {
+    id: string;
+    name: string;
+    position: IVector3;
+    graphs: ITopologyNodeGraph[];
+}
+export interface ITopologyNodeGraph {
+    linkInfo: ITopologyEdge;
+    targetNodeId: string;
+    passable: 0 | 1 | 2 | 3;
+}
+export interface ITopologyEdge {
+    id: string;
+    name: string;
+}

package/dist/src/animations/Tween.d.ts

@@ -0,0 +1,20 @@
+import { Tween as TweenBase } from 'three/addons/libs/tween.module.js';
+import type { Viewer, ViewerEventMap } from '../viewers';
+declare class Tween<PropType extends Record<string, any>> extends TweenBase<PropType> {
+    viewer: Viewer;
+    constructor(viewer: Viewer, source: PropType);
+    _update: ({ time }: ViewerEventMap["afterControlsUpdate"]) => void;
+    easingByMode(mode: AnimationModeType): this;
+    start(time?: number, overrideStartingValues?: boolean): this;
+    stop(): this;
+}
+declare function tweenAnimation<PropType extends Record<string, any>>(viewer: Viewer, source: PropType, target: PropType, options?: AnimationOptions, onUpdate?: (source: PropType, tween: Tween<PropType>) => void, onStart?: (tween: Tween<PropType>) => void): Promise<void>;
+export { Tween, tweenAnimation };
+export type AnimationModeType = 'Linear.None' | 'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' | 'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' | 'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' | 'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' | 'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' | 'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' | 'Circular.In' | 'Circular.Out' | 'Circular.InOut' | 'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' | 'Back.In' | 'Back.Out' | 'Back.InOut' | 'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut';
+export interface AnimationOptions {
+    duration?: number;
+    delay?: number;
+    repeat?: number | boolean;
+    mode?: AnimationModeType;
+    yoyo?: boolean;
+}

package/dist/src/animations/index.d.ts

@@ -0,0 +1 @@
+export * from './Tween';

package/dist/src/effects/MaterialEffects.d.ts

@@ -0,0 +1,10 @@
+import { type Object3D, type ColorRepresentation } from 'three/webgpu';
+export interface HighlightOptions {
+    enabled?: boolean;
+    opacity?: number;
+    color?: ColorRepresentation;
+    overwrite?: boolean;
+}
+export declare class MaterialEffects {
+    static highlight(object: Object3D, options?: HighlightOptions): void;
+}

package/dist/src/effects/TSLEffects.d.ts

@@ -0,0 +1,24 @@
+import { type ColorRepresentation } from 'three';
+export declare class TSLEffects {
+    static flow(parameters?: {
+        baseColor?: ColorRepresentation;
+        flowColor?: ColorRepresentation;
+        speed?: number;
+        scale?: number;
+        intensity?: number;
+    }): import("three/webgpu").Node<"vec3">;
+    static breathe(parameters?: {
+        baseColor?: ColorRepresentation;
+        breathColor?: ColorRepresentation;
+        speed?: number;
+        intensity?: number;
+    }): import("three/webgpu").Node<"vec3">;
+    static fluid(parameters?: {
+        baseColor?: ColorRepresentation;
+        flowColor?: ColorRepresentation;
+        speed?: number;
+        scale?: number;
+        intensity?: number;
+        distortion?: number;
+    }): import("three/webgpu").Node<"vec3">;
+}

package/dist/src/effects/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TSLEffects';
+export * from './MaterialEffects';

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './viewers';
+export * from './loaders';
+export * from './interactions';
+export * from './managers';
+export * from './objects';
+export * from './effects';
+export * from './animations';
+export * from './interfaces';
+export * from './types';

package/dist/src/interactions/InteractionEvent.d.ts

@@ -0,0 +1,39 @@
+import type { Object3D, Intersection, Object3DEventMap } from 'three/webgpu';
+export type InteractionEventType = 'click' | 'dblclick' | 'contextmenu' | 'pointerdown' | 'pointerup' | 'pointermove' | 'pointerenter' | 'pointerleave';
+export interface InteractionEventParameters {
+    type: InteractionEventType;
+    target: Object3D<InteractionEventMap>;
+    intersect: Intersection<Object3D<InteractionEventMap>> | null;
+    originalEvent: PointerEvent | MouseEvent;
+}
+export type InteractionEventMap = Object3DEventMap & {
+    [K in InteractionEventType]: {
+        event: InteractionEvent;
+    };
+};
+/**
+ * Custom event class for 3D object interactions.
+ * Supports event bubbling via `stopPropagation()`.
+ */
+export declare class InteractionEvent {
+    /** The type of event (e.g., 'click', 'pointerdown'). */
+    readonly type: InteractionEventType;
+    /** The original 3D object that triggered the event. */
+    readonly target: Object3D<InteractionEventMap>;
+    /** The current 3D object during the bubbling phase. */
+    currentTarget: Object3D<InteractionEventMap>;
+    /** The intersection data from raycasting, or null if not applicable. */
+    readonly intersect: Intersection | null;
+    /** The original DOM event, or undefined if not applicable. */
+    readonly originalEvent: PointerEvent | MouseEvent;
+    private _propagationStopped;
+    constructor(init: InteractionEventParameters);
+    /**
+     * Stops the event from bubbling up the parent chain.
+     */
+    stopPropagation(): void;
+    /**
+     * Returns true if `stopPropagation()` has been called.
+     */
+    get propagationStopped(): boolean;
+}

package/dist/src/interactions/InteractionManager.d.ts

@@ -0,0 +1,55 @@
+import { type Object3D, type Scene, type Camera } from 'three/webgpu';
+import { type InteractionEventMap } from './InteractionEvent';
+/**
+ * Manages pointer interactions with 3D objects in the scene.
+ * Handles raycasting and event dispatching with bubbling support.
+ */
+export declare class InteractionManager {
+    private domElement;
+    private scene;
+    private camera;
+    private raycaster;
+    private pointer;
+    private hoveredObject;
+    private pointerDownTime;
+    private pointerDownPos;
+    private clickTimer;
+    private longPressThreshold;
+    private moveThreshold;
+    /**
+     * The objects to check for intersections.
+     * If not set, it defaults to the children of the scene.
+     */
+    targetObjects: Object3D<InteractionEventMap>[] | null;
+    /**
+     * Whether to enable pointer move events (pointermove, pointerenter, pointerleave).
+     * Disabled by default for performance optimization.
+     */
+    pointerMoveEventsEnabled: boolean;
+    constructor(domElement: HTMLElement, scene: Scene, camera: Camera);
+    /**
+     * Updates the camera reference (useful when switching cameras).
+     */
+    setCamera(camera: Camera): void;
+    private _bindEvents;
+    private _updatePointer;
+    private _getIntersects;
+    /**
+     * Dispatches an event to the target object and bubbles up the parent chain.
+     */
+    private _dispatchToTarget;
+    /**
+     * Handles a DOM event by raycasting and dispatching to the first intersected object.
+     */
+    private _handleEvent;
+    private _onClick;
+    private _onDblClick;
+    private _onContextMenu;
+    private _onPointerDown;
+    private _onPointerUp;
+    private _onPointerMove;
+    /**
+     * Cleans up event listeners.
+     */
+    dispose(): void;
+}

package/dist/src/interactions/index.d.ts

@@ -0,0 +1,2 @@
+export * from './InteractionEvent';
+export * from './InteractionManager';

package/dist/src/interfaces/base.d.ts

@@ -0,0 +1,11 @@
+export interface IPlaneVector2 {
+    x: number;
+    z: number;
+}
+export interface IVector2 {
+    x: number;
+    y: number;
+}
+export interface IVector3 extends IVector2 {
+    z: number;
+}

package/dist/src/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './base';

package/dist/src/loaders/ModelLoaderManager.d.ts

@@ -0,0 +1,40 @@
+import { FileLoader, type Object3D, type WebGPURenderer, type LoadingManager } from 'three/webgpu';
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+import { FBXLoader } from 'three/addons/loaders/FBXLoader.js';
+import { OBJLoader } from 'three/addons/loaders/OBJLoader.js';
+import { STLLoader } from 'three/addons/loaders/STLLoader.js';
+import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
+import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';
+import { SBMXLoader } from './SBMXLoader';
+import { SBMLoader } from './SBMLoader';
+import type { InteractionEventMap } from '../interactions';
+export interface LoadParameters {
+    persistent?: boolean;
+}
+export declare class ModelLoaderManager {
+    private static CACHE_NAME;
+    static fileLoader: FileLoader;
+    static dracoLoader: DRACOLoader;
+    static ktx2Loader: KTX2Loader;
+    static gltfLoader: GLTFLoader;
+    static sbmxLoader: SBMXLoader;
+    static sbmLoader: SBMLoader;
+    static fbxLoader: FBXLoader;
+    static objLoader: OBJLoader;
+    static stlLoader: STLLoader;
+    static setLoadingManager(loadingManager: LoadingManager): void;
+    /**
+     * Set the renderer to enable KTX2 support and other renderer-dependent features.
+     */
+    static setRenderer(renderer: WebGPURenderer): Promise<void>;
+    /**
+     * Configure Draco decoder path.
+     */
+    static setDracoPath(path: string): void;
+    /**
+     * Configure KTX2 transcoder path.
+     */
+    static setKTX2Path(path: string): void;
+    static loadAsync(url: string, parameters?: LoadParameters): Promise<Object3D<InteractionEventMap>>;
+    private static getPersistentData;
+}

package/dist/src/loaders/SBMLoader.d.ts

@@ -0,0 +1,6 @@
+import { Group, Loader } from 'three/webgpu';
+export declare class SBMLoader extends Loader<Group, string> {
+    load(url: string, onLoad: (sbm: Group) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+    parse(data: ArrayBuffer, path: string, onLoad: (sbm: Group) => void, onError?: (err: unknown) => void): void;
+    parseAsync(data: ArrayBuffer | string, path: string): Promise<Group>;
+}

package/dist/src/loaders/SBMUtils.d.ts

@@ -0,0 +1,5 @@
+import { MeshStandardNodeMaterial } from 'three/webgpu';
+export declare function decodeSbk(buffer: ArrayBuffer): ArrayBuffer | undefined;
+export declare const getTextureName: (dataView: DataView, texnamelen: number, offset: number) => string;
+export declare const generateSbmMaterial: (materialId: string, arr: number[], png: boolean) => MeshStandardNodeMaterial;
+export declare const isPNG: (textureUrl?: string) => boolean;

package/dist/src/loaders/SBMXLoader.d.ts

@@ -0,0 +1,6 @@
+import type { LoadingManager } from 'three/webgpu';
+import { GLTFLoader, type GLTF } from 'three/addons/loaders/GLTFLoader.js';
+export declare class SBMXLoader extends GLTFLoader {
+    constructor(manager?: LoadingManager);
+    parse(data: ArrayBuffer, path: string, onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void;
+}

package/dist/src/loaders/TextureLoaderManager.d.ts

@@ -0,0 +1,11 @@
+import { TextureLoader, CubeTextureLoader, type LoadingManager } from 'three/webgpu';
+import { HDRLoader } from 'three/addons/loaders/HDRLoader.js';
+export declare class TextureLoaderManager {
+    static textureLoader: TextureLoader;
+    static hdrLoader: HDRLoader;
+    static cubeTextureLoader: CubeTextureLoader;
+    static setLoadingManager(loadingManager: LoadingManager): void;
+    static loadAsyncTexture(url: string): Promise<import("three").Texture<HTMLImageElement>>;
+    static loadAsyncHDR(url: string): Promise<import("three").DataTexture>;
+    static loadAsyncCubeTexture(path: string, urls: string[]): Promise<import("three").CubeTexture<unknown>>;
+}

package/dist/src/loaders/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ModelLoaderManager';
+export * from './TextureLoaderManager';
+export * from './SBMLoader';
+export * from './SBMXLoader';

package/dist/src/managers/ObjectManager.d.ts

@@ -0,0 +1,60 @@
+import type { Object3D } from 'three/webgpu';
+/**
+ * Manages 3D objects with custom id and name caching for quick retrieval.
+ */
+export declare class ObjectManager {
+    private idMap;
+    private nameMap;
+    private typeMap;
+    private objectIds;
+    private allObjects;
+    /**
+     * Add an object with a custom id.
+     * One object can have multiple ids.
+     */
+    add(id: string, object: Object3D): void;
+    /**
+     * Get an object by its custom id.
+     */
+    getById<T extends Object3D>(id: string): T | undefined;
+    /**
+     * Get all objects with a given name.
+     */
+    getByName<T extends Object3D>(name: string): Set<T>;
+    /**
+     * Get all objects with a given type.
+     */
+    getByType<T extends Object3D>(type: string): Set<T>;
+    /**
+     * Get all ids associated with an object.
+     */
+    getObjectIds(object: Object3D): Set<string>;
+    /**
+     * Remove an object and all its associated ids.
+     */
+    remove(object: Object3D): void;
+    /**
+     * Remove an object by its id.
+     */
+    removeById(id: string): void;
+    /**
+     * Remove all objects with a given name.
+     */
+    removeByName(name: string): void;
+    /**
+     * Remove all objects with a given type.
+     */
+    removeByType(type: string): void;
+    /**
+     * Clear all cached objects.
+     */
+    clear(): void;
+    /**
+     * Get all cached objects as a Set.
+     */
+    getAll<T extends Object3D>(): Set<T>;
+    /**
+     * Get the number of unique cached objects.
+     */
+    get size(): number;
+}

package/dist/src/managers/index.d.ts

@@ -0,0 +1 @@
+export * from './ObjectManager';

package/dist/src/objects/BaseGroup.d.ts

@@ -0,0 +1,8 @@
+import { type Raycaster, type Intersection, type Object3DEventMap, Group } from 'three/webgpu';
+export declare class BaseGroup<TEventMap extends Object3DEventMap = Object3DEventMap> extends Group<TEventMap> {
+    readonly isBaseGroup = true;
+    type: string;
+    ignoreInvisibleWhenRaycast: boolean;
+    constructor(...args: ConstructorParameters<typeof Group<TEventMap>>);
+    raycast(raycaster: Raycaster, intersects: Intersection[]): boolean | void;
+}

package/dist/src/objects/BaseMesh.d.ts

@@ -0,0 +1,8 @@
+import { type BufferGeometry, type Intersection, type Material, type Object3DEventMap, type Raycaster, Mesh } from 'three/webgpu';
+export declare class BaseMesh<TGeometry extends BufferGeometry = BufferGeometry, TMaterial extends Material | Material[] = Material | Material[], TEventMap extends Object3DEventMap = Object3DEventMap> extends Mesh<TGeometry, TMaterial, TEventMap> {
+    readonly isBaseMesh = true;
+    type: string;
+    ignoreInvisibleWhenRaycast: boolean;
+    constructor(...args: ConstructorParameters<typeof Mesh<TGeometry, TMaterial, TEventMap>>);
+    raycast(raycaster: Raycaster, intersects: Intersection[]): boolean | void;
+}

package/dist/src/objects/BaseSprite.d.ts

@@ -0,0 +1,8 @@
+import { type Raycaster, type Intersection, type Object3DEventMap, Sprite } from 'three/webgpu';
+export declare class BaseSprite<TEventMap extends Object3DEventMap = Object3DEventMap> extends Sprite<TEventMap> {
+    readonly isBaseSprite = true;
+    type: string;
+    ignoreInvisibleWhenRaycast: boolean;
+    constructor(...args: ConstructorParameters<typeof Sprite<TEventMap>>);
+    raycast(raycaster: Raycaster, intersects: Intersection[]): boolean | void;
+}

package/dist/src/objects/CircleMesh.d.ts

@@ -0,0 +1,17 @@
+import { CircleGeometry, MeshStandardNodeMaterial, type MeshStandardNodeMaterialParameters } from 'three/webgpu';
+import type { InteractionEventMap } from '../interactions';
+import { BaseMesh } from './BaseMesh';
+export interface CircleMeshParameters {
+    geometryParameters?: {
+        radius?: number;
+        segments?: number;
+        thetaStart?: number;
+        thetaLength?: number;
+    };
+    materialParameters?: MeshStandardNodeMaterialParameters;
+}
+export declare class CircleMesh extends BaseMesh<CircleGeometry, MeshStandardNodeMaterial, InteractionEventMap> {
+    readonly isCircleMesh = true;
+    type: string;
+    constructor({ geometryParameters, materialParameters }?: CircleMeshParameters);
+}

package/dist/src/objects/ExtrudeMesh.d.ts

@@ -0,0 +1,17 @@
+import { ExtrudeGeometry, MeshStandardNodeMaterial, Shape, type ExtrudeGeometryOptions, type MeshStandardNodeMaterialParameters } from 'three/webgpu';
+import type { InteractionEventMap } from '../interactions';
+import type { IPlaneVector2 } from '../interfaces';
+import { BaseMesh } from './BaseMesh';
+export interface ExtrudeMeshParameters {
+    geometryParameters?: {
+        shape?: Shape | Shape[];
+        options?: ExtrudeGeometryOptions;
+    };
+    materialParameters?: MeshStandardNodeMaterialParameters;
+}
+export declare class ExtrudeMesh extends BaseMesh<ExtrudeGeometry, MeshStandardNodeMaterial, InteractionEventMap> {
+    readonly isExtrudeMesh = true;
+    type: string;
+    constructor({ geometryParameters, materialParameters }?: ExtrudeMeshParameters);
+    static createFromPoints(points: IPlaneVector2[], parameters?: ExtrudeMeshParameters): ExtrudeMesh;
+}

package/dist/src/objects/Model.d.ts

@@ -0,0 +1,17 @@
+import { type Object3D } from 'three/webgpu';
+import { type InteractionEventMap } from '../interactions';
+import { BaseGroup } from './BaseGroup';
+export interface ModelParameters {
+    url: string;
+    cache?: boolean;
+    persistent?: boolean;
+}
+export declare class Model extends BaseGroup<InteractionEventMap> {
+    readonly isModel = true;
+    type: string;
+    private static memoryCache;
+    constructor();
+    loadAsync(parameters: ModelParameters): Promise<Object3D<import("three").Object3DEventMap> | null>;
+    static clearMemoryCache(): void;
+    static clearPersistentCache(): Promise<void>;
+}

package/dist/src/objects/ObjectUtils.d.ts

@@ -0,0 +1,4 @@
+import { type Object3D, type Object3DEventMap, type Material, type BufferGeometry, Mesh } from 'three/webgpu';
+export declare class ObjectUtils {
+    static traverseMeshes<TGeometry extends BufferGeometry, TMaterial extends Material, TEventMap extends Object3DEventMap>(object: Object3D, callback: (object: Mesh<TGeometry, TMaterial, TEventMap>) => void): void;
+}