@mml-io/3d-web-client-core 0.0.0-experimental-16d1b9c-20241218 → 0.0.0-experimental-b74fd73-20250121

package/build/character/CharacterManager.d.ts

@@ -1,4 +1,4 @@
-import { PositionAndRotation } from "mml-web";
+import { PositionAndRotation } from "@mml-io/mml-web";
 import { Euler, Group, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";

package/build/collisions/CollisionsManager.d.ts

@@ -1,4 +1,4 @@
-import { MElement } from "mml-web";
+import { MElement } from "@mml-io/mml-web";
 import { Group, Line3, Matrix4, Ray, Scene, Vector3 } from "three";
 import { MeshBVH } from "three-mesh-bvh";
 export type CollisionMeshState = {

package/build/collisions/getRelativePositionAndRotationRelativeToObject.d.ts

@@ -0,0 +1,3 @@
+import { PositionAndRotation } from "@mml-io/mml-web";
+import { Object3D } from "three";
+export declare function getRelativePositionAndRotationRelativeToObject(positionAndRotation: PositionAndRotation, container: Object3D): PositionAndRotation;

package/build/index.js

@@ -2550,11 +2550,15 @@ var VirtualJoystick = class _VirtualJoystick {
 // src/mml/MMLCompositionScene.ts
 import {
   InteractionManager,
-  MMLClickTrigger,
-  PromptManager,
   LoadingProgressManager,
-  MMLDocumentTimeManager
-} from "mml-web";
+  MMLDocumentTimeManager,
+  PromptManager
+} from "@mml-io/mml-web";
+import {
+  ThreeJSClickTrigger,
+  ThreeJSGraphicsInterface,
+  ThreeJSInteractionAdapter
+} from "@mml-io/mml-web-threejs";
 import { Group as Group3 } from "three";
 var MMLCompositionScene = class {
   constructor(config) {
@@ -2562,21 +2566,55 @@ var MMLCompositionScene = class {
     this.chatProbes = /* @__PURE__ */ new Set();
     this.group = new Group3();
     this.promptManager = PromptManager.init(this.config.targetElement);
+    const graphicsAdapter = {
+      collisionType: null,
+      containerType: null,
+      getGraphicsAdapterFactory: () => {
+        return ThreeJSGraphicsInterface;
+      },
+      getRootContainer: () => {
+        return this.group;
+      },
+      interactionShouldShowDistance(interaction) {
+        return ThreeJSInteractionAdapter.interactionShouldShowDistance(
+          interaction,
+          this.config.camera,
+          this.config.scene
+        );
+      },
+      dispose() {
+      },
+      getAudioListener: () => {
+        return config.audioListener;
+      },
+      getCamera: () => {
+        return config.camera;
+      },
+      getThreeScene: () => {
+        return config.scene;
+      },
+      getUserPositionAndRotation: () => {
+        return this.config.getUserPositionAndRotation();
+      }
+    };
     const { interactionListener, interactionManager } = InteractionManager.init(
       this.config.targetElement,
-      this.config.camera,
-      this.config.scene
+      (interaction) => {
+        return graphicsAdapter.interactionShouldShowDistance(interaction);
+      }
     );
     this.interactionManager = interactionManager;
     this.interactionListener = interactionListener;
     this.loadingProgressManager = new LoadingProgressManager();
     this.documentTimeManager = new MMLDocumentTimeManager();
     this.mmlScene = {
-      getAudioListener: () => this.config.audioListener,
-      getRenderer: () => this.config.renderer,
-      getThreeScene: () => this.config.scene,
+      getGraphicsAdapter() {
+        return graphicsAdapter;
+      },
+      hasGraphicsAdapter() {
+        return true;
+      },
       getRootContainer: () => this.group,
-      getCamera: () => this.config.camera,
       addCollider: (object, mElement) => {
         this.config.collisionsManager.addMeshesGroup(object, mElement);
       },
@@ -2614,7 +2652,11 @@ var MMLCompositionScene = class {
         return this.loadingProgressManager;
       }
     };
-    this.clickTrigger = MMLClickTrigger.init(this.config.targetElement, this.mmlScene);
+    this.clickTrigger = ThreeJSClickTrigger.init(
+      this.config.targetElement,
+      this.group,
+      this.config.camera
+    );
   }
   onChatMessage(message) {
     for (const chatProbe of this.chatProbes) {
@@ -5700,39 +5742,73 @@ var TimeManager = class {
 };
 
 // src/collisions/CollisionsManager.ts
-import {
-  getRelativePositionAndRotationRelativeToObject,
-  MMLCollisionTrigger
-} from "mml-web";
+import { MMLCollisionTrigger } from "@mml-io/mml-web";
 import {
   Box3,
   Color as Color8,
   DoubleSide,
-  Euler as Euler4,
+  Euler as Euler5,
   Group as Group5,
   Line3 as Line32,
-  Matrix4 as Matrix46,
+  Matrix4 as Matrix47,
   Mesh as Mesh5,
   MeshBasicMaterial as MeshBasicMaterial3,
-  Quaternion as Quaternion6,
+  Quaternion as Quaternion7,
   Ray as Ray2,
-  Vector3 as Vector314
+  Vector3 as Vector315
 } from "three";
 import { VertexNormalsHelper } from "three/examples/jsm/helpers/VertexNormalsHelper.js";
 import * as BufferGeometryUtils from "three/examples/jsm/utils/BufferGeometryUtils.js";
 import { MeshBVH, MeshBVHHelper } from "three-mesh-bvh";
+
+// src/collisions/getRelativePositionAndRotationRelativeToObject.ts
+import { Euler as Euler4, Matrix4 as Matrix46, Quaternion as Quaternion6, Vector3 as Vector314 } from "three";
+var tempContainerMatrix = new Matrix46();
+var tempTargetMatrix = new Matrix46();
+var tempPositionVector = new Vector314();
+var tempRotationEuler = new Euler4();
+var tempRotationQuaternion = new Quaternion6();
+var tempScaleVector = new Vector314();
+function getRelativePositionAndRotationRelativeToObject(positionAndRotation, container) {
+  const { x, y, z } = positionAndRotation.position;
+  const { x: rx, y: ry, z: rz } = positionAndRotation.rotation;
+  container.updateWorldMatrix(true, false);
+  tempContainerMatrix.copy(container.matrixWorld).invert();
+  tempPositionVector.set(x, y, z);
+  tempRotationEuler.set(rx, ry, rz);
+  tempRotationQuaternion.setFromEuler(tempRotationEuler);
+  tempScaleVector.set(1, 1, 1);
+  tempTargetMatrix.compose(tempPositionVector, tempRotationQuaternion, tempScaleVector);
+  tempTargetMatrix.premultiply(tempContainerMatrix);
+  tempTargetMatrix.decompose(tempPositionVector, tempRotationQuaternion, tempScaleVector);
+  tempRotationEuler.setFromQuaternion(tempRotationQuaternion);
+  return {
+    position: {
+      x: tempPositionVector.x,
+      y: tempPositionVector.y,
+      z: tempPositionVector.z
+    },
+    rotation: {
+      x: tempRotationEuler.x,
+      y: tempRotationEuler.y,
+      z: tempRotationEuler.z
+    }
+  };
+}
+
+// src/collisions/CollisionsManager.ts
 var CollisionsManager = class {
   constructor(scene) {
     this.debug = false;
-    this.tempVector = new Vector314();
-    this.tempVector2 = new Vector314();
-    this.tempVector3 = new Vector314();
-    this.tempQuaternion = new Quaternion6();
+    this.tempVector = new Vector315();
+    this.tempVector2 = new Vector315();
+    this.tempVector3 = new Vector315();
+    this.tempQuaternion = new Quaternion7();
     this.tempRay = new Ray2();
-    this.tempMatrix = new Matrix46();
-    this.tempMatrix2 = new Matrix46();
+    this.tempMatrix = new Matrix47();
+    this.tempMatrix2 = new Matrix47();
     this.tempBox = new Box3();
-    this.tempEuler = new Euler4();
+    this.tempEuler = new Euler5();
     this.tempSegment = new Line32();
     this.tempSegment2 = new Line32();
     this.collisionMeshState = /* @__PURE__ */ new Map();
@@ -5742,7 +5818,7 @@ var CollisionsManager = class {
   raycastFirst(ray) {
     let minimumDistance = null;
     let minimumHit = null;
-    let minimumNormal = new Vector314();
+    let minimumNormal = new Vector315();
     for (const [, collisionMeshState] of this.collisionMeshState) {
       this.tempRay.copy(ray).applyMatrix4(this.tempMatrix.copy(collisionMeshState.matrix).invert());
       const hit = collisionMeshState.meshBVH.raycastFirst(this.tempRay, DoubleSide);
@@ -5883,7 +5959,7 @@ var CollisionsManager = class {
         const realDistance = intersectionSegment.distance();
         if (realDistance < capsuleRadius) {
           if (!collisionPosition) {
-            collisionPosition = new Vector314().copy(closestPointOnSegment).applyMatrix4(meshState.matrix);
+            collisionPosition = new Vector315().copy(closestPointOnSegment).applyMatrix4(meshState.matrix);
           }
           const ratio = realDistance / modelReferenceDistance;
           const realDepth = capsuleRadius - realDistance;
@@ -5985,7 +6061,7 @@ var GroundPlane = class extends Group6 {
 };
 
 // src/loading-screen/LoadingScreen.ts
-import { LoadingProgressManager as LoadingProgressManager2 } from "mml-web";
+import { LoadingProgressManager as LoadingProgressManager2 } from "@mml-io/mml-web";
 var LoadingScreen = class {
   constructor(loadingProgressManager, config) {
     this.loadingProgressManager = loadingProgressManager;