@mml-io/3d-web-client-core 0.1.0 → 0.3.0

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/build/camera/CameraManager.d.ts

@@ -1,23 +1,37 @@
-import { PerspectiveCamera } from "three";
+import { PerspectiveCamera, Vector3 } from "three";
+import { CollisionsManager } from "../collisions/CollisionsManager";
 export declare class CameraManager {
+    private collisionsManager;
     readonly camera: PerspectiveCamera;
-    private dragging;
-    private target;
-    private targetDistance;
-    private maxTargetDistance;
+    initialDistance: number;
+    private minDistance;
+    private maxDistance;
+    private initialFOV;
+    private fov;
+    private minFOV;
+    private maxFOV;
+    private targetFOV;
+    private minPolarAngle;
+    private maxPolarAngle;
+    private dampingFactor;
+    targetDistance: number;
     private distance;
     private targetPhi;
     private phi;
     private targetTheta;
     private theta;
+    private dragging;
+    private target;
     private hadTarget;
-    constructor();
+    private rayCaster;
+    constructor(collisionsManager: CollisionsManager);
     private onResize;
     private onMouseDown;
     private onMouseUp;
     private onMouseMove;
     private onMouseWheel;
-    setTarget(target: THREE.Vector3): void;
+    setTarget(target: Vector3): void;
     private reverseUpdateFromPositions;
+    adjustCameraPosition(): void;
     update(): void;
 }

package/build/character/Character.d.ts

@@ -10,6 +10,7 @@ export type CharacterDescription = {
     idleAnimationFileUrl: string;
     jogAnimationFileUrl: string;
     sprintAnimationFileUrl: string;
+    airAnimationFileUrl: string;
     modelScale: number;
 };
 export declare class Character {

package/build/character/CharacterManager.d.ts

@@ -1,5 +1,5 @@
 import { PositionAndRotation } from "mml-web";
-import { Group } from "three";
+import { Group, Vector3 } from "three";
 import { CameraManager } from "../camera/CameraManager";
 import { CollisionsManager } from "../collisions/CollisionsManager";
 import { KeyInputManager } from "../input/KeyInputManager";
@@ -20,9 +20,11 @@ export declare class CharacterManager {
     remoteCharacterControllers: Map<number, RemoteController>;
     private characterDescription;
     character: Character | null;
+    private cameraOffsetTarget;
+    private cameraOffset;
     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): Promise<Character>;
+    spawnCharacter(characterDescription: CharacterDescription, id: number, isLocal?: boolean, spawnPosition?: Vector3): Promise<Character>;
     getLocalCharacterPositionAndRotation(): PositionAndRotation;
     clear(): void;
     update(): void;

package/build/character/CharacterMaterial.d.ts

@@ -7,5 +7,6 @@ export declare class CharacterMaterial extends MeshPhysicalMaterial {
     colorsCube216: Color[];
     constructor();
     private generateColorCube;
+    update(): void;
 }
 export {};

package/build/character/LocalController.d.ts

@@ -17,10 +17,20 @@ export declare class LocalController {
         radius: number;
         segment: Line3;
     };
+    private maxWalkSpeed;
+    private maxRunSpeed;
+    private gravity;
+    private jumpForce;
+    private coyoteTimeThreshold;
+    private coyoteTime;
+    private canJump;
     private characterOnGround;
+    private characterWasOnGround;
+    private characterAirborneSince;
+    private currentHeight;
     private characterVelocity;
-    private gravity;
-    private upVector;
+    private vectorUp;
+    private vectorDown;
     private rotationOffset;
     private azimuthalAngle;
     private tempBox;
@@ -28,11 +38,15 @@ export declare class LocalController {
     private tempSegment;
     private tempVector;
     private tempVector2;
-    private jumpInput;
-    private jumpForce;
-    private canJump;
-    private inputDirections;
-    private runInput;
+    private rayCaster;
+    private forward;
+    private backward;
+    private left;
+    private right;
+    private run;
+    private jump;
+    private anyDirection;
+    private conflictingDirections;
     private thirdPersonCamera;
     private speed;
     private targetSpeed;

package/build/character/ModelLoader.d.ts

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

package/build/character/RemoteController.d.ts

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

package/build/collisions/CollisionsManager.d.ts

@@ -1,13 +1,20 @@
 import { MElement } from "mml-web";
-import { Box3, Group, Line3, Scene } from "three";
+import { Box3, Group, Line3, Ray, Scene } from "three";
+import { MeshBVH, MeshBVHVisualizer } from "three-mesh-bvh";
+type CollisionMeshState = {
+    source: Group;
+    meshBVH: MeshBVH;
+    visualizer: MeshBVHVisualizer | null;
+};
 export declare class CollisionsManager {
     private debug;
     private scene;
     private tempVector;
     private tempVector2;
-    private collisionMeshState;
+    collisionMeshState: Map<Group, CollisionMeshState>;
     private collisionTrigger;
     constructor(scene: Scene);
+    raycastFirstDistance(ray: Ray): number | null;
     private createCollisionMeshState;
     addMeshesGroup(group: Group, mElement?: MElement): void;
     updateMeshesGroup(group: Group): void;
@@ -15,3 +22,4 @@ export declare class CollisionsManager {
     private applyCollider;
     applyColliders(tempSegment: Line3, radius: number, boundingBox: Box3): void;
 }
+export {};

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

@@ -2,3 +2,5 @@ import { Vector3 } from "three";
 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;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare const remap: (value: number, minValue: number, maxValue: number, minScaledValue: number, maxScaledValue: number) => number;