build

dist/TPS/AnimationController.d.ts

@@ -0,0 +1,16 @@
+import { Mesh, AnimationMixer } from 'three';
+import type { AnimationClip, AnimationAction } from 'three';
+export type Motion = {
+    [name: string]: AnimationAction;
+};
+export declare class AnimationController {
+    mesh: Mesh;
+    motion: Motion;
+    mixer: AnimationMixer;
+    currentMotionName: string;
+    _targetRotY: number | null;
+    constructor(mesh: Mesh, animations: AnimationClip[]);
+    play(name: string): void;
+    turn(rad: number, immediate: boolean): void;
+    update(deltaTime: number): void;
+}

dist/TPS/KeyInputControl.d.ts

@@ -0,0 +1,17 @@
+import { EventDispatcher } from '../core/EventDispatcher';
+export declare class KeyInputControl extends EventDispatcher {
+    private isDisabled;
+    private isUp;
+    private isDown;
+    private isLeft;
+    private isRight;
+    private isMoveKeyHolding;
+    private frontAngle;
+    private _keydownListener;
+    private _keyupListener;
+    private _blurListener;
+    constructor();
+    jump(): void;
+    updateAngle(): void;
+    dispose(): void;
+}

dist/TPS/TPSCameraControls.d.ts

@@ -0,0 +1,8 @@
+import CameraControls from 'camera-controls';
+import { World } from 'core/World';
+export declare class TPSCameraControls extends CameraControls {
+    world: World;
+    constructor(camera: THREE.PerspectiveCamera, trackObject: THREE.Object3D, world: World, domElement: HTMLElement);
+    get frontAngle(): number;
+    _collisionTest(): number;
+}

dist/core/CharacterController.d.ts

@@ -0,0 +1,43 @@
+import { Vector3 } from 'three';
+import type { Object3D } from 'three';
+import { EventDispatcher } from './EventDispatcher';
+import type { ComputedTriangle } from '../math/triangle';
+export declare class CharacterController extends EventDispatcher {
+    isCharacterController: boolean;
+    object: Object3D;
+    radius: number;
+    position: Vector3;
+    groundCheckDepth: number;
+    maxSlopeGradient: number;
+    isGrounded: boolean;
+    isOnSlope: boolean;
+    isIdling: boolean;
+    isRunning: boolean;
+    isJumping: boolean;
+    direction: number;
+    movementSpeed: number;
+    velocity: Vector3;
+    currentJumpPower: number;
+    jumpStartTime: number;
+    groundHeight: number;
+    groundNormal: Vector3;
+    nearTriangles: ComputedTriangle[];
+    contactInfo: {
+        depth: number;
+        point: Vector3;
+        triangle: ComputedTriangle;
+    }[];
+    private _events;
+    constructor(object3d: Object3D, radius: number);
+    setNearTriangles(nearTriangles: ComputedTriangle[]): void;
+    update(deltaTime: number): void;
+    _updateVelocity(): void;
+    _checkGround(): void;
+    _updatePosition(deltaTime: number): void;
+    _collisionDetection(): void;
+    _solvePosition(): void;
+    setDirection(): void;
+    jump(): void;
+    _updateJumping(): void;
+    teleport(x: number, y: number, z: number): void;
+}

dist/core/EventDispatcher.d.ts

@@ -0,0 +1,35 @@
+export type Listener = (event?: DispatcherEvent) => void;
+export interface DispatcherEvent {
+    type: string;
+    [key: string]: any;
+}
+export declare class EventDispatcher {
+    private _listeners;
+    /**
+     * Adds the specified event listener.
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    addEventListener(type: string, listener: Listener): void;
+    /**
+     * Presence of the specified event listener.
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    hasEventListener(type: string, listener: Listener): boolean;
+    /**
+     * Removes the specified event listener
+     * @param type event name
+     * @param listener handler function
+     * @category Methods
+     */
+    removeEventListener(type: string, listener: Listener): void;
+    /**
+     * Fire an event type.
+     * @param event DispatcherEvent
+     * @category Methods
+     */
+    dispatchEvent(event: DispatcherEvent): void;
+}

dist/core/Octree.d.ts

