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

package/build/camera/CameraManager.d.ts

@@ -1,15 +1,25 @@
 import { PerspectiveCamera } from "three";
 export declare class CameraManager {
     readonly camera: PerspectiveCamera;
-    private dragging;
-    private target;
+    initialDistance: number;
+    private minDistance;
+    private maxDistance;
+    private initialFOV;
+    private fov;
+    private minFOV;
+    private maxFOV;
+    private targetFOV;
+    private minPolarAngle;
+    private maxPolarAngle;
+    private dampingFactor;
     private targetDistance;
-    private maxTargetDistance;
     private distance;
     private targetPhi;
     private phi;
     private targetTheta;
     private theta;
+    private dragging;
+    private target;
     private hadTarget;
     constructor();
     private onResize;

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";
@@ -22,7 +22,7 @@ export declare class CharacterManager {
     character: Character | null;
     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/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

@@ -7,7 +7,11 @@ export declare class CollisionsManager {
     private tempVector2;
     private collisionMeshState;
     private collisionTrigger;
+    colliders: Group;
+    private collisionEnabledMeshes;
     constructor(scene: Scene);
+    private safeAddColliders;
+    private removeFromColliders;
     private createCollisionMeshState;
     addMeshesGroup(group: Group, mElement?: MElement): void;
     updateMeshesGroup(group: Group): void;

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;