@mml-io/mml-web-threejs 0.0.0-experimental-edf5cd7-20250120

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Improbable MV Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,12 @@
+# MML Web ThreeJS
+#### `@mml-io/mml-web-threejs`
+
+[![npm version](https://img.shields.io/npm/v/@mml-io/mml-web-threejs.svg?style=flat)](https://www.npmjs.com/package/@mml-io/mml-web-threejs)
+
+This package contains a library of graphics implementations for connecting MML elements to a [ThreeJS](https://github.com/mrdoob/three.js) app.
+
+It is intended to be used with the following packages:
+* `@mml-io/mml-web`
+    * provides the MML element handling and parsing
+* `@mml-io/mml-web-threejs-standalone`
+    * creates a standalone ThreeJS client for rendering MML elements on a webpage

package/build/ThreeJSClickTrigger.d.ts

@@ -0,0 +1,22 @@
+import * as THREE from "three";
+/**
+ * The ThreeJSClickTrigger class is responsible for handling click events on the MML scene and raycasts into the scene to
+ * determine which object was clicked and then dispatches events to those elements.
+ */
+export declare class ThreeJSClickTrigger {
+    private clickTarget;
+    private rootContainer;
+    private camera;
+    private eventHandlerCollection;
+    private raycaster;
+    private mouseDownTime;
+    private mouseMoveDelta;
+    static init(clickTarget: Document | HTMLElement, rootContainer: THREE.Object3D, camera: THREE.Camera): ThreeJSClickTrigger;
+    private constructor();
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleMouseMove;
+    private handleClick;
+    dispose(): void;
+    private isMaterialIgnored;
+}

package/build/ThreeJSGraphicsAdapter.d.ts

@@ -0,0 +1,7 @@
+import { GraphicsAdapter } from "@mml-io/mml-web";
+import * as THREE from "three";
+export type ThreeJSGraphicsAdapter = GraphicsAdapter<THREE.Object3D, THREE.Object3D, THREE.Object3D> & {
+    getThreeScene(): THREE.Scene;
+    getCamera(): THREE.Camera;
+    getAudioListener(): THREE.AudioListener;
+};

package/build/ThreeJSGraphicsInterface.d.ts

@@ -0,0 +1,3 @@
+import { MMLGraphicsInterface } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "./ThreeJSGraphicsAdapter";
+export declare const ThreeJSGraphicsInterface: MMLGraphicsInterface<ThreeJSGraphicsAdapter>;

package/build/ThreeJSInteractionAdapter.d.ts

@@ -0,0 +1,14 @@
+import { Interaction } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "./ThreeJSGraphicsAdapter";
+export declare class ThreeJSInteractionAdapter {
+    private static worldPos;
+    private static matrix;
+    private static frustum;
+    private static raycaster;
+    private static intersections;
+    private static direction;
+    static interactionShouldShowDistance(interaction: Interaction<ThreeJSGraphicsAdapter>, camera: THREE.Camera, scene: THREE.Scene): number | null;
+    static getRaycastResults(a: THREE.Vector3, b: THREE.Vector3, distance: number, scene: THREE.Scene): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
+    static hasAncestor(object: THREE.Object3D, ancestor: THREE.Object3D): boolean;
+}

package/build/ThreeJSReconnectingStatus.d.ts

@@ -0,0 +1,8 @@
+import * as THREE from "three";
+export type ThreeJSReconnectingStatus = {
+    geometry: THREE.PlaneGeometry;
+    material: THREE.MeshBasicMaterial;
+    width: number;
+    height: number;
+};
+export declare function getThreeJSReconnectingStatus(): ThreeJSReconnectingStatus;

package/build/elements/ThreeJSAudio.d.ts

@@ -0,0 +1,36 @@
+import { Audio, MAudioProps } from "@mml-io/mml-web";
+import { AudioGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSAudio extends AudioGraphics<ThreeJSGraphicsAdapter> {
+    private audio;
+    private audioDebugHelper;
+    private audioDebugConeX;
+    private audioDebugConeY;
+    private audioContextStateChangedListener;
+    private documentTimeListener;
+    private delayedPauseTimer;
+    private srcLoadingInstanceManager;
+    private positionalAudio;
+    private loadedAudioState;
+    constructor(audio: Audio<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    syncAudioTime(): void;
+    private clearAudio;
+    private updateAudio;
+    asyncLoadSourceAsset(contentAddress: string, abortController: AbortController, audioContext: AudioContext, onProgress: (loaded: number, total: number) => void): Promise<AudioBuffer>;
+    setSrc(): void;
+    setStartTime(): void;
+    setPauseTime(): void;
+    setLoopDuration(): void;
+    setLoop(): void;
+    setEnabled(): void;
+    setVolume(volume: number): void;
+    setConeAngle(coneAngle: number | null, mAudioProps: MAudioProps): void;
+    setConeFalloffAngle(coneFalloffAngle: number | null, mAudioProps: MAudioProps): void;
+    setDebug(): void;
+    dispose(): void;
+    private clearDebugVisualisation;
+    private updateDebugVisualisation;
+    private getAudioListener;
+}

package/build/elements/ThreeJSChatProbe.d.ts

@@ -0,0 +1,17 @@
+import { ChatProbe } from "@mml-io/mml-web";
+import { ChatProbeGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSChatProbe extends ChatProbeGraphics<ThreeJSGraphicsAdapter> {
+    private chatProbe;
+    private static DebugGeometry;
+    private static DebugMaterial;
+    private debugMesh;
+    constructor(chatProbe: ChatProbe<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    setRange(): void;
+    setDebug(): void;
+    private clearDebugVisualisation;
+    private updateDebugVisualisation;
+    dispose(): void;
+}

package/build/elements/ThreeJSCube.d.ts

@@ -0,0 +1,22 @@
+import { Cube } from "@mml-io/mml-web";
+import { CubeGraphics } from "@mml-io/mml-web";
+import { MMLColor } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSCube extends CubeGraphics<ThreeJSGraphicsAdapter> {
+    private cube;
+    static boxGeometry: THREE.BoxGeometry;
+    private mesh;
+    private material;
+    constructor(cube: Cube<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    getCollisionElement(): THREE.Object3D<THREE.Object3DEventMap>;
+    setColor(color: MMLColor): void;
+    setWidth(width: number): void;
+    setHeight(height: number): void;
+    setDepth(depth: number): void;
+    setCastShadows(castShadows: boolean): void;
+    setOpacity(opacity: number): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSCylinder.d.ts

@@ -0,0 +1,19 @@
+import { Cylinder, CylinderGraphics, MMLColor } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSCylinder extends CylinderGraphics<ThreeJSGraphicsAdapter> {
+    private cylinder;
+    static cylinderGeometry: THREE.CylinderGeometry;
+    private mesh;
+    private material;
+    constructor(cylinder: Cylinder<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    getCollisionElement(): THREE.Object3D;
+    setColor(color: MMLColor): void;
+    setRadius(radius: number): void;
+    setHeight(height: number): void;
+    setCastShadows(castShadows: boolean): void;
+    setOpacity(opacity: number): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSDebugHelper.d.ts

@@ -0,0 +1,8 @@
+import { DebugHelper, DebugHelperGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSDebugHelper extends DebugHelperGraphics<ThreeJSGraphicsAdapter> {
+    private debugHelper;
+    private debugAxes;
+    constructor(debugHelper: DebugHelper<ThreeJSGraphicsAdapter>);
+    dispose(): void;
+}

package/build/elements/ThreeJSFrame.d.ts

@@ -0,0 +1,27 @@
+import { Frame } from "@mml-io/mml-web";
+import { FrameGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSFrame extends FrameGraphics<ThreeJSGraphicsAdapter> {
+    private frame;
+    private static DebugBoxGeometry;
+    private static DebugConstraintMaterial;
+    private static DebugLoadRangeMaterial;
+    private static DebugUnloadRangeMaterial;
+    private debugMeshes;
+    constructor(frame: Frame<ThreeJSGraphicsAdapter>);
+    setSrc(): void;
+    setDebug(): void;
+    setLoadRange(): void;
+    setUnloadRange(): void;
+    setMinX(): void;
+    setMaxX(): void;
+    setMinY(): void;
+    setMaxY(): void;
+    setMinZ(): void;
+    setMaxZ(): void;
+    disable(): void;
+    enable(): void;
+    dispose(): void;
+    private clearDebugVisualisation;
+    private updateDebugVisualisation;
+}

package/build/elements/ThreeJSImage.d.ts

@@ -0,0 +1,35 @@
+import { Image, ImageGraphics } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSImage extends ImageGraphics<ThreeJSGraphicsAdapter> {
+    private image;
+    private updateMeshCallback;
+    private static planeGeometry;
+    private mesh;
+    private material;
+    private static imageLoader;
+    private srcApplyPromise;
+    private loadedImage;
+    private loadedImageHasTransparency;
+    private srcLoadingInstanceManager;
+    constructor(image: Image<ThreeJSGraphicsAdapter>, updateMeshCallback: () => void);
+    getWidthAndHeight(): {
+        width: number;
+        height: number;
+    };
+    disable(): void;
+    enable(): void;
+    getCollisionElement(): THREE.Object3D;
+    setWidth(): void;
+    setHeight(): void;
+    setCastShadows(castShadows: boolean): void;
+    setOpacity(opacity: number): void;
+    setEmissive(): void;
+    private updateMaterialEmissiveIntensity;
+    setSrc(newValue: string | null): void;
+    private updateWidthAndHeight;
+    private applyImage;
+    private clearImage;
+    dispose(): void;
+}
+export declare function loadImageAsPromise(imageLoader: THREE.ImageLoader, path: string, onProgress?: (loaded: number, total: number) => void): Promise<HTMLImageElement>;

package/build/elements/ThreeJSInteraction.d.ts

@@ -0,0 +1,21 @@
+import { Interaction } from "@mml-io/mml-web";
+import { InteractionGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSInteraction extends InteractionGraphics<ThreeJSGraphicsAdapter> {
+    private positionProbe;
+    private static DebugGeometry;
+    private static DebugMaterial;
+    private debugMesh;
+    constructor(positionProbe: Interaction<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    setRange(): void;
+    setInFocus(): void;
+    setLineOfSight(): void;
+    setPriority(): void;
+    setPrompt(): void;
+    setDebug(): void;
+    private clearDebugVisualisation;
+    private updateDebugVisualisation;
+    dispose(): void;
+}

package/build/elements/ThreeJSLabel.d.ts

@@ -0,0 +1,27 @@
+import { Label, LabelGraphics } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSLabel extends LabelGraphics<ThreeJSGraphicsAdapter> {
+    private label;
+    static labelGeometry: THREE.PlaneGeometry;
+    private mesh;
+    private material;
+    private canvasText;
+    constructor(label: Label<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    getCollisionElement(): THREE.Object3D;
+    setContent(): void;
+    setAlignment(): void;
+    setFontSize(): void;
+    setPadding(): void;
+    setFontColor(): void;
+    setEmissive(): void;
+    setColor(): void;
+    setWidth(width: number): void;
+    setHeight(height: number): void;
+    setCastShadows(castShadows: boolean): void;
+    private redrawText;
+    private updateMaterialEmissiveIntensity;
+    dispose(): void;
+}

package/build/elements/ThreeJSLight.d.ts

@@ -0,0 +1,23 @@
+import { Light } from "@mml-io/mml-web";
+import { LightGraphics } from "@mml-io/mml-web";
+import { MMLColor } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSLight extends LightGraphics<ThreeJSGraphicsAdapter> {
+    private light;
+    private threeLight;
+    private threeLightHelper;
+    constructor(light: Light<ThreeJSGraphicsAdapter>);
+    private createLight;
+    private makeLightHelper;
+    disable(): void;
+    enable(): void;
+    setEnabled(enabled: boolean): void;
+    setCastShadows(castShadows: boolean): void;
+    setAngle(angle: number): void;
+    setIntensity(intensity: number): void;
+    setDistance(distance: number): void;
+    setType(): void;
+    setDebug(debug: boolean): void;
+    setColor(color: MMLColor): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSLink.d.ts

@@ -0,0 +1,12 @@
+import { Link } from "@mml-io/mml-web";
+import { LinkGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSLink extends LinkGraphics<ThreeJSGraphicsAdapter> {
+    private link;
+    constructor(link: Link<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    setHref(): void;
+    setTarget(): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSMElement.d.ts

@@ -0,0 +1,12 @@
+import { MElement } from "@mml-io/mml-web";
+import { MElementGraphics } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSMElement extends MElementGraphics<ThreeJSGraphicsAdapter> {
+    private element;
+    protected container: THREE.Object3D;
+    private currentParentContainer;
+    constructor(element: MElement<ThreeJSGraphicsAdapter>);
+    getContainer(): THREE.Object3D;
+    dispose(): void;
+}

package/build/elements/ThreeJSModel.d.ts

@@ -0,0 +1,74 @@
+import { Model, TransformableElement } from "@mml-io/mml-web";
+import { ModelGraphics } from "@mml-io/mml-web";
+import { IVect3 } from "@mml-io/mml-web";
+import { ModelLoadResult } from "@mml-io/model-loader";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+type ThreeJSModelLoadState = {
+    group: THREE.Object3D;
+    bones: Map<string, THREE.Bone>;
+    boundingBox: {
+        size: THREE.Vector3;
+        centerOffset: THREE.Vector3;
+    };
+};
+type ThreeJSModelAnimState = {
+    currentAnimationClip: THREE.AnimationClip;
+    appliedAnimation: {
+        animationGroup: THREE.AnimationObjectGroup;
+        animationMixer: THREE.AnimationMixer;
+        animationAction: THREE.AnimationAction;
+    } | null;
+};
+export declare class ThreeJSModel extends ModelGraphics<ThreeJSGraphicsAdapter> {
+    private model;
+    private updateMeshCallback;
+    private static modelLoader;
+    private srcLoadingInstanceManager;
+    private animLoadingInstanceManager;
+    private latestSrcModelPromise;
+    private latestAnimPromise;
+    private socketChildrenByBone;
+    private attachments;
+    private registeredParentAttachment;
+    private static DebugBoundingBoxGeometry;
+    private static DebugBoundingBoxMaterial;
+    private debugBoundingBox;
+    protected loadedState: ThreeJSModelLoadState | null;
+    protected animState: ThreeJSModelAnimState | null;
+    private documentTimeTickListener;
+    constructor(model: Model<ThreeJSGraphicsAdapter>, updateMeshCallback: () => void);
+    hasLoadedModel(): boolean;
+    hasLoadedAnimation(): boolean;
+    disable(): void;
+    enable(): void;
+    getBoundingBox(): {
+        centerOffset: IVect3;
+        size: IVect3;
+    } | null;
+    getCollisionElement(): THREE.Object3D<THREE.Object3DEventMap>;
+    setDebug(): void;
+    setCastShadows(castShadows: boolean): void;
+    setAnim(anim: string): void;
+    setAnimEnabled(): void;
+    setAnimLoop(): void;
+    setAnimStartTime(): void;
+    setAnimPauseTime(): void;
+    transformed(): void;
+    setSrc(src: string): void;
+    registerAttachment(attachment: Model<ThreeJSGraphicsAdapter>): void;
+    unregisterAttachment(attachment: Model<ThreeJSGraphicsAdapter>): void;
+    private updateDebugVisualisation;
+    private clearDebugVisualisation;
+    asyncLoadSourceAsset(url: string, onProgress: (loaded: number, total: number) => void): Promise<ModelLoadResult>;
+    private resetAnimationMixer;
+    registerSocketChild(child: TransformableElement<ThreeJSGraphicsAdapter>, socketName: string): void;
+    unregisterSocketChild(child: TransformableElement<ThreeJSGraphicsAdapter>, socketName: string, addToRoot?: boolean): void;
+    private triggerSocketedChildrenTransformed;
+    private playAnimation;
+    private updateAnimation;
+    dispose(): void;
+    private static disposeOfGroup;
+    private static disposeOfMaterial;
+}
+export {};

package/build/elements/ThreeJSPlane.d.ts

@@ -0,0 +1,21 @@
+import { Plane } from "@mml-io/mml-web";
+import { MMLColor } from "@mml-io/mml-web";
+import { PlaneGraphics } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSPlane extends PlaneGraphics<ThreeJSGraphicsAdapter> {
+    private plane;
+    static planeGeometry: THREE.PlaneGeometry;
+    private mesh;
+    private material;
+    constructor(plane: Plane<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    getCollisionElement(): THREE.Object3D;
+    setColor(color: MMLColor): void;
+    setWidth(width: number): void;
+    setHeight(height: number): void;
+    setCastShadows(castShadows: boolean): void;
+    setOpacity(opacity: number): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSPositionProbe.d.ts

@@ -0,0 +1,17 @@
+import { PositionProbe } from "@mml-io/mml-web";
+import { PositionProbeGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSPositionProbe extends PositionProbeGraphics<ThreeJSGraphicsAdapter> {
+    private positionProbe;
+    private static DebugGeometry;
+    private static DebugMaterial;
+    private debugMesh;
+    constructor(positionProbe: PositionProbe<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    setRange(): void;
+    setDebug(): void;
+    private clearDebugVisualisation;
+    private updateDebugVisualisation;
+    dispose(): void;
+}

package/build/elements/ThreeJSPrompt.d.ts

@@ -0,0 +1,14 @@
+import { Prompt } from "@mml-io/mml-web";
+import { PromptGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSPrompt extends PromptGraphics<ThreeJSGraphicsAdapter> {
+    private prompt;
+    constructor(prompt: Prompt<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    setMessage(): void;
+    setPlaceholder(): void;
+    setPrefill(): void;
+    setDebug(): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSRemoteDocument.d.ts

@@ -0,0 +1,9 @@
+import { RemoteDocument, RemoteDocumentGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSRemoteDocument extends RemoteDocumentGraphics<ThreeJSGraphicsAdapter> {
+    private element;
+    private statusUI;
+    constructor(element: RemoteDocument<ThreeJSGraphicsAdapter>);
+    showError(showError: boolean): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSSphere.d.ts

@@ -0,0 +1,20 @@
+import { Sphere } from "@mml-io/mml-web";
+import { MMLColor } from "@mml-io/mml-web";
+import { SphereGraphics } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSSphere extends SphereGraphics<ThreeJSGraphicsAdapter> {
+    private sphere;
+    static sphereGeometry: THREE.SphereGeometry;
+    private mesh;
+    private material;
+    constructor(sphere: Sphere<ThreeJSGraphicsAdapter>);
+    disable(): void;
+    enable(): void;
+    getCollisionElement(): THREE.Object3D;
+    setColor(color: MMLColor): void;
+    setRadius(radius: number): void;
+    setCastShadows(castShadows: boolean): void;
+    setOpacity(opacity: number): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSTransformable.d.ts

@@ -0,0 +1,23 @@
+import { Matr4, TransformableElement, TransformableGraphics } from "@mml-io/mml-web";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSTransformable extends TransformableGraphics<ThreeJSGraphicsAdapter> {
+    private transformableElement;
+    private socketName;
+    private registeredSocketParent;
+    constructor(transformableElement: TransformableElement<ThreeJSGraphicsAdapter>);
+    getWorldMatrix(): Matr4;
+    setVisible(visible: boolean): void;
+    setSocket(socketName: string | null): void;
+    private registerWithParentModel;
+    private getContainer;
+    setX(x: number): void;
+    setY(y: number): void;
+    setZ(z: number): void;
+    setRotationX(rotationX: number): void;
+    setRotationY(rotationY: number): void;
+    setRotationZ(rotationZ: number): void;
+    setScaleX(scaleX: number): void;
+    setScaleY(scaleY: number): void;
+    setScaleZ(scaleZ: number): void;
+    dispose(): void;
+}

package/build/elements/ThreeJSVideo.d.ts

@@ -0,0 +1,36 @@
+import { Video, VideoGraphics } from "@mml-io/mml-web";
+import * as THREE from "three";
+import { ThreeJSGraphicsAdapter } from "../ThreeJSGraphicsAdapter";
+export declare class ThreeJSVideo extends VideoGraphics<ThreeJSGraphicsAdapter> {
+    private video;
+    private updateMeshCallback;
+    private videoSource;
+    private videoMaterial;
+    private mesh;
+    private loadedVideoState;
+    constructor(video: Video<ThreeJSGraphicsAdapter>, updateMeshCallback: () => void);
+    getWidthAndHeight(): {
+        width: number;
+        height: number;
+    };
+    syncVideoTime(): void;
+    private getAudioListener;
+    enable(): void;
+    disable(): void;
+    getCollisionElement(): THREE.Object3D;
+    setSrc(): void;
+    setWidth(): void;
+    setHeight(): void;
+    setEnabled(): void;
+    setCastShadows(): void;
+    setLoop(): void;
+    setVolume(): void;
+    setEmissive(): void;
+    setStartTime(): void;
+    setPauseTime(): void;
+    private updateVideo;
+    private clearSource;
+    dispose(): void;
+    private updateMaterialEmissiveIntensity;
+    private updateWidthAndHeight;
+}

package/build/elements/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./ThreeJSAudio";
+export * from "./ThreeJSChatProbe";
+export * from "./ThreeJSCube";
+export * from "./ThreeJSCylinder";
+export * from "./ThreeJSDebugHelper";
+export * from "./ThreeJSFrame";
+export * from "./ThreeJSImage";
+export * from "./ThreeJSInteraction";
+export * from "./ThreeJSLabel";
+export * from "./ThreeJSLight";
+export * from "./ThreeJSLink";
+export * from "./ThreeJSMElement";
+export * from "./ThreeJSModel";
+export * from "./ThreeJSPlane";
+export * from "./ThreeJSPositionProbe";
+export * from "./ThreeJSPrompt";
+export * from "./ThreeJSRemoteDocument";
+export * from "./ThreeJSSphere";
+export * from "./ThreeJSTransformable";
+export * from "./ThreeJSVideo";

package/build/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./elements";
+export * from "./ThreeJSClickTrigger";
+export * from "./ThreeJSGraphicsAdapter";
+export * from "./ThreeJSGraphicsInterface";
+export * from "./ThreeJSInteractionAdapter";