@pacem/pacem-3d 1.0.0-abel

package/typings/index.d.ts

@@ -0,0 +1,1084 @@
+import { Behaviors } from '@pacem/pacem-core';
+import { Components as Components_2 } from '@pacem/pacem-core';
+import { CustomUIEvent } from '@pacem/pacem-core';
+import { EventKeyModifier } from '@pacem/pacem-core';
+import { Geometry } from '@pacem/pacem-numerical';
+import { ItemsContainer } from '@pacem/pacem-core';
+import { PacemEventTarget } from '@pacem/pacem-core';
+import { Point } from '@pacem/pacem-foundation';
+import { PropertyConverter } from '@pacem/pacem-core';
+import { Rect } from '@pacem/pacem-foundation';
+import { Rgba } from '@pacem/pacem-foundation';
+import { Size } from '@pacem/pacem-foundation';
+
+declare class AdapterUtils {
+    static isMeshGeometry(obj: any): obj is MeshGeometry;
+    static isVector3D(obj: any): obj is Vector3D;
+    static isRgba(obj: any): obj is Rgba;
+    static flattenVectorArray(array: Vector3D[] | UVMap | Rgba[]): number[];
+    static findCamera(items: Renderable[]): Camera;
+    clipPixel(viewportPoint: Point): Point;
+    clipPixel(evt: PointerEventLike, canvas: HTMLCanvasElement): Point;
+    clipPixel(evt: PointerEventLike, viewport: Rect): Point;
+}
+
+declare interface BasicMaterial extends Material {
+    readonly shader: KnownShader.Basic;
+}
+
+declare class BasicMaterialElement extends MaterialElement {
+    constructor();
+}
+
+declare const BooleanOrNumberConverter: PropertyConverter;
+
+declare interface Box3D {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+}
+
+declare interface Camera extends Renderable {
+    /** Target in world coordinates. */
+    lookAt: Vector3D;
+    /** Up vector in world coordinates. */
+    up: Vector3D;
+    near: number;
+    far: number;
+}
+
+export declare namespace Components {
+    export {
+        Drawing3D_2 as Drawing3D
+    }
+}
+
+/**
+ * Computes the unit vector orthogonal to the plane identified by 3 points.
+ * @param a
+ * @param b
+ * @param c
+ */
+declare function computePlaneNormal(a: Vector3D, b: Vector3D, c: Vector3D): Vector3D;
+
+/**
+ * Sets the normals to a mesh geometry by computing each face's unit orthogonal vector.
+ * @param geometry
+ */
+declare function computeSharpVertexNormals(geometry: MeshGeometry): void;
+
+declare interface DiffuseMaterial extends Material {
+    /** Diffuse color, albedo. */
+    emissiveColor?: string;
+    /** Percentage of reflected light. */
+    reflectivity?: number;
+    /** Index of refraction. */
+    refractionRatio?: number;
+}
+
+declare class DragEvent_2 extends UI3DEvent<DragEventArgs> {
+}
+
+declare interface DragEventArgs {
+    readonly offset: Point;
+    readonly item: Renderable;
+}
+
+export declare namespace Drawing3D {
+    export {
+        isStage,
+        isRenderable,
+        isUi3DObject,
+        isCamera,
+        isPerspectiveCamera,
+        isOrthographicCamera,
+        isLight,
+        isMesh,
+        isGeometry,
+        isMeshGeometry,
+        isGroup,
+        computeSharpVertexNormals,
+        computePlaneNormal,
+        isInteraction,
+        Vector3D,
+        Matrix3D,
+        Quaternion,
+        UVMap,
+        Box3D,
+        Sphere3D,
+        Stage,
+        Renderable,
+        Ui3DObject,
+        Camera,
+        OrthographicCamera,
+        PerspectiveCamera,
+        Light,
+        Mesh,
+        Group,
+        DragEventArgs,
+        UI3DEvent,
+        DragEvent_2 as DragEvent,
+        RenderableEvent,
+        RaycastResult,
+        StalePropertyFlag,
+        Interaction,
+        RenderableElement,
+        Ui3DElement,
+        Pacem3DGroupElement,
+        Pacem3DMeshElement,
+        Pacem3DObjectElement,
+        Pacem3DLightElement,
+        Pacem3DCameraElement,
+        Pacem3DPerspectiveCameraElement,
+        Pacem3DOrthographicCameraElement,
+        Pacem3DAdapterElement,
+        NodeGeometry,
+        MeshGeometry,
+        LineGeometry,
+        NotifyChange,
+        Point3DConverter,
+        Point3DOrNumberConverter,
+        QuaternionConverter,
+        BooleanOrNumberConverter,
+        isMaterial,
+        isBasicMaterial,
+        isLineMaterial,
+        isLambertMaterial,
+        isPhongMaterial,
+        isStandardMaterial,
+        isShaderMaterial,
+        KnownShader,
+        Material,
+        BasicMaterial,
+        LineMaterial,
+        DiffuseMaterial,
+        LambertMaterial,
+        SpecularMaterial,
+        PhongMaterial,
+        StandardMaterial,
+        ShaderMaterial,
+        MaterialElement
+    }
+}
+
+export declare namespace Drawing3D_2 {
+    export {
+        isStage,
+        isRenderable,
+        isUi3DObject,
+        isCamera,
+        isPerspectiveCamera,
+        isOrthographicCamera,
+        isLight,
+        isMesh,
+        isGeometry,
+        isMeshGeometry,
+        isGroup,
+        computeSharpVertexNormals,
+        computePlaneNormal,
+        isInteraction,
+        Vector3D,
+        Matrix3D,
+        Quaternion,
+        UVMap,
+        Box3D,
+        Sphere3D,
+        Stage,
+        Renderable,
+        Ui3DObject,
+        Camera,
+        OrthographicCamera,
+        PerspectiveCamera,
+        Light,
+        Mesh,
+        Group,
+        DragEventArgs,
+        UI3DEvent,
+        DragEvent_2 as DragEvent,
+        RenderableEvent,
+        RaycastResult,
+        StalePropertyFlag,
+        Interaction,
+        RenderableElement,
+        Ui3DElement,
+        Pacem3DGroupElement,
+        Pacem3DMeshElement,
+        Pacem3DObjectElement,
+        Pacem3DLightElement,
+        Pacem3DCameraElement,
+        Pacem3DPerspectiveCameraElement,
+        Pacem3DOrthographicCameraElement,
+        Pacem3DAdapterElement,
+        Pacem3DDetector,
+        isMaterial,
+        isBasicMaterial,
+        isLineMaterial,
+        isLambertMaterial,
+        isPhongMaterial,
+        isStandardMaterial,
+        isShaderMaterial,
+        KnownShader,
+        Material,
+        BasicMaterial,
+        LineMaterial,
+        DiffuseMaterial,
+        LambertMaterial,
+        SpecularMaterial,
+        PhongMaterial,
+        StandardMaterial,
+        ShaderMaterial,
+        MaterialElement,
+        BasicMaterialElement,
+        LambertMaterialElement,
+        LineMaterialElement,
+        PhongMaterialElement,
+        StandardMaterialElement,
+        Pacem3DPrimitiveElement,
+        PacemBoxElement,
+        PacemConeElement,
+        PacemCylinderElement,
+        PacemLineElement,
+        PacemPlaneElement,
+        PolyhedronElement,
+        PacemTetrahedronElement,
+        PacemOctahedronElement,
+        PacemHexahedronElement,
+        PacemIcosahedronElement,
+        PacemDodecahedronElement,
+        PacemSphereElement,
+        PacemTorusElement,
+        AdapterUtils,
+        Pacem3DThreeAdapterElement,
+        Pacem3DWgslScriptElement,
+        Pacem3DWebgpuAdapterElement,
+        OrbitCameraBehavior,
+        PacemOrbitCameraBehaviorElement,
+        Pacem3DElement
+    }
+}
+
+declare type FragmentModifierDelegate = (...args: FragmentModifierDelegateArgs) => string;
+
+declare type FragmentModifierDelegateArgs = [worldPositionRef: string, instanceIndexRef: string, timeRef: string, cursorRef: string, sizeRef: string];
+
+declare interface Group extends Ui3DObject {
+    childRenderables: Renderable[];
+}
+
+declare interface Interaction {
+    time: number;
+    cursor: Point;
+    resolution: Size;
+}
+
+declare function isBasicMaterial(obj: any): obj is BasicMaterial;
+
+declare function isCamera(object: any): object is Camera;
+
+declare function isGeometry(object: any): object is NodeGeometry;
+
+declare function isGroup(object: any): object is Group;
+
+declare function isInteraction(object: any): object is Interaction;
+
+declare function isLambertMaterial(obj: any): obj is LambertMaterial;
+
+declare function isLight(object: any): object is Light;
+
+declare function isLineMaterial(obj: any): obj is LineMaterial;
+
+declare function isMaterial(obj: any): obj is Material;
+
+declare function isMesh(object: any): object is Mesh;
+
+declare function isMeshGeometry(object: any): object is MeshGeometry;
+
+declare function isOrthographicCamera(object: any): object is OrthographicCamera;
+
+declare function isPerspectiveCamera(object: any): object is PerspectiveCamera;
+
+declare function isPhongMaterial(obj: any): obj is PhongMaterial;
+
+declare function isRenderable(object: any): object is Renderable;
+
+declare function isShaderMaterial(obj: any): obj is ShaderMaterial;
+
+declare function isStage(object: any): object is Stage;
+
+declare function isStandardMaterial(obj: any): obj is StandardMaterial;
+
+declare function isUi3DObject(object: any): object is Ui3DObject;
+
+declare enum KnownShader {
+    Basic = "basic",
+    Lambert = "lambert",
+    Phong = "phong",
+    Standard = "standard",
+    Line = "line",
+    Custom = "custom"
+}
+
+declare interface LambertMaterial extends DiffuseMaterial {
+    readonly shader: KnownShader.Lambert;
+}
+
+declare class LambertMaterialElement extends MaterialElement {
+    constructor();
+    protected createMaterial(): Promise<LambertMaterial>;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    emissiveColor: string;
+    reflectivity: number;
+    refractionRatio: number;
+}
+
+declare interface Light extends Renderable {
+    intensity: number;
+    target?: Vector3D;
+    color: string;
+    type: 'spot' | 'direction' | 'omni' | 'ambient';
+    attenuationStart?: number;
+    attenuationEnd?: number;
+    angle?: number;
+}
+
+declare class LineGeometry extends NodeGeometry {
+    positions: Vector3D_2[];
+}
+
+declare interface LineMaterial extends Material {
+    readonly shader: KnownShader.Line;
+    lineWidth: number;
+    lineJoin?: CanvasLineJoin;
+    lineCap?: CanvasLineCap;
+    dashArray?: number[];
+}
+
+declare class LineMaterialElement extends MaterialElement {
+    constructor();
+    lineWidth: number;
+    lineJoin?: CanvasLineJoin;
+    lineCap?: CanvasLineCap;
+    dashArray?: number[];
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    protected createMaterial(): Promise<LineMaterial>;
+}
+
+declare interface Material {
+    opacity?: number;
+    wireframe?: boolean;
+    /** Object color. */
+    color?: string | Rgba;
+    visible?: boolean;
+    /** Texture map. */
+    map?: string;
+    texture?: ImageBitmap;
+    /** Renders each face as flat. */
+    flatShading?: boolean;
+    readonly shader: KnownShader;
+    flags: StalePropertyFlag[];
+}
+
+declare abstract class MaterialElement extends PacemEventTarget {
+    #private;
+    constructor(shader: KnownShader);
+    get shader(): KnownShader;
+    private _loadMap;
+    material: Material;
+    opacity: number;
+    wireframe: boolean;
+    color: string;
+    hide: boolean;
+    map?: string;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    viewActivatedCallback(): void;
+    protected updateMaterial(): void;
+    protected createMaterial(): Promise<Material>;
+}
+
+declare type Matrix3D = Geometry.LinearAlgebra.Matrix3D;
+
+declare interface Mesh extends Ui3DObject {
+    geometry: NodeGeometry;
+    material?: Material;
+    backMaterial?: Material;
+}
+
+declare interface MeshGeometry extends NodeGeometry {
+    triangleIndices: number[];
+    textureCoordinates: UVMap;
+    normals: Vector3D_2[];
+}
+
+declare class MeshGeometry extends NodeGeometry {
+    #private;
+    get barycenter(): Vector3D_2;
+    set barycenter(point: Vector3D_2);
+    get boundingBox(): Box3D;
+    set boundingBox(bbox: Box3D);
+    get boundingSphere(): Sphere3D;
+    set boundingSphere(sphere: Sphere3D);
+    constructor(positions: Vector3D_2[], triangleIndices: number[], textureCoordinates?: UVMap, normals?: Vector3D_2[]);
+    positions: Vector3D_2[];
+    triangleIndices: number[];
+    textureCoordinates: UVMap;
+    normals: Vector3D_2[];
+}
+
+declare interface NodeGeometry {
+    positions: Vector3D_2[];
+    boundingBox?: Box3D;
+    barycenter?: Vector3D_2;
+    boundingSphere?: Sphere3D;
+    flags: StalePropertyFlag[];
+    key?: string;
+}
+
+declare abstract class NodeGeometry {
+    constructor(positions?: Vector3D_2[]);
+    static barycenter(positions: Vector3D_2[]): Vector3D_2;
+    static boundingBox(positions: Vector3D_2[]): Box3D;
+    protected setAsDirty(): void;
+}
+
+declare function NotifyChange(callback: (property?: string, old?: any, val?: any) => void): (target: any, prop: string, descriptor?: PropertyDescriptor) => void;
+
+declare class OrbitCameraBehavior {
+    #private;
+    private _config;
+    private readonly _canvas;
+    private readonly _camera;
+    private readonly _scene;
+    private readonly _initialState;
+    private _currentState;
+    private constructor();
+    private static _buildState;
+    /**
+     * Tries to attach a new {@link OrbitCameraBehavior} to the provided element, if the element is a proper renderable and it is ready.
+     * @param element
+     * @returns
+     */
+    static tryAttach(element: any, config?: OrbitCameraConfiguration): OrbitCameraBehavior | null;
+    /** State of the current configuration, obtained from the interaction inputs. */
+    private _input;
+    /** Sibling state of {@link _input} that comes helpful when inertia is involved. */
+    private _progress;
+    get configuration(): OrbitCameraConfiguration;
+    set configuration(v: OrbitCameraConfiguration);
+    private _startHandler;
+    private _avoidHandler;
+    private _endHandler;
+    private _zoomHandler;
+    private _moveHandler;
+    private _getSafeAzimuth;
+    private _getSafePolar;
+    private static _modAngle;
+    private static _getViewXYZ;
+    private _update;
+    private _renderHandler;
+    /** Detaches and removes handlers and resources. */
+    dispose(): void;
+}
+
+declare type OrbitCameraConfiguration = {
+    maxAzimuth: number;
+    minAzimuth: number;
+    minPolar: number;
+    maxPolar: number;
+    inertia: boolean | number;
+    pan: OrbitCameraControl;
+    rotation: OrbitCameraControl;
+    zoom: OrbitCameraControl;
+};
+
+declare type OrbitCameraControl = {
+    enabled: boolean;
+    button?: number;
+    modifiers?: EventKeyModifier[];
+};
+
+declare interface OrthographicCamera extends Camera {
+    type: "orthographic";
+    /** Top frustum coordinate (e.g. 1). */
+    top: number;
+    /** Left frustum coordinate (e.g. -1). */
+    left: number;
+    /** Bottom frustum coordinate (e.g. -1). */
+    bottom: number;
+    /** Right frustum coordinate (e.g. 1). */
+    right: number;
+}
+
+declare abstract class Pacem3DAdapterElement extends PacemEventTarget {
+    /**
+     * When implemented in a derived class, resizes the stage.
+     */
+    abstract invalidateSize(scene: Pacem3DElement, size: Size): void;
+    /**
+     * Initializes the 3d scene and returns its corresponding DOM element.
+     * @param scene {Pacem3DElement} Container for the stage/scene
+     */
+    abstract initialize(scene: Pacem3DElement): Promise<HTMLElement>;
+    /**
+     * When implemented in a derived class, renders the scene.
+     */
+    abstract render(scene: Pacem3DElement): void;
+    /**
+     * Processes the stage content and returns an image accordingly.
+     * */
+    abstract snapshot(scene: Pacem3DElement, bgColor?: string, type?: string, quality?: number): PromiseLike<Blob>;
+    /**
+     * When implemented in a derived class, retrieves the element casting the ray through the provided point (if any).
+     * @param point {Object} 2D to check.
+     */
+    abstract raycast(scene: Pacem3DElement, point: Point, size: Size, callback: (result: RaycastResult) => void): void;
+    /**
+     * When implemented in a derived class, adds a 3d element.
+     * @param item {Pacem3DObject} item to be added
+     */
+    abstract addItem(scene: Pacem3DElement, item: Renderable): void;
+    /**
+     * When implemented in a derived class, removes a 3d element.
+     * @param item {Pacem3DObject} item to be removed
+     */
+    abstract removeItem(scene: Pacem3DElement, item: Renderable): void;
+    /**
+     * Updates the object before the next rendering.
+     * @param item
+     * @param redraw Whether to completely redraw the object (not just its 3d transform) or not
+     */
+    abstract updateItem(scene: Pacem3DElement, item: Renderable): void;
+    /**
+     * Adjusts the camera to zoom-fit specific objects in the viewport.
+     * @param items
+     */
+    abstract zoomFit(scene: Pacem3DElement, ...items: Ui3DObject[]): Promise<void>;
+    abstract project(scene: Pacem3DElement, point3D: Vector3D): Point;
+    /** Gets the native scene instance */
+    abstract getScene(scene: Pacem3DElement): any;
+    /**
+     * Disposes the 2d scene resources.
+     * @param scene {Pacem3DElement} The stage/scene
+     */
+    abstract dispose(scene: Pacem3DElement): void;
+}
+
+declare abstract class Pacem3DCameraElement extends RenderableElement implements Camera {
+    #private;
+    near: number;
+    far: number;
+    up: Vector3D;
+    lookAt: Vector3D;
+    private _resetBoundingSphere;
+    get boundingSphere(): Sphere3D;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+/** @deprecated*/
+declare class Pacem3DDetector {
+    private _detected;
+    constructor();
+    get info(): {
+        main?: any;
+        bits?: any;
+        shader?: any;
+        tex?: any;
+        misc?: any;
+    };
+    get supported(): boolean;
+}
+
+declare class Pacem3DElement extends Components_2.PacemItemsContainerElement<RenderableElement> implements Stage {
+    #private;
+    validate(item: RenderableElement): boolean;
+    private _container;
+    private _resizer;
+    interactive: boolean;
+    transparent: boolean;
+    background: string;
+    adapter: Pacem3DAdapterElement;
+    datasource: Renderable[];
+    /** @deprecated */
+    orbit: boolean;
+    get stage(): HTMLElement;
+    get scene(): any;
+    register(item: RenderableElement): boolean;
+    unregister(item: RenderableElement): boolean;
+    private _refreshDatasource;
+    private _buildUpDatasourceFromDOM;
+    private _itemPropertyChangeHandler;
+    private _add;
+    private _erase;
+    private _initializeAdapter;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _lastHitResult;
+    viewActivatedCallback(): void;
+    private _itemDispatch;
+    private _clickHandler;
+    private _hitTestCallback;
+    private _moveHandler;
+    disconnectedCallback(): void;
+    get size(): Size;
+    private _resizeHandler;
+    render(item?: Renderable, deepUpdate?: boolean, now?: number): void;
+    private _doRender;
+}
+
+declare class Pacem3DGroupElement extends Ui3DElement implements Group {
+    #private;
+    validate(child: RenderableElement): boolean;
+    datasource: Renderable[];
+    get childRenderables(): Renderable[];
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class Pacem3DLightElement extends RenderableElement implements Light {
+    intensity: number;
+    target: Vector3D;
+    color: string;
+    type: 'spot' | 'direction' | 'omni';
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class Pacem3DMeshElement extends Ui3DElement implements Mesh {
+    geometry: NodeGeometry;
+    material: Material;
+    backMaterial: Material;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class Pacem3DObjectElement extends Ui3DElement {
+    content: any;
+    type: string | "obj" | "fbx" | "native";
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class Pacem3DOrthographicCameraElement extends Pacem3DCameraElement implements OrthographicCamera {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    get type(): "orthographic";
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class Pacem3DPerspectiveCameraElement extends Pacem3DCameraElement implements PerspectiveCamera {
+    fov: number;
+    aspect: number;
+    get type(): "perspective";
+    get aspectRatio(): number;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare abstract class Pacem3DPrimitiveElement extends PacemEventTarget {
+    geometry: NodeGeometry;
+    viewActivatedCallback(): void;
+    protected abstract createDefaultGeometry(): NodeGeometry;
+}
+
+declare class Pacem3DThreeAdapterElement extends Pacem3DAdapterElement {
+    private _assertMonoStage;
+    dispose(scene: Pacem3DElement): void;
+    snapshot(scene: Pacem3DElement, background?: string, type?: string, quality?: number): PromiseLike<Blob>;
+    project(scene: Pacem3DElement, point3D: Vector3D): Point;
+    zoomFit(scene: Pacem3DElement, ...items: Ui3DObject[]): Promise<void>;
+    private _3d;
+    private _stage;
+    private _renderer;
+    private _camera;
+    private _scene;
+    private _orbitCtrls;
+    private _objects;
+    private _dict;
+    orbit: boolean;
+    getScene(scene: Pacem3DElement): any;
+    raycast(scene: Pacem3DElement, point: Point, size: Size, callback: (result: RaycastResult) => void): void;
+    initialize(container: Pacem3DElement): Promise<HTMLCanvasElement>;
+    private _setCamera;
+    private _orbitControlsDelegate;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _initOrbitControls;
+    private _disposeOrbitControls;
+    private _updateRenderer;
+    invalidateSize(scene: Pacem3DElement, size?: Size): void;
+    removeItem(scene: Pacem3DElement, item: RenderableElement): void;
+    updateItem(scene: Pacem3DElement, item: RenderableElement): void;
+    addItem(scene: Pacem3DElement, item: RenderableElement): void;
+    private _ensureAndRefresh;
+    private _addOrUpdateItem;
+    render(): void;
+}
+
+declare class Pacem3DWebgpuAdapterElement extends Pacem3DAdapterElement implements ItemsContainer<Pacem3DWgslScriptElement> {
+    #private;
+    invalidateSize(stage: Pacem3DElement, size?: Size): void;
+    get items(): Pacem3DWgslScriptElement[];
+    register(item: Pacem3DWgslScriptElement): boolean;
+    unregister(item: Pacem3DWgslScriptElement): boolean;
+    private _scriptVersionChangeHandler;
+    get supported(): boolean;
+    get active(): boolean;
+    private _webGPUNotSupported;
+    initialize(scene: Pacem3DElement): Promise<HTMLCanvasElement | null>;
+    private _parseWgslModifiers;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    disconnectedCallback(): void;
+    dispose(scene: Pacem3DElement): void;
+    private _reinitialize;
+    modifiers: WGSLModifierDelegates;
+    enableValidation: boolean;
+    private _ensureRenderer;
+    private _updatePipeline;
+    /**
+     * Called when scene datasource changes.
+     * @param scene
+     */
+    render(scene: Pacem3DElement): void;
+    snapshot(scene: Pacem3DElement, background?: string, type?: string, quality?: number): PromiseLike<Blob>;
+    raycast(stage: Pacem3DElement, point: Point, size: Size, callback: (result: RaycastResult) => void): void;
+    private _itemsChangedExec;
+    private _itemsChanged;
+    addItem(stage: Pacem3DElement, item: Renderable): void;
+    removeItem(stage: Pacem3DElement, item: Renderable): void;
+    updateItem(stage: Pacem3DElement, item?: Renderable): void;
+    zoomFit(stage: Pacem3DElement, ...items: Ui3DObject[]): Promise<void>;
+    project(stage: Pacem3DElement, point3D: Geometry.LinearAlgebra.Vector3D): Point;
+    getScene(stage: Pacem3DElement): any;
+}
+
+declare class Pacem3DWgslScriptElement extends Components_2.PacemItemElement {
+    #private;
+    protected findContainer(): ItemsContainer<Pacem3DWgslScriptElement>;
+    get version(): string;
+    type: WGSLModifierScriptType;
+    wgsl: string;
+    viewActivatedCallback(): void;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _computeVersion;
+    disconnectedCallback(): void;
+}
+
+declare class PacemBoxElement extends Pacem3DPrimitiveElement {
+    width: number;
+    height: number;
+    depth: number;
+    widthSegments: number;
+    heightSegments: number;
+    depthSegments: number;
+    static createMeshGeometry(width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number): MeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemConeElement extends Pacem3DPrimitiveElement {
+    radius: number;
+    height: number;
+    sides: number;
+    heightSegments: number;
+    capSegments: number;
+    static createMeshGeometry(radius?: number, height?: number, sides?: number, heightSegments?: number, capSegments?: number): MeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemCylinderElement extends Pacem3DPrimitiveElement {
+    radius: number;
+    height: number;
+    sides: number;
+    heightSegments: number;
+    capSegments: number;
+    static createMeshGeometry(radius?: number, height?: number, sides?: number, heightSegments?: number, capSegments?: number): MeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemDodecahedronElement extends PolyhedronElement {
+    static createMeshGeometry(radius?: number): MeshGeometry;
+    protected createMeshGeometry(radius?: number): MeshGeometry;
+}
+
+declare class PacemHexahedronElement extends PolyhedronElement {
+    static createMeshGeometry(radius?: number): MeshGeometry;
+    protected createMeshGeometry(radius?: number): MeshGeometry;
+}
+
+declare class PacemIcosahedronElement extends PolyhedronElement {
+    static createMeshGeometry(radius?: number): MeshGeometry;
+    protected createMeshGeometry(radius?: number): MeshGeometry;
+}
+
+declare class PacemLineElement extends Pacem3DPrimitiveElement {
+    positions: Vector3D[];
+    static createLineGeometry(positions?: Vector3D[]): LineGeometry;
+    protected createDefaultGeometry(): LineGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemOctahedronElement extends PolyhedronElement {
+    static createMeshGeometry(radius?: number): MeshGeometry;
+    protected createMeshGeometry(radius?: number): MeshGeometry;
+}
+
+declare class PacemOrbitCameraBehaviorElement extends Behaviors.PacemBehavior {
+    #private;
+    maxAzimuth: number;
+    maxPolar: number;
+    minAzimuth: number;
+    minPolar: number;
+    zoomControl: OrbitCameraControl;
+    rotationControl: OrbitCameraControl;
+    panControl: OrbitCameraControl;
+    inertia: boolean | number;
+    private _readyHandler;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    disconnectedCallback(): void;
+    private _buildConfig;
+    private _decorateCore;
+    protected decorate(element: Element): void;
+    protected undecorate(element: Element): void;
+}
+
+declare class PacemPlaneElement extends Pacem3DPrimitiveElement {
+    width: number;
+    length: number;
+    widthSegments: number;
+    lengthSegments: number;
+    static createMeshGeometry(width?: number, length?: number, widthSegments?: number, lengthSegments?: number): MeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemSphereElement extends Pacem3DPrimitiveElement {
+    radius: number;
+    segments: number;
+    static createMeshGeometry(radius?: number, segs?: number): MeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare class PacemTetrahedronElement extends PolyhedronElement {
+    static createMeshGeometry(radius?: number): MeshGeometry;
+    protected createMeshGeometry(radius?: number): MeshGeometry;
+}
+
+declare class PacemTorusElement extends Pacem3DPrimitiveElement {
+    radius: number;
+    innerRadius: number;
+    segments: number;
+    sides: number;
+    static createMeshGeometry(radius?: number, innerRadius?: number, segments?: number, sides?: number): MeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+}
+
+declare interface PerspectiveCamera extends Camera {
+    type: "perspective";
+    /** Vertical field of view in degrees. */
+    fov: number;
+    aspectRatio: number;
+}
+
+declare interface PhongMaterial extends SpecularMaterial {
+    readonly shader: KnownShader.Phong;
+}
+
+declare class PhongMaterialElement extends MaterialElement {
+    constructor();
+    protected createMaterial(): Promise<PhongMaterial>;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    emissiveColor: string;
+    reflectivity: number;
+    refractionRatio: number;
+    specularColor: string;
+    shininess: number;
+    flatShading: boolean;
+}
+
+declare const Point3DConverter: PropertyConverter;
+
+declare const Point3DOrNumberConverter: PropertyConverter;
+
+declare type PointerEventLike = MouseEvent | PointerEvent | TouchEvent;
+
+declare abstract class PolyhedronElement extends Pacem3DPrimitiveElement {
+    radius: number;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _assignMeshGeometry;
+    protected createDefaultGeometry(): MeshGeometry;
+    protected abstract createMeshGeometry(radius: number): MeshGeometry;
+}
+
+declare type Quaternion = Geometry.LinearAlgebra.Quaternion;
+
+declare const QuaternionConverter: PropertyConverter;
+
+declare type RaycastResult = {
+    object: Renderable;
+    point: Vector3D;
+};
+
+declare interface Renderable {
+    stage?: Stage;
+    position: Vector3D;
+    /** Gets or sets whether the drawable is hit-testable. */
+    inert?: boolean;
+    hide?: boolean;
+    tag?: any;
+    flags: StalePropertyFlag[];
+    key?: string;
+    /** @deprecated will be likely removed sooner or later to be handled outside the stage/adapter. */
+    draggable?: boolean;
+}
+
+declare abstract class RenderableElement extends Components_2.PacemCrossItemsContainerElement<RenderableElement> implements Renderable {
+    #private;
+    validate(_: RenderableElement): boolean;
+    protected findContainer(): Pacem3DElement | RenderableElement;
+    get stage(): Pacem3DElement;
+    get parent(): RenderableElement;
+    position: Vector3D;
+    tag: string;
+    inert: boolean;
+    disconnectedCallback(): void;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    get flags(): StalePropertyFlag[];
+    /** Calls for a redraw of the current element in the next rendering process. */
+    protected setAsDirty(...flags: StalePropertyFlag[]): void;
+}
+
+declare class RenderableEvent extends UI3DEvent<Renderable> {
+    constructor(type: string, args: Renderable, originalEvent: MouseEvent | TouchEvent | KeyboardEvent, p: Vector3D);
+}
+
+declare interface ShaderMaterial extends Material {
+    readonly shader: KnownShader.Custom;
+    vertexShader?: string;
+    fragmentShader?: string;
+}
+
+declare interface SpecularMaterial extends DiffuseMaterial {
+    /** Specular color, defines the color of reflections. */
+    specularColor?: string;
+    /** Specular exponent, glossiness. */
+    shininess?: number;
+}
+
+declare interface Sphere3D {
+    center: Vector3D;
+    radius: number;
+}
+
+declare interface Stage extends EventTarget {
+    render(item?: Renderable): any;
+    readonly stage: HTMLElement;
+    readonly scene: any;
+    readonly size: Size;
+    transparent?: boolean;
+    background?: string | Rgba;
+}
+
+declare enum StalePropertyFlag {
+    Position = "position",
+    Transform = "transform",
+    Geometry = "geometry",
+    Children = "children",
+    Material = "material",
+    Light = "light",
+    Camera = "camera",
+    Visibility = "visibility"
+}
+
+declare interface StandardMaterial extends DiffuseMaterial {
+    readonly shader: KnownShader.Phong;
+    roughness?: number;
+    metalness?: number;
+    /** Percentage of reflected light at grazing angles. */
+    fresnel?: number;
+}
+
+declare class StandardMaterialElement extends MaterialElement {
+    constructor();
+    protected createMaterial(): Promise<PhongMaterial>;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    emissiveColor: string;
+    refractionRatio: number;
+    roughness: number;
+    metalness: number;
+    flatShading: boolean;
+}
+
+declare abstract class Ui3DElement extends RenderableElement implements Ui3DObject {
+    rotate: Geometry.LinearAlgebra.Quaternion;
+    scale: Geometry.LinearAlgebra.Point3D;
+    offset: Geometry.LinearAlgebra.Point3D;
+    /** Gets the local transform 3D matrix (4x4). */
+    transformMatrix: Geometry.LinearAlgebra.Matrix3D;
+    /** @deprecated*/
+    scaleX: number;
+    /** @deprecated*/
+    scaleY: number;
+    /** @deprecated*/
+    scaleZ: number;
+    /** @deprecated*/
+    translateX: number;
+    /** @deprecated*/
+    translateY: number;
+    /** @deprecated*/
+    translateZ: number;
+    propertyChangedCallback(name: string, old: any, val: any, first?: boolean): void;
+    private _computeTransformMatrix;
+}
+
+declare abstract class UI3DEvent<T> extends CustomUIEvent<T> {
+    #private;
+    constructor(type: string, eventInit: CustomEventInit<T>, originalEvent: MouseEvent | TouchEvent | KeyboardEvent, point: Vector3D);
+    /** Gets the event's source position in 3d coordinates. */
+    get point(): Vector3D;
+}
+
+declare interface Ui3DObject extends Renderable {
+    rotate?: Quaternion;
+    scale?: Vector3D;
+    offset?: Vector3D;
+    transformMatrix: Matrix3D;
+    /** Gets the plain (untransformed via {@link transformMatrix}) bounding sphere. */
+    readonly boundingSphere?: Sphere3D;
+    /** Gets the plain (untransformed via {@link transformMatrix}) bounding box. */
+    readonly boundingBox?: Box3D;
+}
+
+declare type UVMap = Point[];
+
+declare type Vector3D = Geometry.LinearAlgebra.Vector3D;
+
+declare type Vector3D_2 = Geometry.LinearAlgebra.Vector3D;
+
+declare type VertexInputModifierDelegate = (...args: VertexInputModifierDelegateArgs) => string;
+
+declare type VertexInputModifierDelegateArgs = [vertexInputRef: string, interactionDataRef: string];
+
+declare type VertexOutputModifierDelegate = (...args: VertexOutputModifierDelegateArgs) => string;
+
+declare type VertexOutputModifierDelegateArgs = [vertexOutputRef: string, interactionDataRef: string];
+
+declare type WGSLModifierDelegates = {
+    vertexInput?: string | VertexInputModifierDelegate;
+    vertexOutput?: string | VertexOutputModifierDelegate;
+    fragment?: string | FragmentModifierDelegate;
+    version?: string;
+};
+
+declare type WGSLModifierScriptType = 'vertex-input' | 'vertex-output' | 'fragment';
+
+
+
+declare global {
+    namespace Pacem {
+        export {
+            Components,
+            Drawing3D
+        };
+    }
+}