@@ -0,0 +1,29 @@
+import { ComputedTriangle } from '../math/triangle';
+import { Box3, Line3, Sphere, Vector3 } from 'three';
+import type { Ray, Object3D } from 'three';
+export declare class Octree {
+    box: Box3;
+    bounds: Box3;
+    triangles: ComputedTriangle[];
+    subTrees: Octree[];
+    constructor(box?: Box3);
+    addTriangle(triangle: ComputedTriangle): void;
+    calcBox(): this;
+    split(level: number): void;
+    build(): this;
+    getLineTriangles(line: Line3, result: ComputedTriangle[]): ComputedTriangle[];
+    getRayTriangles(ray: Ray, result: ComputedTriangle[]): ComputedTriangle[];
+    getSphereTriangles(sphere: Sphere, result: ComputedTriangle[]): ComputedTriangle[];
+    getCapsuleTriangles(capsule: Sphere, result: ComputedTriangle[]): void;
+    lineIntersect(line: Line3): false | {
+        distance: number;
+        triangle: ComputedTriangle;
+        position: Vector3;
+    };
+    rayIntersect(ray: Ray): false | {
+        distance: number;
+        triangle: ComputedTriangle | undefined;
+        position: Vector3 | undefined;
+    } | undefined;
+    addGraphNode(object: Object3D): void;
+}

dist/core/World.d.ts

@@ -0,0 +1,16 @@
+import { Octree } from './Octree';
+import { CharacterController } from './CharacterController';
+export declare class World {
+    colliderPool: Octree[];
+    characterPool: CharacterController[];
+    private _fps;
+    private _stepsPerFrame;
+    constructor({ fps, stepsPerFrame }?: {
+        fps?: number | undefined;
+        stepsPerFrame?: number | undefined;
+    });
+    add(object: Octree | CharacterController): void;
+    remove(object: Octree | CharacterController): void;
+    fixedUpdate(): void;
+    step(stepDeltaTime: number): void;
+}

dist/index.d.ts

@@ -0,0 +1,6 @@
+export { World } from './core/World';
+export { Octree } from './core/Octree';
+export { CharacterController } from './core/CharacterController';
+export { AnimationController } from './TPS/AnimationController';
+export { KeyInputControl } from './TPS/KeyInputControl';
+export { TPSCameraControls } from './TPS/TPSCameraControls';

dist/math/collision.d.ts

@@ -0,0 +1,19 @@
+import { Vector3, Line3, Plane, Sphere } from 'three';
+import type { Box3 } from 'three';
+import type { Capsule } from 'three/examples/jsm/math/Capsule.js';
+import type { ComputedTriangle } from './triangle';
+export declare class Intersection {
+    point: Vector3;
+    normal: Vector3;
+    depth: number;
+    set(point: Vector3, normal: Vector3, depth: number): void;
+}
+export declare function isIntersectionCapsuleSphere(capsule: Capsule, sphere: Sphere): boolean;
+export declare function isIntersectionLineBox(line: Line3, box: Box3, hit?: Vector3): boolean;
+export declare function isIntersectionBoxPlane(box: Box3, plane: Plane): boolean;
+export declare function isIntersectionTriangleBox(a: Vector3, b: Vector3, c: Vector3, box: Box3): boolean;
+export declare function isIntersectionSphereSphere(sphere1: Sphere, sphere2: Sphere): boolean;
+export declare function isIntersectionSphereBox(sphere: Sphere, box: Box3): boolean;
+export declare function isIntersectionSphereTriangle(sphere: Sphere, a: Vector3, b: Vector3, c: Vector3, normal: Vector3, out: Intersection): boolean;
+export declare function testLineTriangle(p: Vector3, q: Vector3, a: Vector3, b: Vector3, c: Vector3, hit: Vector3): boolean;
+export declare function testTriangleCapsule(capsule: Capsule, triangle: ComputedTriangle, out: Intersection): boolean;

dist/math/triangle.d.ts

@@ -0,0 +1,8 @@
+import { Vector3, Triangle, Sphere } from 'three';
+export declare class ComputedTriangle extends Triangle {
+    boundingSphere: Sphere | undefined;
+    normal: Vector3;
+    constructor(a: Vector3, b: Vector3, c: Vector3);
+    computeBoundingSphere(): void;
+    extend(amount: number): void;
+}