@mml-io/3d-web-client-core 0.7.0 → 0.9.0

package/build/camera/CameraManager.d.ts

@@ -16,16 +16,17 @@ export declare class CameraManager {
     private dampingFactor;
     targetDistance: number;
     private distance;
+    private desiredDistance;
     private targetPhi;
     private phi;
     private targetTheta;
     private theta;
-    private dragging;
+    dragging: boolean;
     private target;
     private hadTarget;
     private rayCaster;
-    constructor(collisionsManager: CollisionsManager);
-    private onResize;
+    private eventHandlerCollection;
+    constructor(targetElement: HTMLElement, collisionsManager: CollisionsManager, initialPhi?: number, initialTheta?: number);
     private onMouseDown;
     private onMouseUp;
     private onMouseMove;
@@ -33,5 +34,6 @@ export declare class CameraManager {
     setTarget(target: Vector3): void;
     private reverseUpdateFromPositions;
     adjustCameraPosition(): void;
+    dispose(): void;
     update(): void;
 }

package/build/character/Character.d.ts

@@ -2,8 +2,11 @@ import { Color, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
+import { Composer } from "../rendering/composer";
 import { TimeManager } from "../time/TimeManager";
 import { CharacterModel } from "./CharacterModel";
+import { CharacterModelLoader } from "./CharacterModelLoader";
+import { CharacterSpeakingIndicator } from "./CharacterSpeakingIndicator";
 import { CharacterTooltip } from "./CharacterTooltip";
 import { LocalController } from "./LocalController";
 export type CharacterDescription = {
@@ -16,6 +19,7 @@ export type CharacterDescription = {
 };
 export declare class Character {
     private readonly characterDescription;
+    private readonly characterModelLoader;
     private readonly id;
     private readonly isLocal;
     private readonly modelLoadedCallback;
@@ -23,13 +27,15 @@ export declare class Character {
     private readonly keyInputManager;
     private readonly cameraManager;
     private readonly timeManager;
+    private readonly composer;
     controller: LocalController | null;
     name: string | null;
     model: CharacterModel | null;
     color: Color;
     position: Vector3;
     tooltip: CharacterTooltip | null;
-    constructor(characterDescription: CharacterDescription, id: number, isLocal: boolean, modelLoadedCallback: () => void, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager);
+    speakingIndicator: CharacterSpeakingIndicator | null;
+    constructor(characterDescription: CharacterDescription, characterModelLoader: CharacterModelLoader, id: number, isLocal: boolean, modelLoadedCallback: () => void, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager, composer: Composer);
     private load;
     update(time: number): void;
 }

package/build/character/CharacterManager.d.ts

@@ -1,13 +1,17 @@
 import { PositionAndRotation } from "mml-web";
-import { Group, Vector3 } from "three";
+import { Euler, Group, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
+import { Composer } from "../rendering/composer";
 import { TimeManager } from "../time/TimeManager";
 import { Character, CharacterDescription } from "./Character";
+import { CharacterModelLoader } from "./CharacterModelLoader";
 import { CharacterState } from "./CharacterState";
 import { RemoteController } from "./RemoteController";
 export declare class CharacterManager {
+    private readonly composer;
+    private readonly characterModelLoader;
     private readonly collisionsManager;
     private readonly cameraManager;
     private readonly timeManager;
@@ -15,6 +19,7 @@ export declare class CharacterManager {
     private readonly clientStates;
     private readonly sendUpdate;
     private updateLocationHash;
+    private id;
     loadingCharacters: Map<number, Promise<Character>>;
     remoteCharacters: Map<number, Character>;
     remoteCharacterControllers: Map<number, RemoteController>;
@@ -22,10 +27,12 @@ export declare class CharacterManager {
     character: Character | null;
     private cameraOffsetTarget;
     private cameraOffset;
+    private speakingCharacters;
     readonly group: Group;
-    constructor(collisionsManager: CollisionsManager, cameraManager: CameraManager, timeManager: TimeManager, inputManager: KeyInputManager, clientStates: Map<number, CharacterState>, sendUpdate: (update: CharacterState) => void);
-    spawnCharacter(characterDescription: CharacterDescription, id: number, isLocal?: boolean, spawnPosition?: Vector3): Promise<Character>;
+    constructor(composer: Composer, characterModelLoader: CharacterModelLoader, collisionsManager: CollisionsManager, cameraManager: CameraManager, timeManager: TimeManager, inputManager: KeyInputManager, clientStates: Map<number, CharacterState>, sendUpdate: (update: CharacterState) => void);
+    spawnCharacter(characterDescription: CharacterDescription, id: number, isLocal?: boolean, spawnPosition?: Vector3, spawnRotation?: Euler): Promise<Character>;
     getLocalCharacterPositionAndRotation(): PositionAndRotation;
     clear(): void;
+    setSpeakingCharacter(id: number, value: boolean): void;
     update(): void;
 }

package/build/character/CharacterModel.d.ts

@@ -1,16 +1,18 @@
-import { AnimationAction, AnimationMixer, Object3D } from "three";
+import { AnimationAction, AnimationMixer, Bone, Object3D } from "three";
 import { CharacterDescription } from "./Character";
 import { CharacterMaterial } from "./CharacterMaterial";
+import { CharacterModelLoader } from "./CharacterModelLoader";
 import { AnimationState } from "./CharacterState";
 export declare class CharacterModel {
     private readonly characterDescription;
-    private modelLoader;
+    private characterModelLoader;
     mesh: Object3D | null;
     material: CharacterMaterial;
+    headBone: Bone | null;
     animations: Record<string, AnimationAction>;
     animationMixer: AnimationMixer | null;
     currentAnimation: AnimationState;
-    constructor(characterDescription: CharacterDescription);
+    constructor(characterDescription: CharacterDescription, characterModelLoader: CharacterModelLoader);
     init(): Promise<void>;
     updateAnimation(targetAnimation: AnimationState, deltaTime: number): void;
     hideMaterialByMeshName(meshName: any): void;

package/build/character/{ModelLoader.d.ts → CharacterModelLoader.d.ts}

@@ -1,14 +1,14 @@
 import { AnimationClip, Object3D } from "three";
-export declare class ModelLoader {
+export declare class CharacterModelLoader {
     private static instance;
     private readonly loadingManager;
     private readonly gltfLoader;
     private modelCache;
     private ongoingLoads;
     constructor(maxCacheSize?: number);
-    static getInstance(): ModelLoader;
+    static getInstance(): CharacterModelLoader;
     load(fileUrl: string, fileType: "model" | "animation"): Promise<Object3D | AnimationClip | undefined>;
     private loadFromUrl;
 }
-declare const MODEL_LOADER: ModelLoader;
+declare const MODEL_LOADER: CharacterModelLoader;
 export default MODEL_LOADER;

package/build/character/CharacterSpeakingIndicator.d.ts

@@ -0,0 +1,17 @@
+import { Camera, Object3D, Scene, Vector3 } from "three";
+export declare class CharacterSpeakingIndicator {
+    private scene;
+    private vertexShader;
+    private fragmentShader;
+    private uniforms;
+    private geometry;
+    private material;
+    private mesh;
+    private currentAlpha;
+    private targetAlpha;
+    constructor(scene: Scene | Object3D);
+    setBillboarding(position: Vector3, camera: Camera): void;
+    setTime(value: number): void;
+    setSpeaking(value: boolean): void;
+    dispose(): void;
+}

package/build/character/RemoteController.d.ts

@@ -1,16 +1,17 @@
 import { Object3D } from "three";
 import { Character } from "./Character";
+import { CharacterModelLoader } from "./CharacterModelLoader";
 import { AnimationState, CharacterState } from "./CharacterState";
 export declare class RemoteController {
     readonly character: Character;
+    private readonly characterModelLoader;
     readonly id: number;
-    private modelLoader;
     characterModel: Object3D | null;
     private animationMixer;
     private animations;
     currentAnimation: AnimationState;
     networkState: CharacterState;
-    constructor(character: Character, id: number);
+    constructor(character: Character, characterModelLoader: CharacterModelLoader, id: number);
     update(clientUpdate: CharacterState, time: number, deltaTime: number): void;
     setAnimationFromFile(animationType: AnimationState, fileName: string): Promise<void>;
     private transitionToAnimation;

package/build/helpers/math-helpers.d.ts

@@ -1,4 +1,6 @@
-import { Vector3 } from "three";
+import { Quaternion, Vector3, Vector4 } from "three";
+export declare const roundToDecimalPlaces: (value: number, decimalPlaces: number) => number;
+export declare const toArray: (origin: Vector3 | Vector4 | Quaternion, precision?: number) => number[];
 export declare const getSpawnPositionInsideCircle: (radius: number, positions: number, id: number, yPos?: number) => Vector3;
 export declare const round: (n: number, digits: number) => number;
 export declare const ease: (target: number, n: number, factor: number) => number;

package/build/index.d.ts

@@ -1,9 +1,11 @@
 export { CameraManager } from "./camera/CameraManager";
 export { CharacterDescription } from "./character/Character";
 export { CharacterManager } from "./character/CharacterManager";
+export { CharacterModelLoader } from "./character/CharacterModelLoader";
 export { CharacterState, AnimationState } from "./character/CharacterState";
 export { KeyInputManager } from "./input/KeyInputManager";
 export { MMLCompositionScene } from "./mml/MMLCompositionScene";
+export { TweakPane } from "./tweakpane/TweakPane";
 export { Composer } from "./rendering/composer";
 export { TimeManager } from "./time/TimeManager";
 export { CollisionsManager } from "./collisions/CollisionsManager";