@mml-io/3d-web-client-core 0.10.1 → 0.12.0

package/build/camera/CameraManager.d.ts

@@ -38,7 +38,7 @@ export declare class CameraManager {
     private onMouseWheel;
     setTarget(target: Vector3): void;
     setLerpedTarget(target: Vector3, targetDistance: number): void;
-    private reverseUpdateFromPositions;
+    reverseUpdateFromPositions(): void;
     adjustCameraPosition(): void;
     dispose(): void;
     private easeOutExpo;

package/build/character/Character.d.ts

@@ -1,41 +1,36 @@
-import { Color, Vector3 } from "three";
+import { Color, Group } 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 { AnimationState } from "./CharacterState";
 import { CharacterTooltip } from "./CharacterTooltip";
-import { LocalController } from "./LocalController";
-export type CharacterDescription = {
-    meshFileUrl: string;
+export type AnimationConfig = {
     idleAnimationFileUrl: string;
     jogAnimationFileUrl: string;
     sprintAnimationFileUrl: string;
     airAnimationFileUrl: string;
-    modelScale: number;
 };
-export declare class Character {
+export type CharacterDescription = {
+    meshFileUrl?: string;
+    mmlCharacterUrl?: string;
+    mmlCharacterString?: string;
+};
+export declare class Character extends Group {
     private readonly characterDescription;
+    private readonly animationConfig;
     private readonly characterModelLoader;
-    private readonly id;
-    private readonly isLocal;
+    private readonly characterId;
     private readonly modelLoadedCallback;
-    private readonly collisionsManager;
-    private readonly keyInputManager;
     private readonly cameraManager;
-    private readonly timeManager;
     private readonly composer;
-    controller: LocalController | null;
-    name: string | null;
-    model: CharacterModel | null;
+    private model;
     color: Color;
-    position: Vector3;
     tooltip: CharacterTooltip | null;
     speakingIndicator: CharacterSpeakingIndicator | null;
-    constructor(characterDescription: CharacterDescription, characterModelLoader: CharacterModelLoader, id: number, isLocal: boolean, modelLoadedCallback: () => void, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager, composer: Composer);
+    constructor(characterDescription: CharacterDescription, animationConfig: AnimationConfig, characterModelLoader: CharacterModelLoader, characterId: number, modelLoadedCallback: () => void, cameraManager: CameraManager, composer: Composer);
     private load;
-    update(time: number): void;
+    updateAnimation(targetAnimation: AnimationState): void;
+    update(time: number, deltaTime: number): void;
+    getCurrentAnimation(): AnimationState;
 }

package/build/character/CharacterManager.d.ts

@@ -5,7 +5,7 @@ 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 { AnimationConfig, Character, CharacterDescription } from "./Character";
 import { CharacterModelLoader } from "./CharacterModelLoader";
 import { CharacterState } from "./CharacterState";
 import { RemoteController } from "./RemoteController";
@@ -15,22 +15,26 @@ export declare class CharacterManager {
     private readonly collisionsManager;
     private readonly cameraManager;
     private readonly timeManager;
-    private readonly inputManager;
+    private readonly keyInputManager;
     private readonly clientStates;
     private readonly sendUpdate;
+    private readonly animationConfig;
+    private readonly characterDescription;
     private updateLocationHash;
+    readonly headTargetOffset: Vector3;
     private id;
-    loadingCharacters: Map<number, Promise<Character>>;
     remoteCharacters: Map<number, Character>;
     remoteCharacterControllers: Map<number, RemoteController>;
-    private characterDescription;
-    character: Character | null;
+    private localCharacterSpawned;
+    private localController;
+    localCharacter: Character | null;
     private cameraOffsetTarget;
     private cameraOffset;
     private speakingCharacters;
     readonly group: Group;
-    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>;
+    constructor(composer: Composer, characterModelLoader: CharacterModelLoader, collisionsManager: CollisionsManager, cameraManager: CameraManager, timeManager: TimeManager, keyInputManager: KeyInputManager, clientStates: Map<number, CharacterState>, sendUpdate: (update: CharacterState) => void, animationConfig: AnimationConfig, characterDescription: CharacterDescription);
+    spawnLocalCharacter(characterDescription: CharacterDescription, id: number, spawnPosition?: Vector3, spawnRotation?: Euler): void;
+    spawnRemoteCharacter(characterDescription: CharacterDescription, id: number, spawnPosition?: Vector3, spawnRotation?: Euler): void;
     getLocalCharacterPositionAndRotation(): PositionAndRotation;
     clear(): void;
     setSpeakingCharacter(id: number, value: boolean): void;

package/build/character/CharacterMaterial.d.ts

@@ -5,7 +5,7 @@ type TUniform<TValue = any> = {
 export declare class CharacterMaterial extends MeshPhysicalMaterial {
     uniforms: Record<string, TUniform>;
     colorsCube216: Color[];
-    constructor();
+    constructor(color?: Color);
     private generateColorCube;
     update(): void;
 }

package/build/character/CharacterModel.d.ts

@@ -1,10 +1,11 @@
 import { AnimationAction, AnimationMixer, Bone, Object3D } from "three";
-import { CharacterDescription } from "./Character";
+import { AnimationConfig, CharacterDescription } from "./Character";
 import { CharacterMaterial } from "./CharacterMaterial";
 import { CharacterModelLoader } from "./CharacterModelLoader";
 import { AnimationState } from "./CharacterState";
 export declare class CharacterModel {
     private readonly characterDescription;
+    private readonly animationConfig;
     private characterModelLoader;
     mesh: Object3D | null;
     material: CharacterMaterial;
@@ -12,14 +13,16 @@ export declare class CharacterModel {
     animations: Record<string, AnimationAction>;
     animationMixer: AnimationMixer | null;
     currentAnimation: AnimationState;
-    constructor(characterDescription: CharacterDescription, characterModelLoader: CharacterModelLoader);
+    constructor(characterDescription: CharacterDescription, animationConfig: AnimationConfig, characterModelLoader: CharacterModelLoader);
     init(): Promise<void>;
-    updateAnimation(targetAnimation: AnimationState, deltaTime: number): void;
-    hideMaterialByMeshName(meshName: any): void;
-    private setShadows;
-    private applyMaterialToAllSkinnedMeshes;
-    private initAnimationMixer;
+    private applyCustomMaterial;
+    updateAnimation(targetAnimation: AnimationState): void;
+    private setMainMesh;
+    private composeMMLCharacter;
+    private loadCharacterFromDescription;
     private loadMainMesh;
+    private cleanAnimationClips;
     private setAnimationFromFile;
     private transitionToAnimation;
+    update(time: number): void;
 }

package/build/character/CharacterModelLoader.d.ts

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

package/build/character/CharacterTooltip.d.ts

@@ -1,14 +1,12 @@
-import { Camera, Object3D } from "three";
-export declare class CharacterTooltip {
-    private geometry;
-    private material;
-    private mesh;
+import { Camera, Mesh } from "three";
+export declare class CharacterTooltip extends Mesh {
+    private tooltipMaterial;
     private visibleOpacity;
     private targetOpacity;
     private fadingSpeed;
     private secondsToFadeOut;
     private props;
-    constructor(parentModel: Object3D);
+    constructor();
     private redrawText;
     setText(text: string, temporary?: boolean): void;
     hide(): void;

package/build/character/LocalController.d.ts

@@ -1,24 +1,21 @@
-import { Line3 } from "three";
+import { Line3, Quaternion, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
 import { TimeManager } from "../time/TimeManager";
-import { CharacterModel } from "./CharacterModel";
+import { Character } from "./Character";
 import { CharacterState } from "./CharacterState";
 export declare class LocalController {
-    private readonly model;
+    private readonly character;
     private readonly id;
     private readonly collisionsManager;
     private readonly keyInputManager;
     private readonly cameraManager;
     private readonly timeManager;
-    private collisionDetectionSteps;
     capsuleInfo: {
         radius: number;
         segment: Line3;
     };
-    private maxWalkSpeed;
-    private maxRunSpeed;
     private gravity;
     private jumpForce;
     private coyoteTimeThreshold;
@@ -28,6 +25,7 @@ export declare class LocalController {
     private characterWasOnGround;
     private characterAirborneSince;
     private currentHeight;
+    private currentSurfaceAngle;
     private characterVelocity;
     private vectorUp;
     private vectorDown;
@@ -35,9 +33,21 @@ export declare class LocalController {
     private azimuthalAngle;
     private tempMatrix;
     private tempSegment;
+    private tempQuaternion;
+    private tempEuler;
     private tempVector;
     private tempVector2;
+    private tempVector3;
     private rayCaster;
+    private surfaceTempQuaternion;
+    private surfaceTempQuaternion2;
+    private surfaceTempVector1;
+    private surfaceTempVector2;
+    private surfaceTempVector3;
+    private surfaceTempVector4;
+    private surfaceTempVector5;
+    private surfaceTempRay;
+    private lastFrameSurfaceState;
     private forward;
     private backward;
     private left;
@@ -46,19 +56,21 @@ export declare class LocalController {
     private jump;
     private anyDirection;
     private conflictingDirections;
-    private thirdPersonCamera;
-    private speed;
-    private targetSpeed;
     networkState: CharacterState;
-    constructor(model: CharacterModel, id: number, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager);
+    constructor(character: Character, id: number, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager);
+    private updateControllerState;
     update(): void;
     private getTargetAnimation;
     private updateRotationOffset;
     private updateAzimuthalAngle;
     private computeAngularDifference;
     private updateRotation;
-    private addScaledVectorToCharacter;
+    private applyControls;
     private updatePosition;
+    getMovementFromSurfaces(userPosition: Vector3, deltaTime: number): {
+        rotation: Quaternion;
+        position: Vector3;
+    } | null;
     private updateNetworkState;
     private resetPosition;
 }

package/build/character/RemoteController.d.ts

@@ -1,19 +1,11 @@
-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;
-    characterModel: Object3D | null;
-    private animationMixer;
-    private animations;
     currentAnimation: AnimationState;
     networkState: CharacterState;
-    constructor(character: Character, characterModelLoader: CharacterModelLoader, id: number);
+    constructor(character: Character, id: number);
     update(clientUpdate: CharacterState, time: number, deltaTime: number): void;
-    setAnimationFromFile(animationType: AnimationState, fileName: string): Promise<void>;
-    private transitionToAnimation;
     private updateFromNetwork;
 }

package/build/character/url-position.d.ts

@@ -0,0 +1,12 @@
+import { Object3D, Quaternion, Vector3 } from "three";
+export declare function encodeCharacterAndCamera(character: Object3D, camera: Object3D): string;
+export declare function decodeCharacterAndCamera(hash: string): {
+    character: {
+        position: Vector3;
+        quaternion: Quaternion;
+    };
+    camera: {
+        position: Vector3;
+        quaternion: Quaternion;
+    };
+};

package/build/collisions/CollisionsManager.d.ts

@@ -1,7 +1,7 @@
 import { MElement } from "mml-web";
-import { Group, Line3, Matrix4, Ray, Scene } from "three";
+import { Group, Line3, Matrix4, Ray, Scene, Vector3 } from "three";
 import { MeshBVH } from "three-mesh-bvh";
-type CollisionMeshState = {
+export type CollisionMeshState = {
     matrix: Matrix4;
     source: Group;
     meshBVH: MeshBVH;
@@ -14,6 +14,7 @@ export declare class CollisionsManager {
     private tempVector;
     private tempVector2;
     private tempVector3;
+    private tempQuaternion;
     private tempRay;
     private tempMatrix;
     private tempMatrix2;
@@ -24,7 +25,7 @@ export declare class CollisionsManager {
     collisionMeshState: Map<Group, CollisionMeshState>;
     private collisionTrigger;
     constructor(scene: Scene);
-    raycastFirstDistance(ray: Ray): number | null;
+    raycastFirst(ray: Ray): [number, Vector3, CollisionMeshState] | null;
     private createCollisionMeshState;
     addMeshesGroup(group: Group, mElement?: MElement): void;
     updateMeshesGroup(group: Group): void;
@@ -32,4 +33,3 @@ export declare class CollisionsManager {
     private applyCollider;
     applyColliders(tempSegment: Line3, radius: number): void;
 }
-export {};

package/build/index.d.ts

@@ -1,6 +1,8 @@
 export { CameraManager } from "./camera/CameraManager";
-export { CharacterDescription } from "./character/Character";
+export { CharacterDescription, AnimationConfig } from "./character/Character";
 export { CharacterManager } from "./character/CharacterManager";
+export * from "./character/url-position";
+export * from "./helpers/math-helpers";
 export { CharacterModelLoader } from "./character/CharacterModelLoader";
 export { CharacterState, AnimationState } from "./character/CharacterState";
 export { KeyInputManager } from "./input/KeyInputManager";