idk

2023-12-16 22:36:37 +00:00
parent a1608702ed
commit e306b64edf
221 changed files with 47803 additions and 0 deletions
@@ -0,0 +1 @@
+*.js linguist-detectable=false
@@ -0,0 +1,2 @@
+.vscode
+node_modules
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - node
+script:
+  - npm run build
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 swift502
+
+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.
@@ -0,0 +1,103 @@
+<p align="center">
+	<a href="https://jblaha.art/sketchbook/latest"><img src="./src/img/thumbnail.png"></a>
+	<br>
+	<a href="https://jblaha.art/sketchbook/latest">Live demo</a>
+	<br>
+</p>
+
+[![badge](https://img.shields.io/npm/v/sketchbook?style=flat-square)](https://www.npmjs.com/package/sketchbook)
+[![badge](https://img.shields.io/travis/swift502/sketchbook?style=flat-square)](https://travis-ci.org/swift502/Sketchbook)
+[![badge](https://img.shields.io/discord/730763393325334628?label=discord&style=flat-square)](https://discord.gg/fGuEqCe)
+
+# Final update (20. Feb 2023)
+
+As I have no more interest in developing this project, it comes to a conclusion. In order to remain honest about the true state of the project, I am archiving this repository.
+
+- If you wish to modify Sketchbook feel free to fork it.
+- To see if someone is currently maintaining a fork, check out the [Network Graph](https://github.com/swift502/Sketchbook/network).
+- The [NPM package](https://www.npmjs.com/package/sketchbook) name is available, and I'll give it away to anyone who asks for it. The package has never worked properly.
+
+# 📒 Sketchbook
+
+Simple web based game engine built on [three.js](https://github.com/mrdoob/three.js) and [cannon.js](https://github.com/schteppe/cannon.js) focused on third-person character controls and related gameplay mechanics.
+
+Mostly a playground for exploring how conventional third person gameplay mechanics found in modern games work and recreating them in a general way.
+
+## Features
+
+* World
+	* Three.js scene
+	* Cannon.js physics
+	* Variable timescale
+	* Frame skipping
+	* FXAA anti-aliasing
+* Characters
+	* Third-person camera
+	* Raycast character controller with capsule collisions
+	* General state system
+	* Character AI
+* Vehicles
+	* Cars
+	* Airplanes
+	* Helicopters
+
+All planned features can be found in the [GitHub Projects](https://github.com/swift502/Sketchbook/projects).
+
+## Usage
+
+You can define your own scenes in Blender, and then read them with Sketchbook. Sketchbook needs to run on a local server such as [http-server](https://www.npmjs.com/package/http-server) or [webpack-dev-server](https://github.com/webpack/webpack-dev-server) to be able to load external assets.
+
+<!-- #### Script tag -->
+
+1. Import:
+
+```html
+<script src="sketchbook.min.js"></script>
+```
+
+2. Load a glb scene defined in Blender:
+
+```javascript
+const world = new Sketchbook.World('scene.glb');
+```
+
+<!--
+
+#### NPM
+
+1. Install:
+
+```
+npm i sketchbook
+```
+
+2. Import:
+
+```javascript
+import { World } from 'sketchbook';
+```
+
+3. Load a glb scene defined in Blender:
+
+```javascript
+const world = new World('scene.glb');
+```
+
+-->
+
+## Contributing
+
+1. Get the LTS version of [Node.js](https://nodejs.org/en/) 16
+2. [Fork this repository](https://help.github.com/en/github/getting-started-with-github/fork-a-repo)
+3. Run `npm install`
+4. Run `npm run dev`
+5. Make changes and test them out at http://localhost:8080
+6. Commit and [make a pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/creating-a-pull-request-from-a-fork)!
+
+## Credits
+
+Big thank you to each of the following github users for contributing to Sketchbook:
+
+- [aleqsunder](https://github.com/aleqsunder)
+- [barhatsor](https://github.com/barhatsor)
+- [danshuri](https://github.com/danshuri)
@@ -0,0 +1,111 @@
+import * as THREE from 'three';
+import * as CANNON from 'cannon';
+import { KeyBinding } from '../core/KeyBinding';
+import { VectorSpringSimulator } from '../physics/spring_simulation/VectorSpringSimulator';
+import { RelativeSpringSimulator } from '../physics/spring_simulation/RelativeSpringSimulator';
+import { ICharacterAI } from '../interfaces/ICharacterAI';
+import { World } from '../world/World';
+import { IControllable } from '../interfaces/IControllable';
+import { ICharacterState } from '../interfaces/ICharacterState';
+import { IWorldEntity } from '../interfaces/IWorldEntity';
+import { VehicleSeat } from '../vehicles/VehicleSeat';
+import { Vehicle } from '../vehicles/Vehicle';
+import { CapsuleCollider } from '../physics/colliders/CapsuleCollider';
+import { VehicleEntryInstance } from './VehicleEntryInstance';
+import { GroundImpactData } from './GroundImpactData';
+import { EntityType } from '../enums/EntityType';
+export declare class Character extends THREE.Object3D implements IWorldEntity {
+    updateOrder: number;
+    entityType: EntityType;
+    height: number;
+    tiltContainer: THREE.Group;
+    modelContainer: THREE.Group;
+    materials: THREE.Material[];
+    mixer: THREE.AnimationMixer;
+    animations: any[];
+    acceleration: THREE.Vector3;
+    velocity: THREE.Vector3;
+    arcadeVelocityInfluence: THREE.Vector3;
+    velocityTarget: THREE.Vector3;
+    arcadeVelocityIsAdditive: boolean;
+    defaultVelocitySimulatorDamping: number;
+    defaultVelocitySimulatorMass: number;
+    velocitySimulator: VectorSpringSimulator;
+    moveSpeed: number;
+    angularVelocity: number;
+    orientation: THREE.Vector3;
+    orientationTarget: THREE.Vector3;
+    defaultRotationSimulatorDamping: number;
+    defaultRotationSimulatorMass: number;
+    rotationSimulator: RelativeSpringSimulator;
+    viewVector: THREE.Vector3;
+    actions: {
+        [action: string]: KeyBinding;
+    };
+    characterCapsule: CapsuleCollider;
+    rayResult: CANNON.RaycastResult;
+    rayHasHit: boolean;
+    rayCastLength: number;
+    raySafeOffset: number;
+    wantsToJump: boolean;
+    initJumpSpeed: number;
+    groundImpactData: GroundImpactData;
+    raycastBox: THREE.Mesh;
+    world: World;
+    charState: ICharacterState;
+    behaviour: ICharacterAI;
+    controlledObject: IControllable;
+    occupyingSeat: VehicleSeat;
+    vehicleEntryInstance: VehicleEntryInstance;
+    private physicsEnabled;
+    constructor(gltf: any);
+    setAnimations(animations: []): void;
+    setArcadeVelocityInfluence(x: number, y?: number, z?: number): void;
+    setViewVector(vector: THREE.Vector3): void;
+    /**
+     * Set state to the player. Pass state class (function) name.
+     * @param {function} State
+     */
+    setState(state: ICharacterState): void;
+    setPosition(x: number, y: number, z: number): void;
+    resetVelocity(): void;
+    setArcadeVelocityTarget(velZ: number, velX?: number, velY?: number): void;
+    setOrientation(vector: THREE.Vector3, instantly?: boolean): void;
+    resetOrientation(): void;
+    setBehaviour(behaviour: ICharacterAI): void;
+    setPhysicsEnabled(value: boolean): void;
+    readCharacterData(gltf: any): void;
+    handleKeyboardEvent(event: KeyboardEvent, code: string, pressed: boolean): void;
+    handleMouseButton(event: MouseEvent, code: string, pressed: boolean): void;
+    handleMouseMove(event: MouseEvent, deltaX: number, deltaY: number): void;
+    handleMouseWheel(event: WheelEvent, value: number): void;
+    triggerAction(actionName: string, value: boolean): void;
+    takeControl(): void;
+    resetControls(): void;
+    update(timeStep: number): void;
+    inputReceiverInit(): void;
+    displayControls(): void;
+    inputReceiverUpdate(timeStep: number): void;
+    setAnimation(clipName: string, fadeIn: number): number;
+    springMovement(timeStep: number): void;
+    springRotation(timeStep: number): void;
+    getLocalMovementDirection(): THREE.Vector3;
+    getCameraRelativeMovementVector(): THREE.Vector3;
+    setCameraRelativeOrientationTarget(): void;
+    rotateModel(): void;
+    jump(initJumpSpeed?: number): void;
+    findVehicleToEnter(wantsToDrive: boolean): void;
+    enterVehicle(seat: VehicleSeat, entryPoint: THREE.Object3D): void;
+    teleportToVehicle(vehicle: Vehicle, seat: VehicleSeat): void;
+    startControllingVehicle(vehicle: IControllable, seat: VehicleSeat): void;
+    transferControls(entity: IControllable): void;
+    stopControllingVehicle(): void;
+    exitVehicle(): void;
+    occupySeat(seat: VehicleSeat): void;
+    leaveSeat(): void;
+    physicsPreStep(body: CANNON.Body, character: Character): void;
+    feetRaycast(): void;
+    physicsPostStep(body: CANNON.Body, character: Character): void;
+    addToWorld(world: World): void;
+    removeFromWorld(world: World): void;
+}
@@ -0,0 +1,4 @@
+import * as THREE from 'three';
+export declare class GroundImpactData {
+    velocity: THREE.Vector3;
+}
@@ -0,0 +1,11 @@
+import * as THREE from 'three';
+import { VehicleSeat } from '../vehicles/VehicleSeat';
+import { Character } from './Character';
+export declare class VehicleEntryInstance {
+    character: Character;
+    targetSeat: VehicleSeat;
+    entryPoint: THREE.Object3D;
+    wantsToDrive: boolean;
+    constructor(character: Character);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,11 @@
+import { FollowTarget } from './FollowTarget';
+import { ICharacterAI } from '../../interfaces/ICharacterAI';
+import { PathNode } from '../../world/PathNode';
+export declare class FollowPath extends FollowTarget implements ICharacterAI {
+    nodeRadius: number;
+    reverse: boolean;
+    private staleTimer;
+    private targetNode;
+    constructor(firstNode: PathNode, nodeRadius: number);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,12 @@
+import * as THREE from 'three';
+import { ICharacterAI } from '../../interfaces/ICharacterAI';
+import { Character } from '../Character';
+export declare class FollowTarget implements ICharacterAI {
+    character: Character;
+    isTargetReached: boolean;
+    target: THREE.Object3D;
+    private stopDistance;
+    constructor(target: THREE.Object3D, stopDistance?: number);
+    setTarget(target: THREE.Object3D): void;
+    update(timeStep: number): void;
+}
@@ -0,0 +1,8 @@
+import { ICharacterAI } from '../../interfaces/ICharacterAI';
+import { Character } from '../Character';
+export declare class RandomBehaviour implements ICharacterAI {
+    character: Character;
+    private randomFrequency;
+    constructor(randomFrequency?: number);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,20 @@
+import { Character } from '../Character';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+export declare abstract class CharacterStateBase implements ICharacterState {
+    character: Character;
+    timer: number;
+    animationLength: any;
+    canFindVehiclesToEnter: boolean;
+    canEnterVehicles: boolean;
+    canLeaveVehicles: boolean;
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+    noDirection(): boolean;
+    anyDirection(): boolean;
+    fallInAir(): void;
+    animationEnded(timeStep: number): boolean;
+    setAppropriateDropState(): void;
+    setAppropriateStartWalkState(): void;
+    protected playAnimation(animName: string, fadeIn: number): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class DropIdle extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,7 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class DropRolling extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class DropRunning extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class EndWalk extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,7 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class Falling extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class Idle extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class IdleRotateLeft extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class IdleRotateRight extends CharacterStateBase implements ICharacterState {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class JumpIdle extends CharacterStateBase implements ICharacterState {
+    private alreadyJumped;
+    constructor(character: Character);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { ICharacterState } from '../../interfaces/ICharacterState';
+import { Character } from '../Character';
+export declare class JumpRunning extends CharacterStateBase implements ICharacterState {
+    private alreadyJumped;
+    constructor(character: Character);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,7 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class Sprint extends CharacterStateBase {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,5 @@
+import { StartWalkBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class StartWalkBackLeft extends StartWalkBase {
+    constructor(character: Character);
+}
@@ -0,0 +1,5 @@
+import { StartWalkBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class StartWalkBackRight extends StartWalkBase {
+    constructor(character: Character);
+}
@@ -0,0 +1,7 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class StartWalkBase extends CharacterStateBase {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,5 @@
+import { StartWalkBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class StartWalkForward extends StartWalkBase {
+    constructor(character: Character);
+}
@@ -0,0 +1,5 @@
+import { StartWalkBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class StartWalkLeft extends StartWalkBase {
+    constructor(character: Character);
+}
@@ -0,0 +1,5 @@
+import { StartWalkBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class StartWalkRight extends StartWalkBase {
+    constructor(character: Character);
+}
@@ -0,0 +1,7 @@
+import { CharacterStateBase } from './_stateLibrary';
+import { Character } from '../Character';
+export declare class Walk extends CharacterStateBase {
+    constructor(character: Character);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,19 @@
+export * from './CharacterStateBase';
+export * from './DropIdle';
+export * from './DropRolling';
+export * from './DropRunning';
+export * from './EndWalk';
+export * from './Falling';
+export * from './Idle';
+export * from './IdleRotateLeft';
+export * from './IdleRotateRight';
+export * from './JumpIdle';
+export * from './JumpRunning';
+export * from './Sprint';
+export * from './StartWalkBase';
+export * from './StartWalkBackLeft';
+export * from './StartWalkBackRight';
+export * from './StartWalkForward';
+export * from './StartWalkLeft';
+export * from './StartWalkRight';
+export * from './Walk';
@@ -0,0 +1,9 @@
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+export declare class CloseVehicleDoorInside extends CharacterStateBase {
+    private seat;
+    private hasClosedDoor;
+    constructor(character: Character, seat: VehicleSeat);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,9 @@
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+export declare class CloseVehicleDoorOutside extends CharacterStateBase {
+    private seat;
+    private hasClosedDoor;
+    constructor(character: Character, seat: VehicleSeat);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,8 @@
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from 'src/ts/vehicles/VehicleSeat';
+export declare class Driving extends CharacterStateBase {
+    private seat;
+    constructor(character: Character, seat: VehicleSeat);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,18 @@
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+import { Object3D } from 'three';
+export declare class EnteringVehicle extends CharacterStateBase {
+    private vehicle;
+    private animData;
+    private seat;
+    private initialPositionOffset;
+    private startPosition;
+    private endPosition;
+    private startRotation;
+    private endRotation;
+    private factorSimulator;
+    constructor(character: Character, seat: VehicleSeat, entryPoint: Object3D);
+    update(timeStep: number): void;
+    private getEntryAnimations;
+}
@@ -0,0 +1,7 @@
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+import { ExitingStateBase } from './ExitingStateBase';
+export declare class ExitingAirplane extends ExitingStateBase {
+    constructor(character: Character, seat: VehicleSeat);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+import { IControllable } from '../../../interfaces/IControllable';
+export declare abstract class ExitingStateBase extends CharacterStateBase {
+    protected vehicle: IControllable;
+    protected seat: VehicleSeat;
+    protected startPosition: THREE.Vector3;
+    protected endPosition: THREE.Vector3;
+    protected startRotation: THREE.Quaternion;
+    protected endRotation: THREE.Quaternion;
+    protected exitPoint: THREE.Object3D;
+    protected dummyObj: THREE.Object3D;
+    constructor(character: Character, seat: VehicleSeat);
+    detachCharacterFromVehicle(): void;
+    updateEndRotation(): void;
+}
@@ -0,0 +1,7 @@
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+import { ExitingStateBase } from './ExitingStateBase';
+export declare class ExitingVehicle extends ExitingStateBase {
+    constructor(character: Character, seat: VehicleSeat);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+export declare class OpenVehicleDoor extends CharacterStateBase {
+    private seat;
+    private entryPoint;
+    private hasOpenedDoor;
+    private startPosition;
+    private endPosition;
+    private startRotation;
+    private endRotation;
+    private factorSimluator;
+    constructor(character: Character, seat: VehicleSeat, entryPoint: THREE.Object3D);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,9 @@
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from 'src/ts/vehicles/VehicleSeat';
+export declare class Sitting extends CharacterStateBase {
+    private seat;
+    constructor(character: Character, seat: VehicleSeat);
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,12 @@
+import { CharacterStateBase } from '../_stateLibrary';
+import { Character } from '../../Character';
+import { VehicleSeat } from '../../../vehicles/VehicleSeat';
+export declare class SwitchingSeats extends CharacterStateBase {
+    private toSeat;
+    private startPosition;
+    private endPosition;
+    private startRotation;
+    private endRotation;
+    constructor(character: Character, fromSeat: VehicleSeat, toSeat: VehicleSeat);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,40 @@
+import * as THREE from 'three';
+import { World } from '../world/World';
+import { IInputReceiver } from '../interfaces/IInputReceiver';
+import { KeyBinding } from './KeyBinding';
+import { Character } from '../characters/Character';
+import { IUpdatable } from '../interfaces/IUpdatable';
+export declare class CameraOperator implements IInputReceiver, IUpdatable {
+    updateOrder: number;
+    world: World;
+    camera: THREE.Camera;
+    target: THREE.Vector3;
+    sensitivity: THREE.Vector2;
+    radius: number;
+    theta: number;
+    phi: number;
+    onMouseDownPosition: THREE.Vector2;
+    onMouseDownTheta: any;
+    onMouseDownPhi: any;
+    targetRadius: number;
+    movementSpeed: number;
+    actions: {
+        [action: string]: KeyBinding;
+    };
+    upVelocity: number;
+    forwardVelocity: number;
+    rightVelocity: number;
+    followMode: boolean;
+    characterCaller: Character;
+    constructor(world: World, camera: THREE.Camera, sensitivityX?: number, sensitivityY?: number);
+    setSensitivity(sensitivityX: number, sensitivityY?: number): void;
+    setRadius(value: number, instantly?: boolean): void;
+    move(deltaX: number, deltaY: number): void;
+    update(timeScale: number): void;
+    handleKeyboardEvent(event: KeyboardEvent, code: string, pressed: boolean): void;
+    handleMouseWheel(event: WheelEvent, value: number): void;
+    handleMouseButton(event: MouseEvent, code: string, pressed: boolean): void;
+    handleMouseMove(event: MouseEvent, deltaX: number, deltaY: number): void;
+    inputReceiverInit(): void;
+    inputReceiverUpdate(timeStep: number): void;
+}
@@ -0,0 +1,9 @@
+import * as THREE from 'three';
+export declare class ClosestObjectFinder<T> {
+    closestObject: T;
+    private closestDistance;
+    private referencePosition;
+    private maxDistance;
+    constructor(referencePosition: THREE.Vector3, maxDistance?: number);
+    consider(object: T, objectPosition: THREE.Vector3): void;
+}
@@ -0,0 +1,47 @@
+import * as THREE from 'three';
+import * as CANNON from 'cannon';
+import { SimulationFrame } from '../physics/spring_simulation/SimulationFrame';
+import { Side } from '../enums/Side';
+import { Object3D } from 'three';
+import { Space } from '../enums/Space';
+export declare function createCapsuleGeometry(radius?: number, height?: number, N?: number): THREE.Geometry;
+/**
+ * Constructs a 2D matrix from first vector, replacing the Y axes with the global Y axis,
+ * and applies this matrix to the second vector. Saves performance when compared to full 3D matrix application.
+ * Useful for character rotation, as it only happens on the Y axis.
+ * @param {Vector3} a Vector to construct 2D matrix from
+ * @param {Vector3} b Vector to apply basis to
+ */
+export declare function appplyVectorMatrixXZ(a: THREE.Vector3, b: THREE.Vector3): THREE.Vector3;
+export declare function round(value: number, decimals?: number): number;
+export declare function roundVector(vector: THREE.Vector3, decimals?: number): THREE.Vector3;
+/**
+ * Finds an angle between two vectors
+ * @param {THREE.Vector3} v1
+ * @param {THREE.Vector3} v2
+ */
+export declare function getAngleBetweenVectors(v1: THREE.Vector3, v2: THREE.Vector3, dotTreshold?: number): number;
+/**
+ * Finds an angle between two vectors with a sign relative to normal vector
+ */
+export declare function getSignedAngleBetweenVectors(v1: THREE.Vector3, v2: THREE.Vector3, normal?: THREE.Vector3, dotTreshold?: number): number;
+export declare function haveSameSigns(n1: number, n2: number): boolean;
+export declare function haveDifferentSigns(n1: number, n2: number): boolean;
+export declare function setDefaults(options: {}, defaults: {}): {};
+export declare function getGlobalProperties(prefix?: string): any[];
+export declare function spring(source: number, dest: number, velocity: number, mass: number, damping: number): SimulationFrame;
+export declare function springV(source: THREE.Vector3, dest: THREE.Vector3, velocity: THREE.Vector3, mass: number, damping: number): void;
+export declare function threeVector(vec: CANNON.Vec3): THREE.Vector3;
+export declare function cannonVector(vec: THREE.Vector3): CANNON.Vec3;
+export declare function threeQuat(quat: CANNON.Quaternion): THREE.Quaternion;
+export declare function cannonQuat(quat: THREE.Quaternion): CANNON.Quaternion;
+export declare function setupMeshProperties(child: any): void;
+export declare function detectRelativeSide(from: Object3D, to: Object3D): Side;
+export declare function easeInOutSine(x: number): number;
+export declare function easeOutQuad(x: number): number;
+export declare function getRight(obj: THREE.Object3D, space?: Space): THREE.Vector3;
+export declare function getUp(obj: THREE.Object3D, space?: Space): THREE.Vector3;
+export declare function getForward(obj: THREE.Object3D, space?: Space): THREE.Vector3;
+export declare function getBack(obj: THREE.Object3D, space?: Space): THREE.Vector3;
+export declare function getMatrix(obj: THREE.Object3D, space: Space): THREE.Matrix4;
+export declare function countSleepyBodies(): any;
@@ -0,0 +1,16 @@
+import { InfoStackMessage } from './InfoStackMessage';
+import { IWorldEntity } from '../interfaces/IWorldEntity';
+import { EntityType } from '../enums/EntityType';
+import { World } from '../world/World';
+export declare class InfoStack implements IWorldEntity {
+    updateOrder: number;
+    entityType: EntityType;
+    messages: InfoStackMessage[];
+    entranceAnimation: string;
+    exitAnimation: string;
+    messageDuration: number;
+    addMessage(text: string): void;
+    update(timeStep: number): void;
+    addToWorld(world: World): void;
+    removeFromWorld(world: World): void;
+}
@@ -0,0 +1,10 @@
+import { InfoStack } from './InfoStack';
+export declare class InfoStackMessage {
+    domElement: HTMLElement;
+    private customConsole;
+    private elapsedTime;
+    private removalTriggered;
+    constructor(console: InfoStack, domElement: HTMLElement);
+    update(timeStep: number): void;
+    private triggerRemoval;
+}
@@ -0,0 +1,31 @@
+import { World } from '../world/World';
+import { IInputReceiver } from '../interfaces/IInputReceiver';
+import { IUpdatable } from '../interfaces/IUpdatable';
+export declare class InputManager implements IUpdatable {
+    updateOrder: number;
+    world: World;
+    domElement: any;
+    pointerLock: any;
+    isLocked: boolean;
+    inputReceiver: IInputReceiver;
+    boundOnMouseDown: (evt: any) => void;
+    boundOnMouseMove: (evt: any) => void;
+    boundOnMouseUp: (evt: any) => void;
+    boundOnMouseWheelMove: (evt: any) => void;
+    boundOnPointerlockChange: (evt: any) => void;
+    boundOnPointerlockError: (evt: any) => void;
+    boundOnKeyDown: (evt: any) => void;
+    boundOnKeyUp: (evt: any) => void;
+    constructor(world: World, domElement: HTMLElement);
+    update(timestep: number, unscaledTimeStep: number): void;
+    setInputReceiver(receiver: IInputReceiver): void;
+    setPointerLock(enabled: boolean): void;
+    onPointerlockChange(event: MouseEvent): void;
+    onPointerlockError(event: MouseEvent): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onKeyUp(event: KeyboardEvent): void;
+    onMouseWheelMove(event: WheelEvent): void;
+}
@@ -0,0 +1,7 @@
+export declare class KeyBinding {
+    eventCodes: string[];
+    isPressed: boolean;
+    justPressed: boolean;
+    justReleased: boolean;
+    constructor(...code: string[]);
+}
@@ -0,0 +1,17 @@
+import { LoadingTrackerEntry } from './LoadingTrackerEntry';
+import { Scenario } from '../world/Scenario';
+import { World } from '../world/World';
+export declare class LoadingManager {
+    firstLoad: boolean;
+    onFinishedCallback: () => void;
+    private world;
+    private gltfLoader;
+    private loadingTracker;
+    constructor(world: World);
+    loadGLTF(path: string, onLoadingFinished: (gltf: any) => void): void;
+    addLoadingEntry(path: string): LoadingTrackerEntry;
+    doneLoading(trackerEntry: LoadingTrackerEntry): void;
+    createWelcomeScreenCallback(scenario: Scenario): void;
+    private getLoadingPercentage;
+    private isLoadingDone;
+}
@@ -0,0 +1,6 @@
+export declare class LoadingTrackerEntry {
+    path: string;
+    progress: number;
+    finished: boolean;
+    constructor(path: string);
+}
@@ -0,0 +1,5 @@
+export declare class UIManager {
+    static setUserInterfaceVisible(value: boolean): void;
+    static setLoadingScreenVisible(value: boolean): void;
+    static setFPSVisible(value: boolean): void;
+}
@@ -0,0 +1,5 @@
+export declare enum CollisionGroups {
+    Default = 1,
+    Characters = 2,
+    TrimeshColliders = 4
+}
@@ -0,0 +1,8 @@
+export declare enum EntityType {
+    Character = 0,
+    Airplane = 1,
+    Car = 2,
+    Helicopter = 3,
+    Decoration = 4,
+    System = 5
+}
@@ -0,0 +1,4 @@
+export declare enum SeatType {
+    Driver = "driver",
+    Passenger = "passenger"
+}
@@ -0,0 +1,4 @@
+export declare enum Side {
+    Left = "left",
+    Right = "right"
+}
@@ -0,0 +1,4 @@
+export declare enum Space {
+    Local = "local",
+    Global = "global"
+}
@@ -0,0 +1,5 @@
+import { Character } from '../characters/Character';
+export interface ICharacterAI {
+    character: Character;
+    update(timeStep: number): void;
+}
@@ -0,0 +1,7 @@
+export interface ICharacterState {
+    canFindVehiclesToEnter: boolean;
+    canEnterVehicles: boolean;
+    canLeaveVehicles: boolean;
+    update(timeStep: number): void;
+    onInputChange(): void;
+}
@@ -0,0 +1,3 @@
+export interface ICollider {
+    body: CANNON.Body;
+}
@@ -0,0 +1,15 @@
+import { Character } from '../characters/Character';
+import { IInputReceiver } from './IInputReceiver';
+import { VehicleSeat } from '../vehicles/VehicleSeat';
+import { EntityType } from '../enums/EntityType';
+export interface IControllable extends IInputReceiver {
+    entityType: EntityType;
+    seats: VehicleSeat[];
+    position: THREE.Vector3;
+    controllingCharacter: Character;
+    triggerAction(actionName: string, value: boolean): void;
+    resetControls(): void;
+    allowSleep(value: boolean): void;
+    onInputChange(): void;
+    noDirectionPressed(): boolean;
+}
@@ -0,0 +1,12 @@
+import { KeyBinding } from '../core/KeyBinding';
+export interface IInputReceiver {
+    actions: {
+        [action: string]: KeyBinding;
+    };
+    handleKeyboardEvent(event: KeyboardEvent, code: string, pressed: boolean): void;
+    handleMouseButton(event: MouseEvent, code: string, pressed: boolean): void;
+    handleMouseMove(event: MouseEvent, deltaX: number, deltaY: number): void;
+    handleMouseWheel(event: WheelEvent, value: number): void;
+    inputReceiverInit(): void;
+    inputReceiverUpdate(timeStep: number): void;
+}
@@ -0,0 +1,5 @@
+import { World } from '../world/World';
+import { LoadingManager } from '../core/LoadingManager';
+export interface ISpawnPoint {
+    spawn(loadingManager: LoadingManager, world: World): void;
+}
@@ -0,0 +1,4 @@
+export interface IUpdatable {
+    updateOrder: number;
+    update(timestep: number, unscaledTimeStep: number): void;
+}
@@ -0,0 +1,8 @@
+import { World } from '../world/World';
+import { EntityType } from '../enums/EntityType';
+import { IUpdatable } from './IUpdatable';
+export interface IWorldEntity extends IUpdatable {
+    entityType: EntityType;
+    addToWorld(world: World): void;
+    removeFromWorld(world: World): void;
+}
@@ -0,0 +1,9 @@
+import * as CANNON from 'cannon';
+import * as THREE from 'three';
+import { ICollider } from '../../interfaces/ICollider';
+export declare class BoxCollider implements ICollider {
+    options: any;
+    body: CANNON.Body;
+    debugModel: THREE.Mesh;
+    constructor(options: any);
+}
@@ -0,0 +1,7 @@
+import * as CANNON from 'cannon';
+import { ICollider } from '../../interfaces/ICollider';
+export declare class CapsuleCollider implements ICollider {
+    options: any;
+    body: CANNON.Body;
+    constructor(options: any);
+}
@@ -0,0 +1,10 @@
+import * as CANNON from 'cannon';
+import { ICollider } from '../../interfaces/ICollider';
+import { Object3D } from 'three';
+export declare class ConvexCollider implements ICollider {
+    mesh: any;
+    options: any;
+    body: CANNON.Body;
+    debugModel: any;
+    constructor(mesh: Object3D, options: any);
+}
@@ -0,0 +1,9 @@
+import * as CANNON from 'cannon';
+import * as THREE from 'three';
+import { ICollider } from '../../interfaces/ICollider';
+export declare class SphereCollider implements ICollider {
+    options: any;
+    body: CANNON.Body;
+    debugModel: THREE.Mesh;
+    constructor(options: any);
+}
@@ -0,0 +1,10 @@
+import * as CANNON from 'cannon';
+import { ICollider } from '../../interfaces/ICollider';
+import { Object3D } from 'three';
+export declare class TrimeshCollider implements ICollider {
+    mesh: any;
+    options: any;
+    body: CANNON.Body;
+    debugModel: any;
+    constructor(mesh: Object3D, options: any);
+}
@@ -0,0 +1,19 @@
+import { SimulatorBase } from './SimulatorBase';
+import { SimulationFrame } from './SimulationFrame';
+export declare class RelativeSpringSimulator extends SimulatorBase {
+    position: number;
+    velocity: number;
+    target: number;
+    lastLerp: number;
+    cache: SimulationFrame[];
+    constructor(fps: number, mass: number, damping: number, startPosition?: number, startVelocity?: number);
+    /**
+     * Advances the simulation by given time step
+     * @param {number} timeStep
+     */
+    simulate(timeStep: number): void;
+    /**
+     * Gets another simulation frame
+     */
+    getFrame(isLastFrame: boolean): SimulationFrame;
+}
@@ -0,0 +1,5 @@
+export declare class SimulationFrame {
+    position: number;
+    velocity: number;
+    constructor(position: number, velocity: number);
+}
@@ -0,0 +1,5 @@
+export declare class SimulationFrameVector {
+    position: THREE.Vector3;
+    velocity: THREE.Vector3;
+    constructor(position: THREE.Vector3, velocity: THREE.Vector3);
+}
@@ -0,0 +1,17 @@
+export declare abstract class SimulatorBase {
+    mass: any;
+    damping: any;
+    frameTime: number;
+    offset: number;
+    abstract cache: any[];
+    constructor(fps: number, mass: number, damping: number);
+    setFPS(value: number): void;
+    lastFrame(): any;
+    /**
+     * Generates frames between last simulation call and the current one
+     * @param {timeStep} timeStep
+     */
+    generateFrames(timeStep: number): void;
+    abstract getFrame(isLastFrame: boolean): any;
+    abstract simulate(timeStep: number): void;
+}
@@ -0,0 +1,18 @@
+import { SimulatorBase } from './SimulatorBase';
+import { SimulationFrame } from './SimulationFrame';
+export declare class SpringSimulator extends SimulatorBase {
+    position: number;
+    velocity: number;
+    target: number;
+    cache: SimulationFrame[];
+    constructor(fps: number, mass: number, damping: number, startPosition?: number, startVelocity?: number);
+    /**
+     * Advances the simulation by given time step
+     * @param {number} timeStep
+     */
+    simulate(timeStep: number): void;
+    /**
+     * Gets another simulation frame
+     */
+    getFrame(isLastFrame: boolean): SimulationFrame;
+}
@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+import { SimulatorBase } from './SimulatorBase';
+import { SimulationFrameVector } from './SimulationFrameVector';
+export declare class VectorSpringSimulator extends SimulatorBase {
+    position: THREE.Vector3;
+    velocity: THREE.Vector3;
+    target: THREE.Vector3;
+    cache: SimulationFrameVector[];
+    constructor(fps: number, mass: number, damping: number);
+    init(): void;
+    /**
+     * Advances the simulation by given time step
+     * @param {number} timeStep
+     */
+    simulate(timeStep: number): void;
+    /**
+     * Gets another simulation frame
+     */
+    getFrame(isLastFrame: boolean): SimulationFrameVector;
+}
@@ -0,0 +1,2 @@
+import '../css/main.css';
+export { World } from './world/World';
@@ -0,0 +1,27 @@
+import * as THREE from 'three';
+import * as CANNON from 'cannon';
+import { Vehicle } from './Vehicle';
+import { IControllable } from '../interfaces/IControllable';
+import { IWorldEntity } from '../interfaces/IWorldEntity';
+import { EntityType } from '../enums/EntityType';
+export declare class Airplane extends Vehicle implements IControllable, IWorldEntity {
+    entityType: EntityType;
+    rotor: THREE.Object3D;
+    leftAileron: THREE.Object3D;
+    rightAileron: THREE.Object3D;
+    elevators: THREE.Object3D[];
+    rudder: THREE.Object3D;
+    private steeringSimulator;
+    private aileronSimulator;
+    private elevatorSimulator;
+    private rudderSimulator;
+    private enginePower;
+    private lastDrag;
+    constructor(gltf: any);
+    noDirectionPressed(): boolean;
+    update(timeStep: number): void;
+    physicsPreStep(body: CANNON.Body, plane: Airplane): void;
+    onInputChange(): void;
+    readAirplaneData(gltf: any): void;
+    inputReceiverInit(): void;
+}
@@ -0,0 +1,27 @@
+import * as CANNON from 'cannon';
+import { Vehicle } from './Vehicle';
+import { IControllable } from '../interfaces/IControllable';
+import { EntityType } from '../enums/EntityType';
+export declare class Car extends Vehicle implements IControllable {
+    entityType: EntityType;
+    drive: string;
+    get speed(): number;
+    private _speed;
+    private steeringWheel;
+    private airSpinTimer;
+    private steeringSimulator;
+    private gear;
+    private shiftTimer;
+    private timeToShift;
+    private canTiltForwards;
+    private characterWantsToExit;
+    constructor(gltf: any);
+    noDirectionPressed(): boolean;
+    update(timeStep: number): void;
+    shiftUp(): void;
+    shiftDown(): void;
+    physicsPreStep(body: CANNON.Body, car: Car): void;
+    onInputChange(): void;
+    inputReceiverInit(): void;
+    readCarData(gltf: any): void;
+}
@@ -0,0 +1,18 @@
+import * as THREE from 'three';
+import * as CANNON from 'cannon';
+import { Vehicle } from './Vehicle';
+import { IControllable } from '../interfaces/IControllable';
+import { IWorldEntity } from '../interfaces/IWorldEntity';
+import { EntityType } from '../enums/EntityType';
+export declare class Helicopter extends Vehicle implements IControllable, IWorldEntity {
+    entityType: EntityType;
+    rotors: THREE.Object3D[];
+    private enginePower;
+    constructor(gltf: any);
+    noDirectionPressed(): boolean;
+    update(timeStep: number): void;
+    onInputChange(): void;
+    physicsPreStep(body: CANNON.Body, heli: Helicopter): void;
+    readHelicopterData(gltf: any): void;
+    inputReceiverInit(): void;
+}
@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+import { Vehicle } from './Vehicle';
+import { VehicleSeat } from './VehicleSeat';
+export declare class VehicleDoor {
+    vehicle: Vehicle;
+    seat: VehicleSeat;
+    doorObject: THREE.Object3D;
+    doorVelocity: number;
+    doorWorldPos: THREE.Vector3;
+    lastTrailerPos: THREE.Vector3;
+    lastTrailerVel: THREE.Vector3;
+    rotation: number;
+    achievingTargetRotation: boolean;
+    physicsEnabled: boolean;
+    targetRotation: number;
+    rotationSpeed: number;
+    lastVehicleVel: THREE.Vector3;
+    lastVehiclePos: THREE.Vector3;
+    private sideMultiplier;
+    constructor(seat: VehicleSeat, object: THREE.Object3D);
+    update(timestep: number): void;
+    preStepCallback(): void;
+    open(): void;
+    close(): void;
+    resetPhysTrailer(): void;
+}
@@ -0,0 +1,17 @@
+import * as THREE from 'three';
+import { SeatType } from '../enums/SeatType';
+import { IControllable } from '../interfaces/IControllable';
+import { VehicleDoor } from './VehicleDoor';
+import { Character } from '../characters/Character';
+export declare class VehicleSeat {
+    vehicle: IControllable;
+    seatPointObject: THREE.Object3D;
+    connectedSeatsString: string;
+    connectedSeats: VehicleSeat[];
+    type: SeatType;
+    entryPoints: THREE.Object3D[];
+    door: VehicleDoor;
+    occupiedBy: Character;
+    constructor(vehicle: IControllable, object: THREE.Object3D, gltf: any);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,8 @@
+export declare class Wheel {
+    wheelObject: THREE.Object3D;
+    position: THREE.Vector3;
+    steering: boolean;
+    drive: string;
+    rayCastWheelInfoIndex: number;
+    constructor(wheelObject: THREE.Object3D);
+}
@@ -0,0 +1,53 @@
+import { Character } from '../characters/Character';
+import * as THREE from 'three';
+import * as CANNON from 'cannon';
+import { World } from '../world/World';
+import { KeyBinding } from '../core/KeyBinding';
+import { VehicleSeat } from './VehicleSeat';
+import { Wheel } from './Wheel';
+import { EntityType } from '../enums/EntityType';
+import { IWorldEntity } from '../interfaces/IWorldEntity';
+export declare abstract class Vehicle extends THREE.Object3D implements IWorldEntity {
+    updateOrder: number;
+    abstract entityType: EntityType;
+    controllingCharacter: Character;
+    actions: {
+        [action: string]: KeyBinding;
+    };
+    rayCastVehicle: CANNON.RaycastVehicle;
+    seats: VehicleSeat[];
+    wheels: Wheel[];
+    drive: string;
+    camera: any;
+    world: World;
+    help: THREE.AxesHelper;
+    collision: CANNON.Body;
+    materials: THREE.Material[];
+    spawnPoint: THREE.Object3D;
+    private modelContainer;
+    private firstPerson;
+    constructor(gltf: any, handlingSetup?: any);
+    noDirectionPressed(): boolean;
+    update(timeStep: number): void;
+    forceCharacterOut(): void;
+    onInputChange(): void;
+    resetControls(): void;
+    allowSleep(value: boolean): void;
+    handleKeyboardEvent(event: KeyboardEvent, code: string, pressed: boolean): void;
+    setFirstPersonView(value: boolean): void;
+    toggleFirstPersonView(): void;
+    triggerAction(actionName: string, value: boolean): void;
+    handleMouseButton(event: MouseEvent, code: string, pressed: boolean): void;
+    handleMouseMove(event: MouseEvent, deltaX: number, deltaY: number): void;
+    handleMouseWheel(event: WheelEvent, value: number): void;
+    inputReceiverInit(): void;
+    inputReceiverUpdate(timeStep: number): void;
+    setPosition(x: number, y: number, z: number): void;
+    setSteeringValue(val: number): void;
+    applyEngineForce(force: number): void;
+    setBrake(brakeForce: number, driveFilter?: string): void;
+    addToWorld(world: World): void;
+    removeFromWorld(world: World): void;
+    readVehicleData(gltf: any): void;
+    private connectSeats;
+}
@@ -0,0 +1,9 @@
+import { ISpawnPoint } from '../interfaces/ISpawnPoint';
+import * as THREE from 'three';
+import { World } from './World';
+import { LoadingManager } from '../core/LoadingManager';
+export declare class CharacterSpawnPoint implements ISpawnPoint {
+    private object;
+    constructor(object: THREE.Object3D);
+    spawn(loadingManager: LoadingManager, world: World): void;
+}
@@ -0,0 +1,10 @@
+import * as THREE from 'three';
+import { World } from './World';
+import { IUpdatable } from '../interfaces/IUpdatable';
+export declare class Ocean implements IUpdatable {
+    updateOrder: number;
+    material: THREE.ShaderMaterial;
+    private world;
+    constructor(object: any, world: World);
+    update(timeStep: number): void;
+}
@@ -0,0 +1,10 @@
+import { PathNode } from './PathNode';
+export declare class Path {
+    nodes: {
+        [nodeName: string]: PathNode;
+    };
+    private rootNode;
+    constructor(root: THREE.Object3D);
+    addNode(child: any): void;
+    connectNodes(): void;
+}
@@ -0,0 +1,9 @@
+import { Path } from './Path';
+import { Object3D } from 'three';
+export declare class PathNode {
+    object: Object3D;
+    path: Path;
+    nextNode: PathNode;
+    previousNode: PathNode;
+    constructor(child: THREE.Object3D, path: Path);
+}
@@ -0,0 +1,18 @@
+import { World } from '../world/World';
+import { LoadingManager } from '../core/LoadingManager';
+export declare class Scenario {
+    id: string;
+    name: string;
+    spawnAlways: boolean;
+    default: boolean;
+    world: World;
+    descriptionTitle: string;
+    descriptionContent: string;
+    private rootNode;
+    private spawnPoints;
+    private invisible;
+    private initialCameraAngle;
+    constructor(root: THREE.Object3D, world: World);
+    createLaunchLink(): void;
+    launch(loadingManager: LoadingManager, world: World): void;
+}
@@ -0,0 +1,23 @@
+import * as THREE from 'three';
+import { World } from './World';
+import { IUpdatable } from '../interfaces/IUpdatable';
+import { default as CSM } from 'three-csm';
+export declare class Sky extends THREE.Object3D implements IUpdatable {
+    updateOrder: number;
+    sunPosition: THREE.Vector3;
+    csm: CSM;
+    set theta(value: number);
+    set phi(value: number);
+    private _phi;
+    private _theta;
+    private hemiLight;
+    private maxHemiIntensity;
+    private minHemiIntensity;
+    private skyMesh;
+    private skyMaterial;
+    private world;
+    constructor(world: World);
+    update(timeScale: number): void;
+    refreshSunPosition(): void;
+    refreshHemiIntensity(): void;
+}
@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+import { ISpawnPoint } from '../interfaces/ISpawnPoint';
+import { World } from '../world/World';
+import { LoadingManager } from '../core/LoadingManager';
+export declare class VehicleSpawnPoint implements ISpawnPoint {
+    type: string;
+    driver: string;
+    firstAINode: string;
+    private object;
+    constructor(object: THREE.Object3D);
+    spawn(loadingManager: LoadingManager, world: World): void;
+    private getNewVehicleByType;
+}
@@ -0,0 +1,72 @@
+import * as THREE from 'three';
+import * as CANNON from 'cannon';
+import { CameraOperator } from '../core/CameraOperator';
+import { Stats } from '../../lib/utils/Stats';
+import { CannonDebugRenderer } from '../../lib/cannon/CannonDebugRenderer';
+import { InputManager } from '../core/InputManager';
+import { LoadingManager } from '../core/LoadingManager';
+import { InfoStack } from '../core/InfoStack';
+import { IWorldEntity } from '../interfaces/IWorldEntity';
+import { IUpdatable } from '../interfaces/IUpdatable';
+import { Character } from '../characters/Character';
+import { Path } from './Path';
+import { Vehicle } from '../vehicles/Vehicle';
+import { Scenario } from './Scenario';
+import { Sky } from './Sky';
+export declare class World {
+    renderer: THREE.WebGLRenderer;
+    camera: THREE.PerspectiveCamera;
+    composer: any;
+    stats: Stats;
+    graphicsWorld: THREE.Scene;
+    sky: Sky;
+    physicsWorld: CANNON.World;
+    parallelPairs: any[];
+    physicsFrameRate: number;
+    physicsFrameTime: number;
+    physicsMaxPrediction: number;
+    clock: THREE.Clock;
+    renderDelta: number;
+    logicDelta: number;
+    requestDelta: number;
+    sinceLastFrame: number;
+    justRendered: boolean;
+    params: any;
+    inputManager: InputManager;
+    cameraOperator: CameraOperator;
+    timeScaleTarget: number;
+    console: InfoStack;
+    cannonDebugRenderer: CannonDebugRenderer;
+    scenarios: Scenario[];
+    characters: Character[];
+    vehicles: Vehicle[];
+    paths: Path[];
+    scenarioGUIFolder: any;
+    updatables: IUpdatable[];
+    private lastScenarioID;
+    constructor(worldScenePath?: any);
+    update(timeStep: number, unscaledTimeStep: number): void;
+    updatePhysics(timeStep: number): void;
+    isOutOfBounds(position: CANNON.Vec3): boolean;
+    outOfBoundsRespawn(body: CANNON.Body, position?: CANNON.Vec3): void;
+    /**
+     * Rendering loop.
+     * Implements fps limiter and frame-skipping
+     * Calls world's "update" function before rendering.
+     * @param {World} world
+     */
+    render(world: World): void;
+    setTimeScale(value: number): void;
+    add(worldEntity: IWorldEntity): void;
+    registerUpdatable(registree: IUpdatable): void;
+    remove(worldEntity: IWorldEntity): void;
+    unregisterUpdatable(registree: IUpdatable): void;
+    loadScene(loadingManager: LoadingManager, gltf: any): void;
+    launchScenario(scenarioID: string, loadingManager?: LoadingManager): void;
+    restartScenario(): void;
+    clearEntities(): void;
+    scrollTheTimeScale(scrollAmount: number): void;
+    updateControls(controls: any): void;
+    private generateHTML;
+    private createParamsGUI;
+}
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+	<title>Sketchbook</title>
+</head>
+
+<body>
+	<script src="build/sketchbook.min.js"></script>
+	<script>
+		const world = new Sketchbook.World('build/assets/world.glb');
+	</script>
+</body>
+
+</html>
--- a/Show More
+++ b/Show More