@mml-io/3d-web-client-core 0.15.0 → 0.17.0

package/build/camera/CameraManager.d.ts

@@ -1,22 +1,27 @@
 import { PerspectiveCamera, Vector3 } from "three";
 import { CollisionsManager } from "../collisions/CollisionsManager";
+import { TweakPane } from "../tweakpane/TweakPane";
 export declare class CameraManager {
     private collisionsManager;
     readonly camera: PerspectiveCamera;
     initialDistance: number;
-    private minDistance;
-    private maxDistance;
-    private initialFOV;
-    private fov;
-    private minFOV;
-    private maxFOV;
+    minDistance: number;
+    maxDistance: number;
+    initialFOV: number;
+    maxFOV: number;
+    minFOV: number;
+    damping: number;
+    dampingScale: number;
+    zoomScale: number;
+    zoomDamping: number;
+    invertFOVMapping: boolean;
+    fov: number;
     private targetFOV;
     minPolarAngle: number;
     private maxPolarAngle;
-    private dampingFactor;
     targetDistance: number;
-    private distance;
-    private desiredDistance;
+    distance: number;
+    desiredDistance: number;
     private targetPhi;
     private phi;
     private targetTheta;
@@ -35,6 +40,7 @@ export declare class CameraManager {
     private lastTouchX;
     private lastTouchY;
     constructor(targetElement: HTMLElement, collisionsManager: CollisionsManager, initialPhi?: number, initialTheta?: number);
+    setupTweakPane(tweakPane: TweakPane): void;
     private onTouchStart;
     private onTouchMove;
     private onTouchEnd;
@@ -42,6 +48,7 @@ export declare class CameraManager {
     private onMouseUp;
     private onMouseMove;
     private onMouseWheel;
+    private onContextMenu;
     setTarget(target: Vector3): void;
     setLerpedTarget(target: Vector3, targetDistance: number): void;
     reverseUpdateFromPositions(): void;
@@ -49,5 +56,6 @@ export declare class CameraManager {
     dispose(): void;
     private easeOutExpo;
     updateAspect(aspect: number): void;
+    recomputeFoV(immediately?: boolean): void;
     update(): void;
 }

package/build/character/Character.d.ts

@@ -10,26 +10,38 @@ export type AnimationConfig = {
     jogAnimationFileUrl: string;
     sprintAnimationFileUrl: string;
     airAnimationFileUrl: string;
+    doubleJumpAnimationFileUrl: string;
 };
 export type CharacterDescription = {
     meshFileUrl?: string;
     mmlCharacterUrl?: string;
     mmlCharacterString?: string;
+} & ({
+    meshFileUrl: string;
+} | {
+    mmlCharacterUrl: string;
+} | {
+    mmlCharacterString: string;
+});
+export type CharacterConfig = {
+    username: string;
+    characterDescription: CharacterDescription;
+    animationConfig: AnimationConfig;
+    characterModelLoader: CharacterModelLoader;
+    characterId: number;
+    modelLoadedCallback: () => void;
+    cameraManager: CameraManager;
+    composer: Composer;
+    isLocal: boolean;
 };
 export declare class Character extends Group {
-    private readonly characterDescription;
-    private readonly animationConfig;
-    private readonly characterModelLoader;
-    private readonly characterId;
-    private readonly modelLoadedCallback;
-    private readonly cameraManager;
-    private readonly composer;
-    private readonly isLocal;
+    private config;
     private model;
     color: Color;
-    tooltip: CharacterTooltip | null;
+    tooltip: CharacterTooltip;
     speakingIndicator: CharacterSpeakingIndicator | null;
-    constructor(characterDescription: CharacterDescription, animationConfig: AnimationConfig, characterModelLoader: CharacterModelLoader, characterId: number, modelLoadedCallback: () => void, cameraManager: CameraManager, composer: Composer, isLocal: boolean);
+    constructor(config: CharacterConfig);
+    updateCharacter(username: string, characterDescription: CharacterDescription): void;
     private load;
     updateAnimation(targetAnimation: AnimationState): void;
     update(time: number, deltaTime: number): void;

package/build/character/CharacterManager.d.ts

@@ -3,38 +3,50 @@ import { Euler, Group, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
+import { VirtualJoystick } from "../input/VirtualJoystick";
 import { Composer } from "../rendering/composer";
 import { TimeManager } from "../time/TimeManager";
+import { TweakPane } from "../tweakpane/TweakPane";
 import { AnimationConfig, Character, CharacterDescription } from "./Character";
 import { CharacterModelLoader } from "./CharacterModelLoader";
 import { CharacterState } from "./CharacterState";
+import { LocalController } from "./LocalController";
 import { RemoteController } from "./RemoteController";
+export type CharacterManagerConfig = {
+    composer: Composer;
+    characterModelLoader: CharacterModelLoader;
+    collisionsManager: CollisionsManager;
+    cameraManager: CameraManager;
+    timeManager: TimeManager;
+    keyInputManager: KeyInputManager;
+    virtualJoystick?: VirtualJoystick;
+    remoteUserStates: Map<number, CharacterState>;
+    sendUpdate: (update: CharacterState) => void;
+    animationConfig: AnimationConfig;
+    characterResolve: (clientId: number) => {
+        username: string;
+        characterDescription: CharacterDescription;
+    };
+    updateURLLocation?: boolean;
+};
 export declare class CharacterManager {
-    private readonly composer;
-    private readonly characterModelLoader;
-    private readonly collisionsManager;
-    private readonly cameraManager;
-    private readonly timeManager;
-    private readonly keyInputManager;
-    private readonly clientStates;
-    private readonly sendUpdate;
-    private readonly animationConfig;
-    private readonly characterDescription;
-    private updateLocationHash;
+    private config;
     readonly headTargetOffset: Vector3;
-    private id;
+    private localClientId;
     remoteCharacters: Map<number, Character>;
     remoteCharacterControllers: Map<number, RemoteController>;
     private localCharacterSpawned;
-    private localController;
+    localController: LocalController;
     localCharacter: Character | null;
     private speakingCharacters;
     readonly group: Group;
-    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;
+    constructor(config: CharacterManagerConfig);
+    spawnLocalCharacter(id: number, username: string, characterDescription: CharacterDescription, spawnPosition?: Vector3, spawnRotation?: Euler): void;
+    setupTweakPane(tweakPane: TweakPane): void;
+    spawnRemoteCharacter(id: number, username: string, characterDescription: CharacterDescription, spawnPosition?: Vector3, spawnRotation?: Euler): void;
     getLocalCharacterPositionAndRotation(): PositionAndRotation;
     clear(): void;
     setSpeakingCharacter(id: number, value: boolean): void;
+    respawnIfPresent(id: number): void;
     update(): void;
 }

package/build/character/CharacterMaterial.d.ts

@@ -1,16 +1,19 @@
 import { Color, MeshStandardMaterial } from "three";
 import { CameraManager } from "../camera/CameraManager";
+export type CharacterMaterialConfig = {
+    isLocal: boolean;
+    cameraManager: CameraManager;
+    characterId: number;
+    originalMaterial: MeshStandardMaterial;
+    colorOverride?: Color;
+};
 export declare class CharacterMaterial extends MeshStandardMaterial {
-    private isLocal;
-    private cameraManager;
-    private characterId;
-    private originalMaterial;
-    private colorOverride?;
+    private config;
     private uniforms;
     private colorsCube216;
     private targetAlpha;
     private currentAlpha;
-    constructor(isLocal: boolean, cameraManager: CameraManager, characterId: number, originalMaterial: MeshStandardMaterial, colorOverride?: Color | undefined);
+    constructor(config: CharacterMaterialConfig);
     private generateColorCube;
     update(): void;
 }

package/build/character/CharacterModel.d.ts

@@ -1,16 +1,21 @@
 import { type MMLCharacterDescription } from "@mml-io/3d-web-avatar";
+import { ModelLoader } from "@mml-io/model-loader";
 import { AnimationAction, AnimationMixer, Bone, Object3D } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { AnimationConfig, CharacterDescription } from "./Character";
 import { CharacterModelLoader } from "./CharacterModelLoader";
 import { AnimationState } from "./CharacterState";
+export type CharacterModelConfig = {
+    characterDescription: CharacterDescription;
+    animationConfig: AnimationConfig;
+    characterModelLoader: CharacterModelLoader;
+    cameraManager: CameraManager;
+    characterId: number;
+    isLocal: boolean;
+};
 export declare class CharacterModel {
-    private readonly characterDescription;
-    private readonly animationConfig;
-    private characterModelLoader;
-    private readonly cameraManager;
-    private readonly characterId;
-    private readonly isLocal;
+    private config;
+    static ModelLoader: ModelLoader;
     mesh: Object3D | null;
     headBone: Bone | null;
     private materials;
@@ -18,7 +23,8 @@ export declare class CharacterModel {
     animationMixer: AnimationMixer | null;
     currentAnimation: AnimationState;
     mmlCharacterDescription: MMLCharacterDescription;
-    constructor(characterDescription: CharacterDescription, animationConfig: AnimationConfig, characterModelLoader: CharacterModelLoader, cameraManager: CameraManager, characterId: number, isLocal: boolean);
+    private isPostDoubleJump;
+    constructor(config: CharacterModelConfig);
     init(): Promise<void>;
     private applyCustomMaterials;
     updateAnimation(targetAnimation: AnimationState): void;

package/build/character/CharacterModelLoader.d.ts

@@ -1,8 +1,7 @@
 import { AnimationClip, Object3D } from "three";
 export declare class CharacterModelLoader {
     private debug;
-    private readonly loadingManager;
-    private readonly gltfLoader;
+    private readonly modelLoader;
     private modelCache;
     private ongoingLoads;
     constructor(maxCacheSize?: number, debug?: boolean);

package/build/character/CharacterState.d.ts

@@ -4,7 +4,8 @@ export declare enum AnimationState {
     "running" = 2,
     "jumpToAir" = 3,
     "air" = 4,
-    "airToGround" = 5
+    "airToGround" = 5,
+    "doubleJump" = 6
 }
 export type CharacterState = {
     id: number;
@@ -17,5 +18,14 @@ export type CharacterState = {
         quaternionY: number;
         quaternionW: number;
     };
+    camPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    camQuaternion?: {
+        y: number;
+        w: number;
+    };
     state: AnimationState;
 };

package/build/character/CharacterTooltip.d.ts

@@ -1,14 +1,30 @@
-import { Camera, Mesh } from "three";
+import { Camera, Color, Mesh } from "three";
+declare enum LabelAlignment {
+    left = "left",
+    center = "center",
+    right = "right"
+}
+export type CharacterTooltipConfig = {
+    alignment: LabelAlignment;
+    width: number;
+    height: number;
+    fontSize: number;
+    padding: number;
+    color: Color;
+    fontColor: Color;
+    castShadows: boolean;
+};
 export declare class CharacterTooltip extends Mesh {
     private tooltipMaterial;
     private visibleOpacity;
     private targetOpacity;
     private fadingSpeed;
     private secondsToFadeOut;
-    private props;
-    constructor();
+    private config;
+    constructor(configArg?: Partial<CharacterTooltipConfig>);
     private redrawText;
     setText(text: string, temporary?: boolean): void;
     hide(): void;
     update(camera: Camera): void;
 }
+export {};

package/build/character/LocalController.d.ts

@@ -2,26 +2,45 @@ import { Line3, Quaternion, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
+import { VirtualJoystick } from "../input/VirtualJoystick";
 import { TimeManager } from "../time/TimeManager";
 import { Character } from "./Character";
 import { CharacterState } from "./CharacterState";
+export type LocalControllerConfig = {
+    id: number;
+    character: Character;
+    collisionsManager: CollisionsManager;
+    keyInputManager: KeyInputManager;
+    virtualJoystick?: VirtualJoystick;
+    cameraManager: CameraManager;
+    timeManager: TimeManager;
+};
 export declare class LocalController {
-    private readonly character;
-    private readonly id;
-    private readonly collisionsManager;
-    private readonly keyInputManager;
-    private readonly cameraManager;
-    private readonly timeManager;
+    private config;
     capsuleInfo: {
         radius: number;
         segment: Line3;
     };
-    private gravity;
-    private jumpForce;
-    private coyoteTimeThreshold;
-    private coyoteTime;
-    private canJump;
-    private characterOnGround;
+    gravity: number;
+    jumpForce: number;
+    doubleJumpForce: number;
+    coyoteTimeThreshold: number;
+    canJump: boolean;
+    canDoubleJump: boolean;
+    coyoteJumped: boolean;
+    doubleJumpUsed: boolean;
+    jumpCounter: number;
+    airResistance: number;
+    groundResistance: number;
+    airControlModifier: number;
+    groundWalkControl: number;
+    groundRunControl: number;
+    baseControl: number;
+    minimumSurfaceAngle: number;
+    latestPosition: Vector3;
+    characterOnGround: boolean;
+    coyoteTime: boolean;
+    private collisionDetectionSteps;
     private characterWasOnGround;
     private characterAirborneSince;
     private currentHeight;
@@ -56,8 +75,10 @@ export declare class LocalController {
     private jump;
     private anyDirection;
     private conflictingDirections;
+    jumpPressed: boolean;
+    jumpReleased: boolean;
     networkState: CharacterState;
-    constructor(character: Character, id: number, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager);
+    constructor(config: LocalControllerConfig);
     private updateControllerState;
     update(): void;
     private getTargetAnimation;
@@ -65,6 +86,7 @@ export declare class LocalController {
     private updateAzimuthalAngle;
     private computeAngularDifference;
     private updateRotation;
+    private processJump;
     private applyControls;
     private updatePosition;
     getMovementFromSurfaces(userPosition: Vector3, deltaTime: number): {

package/build/character/RemoteController.d.ts

@@ -1,11 +1,14 @@
 import { Character } from "./Character";
 import { AnimationState, CharacterState } from "./CharacterState";
+export type RemoteControllerConfig = {
+    id: number;
+    character: Character;
+};
 export declare class RemoteController {
-    readonly character: Character;
-    readonly id: number;
+    private config;
     currentAnimation: AnimationState;
     networkState: CharacterState;
-    constructor(character: Character, id: number);
+    constructor(config: RemoteControllerConfig);
     update(clientUpdate: CharacterState, time: number, deltaTime: number): void;
     private updateFromNetwork;
 }

package/build/ground-plane/GroundPlane.d.ts

@@ -0,0 +1,9 @@
+import { Group } from "three";
+export declare class GroundPlane extends Group {
+    private readonly floorSize;
+    private readonly floorTexture;
+    private readonly floorGeometry;
+    private readonly floorMaterial;
+    private readonly floorMesh;
+    constructor();
+}

package/build/index.d.ts

@@ -6,9 +6,13 @@ export * from "./helpers/math-helpers";
 export { CharacterModelLoader } from "./character/CharacterModelLoader";
 export { CharacterState, AnimationState } from "./character/CharacterState";
 export { KeyInputManager } from "./input/KeyInputManager";
+export { VirtualJoystick } from "./input/VirtualJoystick";
 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";
 export { Sun } from "./sun/Sun";
+export { GroundPlane } from "./ground-plane/GroundPlane";
+export { LoadingScreen } from "./loading-screen/LoadingScreen";
+export { EnvironmentConfiguration } from "./rendering/composer";