@mml-io/3d-web-client-core 0.0.0-experimental-751c031-20230804

package/build/camera/CameraManager.d.ts

@@ -0,0 +1,37 @@
+import { PerspectiveCamera, Vector3 } from "three";
+import { CollisionsManager } from "../collisions/CollisionsManager";
+export declare class CameraManager {
+    private collisionsManager;
+    readonly camera: PerspectiveCamera;
+    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;
+    private rayCaster;
+    constructor(collisionsManager: CollisionsManager);
+    private onResize;
+    private onMouseDown;
+    private onMouseUp;
+    private onMouseMove;
+    private onMouseWheel;
+    setTarget(target: Vector3): void;
+    private reverseUpdateFromPositions;
+    adjustCameraPosition(): void;
+    update(): void;
+}

package/build/character/Character.d.ts

@@ -0,0 +1,33 @@
+import { Color, 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 { LocalController } from "./LocalController";
+export type CharacterDescription = {
+    meshFileUrl: string;
+    idleAnimationFileUrl: string;
+    jogAnimationFileUrl: string;
+    sprintAnimationFileUrl: string;
+    airAnimationFileUrl: string;
+    modelScale: number;
+};
+export declare class Character {
+    private readonly characterDescription;
+    private readonly id;
+    private readonly isLocal;
+    private readonly modelLoadedCallback;
+    private readonly collisionsManager;
+    private readonly keyInputManager;
+    private readonly cameraManager;
+    private readonly timeManager;
+    controller: LocalController | null;
+    name: string | null;
+    model: CharacterModel | null;
+    color: Color;
+    position: Vector3;
+    constructor(characterDescription: CharacterDescription, id: number, isLocal: boolean, modelLoadedCallback: () => void, collisionsManager: CollisionsManager, keyInputManager: KeyInputManager, cameraManager: CameraManager, timeManager: TimeManager);
+    private load;
+    update(time: number): void;
+}

package/build/character/CharacterManager.d.ts

@@ -0,0 +1,31 @@
+import { PositionAndRotation } from "mml-web";
+import { Group, Vector3 } from "three";
+import { CameraManager } from "../camera/CameraManager";
+import { CollisionsManager } from "../collisions/CollisionsManager";
+import { KeyInputManager } from "../input/KeyInputManager";
+import { TimeManager } from "../time/TimeManager";
+import { Character, CharacterDescription } from "./Character";
+import { CharacterState } from "./CharacterState";
+import { RemoteController } from "./RemoteController";
+export declare class CharacterManager {
+    private readonly collisionsManager;
+    private readonly cameraManager;
+    private readonly timeManager;
+    private readonly inputManager;
+    private readonly clientStates;
+    private readonly sendUpdate;
+    private updateLocationHash;
+    loadingCharacters: Map<number, Promise<Character>>;
+    remoteCharacters: Map<number, Character>;
+    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, spawnPosition?: Vector3): Promise<Character>;
+    getLocalCharacterPositionAndRotation(): PositionAndRotation;
+    clear(): void;
+    update(): void;
+}

package/build/character/CharacterMaterial.d.ts

@@ -0,0 +1,12 @@
+import { Color, MeshPhysicalMaterial } from "three";
+type TUniform<TValue = any> = {
+    value: TValue;
+};
+export declare class CharacterMaterial extends MeshPhysicalMaterial {
+    uniforms: Record<string, TUniform>;
+    colorsCube216: Color[];
+    constructor();
+    private generateColorCube;
+    update(): void;
+}
+export {};

package/build/character/CharacterModel.d.ts

@@ -0,0 +1,23 @@
+import { AnimationAction, AnimationMixer, Object3D } from "three";
+import { CharacterDescription } from "./Character";
+import { CharacterMaterial } from "./CharacterMaterial";
+import { AnimationState } from "./CharacterState";
+export declare class CharacterModel {
+    private readonly characterDescription;
+    private modelLoader;
+    mesh: Object3D | null;
+    material: CharacterMaterial;
+    animations: Record<string, AnimationAction>;
+    animationMixer: AnimationMixer | null;
+    currentAnimation: AnimationState;
+    constructor(characterDescription: CharacterDescription);
+    init(): Promise<void>;
+    updateAnimation(targetAnimation: AnimationState, deltaTime: number): void;
+    hideMaterialByMeshName(meshName: any): void;
+    private setShadows;
+    private applyMaterialToAllSkinnedMeshes;
+    private initAnimationMixer;
+    private loadMainMesh;
+    private setAnimationFromFile;
+    private transitionToAnimation;
+}

package/build/character/CharacterState.d.ts

@@ -0,0 +1,21 @@
+export declare enum AnimationState {
+    "idle" = 0,
+    "walking" = 1,
+    "running" = 2,
+    "jumpToAir" = 3,
+    "air" = 4,
+    "airToGround" = 5
+}
+export type CharacterState = {
+    id: number;
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation: {
+        quaternionY: number;
+        quaternionW: number;
+    };
+    state: AnimationState;
+};

package/build/character/LocalController.d.ts

@@ -0,0 +1,64 @@
+import { Line3 } 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 { CharacterState } from "./CharacterState";
+export declare class LocalController {
+    private readonly model;
+    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;
+    private coyoteTime;
+    private canJump;
+    private characterOnGround;
+    private characterWasOnGround;
+    private characterAirborneSince;
+    private currentHeight;
+    private characterVelocity;
+    private vectorUp;
+    private vectorDown;
+    private rotationOffset;
+    private azimuthalAngle;
+    private tempBox;
+    private tempMatrix;
+    private tempSegment;
+    private tempVector;
+    private tempVector2;
+    private rayCaster;
+    private forward;
+    private backward;
+    private left;
+    private right;
+    private run;
+    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);
+    update(): void;
+    private getTargetAnimation;
+    private updateRotationOffset;
+    private updateAzimuthalAngle;
+    private updateRotation;
+    private addScaledVectorToCharacter;
+    private updatePosition;
+    private updateNetworkState;
+    private resetPosition;
+}

package/build/character/ModelLoader.d.ts

@@ -0,0 +1,14 @@
+import { AnimationClip, Object3D } from "three";
+export declare class ModelLoader {
+    private static instance;
+    private readonly loadingManager;
+    private readonly gltfLoader;
+    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

@@ -0,0 +1,18 @@
+import { Object3D } from "three";
+import { Character } from "./Character";
+import { AnimationState, CharacterState } from "./CharacterState";
+export declare class RemoteController {
+    readonly character: Character;
+    readonly id: number;
+    private modelLoader;
+    characterModel: Object3D | null;
+    private animationMixer;
+    private animations;
+    currentAnimation: AnimationState;
+    networkState: CharacterState;
+    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/collisions/CollisionsManager.d.ts

@@ -0,0 +1,25 @@
+import { MElement } from "mml-web";
+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;
+    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;
+    removeMeshesGroup(group: Group): void;
+    private applyCollider;
+    applyColliders(tempSegment: Line3, radius: number, boundingBox: Box3): void;
+}
+export {};

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

@@ -0,0 +1,6 @@
+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;

package/build/index.d.ts

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