babylonjs-toolkit 9.9.1 → 9.9.3

package/lib/babylon.toolkit.d.ts

@@ -7,7 +7,7 @@ declare namespace TOOLKIT {
     * @class SceneManager - All rights reserved (c) 2024 Mackey Kinard
     */
     class SceneManager {
-        /** Gets the toolkit framework version string (9.9.1 - R1) */
+        /** Gets the toolkit framework version string (9.9.3 - R1) */
         static get Version(): string;
         /** Gets the toolkit framework copyright notice */
         static get Copyright(): string;
@@ -1977,6 +1977,7 @@ declare namespace TOOLKIT {
         private _licenseName;
         private _licenseType;
         private _pendingReflectionTextures;
+        private _deferredCustomMaterials;
         private static ScriptBundleCache;
         /** @hidden */
         constructor(loader: BABYLON.GLTF2.GLTFLoader);
@@ -1988,6 +1989,7 @@ declare namespace TOOLKIT {
         onReady(): void;
         /** @hidden */
         onComplete(): void;
+        loadProjectScriptAsync(): Promise<void>;
         getScriptBundleTag(): string;
         getScriptBundleUrl(): string;
         finishComplete(): void;
@@ -2005,6 +2007,7 @@ declare namespace TOOLKIT {
         /** @hidden */
         loadSceneAsync(context: string, scene: BABYLON.GLTF2.Loader.IScene): Promise<void> | null;
         private _loadSceneInternalAsync;
+        private _resolveDeferredCustomMaterials;
         private _loadSceneExAsync;
         /** @hidden */
         loadNodeAsync(context: string, node: BABYLON.GLTF2.Loader.INode, assign: (babylonMesh: BABYLON.TransformNode) => void): Promise<BABYLON.TransformNode> | null;
@@ -3615,6 +3618,2772 @@ declare namespace TOOLKIT {
         private getWGSLFragmentNormalCode;
     }
 }
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class CheckpointManager
+    */
+    class CheckpointManager extends TOOLKIT.ScriptComponent {
+        private checkPointList;
+        private checkPointCount;
+        private checkPointIndex;
+        private nextCheckPoint;
+        private startRaceTime;
+        private totalRaceTime;
+        private lapNumber;
+        private lapTimer;
+        private lapTimes;
+        private playerID;
+        private playerName;
+        private raceOver;
+        register(id: number, name: string): void;
+        getLapTimes(): number[];
+        getLapNumber(): number;
+        getCheckPoint(): number;
+        getPlayerName(): string;
+        getPlayerID(): number;
+        getRaceTime(): number;
+        getRaceOver(): boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+        private nextCheckPointName;
+        protected update(): void;
+        protected late(): void;
+        startRaceTimer(): void;
+    }
+}
+declare namespace PROJECT {
+    interface ITrackNode {
+        radius: number;
+        position: TOOLKIT.IUnityVector3;
+        rotation: TOOLKIT.IUnityVector4;
+        localPosition: BABYLON.Vector3;
+        localRotation: BABYLON.Quaternion;
+        localDistance: number;
+    }
+    interface IControlPoint {
+        speed: number;
+        tvalue: number;
+        position: TOOLKIT.IUnityVector3;
+    }
+    class RoutePoint {
+        position: BABYLON.Vector3;
+        direction: BABYLON.Vector3;
+    }
+    class PlayerRaceStats {
+        id: number;
+        name: string;
+        position: number;
+    }
+    /**
+    * Babylon Script Component
+    * @class BT_RaceTrackManager
+    */
+    class RaceTrackManager extends TOOLKIT.ScriptComponent {
+        static TrackLength: number;
+        static TotalLapCount: number;
+        static WinnerTransform: BABYLON.TransformNode;
+        private static CheckPointTag;
+        private static CheckPointList;
+        private static LeaderBoardList;
+        private static PlayerVehicleList;
+        private trackNodes;
+        private raceLineData_1;
+        private raceLineData_2;
+        private raceLineData_3;
+        private raceLineData_4;
+        private raceLineData_5;
+        private raceLineColor_1;
+        private raceLineColor_2;
+        private raceLineColor_3;
+        private raceLineColor_4;
+        private raceLineColor_5;
+        private debugMeshLines_1;
+        private debugMeshLines_2;
+        private debugMeshLines_3;
+        private debugMeshLines_4;
+        private debugMeshLines_5;
+        private p0n;
+        private p1n;
+        private p2n;
+        private p3n;
+        private i;
+        private static _EventBus;
+        static get EventBus(): TOOLKIT.LocalMessageBus;
+        drawDebugLines: boolean;
+        getTrackNodes(): PROJECT.ITrackNode[];
+        getControlPoints(line: number): PROJECT.IControlPoint[];
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected after(): void;
+        protected destroy(): void;
+        getRoutePoint(distance: number): PROJECT.RoutePoint;
+        getRoutePointToRef(distance: number, result: PROJECT.RoutePoint): void;
+        getRoutePosition(distance: number): BABYLON.Vector3;
+        getRoutePositionToRef(distance: number, result: BABYLON.Vector3): void;
+        /** Gets the checkpoint tag identifier */
+        static GetCheckpointTag(): string;
+        /** Get the checkpoint position list */
+        static GetCheckpointList(): BABYLON.AbstractMesh[];
+        /** Get the total number of checkpoints */
+        static GetCheckpointCount(): number;
+        /** Calculates the fraction distance to next checkpoint */
+        private static GetCheckpointDistance;
+        /** Register vehicle with track manager */
+        static RegisterVehicle(vehicle: BABYLON.TransformNode): void;
+        /** Gets the registered player vehicles */
+        static GetPlayerVehicles(): BABYLON.TransformNode[];
+        /** Register player with track manager */
+        static RegisterPlayer(id: number, name: string): void;
+        /** Update player leaderboard information */
+        static UpdateLeaderboard(id: number, lap: number, checkpoint: number, position: BABYLON.Vector3): void;
+        /** Get player leaderboard position */
+        static GetLeaderboardPosition(id: number): number;
+        /** Get leaderboard position list */
+        static GetLeaderboardPositionList(): PROJECT.PlayerRaceStats[];
+        /** Sort leaderboard position list */
+        private static SortLeaderboardPositionList;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon remote vehicle controller class (Colyseus Universal Game Room)
+    * @class RemoteCarController
+    */
+    class RemoteCarController extends TOOLKIT.ScriptComponent {
+        private static ShowSensorLines;
+        centerOfMass: number;
+        burnoutWheelPitch: number;
+        linkTrackManager: boolean;
+        playVehicleSounds: boolean;
+        smokeTexture: BABYLON.Texture;
+        skidThreashold: number;
+        smokeIntensity: number;
+        wheelDrawVelocity: number;
+        smokeOpacity: number;
+        smokeDonuts: number;
+        private steeringWheelHub;
+        private steeringWheelAxis;
+        private maxSteeringAngle;
+        private maxSteeringSpeed;
+        private _animator;
+        private _engineAudioSource;
+        private _skidAudioSource;
+        private brakeLightsMesh;
+        private brakeLightsTrans;
+        private reverseLightsMesh;
+        private reverseLightsTrans;
+        private frontLeftWheelTrans;
+        private frontRightWheelTrans;
+        private backLeftWheelTrans;
+        private backRightWheelTrans;
+        private frontLeftWheelMesh;
+        private frontRightWheelMesh;
+        private backLeftWheelMesh;
+        private backRightWheelMesh;
+        private frontLeftWheelEmitter;
+        private frontRightWheelEmitter;
+        private backLeftWheelEmitter;
+        private backRightWheelEmitter;
+        private frontLeftWheelParticle;
+        private frontRightWheelParticle;
+        private backLeftWheelParticle;
+        private backRightWheelParticle;
+        private frontLeftContact;
+        private frontRightContact;
+        private rearLeftContact;
+        private rearRightContact;
+        private frontLeftContactTag;
+        private frontRightContactTag;
+        private rearLeftContactTag;
+        private rearRightContactTag;
+        private frontLeftContactPoint;
+        private frontRightContactPoint;
+        private rearLeftContactPoint;
+        private rearRightContactPoint;
+        private frontLeftContactNormal;
+        private frontRightContactNormal;
+        private rearLeftContactNormal;
+        private rearRightContactNormal;
+        private startRaycastPosition;
+        private endRaycastPosition;
+        private smokeIntensityFactor;
+        private downDirection;
+        private downDistance;
+        private lastPitch;
+        private lastBrake;
+        private lastReverse;
+        private lastBurnout;
+        private lastSteering;
+        private lastSKID_FL;
+        private lastSKID_FR;
+        private lastSKID_RL;
+        private lastSKID_RR;
+        private lastSPIN_FL;
+        private lastSPIN_FR;
+        private lastSPIN_RL;
+        private lastSPIN_RR;
+        private PITCH_FL;
+        private PITCH_FR;
+        private PITCH_RL;
+        private PITCH_RR;
+        private WHEEL_SKID_PITCH;
+        getFrontLeftWheelContact(): boolean;
+        getFrontRightWheelContact(): boolean;
+        getRearLeftWheelContact(): boolean;
+        getRearRightWheelContact(): boolean;
+        getFrontLeftWheelContactTag(): string;
+        getFrontRightWheelContactTag(): string;
+        getRearLeftWheelContactTag(): string;
+        getRearRightWheelContactTag(): string;
+        getFrontLeftWheelContactPoint(): BABYLON.Vector3;
+        getFrontRightWheelContactPoint(): BABYLON.Vector3;
+        getRearLeftWheelContactPoint(): BABYLON.Vector3;
+        getRearRightWheelContactPoint(): BABYLON.Vector3;
+        getFrontLeftWheelContactNormal(): BABYLON.Vector3;
+        getFrontRightWheelContactNormal(): BABYLON.Vector3;
+        getRearLeftWheelContactNormal(): BABYLON.Vector3;
+        getRearRightWheelContactNormal(): BABYLON.Vector3;
+        protected m_frontLeftWheelSkid: number;
+        protected m_frontRightWheelSkid: number;
+        protected m_backLeftWheelSkid: number;
+        protected m_backRightWheelSkid: number;
+        protected m_velocityOffset: BABYLON.Vector3;
+        protected m_linearVelocity: BABYLON.Vector3;
+        protected m_lastPosition: BABYLON.Vector3;
+        protected m_positionCenter: BABYLON.Vector3;
+        protected m_scaledVelocity: number;
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected destroy(): void;
+        protected updateVehicleProperties(): void;
+        private createSmokeParticleSystem;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon Script Component
+     * @class SideCameraController
+     */
+    class SideCameraController extends TOOLKIT.ScriptComponent {
+        private _camera;
+        private _adt;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected ready(): void;
+        protected update(): void;
+        protected late(): void;
+        protected step(): void;
+        protected fixed(): void;
+        protected after(): void;
+        protected reset(): void;
+        protected destroy(): void;
+        private enableWindowView;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon skidmark section class (Havok Physics Engine)
+     * @class SkidMarkSection
+     */
+    class SkidMarkSection {
+        Pos: BABYLON.Vector3;
+        Normal: BABYLON.Vector3;
+        Tangent: BABYLON.Vector4;
+        Posl: BABYLON.Vector3;
+        Posr: BABYLON.Vector3;
+        Intensity: number;
+        LastIndex: number;
+    }
+    /**
+     * Babylon Script Component
+     * @class SkidMarkManager
+     */
+    class SkidMarkManager extends TOOLKIT.ScriptComponent {
+        private static MAX_MARKS;
+        private static GROUND_OFFSET;
+        private static GPU_TRIANGLES;
+        private static MARK_COLOR;
+        private static MARK_WIDTH;
+        private static TEX_INTENSITY;
+        private static MIN_DISTANCE;
+        private static MIN_SQR_DISTANCE;
+        private static TEXTURE_MARKS;
+        private static SkidBufferPositions;
+        private static SkidBufferNormals;
+        private static SkidBufferTangents;
+        private static SkidBufferColors;
+        private static SkidBufferUvs;
+        private static SkidBufferIndices;
+        private static SkidMarkSections;
+        private static SkidMarkIndex;
+        private static SkidMarkMesh;
+        private static SkidMarkUpdated;
+        private static TempVector3_POS;
+        private static TempVector3_DIR;
+        private static TempVector3_XDIR;
+        private static TempVector3_SDIR;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+        protected update(): void;
+        static AddSkidMarkSegment(pos: BABYLON.Vector3, normal: BABYLON.Vector3, intensity: number, lastIndex: number): BABYLON.Nullable<number>;
+        private static CreateSkidMarkManager;
+        private static AddSkidMarkVertexData;
+        private static UpdateSkidMarkManager;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon standard rigidbody vehicle controller class (Native Bullet Physics 2.82)
+     * @class StandardCarController
+     */
+    class StandardCarController extends TOOLKIT.ScriptComponent {
+        static DEFAULT_SKID_FACTOR: number;
+        static DEFAULT_PITCH_FACTOR: number;
+        static DEFAULT_SPEED_FACTOR: number;
+        static DEFAULT_DONUT_FACTOR: number;
+        static DEFAULT_BRAKE_DEADZONE: number;
+        static SimplexNoise2D: TOOLKIT.NoiseFunction2D;
+        MIN_RPM: number;
+        MAX_RPM: number;
+        private _animator;
+        private _rigidbody;
+        private _engineAudioSource;
+        private _skidAudioSource;
+        private _nosAudioSource;
+        private _positionLocked;
+        private _prevHandBrakeRequested;
+        private _donutEngineScale;
+        private steeringWheelHub;
+        private steeringWheelAxis;
+        private maxSteeringAngle;
+        private maxSteeringSpeed;
+        private gearIndex;
+        private shiftingTime;
+        private shiftingSide;
+        private shiftingBrake;
+        private engineForce;
+        private footBraking;
+        private handBraking;
+        private linearDamping;
+        private angularDamping;
+        private forwardSpeed;
+        private absoluteSpeed;
+        private americanSpeed;
+        private gradientSpeed;
+        private smoothedGradientSpeed;
+        private smoothedSteeringSpeed;
+        private frontWheelPower;
+        private backWheelPower;
+        private wheelBrakingForce;
+        private enginePitchLevel;
+        private smokeIntensityFactor;
+        private handBrakingHoldTimer;
+        private raycastVehicle;
+        private brakeLightsMesh;
+        private brakeLightsTrans;
+        private reverseLightsMesh;
+        private reverseLightsTrans;
+        private frontLeftWheelTrans;
+        private frontRightWheelTrans;
+        private backLeftWheelTrans;
+        private backRightWheelTrans;
+        private frontLeftWheelMesh;
+        private frontRightWheelMesh;
+        private backLeftWheelMesh;
+        private backRightWheelMesh;
+        private frontLeftWheelEmitter;
+        private frontRightWheelEmitter;
+        private backLeftWheelEmitter;
+        private backRightWheelEmitter;
+        private frontLeftWheelParticle;
+        private frontRightWheelParticle;
+        private backLeftWheelParticle;
+        private backRightWheelParticle;
+        private frontLeftWheelCollider;
+        private frontRightWheelCollider;
+        private backLeftWheelCollider;
+        private backRightWheelCollider;
+        private engineTorqueCurve;
+        private physicsSteerAngleL;
+        private physicsSteerAngleR;
+        private visualSteerAngleL;
+        private visualSteerAngleR;
+        private visualSteerBoostL;
+        private visualSteerBoostR;
+        private idleNoiseDelta;
+        private driveNoiseDelta;
+        private boostSpeedTimer;
+        private burnoutMeter;
+        private donutMeter;
+        private wheelRadius;
+        private engineRPM;
+        private pitchRPM;
+        private shiftRPM;
+        private wheelRPM;
+        private transmissionInputRPM;
+        private actualEngineRPM;
+        private targetEngineRPM;
+        private throttleRPM;
+        private engineLoad;
+        private gearShiftCooldown;
+        private isShifting;
+        private shiftDirection;
+        private clutchEngagement;
+        private engineBraking;
+        private shiftHysteresis;
+        private SKID_FL;
+        private SKID_FR;
+        private SKID_RL;
+        private SKID_RR;
+        private PITCH_FL;
+        private PITCH_FR;
+        private PITCH_RL;
+        private PITCH_RR;
+        private FRONT_LEFT;
+        private FRONT_RIGHT;
+        private BACK_LEFT;
+        private BACK_RIGHT;
+        private WHEEL_SKID_PITCH;
+        private POWER_BOOST_PITCH;
+        private SPIN_FL_Rotation;
+        private SPIN_FR_Rotation;
+        private SPIN_RL_Rotation;
+        private SPIN_RR_Rotation;
+        isBraking(): boolean;
+        isBoosting(): boolean;
+        private allowRollingReverseBurnout;
+        getFootBraking(): boolean;
+        getHandBraking(): boolean;
+        getLinearVelocity(): BABYLON.Vector3;
+        getCurrentForward(): number;
+        getCurrentTurning(): number;
+        getCurrentSkidding(): boolean;
+        getBurnoutButton(): boolean;
+        getDonutButton(): boolean;
+        getReverseThrottle(): boolean;
+        getEnginePitchLevel(): number;
+        getCurrentBurnout(): boolean;
+        getFrontLeftSkid(): number;
+        getFrontRightSkid(): number;
+        getBackLeftSkid(): number;
+        getBackRightSkid(): number;
+        getWheelSkidPitch(): number;
+        getRigidbodyPhysics(): TOOLKIT.RigidbodyPhysics;
+        getRaycastVehicle(): TOOLKIT.RaycastVehicle;
+        getGradientSpeed(): number;
+        getForwardSpeed(): number;
+        getAbsoluteSpeed(): number;
+        getAmericanSpeed(): number;
+        getTopEngineSpeed(): number;
+        getNormalizedSpeed(): number;
+        getMaxReversePower(): number;
+        getCurrentGearIndex(): number;
+        getCurrentEngineRPM(): number;
+        getCurrentEngineForce(): number;
+        getCurrentEnginePitch(): number;
+        getGearShiftRatioCount(): number;
+        getSmokeTextureMask(): BABYLON.Texture;
+        getBrakeLightsMesh(): BABYLON.TransformNode;
+        getReverseLightsMesh(): BABYLON.TransformNode;
+        getFrontLeftWheelNode(): BABYLON.TransformNode;
+        getFrontRightWheelNode(): BABYLON.TransformNode;
+        getBackLeftWheelNode(): BABYLON.TransformNode;
+        getBackRightWheelNode(): BABYLON.TransformNode;
+        getWheelBurnoutEnabled(): boolean;
+        getWheelDonutsEnabled(): boolean;
+        getCurrentDonutSpinTime(): number;
+        isStartPositionLocked(): boolean;
+        /**
+         * Snap the car to its current transform position and lock it there.
+         * Engine revs, burnout state machine, and wheel spin visuals continue to run.
+         * Call this when placing the car on the grid before the countdown starts.
+         */
+        lockStartPosition(): void;
+        /**
+         * Release the position lock. If the car had a stationary burnout actively built up,
+         * the burnout launch kick fires immediately for an explosive start.
+         * Call this on GO / when the countdown finishes.
+         */
+        unlockStartPosition(): void;
+        getSmokeIntensityFactor(): number;
+        getWheelVelocityOffset(): BABYLON.Vector3;
+        smokeTexture: BABYLON.Texture;
+        skidThreashold: number;
+        wheelDrawVelocity: number;
+        smokeIntensity: number;
+        smokeOpacity: number;
+        smokeDonuts: number;
+        burnoutTurnFactor: number;
+        maxSteerBoost: number;
+        overSteerSpeed: number;
+        overSteerTimeout: number;
+        topEngineSpeed: number;
+        topBoosterSpeed: number;
+        powerChangeRate: number;
+        powerCoefficient: number;
+        boosterCoefficient: number;
+        gravitationalForce: number;
+        driftSpeedDampener: number;
+        lowGearCoefficient: number;
+        lowGearDampener: number;
+        stationaryBoost: number;
+        lowSpeedSteering: number;
+        highSpeedSteering: number;
+        steeringInputCurve: number;
+        maximumYawRateLow: number;
+        maximumYawRateHigh: number;
+        debugBurnout: boolean;
+        debugBurnoutEveryNFrames: number;
+        debugSteering: boolean;
+        debugSteeringEveryNFrames: number;
+        private _debugSteeringCounter;
+        debugDonut: boolean;
+        debugDonutEveryNFrames: number;
+        private _donutLogCounter;
+        donutTurningRadius: number;
+        donutPowerBlend: number;
+        donutSpeedScaling: number;
+        donutRotationBoost: number;
+        donutAngularDamping: number;
+        donutFrontFriction: number;
+        donutRearFriction: number;
+        donutFrontWheelPull: number;
+        donutYawDegPerSec: number;
+        donutYawResponse: number;
+        donutSpeedGovernorEnabled: boolean;
+        donutSpeedGovernorGain: number;
+        donutSpeedGovernorResponse: number;
+        donutSpeedGovernorMinScale: number;
+        donutSpeedGovernorMaxScale: number;
+        donutVelocityPinEnabled: boolean;
+        donutVelocityPinResponse: number;
+        roadConnectAccel: number;
+        smoothFlyingImpulse: number;
+        stableDownImpulse: number;
+        constImpulseForce: number;
+        transmissionRatio: number;
+        differentialRatio: number;
+        burnoutFirstGearMultiplier: number;
+        maxBoosterTime: number;
+        minBoosterSpeed: number;
+        maxFrontBraking: number;
+        maxReversePower: number;
+        minBrakingForce: number;
+        maxBrakingForce: number;
+        handBrakingForce: number;
+        handBrakingTimer: number;
+        defaultBrakingWindow: number;
+        counterSteerLockoutWindowPercent: number;
+        counterSteerLockoutDeadzone: number;
+        linearBrakingForce: number;
+        angularBrakingForce: number;
+        frontSkidFriction: number;
+        rearSkidFriction: number;
+        burnoutTimeDelay: number;
+        burnoutWheelPitch: number;
+        stationaryBurnoutSkidPitch: number;
+        burnoutPeelAwaySkidPitch: number;
+        burnoutPeelAwayPitchRampTime: number;
+        burnoutLaunchChirpSound: string;
+        burnoutCoefficient: number;
+        burnoutTriggerMark: number;
+        stationaryBurnoutPrimeSpeedMph: number;
+        stationaryBurnoutPrimeHoldTime: number;
+        stationaryBurnoutPrimeReleaseSpeedMph: number;
+        stationaryBurnoutRevMinRpmOffset: number;
+        stationaryBurnoutRevMaxFactor: number;
+        stationaryBurnoutRevLerpSpeed: number;
+        burnoutLaunchRpmCarryTime: number;
+        burnoutLaunchRpmCarryFloorFactor: number;
+        normalLaunchTractionRamp: number;
+        normalLaunchTractionMin: number;
+        burnoutLaunchKickDuration: number;
+        burnoutLaunchKickMultiplier: number;
+        burnoutLaunchFrictionRestore: number;
+        debugLaunch: boolean;
+        debugLaunchEveryNFrames: number;
+        debugFrictionRestore: boolean;
+        debugFrictionRestoreEveryNFrames: number;
+        debugFrictionSnapDelta: number;
+        skidReleaseBrakeFadeTime: number;
+        skidReleaseFrictionLerpScale: number;
+        skidReleaseFrictionRestoreSpeed: number;
+        skidReleaseSnapRatio: number;
+        skidStopFrictionResetSpeed: number;
+        skidLaunchFrictionResetSpeed: number;
+        burnoutStopFrictionResetSpeed: number;
+        burnoutLaunchFrictionResetSpeed: number;
+        burnoutExitArcadeFadeTime: number;
+        burnoutExitFrictionRampTime: number;
+        burnoutExitArcadeReleaseTime: number;
+        enableAutoBurnouts: boolean;
+        grassPenaltyMask: number;
+        curbPenaltyMask: number;
+        minPenaltySpeed: number;
+        linearWheelDrag: number;
+        frictionWheelSlip: number;
+        showSensorLines: boolean;
+        powerBooster: boolean;
+        linkTrackManager: boolean;
+        playVehicleSounds: boolean;
+        postNetworkAttributes: boolean;
+        wheelDriveType: number;
+        gearBoxMultiplier: number;
+        currentPitchScale: number;
+        gearBoxPitchScale: number;
+        gearBoxShiftDelay: number;
+        gearBoxShiftRatios: number[];
+        gearBoxShiftUpRanges: number[];
+        gearBoxShiftDownRanges: number[];
+        throttleBrakingForce: number;
+        throttleEngineSpeed: number;
+        frictionLerpSpeed: number;
+        burnoutLerpSpeed: number;
+        skidTurningAssist: number;
+        skidSteeringKick: number;
+        skidSteeringAngle: number;
+        skidReleaseWindow: number;
+        skidReleaseLinger: number;
+        ackermanWheelBase: number;
+        ackermanRearTrack: number;
+        ackermanTurnRadius: number;
+        ackermanMaxRadius: number;
+        ackermanTurnFactor: number;
+        radiusBrakingForce: number;
+        steeringSlewTau: number;
+        minSteeringSlew: number;
+        readBurnoutMeter(): number;
+        resetBurnoutMeter(): void;
+        readDonutMeter(): number;
+        resetDonutMeter(): void;
+        getBoosterTime(): number;
+        setBoosterTime(time: number): void;
+        resetBoosterTime(): void;
+        roadSurfaceFactor: number;
+        movementTilting: boolean;
+        surfaceDetection: boolean;
+        idleShakeRate: number;
+        idleShakeNoise: number;
+        maxForwardAngle: number;
+        maxLateralAngle: number;
+        lerpForwardFactor: number;
+        lerpLateralFactor: number;
+        shiftForwardExtra: number;
+        shiftLateralExtra: number;
+        forwardPitchFactor: number;
+        lateralRollFactor: number;
+        forwardRecoverRate: number;
+        lateralRecoverRate: number;
+        lowSpeedScale: number;
+        highSpeedScale: number;
+        lowForwardNoise: number;
+        highForwardNoise: number;
+        lowLateralNoise: number;
+        highLateralNoise: number;
+        speedThreashold: number;
+        boosterTransform: BABYLON.TransformNode;
+        chassisTransform: BABYLON.TransformNode;
+        tiltChassisEulers: BABYLON.Vector3;
+        protected m_physicsWorld: any;
+        protected m_frontLeftWheel: TOOLKIT.btWheelInfo;
+        protected m_frontRightWheel: TOOLKIT.btWheelInfo;
+        protected m_backLeftWheel: TOOLKIT.btWheelInfo;
+        protected m_backRightWheel: TOOLKIT.btWheelInfo;
+        protected m_frontLeftWheelSkid: number;
+        protected m_frontRightWheelSkid: number;
+        protected m_backLeftWheelSkid: number;
+        protected m_backRightWheelSkid: number;
+        protected m_angularDampener: BABYLON.Vector3;
+        protected m_velocityOffset: BABYLON.Vector3;
+        protected m_linearVelocity: BABYLON.Vector3;
+        protected m_lastPosition: BABYLON.Vector3;
+        protected m_scaledVelocity: number;
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected destroy(): void;
+        protected awakeVehicleState(): void;
+        protected initVehicleState(): void;
+        protected updateVehicleState(): void;
+        protected destroyVehicleState(): void;
+        private donutButton;
+        private burnoutButton;
+        private burnoutTimer;
+        private burnoutElapsed;
+        private restoreTimer;
+        private restoreTimerDuration;
+        private cooldownTimer;
+        private wheelDonuts;
+        private wheelBurnout;
+        private _prevBurnoutButton;
+        private _burnoutLatchedDriveSign;
+        private _stationaryBurnoutPrimed;
+        private _stationaryBurnoutPrimeTimer;
+        private _prevStationaryBurnoutWanted;
+        private _burnoutLaunchKickTimer;
+        private _burnoutLaunchHoldRpm;
+        private _burnoutLaunchRpmCarryTimer;
+        private _burnoutLaunchRpmCarryDuration;
+        private _burnoutPeelAwayPitchRampTimer;
+        private _burnoutPeelAwayPitchRampDuration;
+        private _stationaryLaunchSnapActive;
+        private _burnoutLowGearClimbActive;
+        private _burnoutLowGearClimbStationary;
+        private _burnoutLowGearClimbDriveSign;
+        private _burnoutStartedFromStationary;
+        private _launchLogCounter;
+        private _handBrakeEntrySteerSign;
+        private _skidReleaseBrakeTimer;
+        private _skidFrictionRestorePending;
+        private _burnoutExitArcadeFadeTimer;
+        private _burnoutExitFrictionRampTimer;
+        private _burnoutExitArcadeReleaseTimer;
+        private _burnoutResidualFrictionRestorePending;
+        private _prevWheelBurnoutState;
+        private _lockedPosition;
+        private _lockedRotationQuaternion;
+        private wheelSkidding;
+        private donutSpinTime;
+        private currentForward;
+        private currentTurning;
+        private rampedTurning;
+        private currentBoosting;
+        private currentSkidding;
+        private currentDrivePower;
+        private targetDrivePower;
+        private animatorSteerAngle;
+        /** Drives the raycast vehicle with the specfied movement properties. */
+        drive(throttle: number, steering: number, braking: boolean, burnout: boolean, booster?: number, autopilot?: boolean, nos?: boolean, donut?: boolean): void;
+        private processAckermanSteering;
+        private syncVehicleState;
+        private currentPitch;
+        private currentRoll;
+        private previousSpeed;
+        private syncVehicleTilting;
+        private updateGearShifting;
+        private shouldUpshift;
+        private shouldDownshift;
+        private initiateGearShift;
+        private armBurnoutLowGearClimb;
+        private resetBurnoutLowGearClimb;
+        private isBurnoutLowGearClimbActive;
+        private updateBurnoutLowGearClimbState;
+        private armBurnoutLaunchAudio;
+        private isStationaryBurnoutSkidAudioActive;
+        private isBurnoutPeelAwaySkidAudioActive;
+        private getWheelSkidAudioPitchScale;
+        private getBurnoutLaunchRpmCarryFloor;
+        private updateClutchEngagement;
+        private getIdleRPM;
+        private writeTransformMetadata;
+        private getVehicleEngineTorque;
+        private createSmokeParticleSystem;
+        private updateCurrentSkidInfo;
+        private updateCurrentContactMask;
+        private hasPenaltyContactMask;
+        private updateCurrentBrakeDamping;
+        private updateCurrentRotationDelta;
+        private updateCurrentRotationBoost;
+        private clearWheelRotationBoost;
+        private hasBurnoutResidualState;
+        private resetBurnoutFrictionForStopOrLaunch;
+        private resetSkidFrictionForStopOrLaunch;
+        private restoreWheelFrictionToDefault;
+        private isWheelFrictionAtDefault;
+        private updateCurrentFrictionSlip;
+        private armBurnoutExitSmoothing;
+        private clearBurnoutExitSmoothing;
+        private frontLeftContact;
+        private frontRightContact;
+        private rearLeftContact;
+        private rearRightContact;
+        private frontLeftContactTag;
+        private frontRightContactTag;
+        private rearLeftContactTag;
+        private rearRightContactTag;
+        private frontLeftContactMask;
+        private frontRightContactMask;
+        private rearLeftContactMask;
+        private rearRightContactMask;
+        private frontLeftContactPoint;
+        private frontRightContactPoint;
+        private rearLeftContactPoint;
+        private rearRightContactPoint;
+        private frontLeftContactNormal;
+        private frontRightContactNormal;
+        private rearLeftContactNormal;
+        private rearRightContactNormal;
+        private frontLeftFrictionLerping;
+        private frontRightFrictionLerping;
+        private rearLeftFrictionLerping;
+        private rearRightFrictionLerping;
+        private frontLeftFrictionPenalty;
+        private frontRightFrictionPenalty;
+        private rearLeftFrictionPenalty;
+        private rearRightFrictionPenalty;
+        private startRaycastPosition;
+        private endRaycastPosition;
+        private downDirection;
+        private downDistance;
+        getFrontLeftWheelContact(): boolean;
+        getFrontRightWheelContact(): boolean;
+        getRearLeftWheelContact(): boolean;
+        getRearRightWheelContact(): boolean;
+        getFrontLeftWheelContactTag(): string;
+        getFrontRightWheelContactTag(): string;
+        getRearLeftWheelContactTag(): string;
+        getRearRightWheelContactTag(): string;
+        getFrontLeftWheelContactPoint(): BABYLON.Vector3;
+        getFrontRightWheelContactPoint(): BABYLON.Vector3;
+        getRearLeftWheelContactPoint(): BABYLON.Vector3;
+        getRearRightWheelContactPoint(): BABYLON.Vector3;
+        getFrontLeftWheelContactNormal(): BABYLON.Vector3;
+        getFrontRightWheelContactNormal(): BABYLON.Vector3;
+        getRearLeftWheelContactNormal(): BABYLON.Vector3;
+        getRearRightWheelContactNormal(): BABYLON.Vector3;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class VehicleCameraManager
+    */
+    class VehicleCameraManager extends TOOLKIT.ScriptComponent {
+        enableCamera: boolean;
+        followTarget: boolean;
+        followHeight: number;
+        pitchingAngle: number;
+        rotationDamping: number;
+        minimumDistance: number;
+        maximumDistance: number;
+        buttonCamera: number;
+        keyboardCamera: number;
+        tickRemoteEntities: boolean;
+        fastMotionBlur: boolean;
+        lowSpeedBlurring: number;
+        highSpeedBlurring: number;
+        motionBlurSamples: number;
+        isObjectBasedBlur: boolean;
+        fastCameraShake: boolean;
+        lowSpeedShaking: number;
+        highSpeedShaking: number;
+        autoAttachCamera: boolean;
+        private firstPerson;
+        private cameraPivot;
+        private targetEulers;
+        private cameraRotation;
+        private cameraPivotOffset;
+        private motionBlurAttached;
+        protected m_freeCamera: BABYLON.FreeCamera;
+        protected m_motionBlur: BABYLON.MotionBlurPostProcess;
+        protected m_cameraTransform: BABYLON.TransformNode;
+        protected m_inputController: PROJECT.VehicleInputController;
+        protected m_standardController: PROJECT.StandardCarController;
+        protected m_firstPersonOffset: BABYLON.Vector3;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected late(): void;
+        protected destroy(): void;
+        protected awakeCameraManager(): void;
+        protected initCameraManager(): void;
+        protected lateUpdateCameraManager(): void;
+        protected destroyCameraManager(): void;
+        attachPlayerCamera(player: TOOLKIT.PlayerNumber): void;
+        togglePlayerCamera(): void;
+        firstPersonCamera(): void;
+        thirdPersonCamera(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon Script Component
+     * @class VehicleInputController
+     */
+    interface ISteeringWheelDevice {
+        deviceName: string;
+        forwardButton: number;
+        backwardButton: number;
+        leftHandBrake: number;
+        rightHandBrake: number;
+        leftBurnoutBoost: number;
+        rightBurnoutBoost: number;
+        leftDonutBoost: number;
+        rightDonutBoost: number;
+    }
+    class VehicleInputController extends TOOLKIT.ScriptComponent {
+        private playerDeltaX;
+        private playerDeltaY;
+        private playerMouseX;
+        private playerMouseY;
+        private ackermanRadius;
+        private autoturnRadius;
+        private recoveryRadius;
+        private waypointPosition;
+        private waypointCount;
+        private waypointIndex;
+        private noMovementTime;
+        private reverseFixMode;
+        private recoveryFixMode;
+        private nextTargetSpeed;
+        private prevTargetSpeed;
+        private vehicleResetCheck;
+        private randomSkillFactor;
+        private showChaseRabbit;
+        private showSensorLines;
+        private steeringWheelMode;
+        private rabbitTrackerLine;
+        private rabbitTrackerColor;
+        private greenTrackingColor;
+        private redTrackingColor;
+        private localTargetPosition;
+        private avoidPositionOffset;
+        private avoidanceLerp;
+        private avoidanceTimer;
+        private avoidanceValue;
+        private _avoidanceSteerSmoothed;
+        private _debugAvoidanceCounter;
+        private _frontThreatHit;
+        private _frontThreatDistance;
+        private _frontThreatSensor;
+        private _frontThreatTag;
+        private randomTurning;
+        private randomBoosting;
+        private randomDistance;
+        private lastCheckpoint;
+        private mainCenterSensorLine;
+        private mainRightSensorLine;
+        private mainLeftSensorLine;
+        private angleRightSensorLine;
+        private angleLeftSensorLine;
+        private sideRightSensorLine;
+        private sideLeftSensorLine;
+        private backRightSensorLine;
+        private backLeftSensorLine;
+        private sidewaysOffsetVector;
+        private backBumperEdgeVector;
+        private sensorStartPos;
+        private sensorPointPos;
+        private sensorAnglePos;
+        private rsideStartPos;
+        private rsidePointPos;
+        private lsideStartPos;
+        private lsidePointPos;
+        private tempScaleVector;
+        private rbackStartPos;
+        private rbackPointPos;
+        private lbackStartPos;
+        private lbackPointPos;
+        private trackVehiclePosition;
+        private trackRabbitPosition;
+        getPlayerDeltaX(): number;
+        getPlayerDeltaY(): number;
+        getPlayerMouseX(): number;
+        getPlayerMouseY(): number;
+        getWaypointIndex(): number;
+        getChaseRabbitMesh(): BABYLON.Mesh;
+        resetChaseRabbitMesh(): void;
+        getChasePointMesh(): BABYLON.Mesh;
+        resetChasePointMesh(): void;
+        enableInput: boolean;
+        resetTiming: number;
+        playerNumber: TOOLKIT.PlayerNumber;
+        pedelForward: number;
+        triggerForward: number;
+        keyboardForawrd: number;
+        auxKeyboardForawrd: number;
+        pedalBackward: number;
+        triggerBackwards: number;
+        keyboardBackwards: number;
+        auxKeyboardBackwards: number;
+        pedalBooster: number;
+        keyboardBooster: number;
+        leftButtonBooster: number;
+        rightButtonBooster: number;
+        buttonHandbrake: number;
+        keyboardHandbrake: number;
+        leftWheelHandbrake: number;
+        rightWheelHandbrake: number;
+        keyboardBurnout: number;
+        buttonBurnout: number;
+        leftWheelBurnout: number;
+        rightWheelBurnout: number;
+        keyboardDonut: number;
+        buttonDonut: number;
+        leftWheelDonut: number;
+        rightWheelDonut: number;
+        raceLineNode: number;
+        minLookAhead: number;
+        maxLookAhead: number;
+        driverSkillLevel: number;
+        chaseRabbitSpeed: number;
+        throttleSensitivity: number;
+        steeringSensitivity: number;
+        brakingSensitivity: number;
+        brakingTurnAngle: number;
+        brakingSpeedLimit: number;
+        skiddingSpeedLimit: number;
+        linearDampenForce: number;
+        driveSpeedMultiplier: number;
+        driveLineDistance: number;
+        resetMovingTimeout: number;
+        reverseThrottleTime: number;
+        maxRaceTrackSpeed: number;
+        trackManagerIdentity: string;
+        vehicleTag: string;
+        obstacleTag: string;
+        sensorLength: number;
+        spacerWidths: number;
+        angleFactors: number;
+        initialOffsetX: number;
+        initialOffsetY: number;
+        initialOffsetZ: number;
+        sidewaysLength: number;
+        sidewaysOffset: number;
+        backBumperEdge: number;
+        powerBoosting: number;
+        wonderDistance: number;
+        avoidanceFactor: number;
+        avoidanceSpeed: number;
+        avoidanceTimeout: number;
+        avoidanceDistance: number;
+        avoidanceSteeringGain: number;
+        avoidanceSteeringGainHigh: number;
+        avoidanceSteerSmoothing: number;
+        avoidanceSteerDeadband: number;
+        frontSlowdownGain: number;
+        frontSlowdownMinThrottle: number;
+        frontBrakeProximity: number;
+        frontBrakeForce: number;
+        frontHardBrakeProximity: number;
+        frontHardBrakeStrength: number;
+        avoidanceProximityBoost: number;
+        avoidanceSteerCarryover: number;
+        debugAvoidance: boolean;
+        debugAvoidanceEveryNFrames: number;
+        private reversingFlag;
+        private reversingTime;
+        private reversingWait;
+        private reversingFor;
+        protected m_chasePointMesh: BABYLON.Mesh;
+        protected m_chaseRabbitMesh: BABYLON.Mesh;
+        protected m_circuitInterfaces: PROJECT.ITrackNode[];
+        protected m_circuitRaceLine_1: PROJECT.IControlPoint[];
+        protected m_circuitRaceLine_2: PROJECT.IControlPoint[];
+        protected m_circuitRaceLine_3: PROJECT.IControlPoint[];
+        protected m_circuitRaceLine_4: PROJECT.IControlPoint[];
+        protected m_circuitRaceLine_5: PROJECT.IControlPoint[];
+        protected m_rigidbodyPhysics: TOOLKIT.RigidbodyPhysics;
+        protected m_checkpointManager: PROJECT.CheckpointManager;
+        protected m_standardCarController: PROJECT.StandardCarController;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected destroy(): void;
+        protected awakeVehicleController(): void;
+        protected initVehicleController(): void;
+        protected updateVehicleController(): void;
+        protected updateManualInputDrive(): void;
+        private autoDriveRaycastResult;
+        protected updateAutoPilotDrive(): void;
+        protected getDriverSkillFactor(): number;
+        protected getCurrentTrackNode(index: number): PROJECT.ITrackNode;
+        protected getCurrentControlPoint(lane: number, index: number): PROJECT.IControlPoint;
+        protected getRandomNumber(min: number, max: number): number;
+        protected generateRandonNumber(min: number, max: number, decimals?: number): number;
+        protected destroyVehicleController(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class VehicleNetworkLabel
+    */
+    class VehicleNetworkLabel extends TOOLKIT.ScriptComponent {
+        label: BABYLON.GUI.TextBlock;
+        rect: BABYLON.GUI.Rectangle;
+        autoCreate: boolean;
+        offsetX: number;
+        offsetY: number;
+        labelColor: BABYLON.Color3;
+        borderColor: BABYLON.Color3;
+        backgroundColor: BABYLON.Color3;
+        labelCreated: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected update(): void;
+        createLabel(name: string): void;
+        protected destroy(): void;
+        private static AdvDynamicTexture;
+        /** Get the default fullscreen user interface advanced dynamic texture */
+        static GetFullscreenUI(scene: BABYLON.Scene, sampling?: number): BABYLON.GUI.AdvancedDynamicTexture;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Double Sided Shader Material (BABYLON.PBRMaterial)
+     * Disables backface culling so both sides of geometry are rendered.
+     * Ported from Unity "Custom/DoubleSided".
+     * @class DoubleSided
+     */
+    class DoubleSided extends TOOLKIT.CustomShaderMaterial {
+        constructor(name: string, scene: BABYLON.Scene);
+        awake(): void;
+        update(): void;
+        getShaderName(): string;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Vertex Color Splat Shader Material (BABYLON.PBRMaterial)
+     * Blends albedo (Splat1) with a second texture (Splat3) using vertex color blue channel.
+     * Ported from Unity "Custom/Vertex Color Splat Surf Shader".
+     * @class Splat
+     */
+    class VertexSplat extends TOOLKIT.CustomShaderMaterial {
+        constructor(name: string, scene: BABYLON.Scene);
+        awake(): void;
+        update(): void;
+        getShaderName(): string;
+        getCustomVertexCode(wgsl: boolean): string;
+    }
+    /**
+     * Vertex Color Splat Shader Plugin (BABYLON.MaterialPluginBase)
+     * @class VertexSplatPlugin
+     */
+    class VertexSplatPlugin extends TOOLKIT.CustomShaderMaterialPlugin {
+        constructor(customMaterial: TOOLKIT.CustomShaderMaterial, shaderName: string);
+        isCompatible(shaderLanguage: BABYLON.ShaderLanguage): boolean;
+        getCustomCode(shaderType: string, shaderLanguage: BABYLON.ShaderLanguage): any;
+        /** This gets the uniforms used in the shader code */
+        getUniforms(shaderLanguage: BABYLON.ShaderLanguage): any;
+        /** This gets the samplers used in the shader code */
+        getSamplers(samplers: string[]): void;
+        /** This get the attributes used in the shader code */
+        getAttributes(attributes: string[], scene: BABYLON.Scene, mesh: BABYLON.AbstractMesh): void;
+        /** This prepares the shader defines */
+        prepareDefines(defines: BABYLON.MaterialDefines, scene: BABYLON.Scene, mesh: BABYLON.AbstractMesh): void;
+        /** This is used to update the uniforms bound to a mesh */
+        bindForSubMesh(uniformBuffer: BABYLON.UniformBuffer, scene: BABYLON.Scene, engine: BABYLON.AbstractEngine, subMesh: BABYLON.SubMesh): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon toolkit default camera system class
+     * @class DefaultCameraSystem - All rights reserved (c) 2020 Mackey Kinard
+     * https://doc.babylonjs.com/divingDeeper/postProcesses/defaultRenderingPipeline
+     */
+    class DefaultCameraSystem extends TOOLKIT.ScriptComponent {
+        protected static PlayerOneCamera: BABYLON.FreeCamera;
+        protected static PlayerTwoCamera: BABYLON.FreeCamera;
+        protected static PlayerThreeCamera: BABYLON.FreeCamera;
+        protected static PlayerFourCamera: BABYLON.FreeCamera;
+        protected static XRExperienceHelper: BABYLON.WebXRDefaultExperience;
+        private static multiPlayerView;
+        private static multiPlayerCount;
+        private static multiPlayerCameras;
+        private static stereoCameras;
+        private static startupMode;
+        private static cameraReady;
+        private static cameraInstance;
+        private static renderingPipeline;
+        private static screenSpacePipeline;
+        static GetRenderingPipeline(): BABYLON.DefaultRenderingPipeline;
+        static GetScreenSpacePipeline(): BABYLON.SSAORenderingPipeline;
+        static IsCameraSystemReady(): boolean;
+        /** Register handler that is triggered when the webxr experience helper has been created */
+        static OnXRExperienceHelperObservable: BABYLON.Observable<BABYLON.WebXRDefaultExperience>;
+        /** Default Follow Speed */
+        static FOLLOW_SPEED: number;
+        private mainCamera;
+        private cameraType;
+        private cameraInertia;
+        private cameraController;
+        private immersiveOptions;
+        private arcRotateConfig;
+        private multiPlayerSetup;
+        private fullScreenToggle;
+        private setPointerLock;
+        private setCameraTarget;
+        private setSpatialAudio;
+        private editorPostProcessing;
+        protected m_cameraRig: BABYLON.TargetCamera;
+        isMainCamera(): boolean;
+        getCameraType(): number;
+        getTargetTransform(): BABYLON.TransformNode;
+        setTargetTransform(target: BABYLON.TransformNode): void;
+        enableSpatialAudio(value: boolean): void;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected destroy(): void;
+        protected awakeCameraSystemState(): void;
+        protected startCameraSystemState(): Promise<void>;
+        protected updateCameraSystemState(): void;
+        protected cleanCameraSystemState(): void;
+        protected destroyCameraSystemState(): void;
+        /*********************************************/
+        /** Follow Target Camera Controller Helpers  */
+        /*********************************************/
+        targetCameraOffset: BABYLON.Vector3;
+        getCameraPivotPosition(): BABYLON.Vector3;
+        getCameraPivotRotation(): BABYLON.Quaternion;
+        getCameraBoomNode(): BABYLON.TransformNode;
+        getCameraTransform(): BABYLON.TransformNode;
+        private cameraNode;
+        private cameraPivot;
+        private cameraDistance;
+        private cameraPivotOffset;
+        private cameraBoomPosition;
+        private dollyDirection;
+        private rotationEulers;
+        private scaledCamDirection;
+        private scaledMaxDirection;
+        private parentNodePosition;
+        private maximumCameraPos;
+        private cameraRaycastShape;
+        private targetRotationVector;
+        private resetCameraRotation;
+        private updateCameraController;
+        getBoomArmMaxDistance(): number;
+        setBoomArmMaxDistance(distance: number): void;
+        setSmoothBoomArmLength(length: number, speed: number, updateMaxDistance?: boolean): void;
+        private smoothBoomArmLength;
+        private smoothBoomArmSpeed;
+        private updateSmoothBoomArmLength;
+        static EnableTracking(value: boolean): void;
+        static IsTrackingEnabled(): boolean;
+        static SetAutoUpdate(value: boolean): void;
+        static IsAutoUpdateEnabled(): boolean;
+        static GetFollowTarget(): BABYLON.TransformNode;
+        static SetFollowTarget(target: BABYLON.TransformNode): void;
+        static ResetFollowTarget(): void;
+        static UpdateFollowTarget(): void;
+        /** Get the WebXR default experience helper */
+        static GetWebXR(): BABYLON.WebXRDefaultExperience;
+        /** Is universal camera system in WebXR mode */
+        static IsInWebXR(): boolean;
+        /** Setup navigation mesh for WebXR */
+        private static SetupNavigationWebXR;
+        /** Get main camera rig for the scene */
+        static GetMainCamera(scene: BABYLON.Scene, detach?: boolean): BABYLON.FreeCamera;
+        /** Get universal camera rig for desired player */
+        static GetPlayerCamera(scene: BABYLON.Scene, player?: TOOLKIT.PlayerNumber, detach?: boolean): BABYLON.FreeCamera;
+        /** Get camera transform node for desired player */
+        static GetCameraTransform(scene: BABYLON.Scene, player?: TOOLKIT.PlayerNumber): BABYLON.TransformNode;
+        /** Are stereo side side camera services available. */
+        static IsStereoCameras(): boolean;
+        /** Are local multi player view services available. */
+        static IsMultiPlayerView(): boolean;
+        /** Get the current local multi player count */
+        static GetMultiPlayerCount(): number;
+        /** Activates current local multi player cameras. */
+        static ActivateMultiPlayerCameras(scene: BABYLON.Scene): boolean;
+        /** Disposes current local multiplayer cameras */
+        static DisposeMultiPlayerCameras(): void;
+        /** Sets the multi player camera view layout */
+        static SetMultiPlayerViewLayout(scene: BABYLON.Scene, totalNumPlayers: number): boolean;
+    }
+    /*********************************************/
+    /** Camera Editor Properties Support Classes */
+    /*********************************************/
+    interface IEditorArcRtotate {
+        alpha: number;
+        beta: number;
+        radius: number;
+        target: TOOLKIT.IUnityVector3;
+    }
+    interface IEditorPostProcessing {
+        usePostProcessing: boolean;
+        highDynamicRange: boolean;
+        screenAntiAliasing: PROJECT.IEditorAntiAliasing;
+        focalDepthOfField: PROJECT.IEditorDepthOfField;
+        chromaticAberration: PROJECT.IEditorChromaticAberration;
+        glowLayerProperties: PROJECT.IEditorGlowLayer;
+        grainEffectProperties: PROJECT.IEditorGrainEffect;
+        sharpEffectProperties: PROJECT.IEditorSharpenEffect;
+        bloomEffectProperties: PROJECT.IEditorBloomProcessing;
+        imageProcessingConfig: PROJECT.IEditorImageProcessing;
+        screenSpaceRendering: PROJECT.IEditorScreenSpace;
+    }
+    interface IEditorScreenSpace {
+        SSAO: boolean;
+        SSAORatio: number;
+        combineRatio: number;
+        totalStrength: number;
+        radius: number;
+        area: number;
+        fallOff: number;
+        baseValue: number;
+    }
+    interface IEditorAntiAliasing {
+        msaaSamples: number;
+        fxaaEnabled: boolean;
+        fxaaScaling: boolean;
+        fxaaSamples: number;
+    }
+    interface IEditorDepthOfField {
+        depthOfField: boolean;
+        blurLevel: number;
+        focalStop: number;
+        focalLength: number;
+        focusDistance: number;
+        maxLensSize: number;
+    }
+    interface IEditorChromaticAberration {
+        aberrationEnabled: boolean;
+        aberrationAmount: number;
+        adaptScaleViewport: boolean;
+        alphaMode: number;
+        alwaysForcePOT: boolean;
+        pixelPerfectMode: boolean;
+        fullscreenViewport: boolean;
+    }
+    interface IEditorGlowLayer {
+        glowEnabled: boolean;
+        glowIntensity: number;
+        blurKernelSize: number;
+    }
+    interface IEditorGrainEffect {
+        grainEnabled: boolean;
+        grainAnimated: boolean;
+        grainIntensity: number;
+        adaptScaleViewport: boolean;
+    }
+    interface IEditorSharpenEffect {
+        sharpenEnabled: boolean;
+        sharpEdgeAmount: number;
+        sharpColorAmount: number;
+        adaptScaleViewport: boolean;
+    }
+    interface IEditorBloomProcessing {
+        bloomEnabled: boolean;
+        bloomKernel: number;
+        bloomScale: number;
+        bloomWeight: number;
+        bloomThreshold: number;
+    }
+    interface IEditorColorCurves {
+        curvesEnabled: boolean;
+        globalDen: number;
+        globalExp: number;
+        globalHue: number;
+        globalSat: number;
+        highlightsDen: number;
+        highlightsExp: number;
+        highlightsHue: number;
+        highlightsSat: number;
+        midtonesDen: number;
+        midtonesExp: number;
+        midtonesHue: number;
+        midtonesSat: number;
+        shadowsDen: number;
+        shadowsExp: number;
+        shadowsHue: number;
+        shadowsSat: number;
+    }
+    interface IEditorImageProcessing {
+        imageProcessing: boolean;
+        imageContrast: number;
+        imageExposure: number;
+        toneMapping: boolean;
+        toneMapType: number;
+        vignetteEnabled: boolean;
+        vignetteBlendMode: number;
+        vignetteCameraFov: number;
+        vignetteStretch: number;
+        vignetteCentreX: number;
+        vignetteCentreY: number;
+        vignetteWeight: number;
+        vignetteColor: TOOLKIT.IUnityColor;
+        useColorGrading: boolean;
+        setGradingTexture: any;
+        imagingColorCurves: PROJECT.IEditorColorCurves;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon Script Component
+     * @class DebugInformation
+     */
+    class DebugInformation extends TOOLKIT.ScriptComponent {
+        private keys;
+        private show;
+        private popup;
+        private views;
+        private xbox;
+        private color;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected destroy(): void;
+        protected openFullscreen(elem: any): void;
+        protected closeFullscreen(): void;
+        /**
+         * Ask the browser to promote the current element to fullscreen rendering mode
+         * @param element defines the DOM element to promote
+         */
+        static _RequestFullscreen(element: HTMLElement): void;
+        /**
+         * Asks the browser to exit fullscreen mode
+         */
+        static _ExitFullscreen(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class AssetExporter
+    */
+    class AssetExporter extends TOOLKIT.ScriptComponent {
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected fixed(): void;
+        protected update(): void;
+        protected late(): void;
+        protected after(): void;
+        protected ready(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class AssetPreloader
+    */
+    class AssetPreloader extends TOOLKIT.ScriptComponent implements TOOLKIT.IAssetPreloader {
+        private parentMeshes;
+        private importMeshes;
+        private assetContainers;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected destroy(): void;
+        /** Add asset preloader tasks (https://doc.babylonjs.com/divingDeeper/importers/assetManager) */
+        addPreloaderTasks(assetsManager: TOOLKIT.PreloadAssetsManager): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class NodeMaterialInstance
+    */
+    class NodeMaterialInstance extends TOOLKIT.ScriptComponent {
+        private nodeMaterialData;
+        private setCustomRootUrl;
+        getMaterialInstance(): BABYLON.NodeMaterial;
+        protected m_nodeMaterial: BABYLON.NodeMaterial;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class NodeMaterialParticle
+    */
+    class NodeMaterialParticle extends TOOLKIT.ScriptComponent {
+        private nodeMaterialEditor;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected setupNodeMaterial(materialInstance: BABYLON.NodeMaterial): void;
+        protected update(): void;
+        protected late(): void;
+        protected after(): void;
+        protected fixed(): void;
+        protected ready(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class NodeMaterialProcess
+    */
+    class NodeMaterialProcess extends TOOLKIT.ScriptComponent {
+        private nodeMaterialEditor;
+        private numberOfSamples;
+        private samplingMode;
+        private textureType;
+        private textureFormat;
+        private sizeRatio;
+        private resuable;
+        getPostProcess(): BABYLON.PostProcess;
+        protected m_postProcess: BABYLON.PostProcess;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+        protected setupNodeMaterial(materialInstance: BABYLON.NodeMaterial): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class NodeMaterialTexture
+    */
+    class NodeMaterialTexture extends TOOLKIT.ScriptComponent {
+        private nodeMaterialEditor;
+        private textureSize;
+        getProceduralTexture(): BABYLON.ProceduralTexture;
+        protected m_proceduralTexture: BABYLON.ProceduralTexture;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+        protected setupNodeMaterial(materialInstance: BABYLON.NodeMaterial): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class MobileInputController
+    */
+    class MobileInputController extends TOOLKIT.ScriptComponent {
+        static get Instance(): PROJECT.MobileInputController;
+        private static StaticInstance;
+        private styleSheet;
+        private controlType;
+        private parentElement;
+        private maxReadyTimeout;
+        private maxMoveDistance;
+        private maxMoveDeadzone;
+        private uiParentElement;
+        private leftBaseElement;
+        private rightBaseElement;
+        private buttonBaseElement;
+        private leftStickStyle;
+        private rightStickStyle;
+        private leftStickFactor;
+        private rightStickFactor;
+        private invertLeftStickY;
+        private centerLeftJoystick;
+        private enableLeftJoystick;
+        private invertRightStickY;
+        private centerRightJoystick;
+        private enableRightJoystick;
+        private enableMouseAxes;
+        private enableVirtualButtons;
+        private virtualButtonControls;
+        protected m_leftStick: TOOLKIT.TouchJoystickHandler;
+        protected m_rightStick: TOOLKIT.TouchJoystickHandler;
+        protected m_mobileDevice: boolean;
+        getLeftStick(): TOOLKIT.TouchJoystickHandler;
+        getRightStick(): TOOLKIT.TouchJoystickHandler;
+        getLeftStickEnabled(): boolean;
+        getRightStickEnabled(): boolean;
+        getLeftStickElement(): HTMLDivElement;
+        getRightStickElement(): HTMLDivElement;
+        showLeftStickElement(show: boolean): void;
+        showRightStickElement(show: boolean): void;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected ready(): void;
+        protected update(): void;
+        protected destroy(): void;
+        protected loadStyleSheet(): void;
+        protected loadHtmlMarkup(): void;
+        protected createHtmlElements(): void;
+    }
+    /**
+     * Manage the joystick inputs to control a free camera.
+     * @see https://doc.babylonjs.com/how_to/customizing_camera_inputs
+     */
+    class FreeCameraTouchJoystickInput implements BABYLON.ICameraInput<BABYLON.FreeCamera> {
+        /**
+         * Define the camera the input is attached to.
+         */
+        camera: BABYLON.FreeCamera;
+        /**
+         * Define the joystick controlling the input
+         */
+        controller: BABYLON.Nullable<PROJECT.MobileInputController>;
+        /**
+         * Defines the joystick rotation sensiblity.
+         * This is the threshold from when rotation starts to be accounted for to prevent jittering.
+         */
+        joystickAngularSensibility: number;
+        /**
+         * Defines the joystick move sensiblity.
+         * This is the threshold from when moving starts to be accounted for for to prevent jittering.
+         */
+        joystickMoveSensibility: number;
+        /**
+         * Defines the minimum value at which any analog stick input is ignored.
+         * Note: This value should only be a value between 0 and 1.
+         */
+        deadzoneDelta: number;
+        private _yAxisScale;
+        /**
+         * Gets or sets a boolean indicating that Yaxis (for right stick) should be inverted
+         */
+        get invertYAxis(): boolean;
+        set invertYAxis(value: boolean);
+        private LSValues;
+        private RSValues;
+        private _cameraTransform;
+        private _deltaTransform;
+        private _vector3;
+        private _vector2;
+        private _attached;
+        /**
+         * Attach the input controls to a specific dom element to get the input from.
+         */
+        attachControl(): void;
+        /**
+         * Detach the current controls from the specified dom element.
+         */
+        detachControl(): void;
+        /**
+         * Update the current camera state depending on the inputs that have been used this frame.
+         * This is a dynamically created lambda to avoid the performance penalty of looping for inputs in the render loop.
+         */
+        checkInputs(): void;
+        /**
+         * Gets the class name of the current input.
+         * @returns the class name
+         */
+        getClassName(): string;
+        /**
+         * Get the friendly name associated with the input class.
+         * @returns the input friendly name
+         */
+        getSimpleName(): string;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class MobileOccludeMaterial
+    */
+    class MobileOccludeMaterial extends TOOLKIT.ScriptComponent {
+        private applyToMaterial;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class MobileShadowMaterial
+    */
+    class MobileShadowMaterial extends TOOLKIT.ScriptComponent {
+        private createNewMaterial;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class BallSocketJoint
+    */
+    class BallSocketJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        pivotA: BABYLON.Vector3;
+        pivotB: BABYLON.Vector3;
+        axisA: BABYLON.Vector3;
+        axisB: BABYLON.Vector3;
+        constraint: BABYLON.BallAndSocketConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class DistanceJoint
+    */
+    class DistanceJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        maxDistance: number;
+        constraint: BABYLON.DistanceConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class FixedHingeJoint
+    */
+    class FixedHingeJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        pivotA: BABYLON.Vector3;
+        pivotB: BABYLON.Vector3;
+        constraint: BABYLON.HingeConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class LockedJoint
+    */
+    class LockedJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        pivotA: BABYLON.Vector3;
+        pivotB: BABYLON.Vector3;
+        axisA: BABYLON.Vector3;
+        axisB: BABYLON.Vector3;
+        constraint: BABYLON.LockConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class PrismaticJoint
+    */
+    class PrismaticJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        pivotA: BABYLON.Vector3;
+        pivotB: BABYLON.Vector3;
+        axisA: BABYLON.Vector3;
+        axisB: BABYLON.Vector3;
+        constraint: BABYLON.PrismaticConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class SixdofJoint
+    */
+    class SixdofJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        pivotA: BABYLON.Vector3;
+        pivotB: BABYLON.Vector3;
+        perpAxisA: BABYLON.Vector3;
+        perpAxisB: BABYLON.Vector3;
+        axisLimits: BABYLON.Physics6DoFLimit[];
+        constraint: BABYLON.Physics6DoFConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class SliderJoint
+    */
+    class SliderJoint extends TOOLKIT.ScriptComponent {
+        bodyA: BABYLON.TransformNode;
+        bodyB: BABYLON.TransformNode;
+        pivotA: BABYLON.Vector3;
+        pivotB: BABYLON.Vector3;
+        axisA: BABYLON.Vector3;
+        axisB: BABYLON.Vector3;
+        constraint: BABYLON.SliderConstraint;
+        collisionsEnabled: boolean;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class RemotePlayerController
+    */
+    class RemotePlayerController extends TOOLKIT.ScriptComponent {
+        updateStateParams: boolean;
+        smoothMotionTime: number;
+        smoothInputVectors: boolean;
+        private animationState;
+        private animationStateParams;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected update(): void;
+        protected destroy(): void;
+        private attachAnimationController;
+        private validateAnimationStateParams;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon toolkit standard player controller class
+     * @class StandardPlayerController - All rights reserved (c) 2020 Mackey Kinard
+    */
+    class StandardPlayerController extends TOOLKIT.ScriptComponent {
+        static MIN_VERTICAL_VELOCITY: number;
+        static MIN_GROUND_DISTANCE: number;
+        static MIN_MOVE_EPSILON: number;
+        static MIN_TIMER_OFFSET: number;
+        static MIN_SLOPE_LIMIT: number;
+        static PLAYER_HEIGHT: string;
+        enableInput: boolean;
+        attachCamera: boolean;
+        rotateCamera: boolean;
+        mouseWheel: boolean;
+        toggleView: boolean;
+        freeLooking: boolean;
+        requireSprintButton: boolean;
+        gravitationalForce: number;
+        minFallVelocity: number;
+        verticalStepSpeed: number;
+        minStepUpHeight: number;
+        rigidBodyMass: number;
+        airbornTimeout: number;
+        maxAngle: number;
+        speedFactor: number;
+        rootMotion: boolean;
+        moveSpeed: number;
+        walkSpeed: number;
+        lookSpeed: number;
+        jumpSpeed: number;
+        jumpDelay: number;
+        eyesHeight: number;
+        pivotHeight: number;
+        maxDistance: number;
+        scrollSpeed: number;
+        topLookLimit: number;
+        downLookLimit: number;
+        lowTurnSpeed: number;
+        highTurnSpeed: number;
+        smoothDampTime: number;
+        smoothInputVectors: boolean;
+        smoothAcceleration: boolean;
+        accelerationSpeed: number;
+        decelerationSpeed: number;
+        avatarSkinTag: string;
+        climbVolumeTag: string;
+        vaultVolumeTag: string;
+        maxHeightRanges: any;
+        useClimbSystem: boolean;
+        distanceFactor: number;
+        cameraSmoothing: number;
+        cameraCollisions: boolean;
+        inputMagnitude: number;
+        landingEpsilon: number;
+        minimumDistance: number;
+        movementAllowed: boolean;
+        playerInputX: number;
+        playerInputZ: number;
+        playerMouseX: number;
+        playerMouseY: number;
+        runKeyRequired: boolean;
+        buttonRun: number;
+        keyboardRun: number;
+        buttonJump: number;
+        keyboardJump: number;
+        buttonCamera: number;
+        keyboardCamera: number;
+        postNetworkAttributes: boolean;
+        playerNumber: TOOLKIT.PlayerNumber;
+        boomPosition: BABYLON.Vector3;
+        airbornVelocity: BABYLON.Vector3;
+        movementVelocity: BABYLON.Vector3;
+        targetCameraOffset: BABYLON.Vector3;
+        isAnimationEnabled(): boolean;
+        isRunButtonPressed(): boolean;
+        isJumpButtonPressed(): boolean;
+        getPlayerJumped(): boolean;
+        getPlayerJumping(): boolean;
+        getPlayerFalling(): boolean;
+        getPlayerSliding(): boolean;
+        getPlayerGrounded(): boolean;
+        getFallTriggered(): boolean;
+        getMovementSpeed(): number;
+        getCameraBoomNode(): BABYLON.TransformNode;
+        getCameraTransform(): BABYLON.TransformNode;
+        getAnimationState(): TOOLKIT.AnimationState;
+        getVerticalVelocity(): number;
+        getCharacterController(): TOOLKIT.CharacterController;
+        getPlayerLookRotation(): BABYLON.Vector3;
+        getPlayerMoveDirection(): PROJECT.PlayerMoveDirection;
+        getInputMovementVector(): BABYLON.Vector3;
+        getInputMagnitudeValue(): number;
+        getCameraPivotPosition(): BABYLON.Vector3;
+        getCameraPivotRotation(): BABYLON.Quaternion;
+        rayClimbOffset: number;
+        rayClimbLength: number;
+        getClimbContact(): boolean;
+        getClimbContactNode(): BABYLON.TransformNode;
+        getClimbContactPoint(): BABYLON.Vector3;
+        getClimbContactAngle(): number;
+        getClimbContactNormal(): BABYLON.Vector3;
+        getClimbContactDistance(): number;
+        canClimbObstaclePredicate: (action: number) => boolean;
+        rayHeightOffset: number;
+        rayHeightLength: number;
+        getHeightContact(): boolean;
+        getHeightContactNode(): BABYLON.TransformNode;
+        getHeightContactPoint(): BABYLON.Vector3;
+        getHeightContactAngle(): number;
+        getHeightContactNormal(): BABYLON.Vector3;
+        getHeightContactDistance(): number;
+        private abstractMesh;
+        private cameraDistance;
+        private forwardCamera;
+        private avatarRadius;
+        private groundingObject;
+        private groundingCallback;
+        private dollyDirection;
+        private cameraEulers;
+        private rotationEulers;
+        private cameraPivotOffset;
+        private cameraForwardVector;
+        private cameraRightVector;
+        private desiredForwardVector;
+        private desiredRightVector;
+        private lastRotationQuaternion;
+        private scaledCamDirection;
+        private scaledMaxDirection;
+        private parentNodePosition;
+        private maximumCameraPos;
+        private tempWorldPosition;
+        private cameraRaycastShape;
+        private defaultRaycastGroup;
+        private defaultRaycastMask;
+        private cameraRaycastMask;
+        private avatarSkins;
+        private cameraNode;
+        private cameraPivot;
+        private navigationAgent;
+        private characterController;
+        private verticalVelocity;
+        private smoothMotionSpeed;
+        private movementSpeed;
+        private isRunPressed;
+        private isJumpPressed;
+        private isCharacterSliding;
+        private isCharacterFalling;
+        private isCharacterGrounded;
+        private isCharacterFallTriggered;
+        private isCharacterJumpFrame;
+        private isCharacterJumping;
+        private isCharacterLanding;
+        private isCharacterRising;
+        private isCharacterNavigating;
+        private navigationAngularSpeed;
+        private updateStateParams;
+        private animationStateParams;
+        private sphereCollisionShape;
+        private hasGroundedContact;
+        private showDebugColliders;
+        private colliderVisibility;
+        private colliderRenderGroup;
+        private groundCheckDistance;
+        private deltaTime;
+        private minJumpTimer;
+        private delayJumpTimer;
+        private playerControl;
+        private canPlayerJump;
+        private animationState;
+        private lastJumpVelocity;
+        private inputMovementVector;
+        private playerLookRotation;
+        private playerRotationVector;
+        private playerMovementVelocity;
+        private playerRotationQuaternion;
+        private playerMoveDirection;
+        private forwardDirection;
+        private downDirection;
+        private climbContact;
+        private climbContactNode;
+        private climbContactAngle;
+        private climbContactPoint;
+        private climbContactNormal;
+        private climbContactDistance;
+        private climbSensorLine;
+        private offsetClimbRaycastPosition;
+        private startClimbRaycastPosition;
+        private endClimbRaycastPosition;
+        private heightContact;
+        private heightContactNode;
+        private heightContactAngle;
+        private heightContactPoint;
+        private heightContactNormal;
+        private heightContactDistance;
+        private heightSensorLine;
+        private offsetHeightRaycastPosition;
+        private startHeightRaycastPosition;
+        private endHeightRaycastPosition;
+        protected m_velocityOffset: BABYLON.Vector3;
+        protected m_actualVelocity: BABYLON.Vector3;
+        protected m_linearVelocity: BABYLON.Vector3;
+        protected m_lastPosition: BABYLON.Vector3;
+        protected m_positionCenter: BABYLON.Vector3;
+        protected m_scaledVelocity: number;
+        protected playerDrawVelocity: number;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected after(): void;
+        protected update(): void;
+        protected destroy(): void;
+        /** Register handler that is triggered before the controller has been updated */
+        onPreUpdateObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered before the controller movement has been applied */
+        onBeforeMoveObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after the controller has been updated */
+        onPostUpdateObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after player input has been updated */
+        onPlayerInputObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered when player position should be updated */
+        onPlayerPositionObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after performing action has been updated */
+        onUpdateActionObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        private _deltaMotionPosition;
+        getDeltaMotionPosition(): BABYLON.Vector3;
+        private _deltaMotionRotation;
+        getDeltaMotionRotation(): BABYLON.Quaternion;
+        private isPerformingAction;
+        private isRootMotionAction;
+        private isActionInterruptable;
+        private afterActionHandler;
+        private performActionTimer;
+        private performActionNumber;
+        private playerRotationSpeed;
+        private rotatePlayerTowards;
+        private matchStartTime;
+        private matchTargetTime;
+        private matchTargetOffset;
+        private matchTargetHeight;
+        private lockTargetHeight;
+        private lastStartHeight;
+        private lastTargetHeight;
+        private lastTargetNormal;
+        private lastTargetRotation;
+        private lastDeltaPosition;
+        private lastDeltaRotation;
+        getIsPerformingAction(): boolean;
+        getIsRootMotionAction(): boolean;
+        getIsActionInterruptable(): boolean;
+        playActionAnimation(action: number, interruptableAction?: boolean, enableRootMotion?: boolean, afterActionComplete?: () => void): void;
+        resetActionAnimationState(): void;
+        private updateAnimationActionState;
+        /** Set the player world position */
+        setWorldPosition(x: number, y: number, z: number): void;
+        /** TODO */
+        setPlayerControl(mode: PROJECT.PlayerInputControl): void;
+        /** TODO */
+        togglePlayerControl(): void;
+        private showAvatarSkins;
+        /** TODO */
+        attachPlayerCamera(player: TOOLKIT.PlayerNumber): void;
+        private ikLeftFootTarget;
+        private ikLeftPoleTarget;
+        private ikRightFootTarget;
+        private ikRightPoleTarget;
+        private abstractSkinMesh;
+        private rootBoneTransform;
+        private leftFootTransform;
+        private leftFootPoleOffset;
+        private leftFootMaxAngle;
+        private rightFootTransform;
+        private rightFootPoleOffset;
+        private rightFootMaxAngle;
+        private ikLeftController;
+        private ikRightController;
+        onAnimatorIK: () => void;
+        getPlayerMesh(): BABYLON.AbstractMesh;
+        getRootHipBone(): BABYLON.Bone;
+        getLeftFootBone(): BABYLON.Bone;
+        getRightFootBone(): BABYLON.Bone;
+        getLeftFootTarget(): BABYLON.Mesh;
+        getRightFootTarget(): BABYLON.Mesh;
+        getLeftFootPoleTarget(): BABYLON.Mesh;
+        getRightFootPoleTarget(): BABYLON.Mesh;
+        getRootBoneTransform(): BABYLON.TransformNode;
+        getLeftFootTransform(): BABYLON.TransformNode;
+        getRightFootTransform(): BABYLON.TransformNode;
+        getLeftFootController(): BABYLON.BoneIKController;
+        getRightFootController(): BABYLON.BoneIKController;
+        isGroundedFootIKActive(): boolean;
+        setupBoneControllers(): void;
+        private attachAnimationController;
+        private updateAnimatorTargetMeshes;
+        /** TODO */
+        enableCharacterController(state: boolean): void;
+        /** TODO */
+        resetPlayerRotation(): void;
+        /** TODO */
+        resetPlayerJumpingState(): void;
+        private awakePlayerController;
+        private startPlayerController;
+        private updatePlayerPosition;
+        private updatePlayerController;
+        private afterPlayerController;
+        private updateCharacterController;
+        private updateCameraController;
+        getBoomArmMaxDistance(): number;
+        setBoomArmMaxDistance(distance: number): void;
+        setSmoothBoomArmLength(length: number, speed: number, updateMaxDistance?: boolean): void;
+        private smoothBoomArmLength;
+        private smoothBoomArmSpeed;
+        private updateSmoothBoomArmLength;
+        private castPhysicsClimbingVolumeRay;
+        private castPhysicsHeightCheckVolumeRay;
+        private getCheckedVerticalVelocity;
+        private destroyPlayerController;
+        private validateAnimationStateParams;
+    }
+    /**
+    * Babylon Interface Definition
+    * @interface AnimationStateParams
+    */
+    interface AnimationStateParams {
+        moveDirection: string;
+        inputMagnitude: string;
+        horizontalInput: string;
+        verticalInput: string;
+        mouseXInput: string;
+        mouseYInput: string;
+        heightInput: string;
+        speedInput: string;
+        jumpFrame: string;
+        jumpState: string;
+        actionState: string;
+        fallingState: string;
+        slidingState: string;
+        groundedState: string;
+    }
+    /**
+    * Babylon Enum Definition
+    * @interface PlayerInputControl
+    */
+    enum PlayerInputControl {
+        FirstPersonStrafing = 0,
+        ThirdPersonStrafing = 1
+    }
+    /**
+    * Babylon Enum Definition
+    * @interface PlayerMoveDirection
+    */
+    enum PlayerMoveDirection {
+        Stationary = 0,
+        Forward = 1,
+        ForwardLeft = 2,
+        ForwardRight = 3,
+        Backward = 4,
+        BackwardLeft = 5,
+        BackwardRight = 6,
+        StrafingLeft = 7,
+        StrafingRight = 8
+    }
+    /**
+    * Babylon Enum Definition
+    * @interface ActionAnimationType
+    */
+    enum ActionAnimationType {
+        Neutral = 0,
+        StepUp = 1,
+        JumpUp = 2,
+        ClimbUp = 3,
+        VaultOver = 4
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon toolkit third person player controller class
+     * @class ThirdPersonPlayerController - All rights reserved (c) 2020 Mackey Kinard
+    */
+    class ThirdPersonPlayerController extends TOOLKIT.ScriptComponent {
+        static MIN_VERTICAL_VELOCITY: number;
+        static MIN_GROUND_DISTANCE: number;
+        static MIN_MOVE_EPSILON: number;
+        static MIN_TIMER_OFFSET: number;
+        static MIN_SLOPE_LIMIT: number;
+        static PLAYER_HEIGHT: string;
+        enableInput: boolean;
+        attachCamera: boolean;
+        mouseWheel: boolean;
+        requireSprintButton: boolean;
+        gravitationalForce: number;
+        minFallVelocity: number;
+        verticalStepSpeed: number;
+        minStepUpHeight: number;
+        rigidBodyMass: number;
+        airbornTimeout: number;
+        maxAngle: number;
+        speedFactor: number;
+        rootMotion: boolean;
+        moveSpeed: number;
+        walkSpeed: number;
+        jumpSpeed: number;
+        jumpDelay: number;
+        lowTurnSpeed: number;
+        highTurnSpeed: number;
+        smoothDampTime: number;
+        smoothInputVectors: boolean;
+        smoothAcceleration: boolean;
+        accelerationSpeed: number;
+        decelerationSpeed: number;
+        climbVolumeTag: string;
+        vaultVolumeTag: string;
+        maxHeightRanges: any;
+        useClimbSystem: boolean;
+        distanceFactor: number;
+        inputMagnitude: number;
+        landingEpsilon: number;
+        minimumDistance: number;
+        movementAllowed: boolean;
+        playerInputX: number;
+        playerInputZ: number;
+        playerMouseX: number;
+        playerMouseY: number;
+        runKeyRequired: boolean;
+        buttonRun: number;
+        keyboardRun: number;
+        buttonJump: number;
+        keyboardJump: number;
+        buttonCamera: number;
+        keyboardCamera: number;
+        postNetworkAttributes: boolean;
+        playerNumber: TOOLKIT.PlayerNumber;
+        airbornVelocity: BABYLON.Vector3;
+        movementVelocity: BABYLON.Vector3;
+        isAnimationEnabled(): boolean;
+        isRunButtonPressed(): boolean;
+        isJumpButtonPressed(): boolean;
+        getPlayerJumped(): boolean;
+        getPlayerJumping(): boolean;
+        getPlayerFalling(): boolean;
+        getPlayerSliding(): boolean;
+        getPlayerGrounded(): boolean;
+        getFallTriggered(): boolean;
+        getMovementSpeed(): number;
+        getAnimationState(): TOOLKIT.AnimationState;
+        getVerticalVelocity(): number;
+        getCharacterController(): TOOLKIT.CharacterController;
+        getPlayerLookRotation(): BABYLON.Vector3;
+        getPlayerMoveDirection(): PROJECT.PlayerMoveDirection;
+        getInputMovementVector(): BABYLON.Vector3;
+        getInputMagnitudeValue(): number;
+        rayClimbOffset: number;
+        rayClimbLength: number;
+        getClimbContact(): boolean;
+        getClimbContactNode(): BABYLON.TransformNode;
+        getClimbContactPoint(): BABYLON.Vector3;
+        getClimbContactAngle(): number;
+        getClimbContactNormal(): BABYLON.Vector3;
+        getClimbContactDistance(): number;
+        canClimbObstaclePredicate: (action: number) => boolean;
+        rayHeightOffset: number;
+        rayHeightLength: number;
+        getHeightContact(): boolean;
+        getHeightContactNode(): BABYLON.TransformNode;
+        getHeightContactPoint(): BABYLON.Vector3;
+        getHeightContactAngle(): number;
+        getHeightContactNormal(): BABYLON.Vector3;
+        getHeightContactDistance(): number;
+        private freeCamera;
+        private cameraForwardVector;
+        private cameraRightVector;
+        private desiredForwardVector;
+        private desiredRightVector;
+        private lastRotationQuaternion;
+        private avatarSkins;
+        private avatarRadius;
+        private navigationAgent;
+        private characterController;
+        private verticalVelocity;
+        private smoothMotionSpeed;
+        private movementSpeed;
+        private isRunPressed;
+        private isJumpPressed;
+        private isCharacterSliding;
+        private isCharacterFalling;
+        private isCharacterGrounded;
+        private isCharacterFallTriggered;
+        private isCharacterJumpFrame;
+        private isCharacterJumping;
+        private isCharacterRising;
+        private isCharacterLanding;
+        private isCharacterNavigating;
+        private navigationAngularSpeed;
+        private updateStateParams;
+        private animationStateParams;
+        private sphereCollisionShape;
+        private hasGroundedContact;
+        private showDebugColliders;
+        private colliderVisibility;
+        private colliderRenderGroup;
+        private groundCheckDistance;
+        private deltaTime;
+        private delayJumpTimer;
+        private canPlayerJump;
+        private animationState;
+        private lastJumpVelocity;
+        private inputMovementVector;
+        private playerLookRotation;
+        private playerMovementVelocity;
+        private playerRotationQuaternion;
+        private playerMoveDirection;
+        private forwardDirection;
+        private downDirection;
+        private climbContact;
+        private climbContactNode;
+        private climbContactAngle;
+        private climbContactPoint;
+        private climbContactNormal;
+        private climbContactDistance;
+        private climbSensorLine;
+        private offsetClimbRaycastPosition;
+        private startClimbRaycastPosition;
+        private endClimbRaycastPosition;
+        private heightContact;
+        private heightContactNode;
+        private heightContactAngle;
+        private heightContactPoint;
+        private heightContactNormal;
+        private heightContactDistance;
+        private heightSensorLine;
+        private offsetHeightRaycastPosition;
+        private startHeightRaycastPosition;
+        private endHeightRaycastPosition;
+        protected m_velocityOffset: BABYLON.Vector3;
+        protected m_actualVelocity: BABYLON.Vector3;
+        protected m_linearVelocity: BABYLON.Vector3;
+        protected m_lastPosition: BABYLON.Vector3;
+        protected m_positionCenter: BABYLON.Vector3;
+        protected m_scaledVelocity: number;
+        protected playerDrawVelocity: number;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected after(): void;
+        protected update(): void;
+        protected destroy(): void;
+        /** Character controller position
+         * @deprecated Moved to default camera controller
+         * @see PROJECT.DefaultCameraSystem
+         */
+        boomPosition: BABYLON.Vector3;
+        /** Register handler that is triggered before the controller has been updated */
+        onPreUpdateObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered before the controller movement has been applied */
+        onBeforeMoveObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after the controller has been updated */
+        onPostUpdateObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after player input has been updated */
+        onPlayerInputObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered when player position should be updated */
+        onPlayerPositionObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after performing action has been updated */
+        onUpdateActionObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        /** Register handler that is triggered after animation state has been updated */
+        onAnimationStateObservable: BABYLON.Observable<BABYLON.TransformNode>;
+        private _deltaMotionPosition;
+        getDeltaMotionPosition(): BABYLON.Vector3;
+        private _deltaMotionRotation;
+        getDeltaMotionRotation(): BABYLON.Quaternion;
+        private isPerformingAction;
+        private isRootMotionAction;
+        private isActionInterruptable;
+        private afterActionHandler;
+        private performActionTimer;
+        private performActionNumber;
+        private playerRotationSpeed;
+        private rotatePlayerTowards;
+        private matchStartTime;
+        private matchTargetTime;
+        private matchTargetOffset;
+        private matchTargetHeight;
+        private lockTargetHeight;
+        private lastStartHeight;
+        private lastTargetHeight;
+        private lastTargetNormal;
+        private lastTargetRotation;
+        private lastDeltaPosition;
+        private lastDeltaRotation;
+        getIsPerformingAction(): boolean;
+        getIsRootMotionAction(): boolean;
+        getIsActionInterruptable(): boolean;
+        playActionAnimation(action: number, interruptableAction?: boolean, enableRootMotion?: boolean, afterActionComplete?: () => void): void;
+        resetActionAnimationState(): void;
+        private updateAnimationActionState;
+        /** Set the player world position */
+        setWorldPosition(x: number, y: number, z: number): void;
+        private ikLeftFootTarget;
+        private ikLeftPoleTarget;
+        private ikRightFootTarget;
+        private ikRightPoleTarget;
+        private abstractSkinMesh;
+        private rootBoneTransform;
+        private leftFootTransform;
+        private leftFootPoleOffset;
+        private leftFootMaxAngle;
+        private rightFootTransform;
+        private rightFootPoleOffset;
+        private rightFootMaxAngle;
+        private ikLeftController;
+        private ikRightController;
+        onAnimatorIK: () => void;
+        getPlayerMesh(): BABYLON.AbstractMesh;
+        getRootHipBone(): BABYLON.Bone;
+        getLeftFootBone(): BABYLON.Bone;
+        getRightFootBone(): BABYLON.Bone;
+        getLeftFootTarget(): BABYLON.Mesh;
+        getRightFootTarget(): BABYLON.Mesh;
+        getLeftFootPoleTarget(): BABYLON.Mesh;
+        getRightFootPoleTarget(): BABYLON.Mesh;
+        getRootBoneTransform(): BABYLON.TransformNode;
+        getLeftFootTransform(): BABYLON.TransformNode;
+        getRightFootTransform(): BABYLON.TransformNode;
+        getLeftFootController(): BABYLON.BoneIKController;
+        getRightFootController(): BABYLON.BoneIKController;
+        isGroundedFootIKActive(): boolean;
+        setupBoneControllers(): void;
+        private attachAnimationController;
+        private updateAnimatorTargetMeshes;
+        /** TODO */
+        enableCharacterController(state: boolean): void;
+        /** TODO */
+        resetPlayerJumpingState(): void;
+        private awakePlayerController;
+        private startPlayerController;
+        private updatePlayerPosition;
+        private updatePlayerController;
+        private afterPlayerController;
+        private updateCharacterController;
+        private castPhysicsClimbingVolumeRay;
+        private castPhysicsHeightCheckVolumeRay;
+        private getCheckedVerticalVelocity;
+        private destroyPlayerController;
+        private validateAnimationStateParams;
+    }
+    /**
+    * Babylon Enum Definition
+    * @interface ThirdPersonControl
+    */
+    enum ThirdPersonControl {
+        ThirdPersonTurning = 0,
+        ThirdPersonForward = 1
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class FxParticleSystem
+    */
+    class FxParticleSystem extends TOOLKIT.ScriptComponent {
+        getParticleEmitter(): BABYLON.AbstractMesh;
+        getParticleSystem(): BABYLON.ParticleSystem | BABYLON.GPUParticleSystem;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected m_particleEmitter: BABYLON.AbstractMesh;
+        protected m_particleSystem: BABYLON.ParticleSystem | BABYLON.GPUParticleSystem;
+        protected awake(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon water material system pro class (Babylon Water Material)
+     * @class SkyMaterialSystem - All rights reserved (c) 2020 Mackey Kinard
+     */
+    class SkyMaterialSystem extends TOOLKIT.ScriptComponent {
+        private skyfog;
+        private skysize;
+        private probesize;
+        private reflections;
+        private reflectlevel;
+        private skytintcolor;
+        getSkyboxMesh(): BABYLON.AbstractMesh;
+        getSkyMaterial(): BABYLON.SkyMaterial;
+        getReflectionProbe(): BABYLON.ReflectionProbe;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected late(): void;
+        protected after(): void;
+        protected destroy(): void;
+        protected m_skyboxMesh: BABYLON.Mesh;
+        protected m_skyMaterial: BABYLON.SkyMaterial;
+        protected m_reflectProbe: BABYLON.ReflectionProbe;
+        protected awakeSkyboxMaterial(): void;
+        protected destroySkyboxMaterial(): void;
+        /** Set Skybox Mesh tint color. (Box Mesh Vertex Colors) */
+        setSkyboxTintColor(color: BABYLON.Color3): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+     * Babylon water system (Colyseus Universal Game Room)
+     * @class WaterMaterialSystem - All rights reserved (c) 2020 Mackey Kinard
+     */
+    class WaterMaterialSystem extends TOOLKIT.ScriptComponent {
+        private waterTag;
+        private targetSize;
+        private renderSize;
+        private depthFactor;
+        private reflectSkybox;
+        private subDivisions;
+        private heightOffset;
+        private windDirection;
+        private windForce;
+        private waveSpeed;
+        private waveLength;
+        private waveHeight;
+        private bumpHeight;
+        private bumpSuperimpose;
+        private bumpAffectsReflection;
+        private waterColor;
+        private colorBlendFactor;
+        private waterColor2;
+        private colorBlendFactor2;
+        private disableClipPlane;
+        private fresnelSeparate;
+        getWaterGeometry(): BABYLON.AbstractMesh;
+        getWaterMaterial(): BABYLON.WaterMaterial;
+        protected m_waterGeometry: BABYLON.AbstractMesh;
+        protected m_waterMaterial: BABYLON.WaterMaterial;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected late(): void;
+        protected after(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class SnapshotManager
+    */
+    class SnapshotManager extends TOOLKIT.ScriptComponent {
+        /** Is Snapshot Rendering Currently Enabled */
+        static IsSnapshotRenderingEnabled(): boolean;
+        /**
+         * Enable snapshot rendering
+         * Use this method instead of engine.snapshotRendering=true, to make sure everything is ready before enabling snapshot rendering.
+         * Note that this method is ref-counted and works in pair with disableSnapshotRendering(): you should call enableSnapshotRendering() as many times as you call disableSnapshotRendering().
+         */
+        static EnableSnapshotRendering(): void;
+        /**
+         * Disable snapshot rendering
+         * Note that this method is ref-counted and works in pair with disableSnapshotRendering(): you should call enableSnapshotRendering() as many times as you call disableSnapshotRendering().
+         */
+        static DisableSnapshotRendering(): void;
+        /**
+         * Reset the snapshot helper and the list of meshes to render snapshots for.
+         * @param scene The scene to reset the snapshot helper for.
+         */
+        static ResetSnapshotHelper(scene: BABYLON.Scene): void;
+        /**
+         * Get the snapshot helper.
+         * @returns The snapshot helper.
+         */
+        static GetSnapshotHelper(): BABYLON.SnapshotRenderingHelper;
+        private static _HelperEnabled;
+        private static _SnapshotHelper;
+        private autoStart;
+        private autoUpdate;
+        private delayTimeout;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+        protected ready(): void;
+        protected update(): void;
+        protected destroy(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class SnapshotRenderer
+    */
+    class SnapshotRenderer extends TOOLKIT.ScriptComponent {
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class DefaultMuteButton
+    */
+    class DefaultMuteButton extends TOOLKIT.ScriptComponent {
+        private static audioSystemInitialized;
+        static IsAudioSystemInitialized(): boolean;
+        private buttonIdentifier;
+        private buttonClassname;
+        private buttonContainer;
+        private buttonElement;
+        private muteIconElement;
+        private mutedIconElement;
+        private muteButtonState;
+        private mutedIconUrl;
+        private muteIconUrl;
+        private toggleEffects;
+        private autoPlayList;
+        private audioSources;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected ready(): void;
+        protected createMuteButton(): void;
+        protected handleButtonClick(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class SceneSoundSystem
+    */
+    class SceneSoundSystem extends TOOLKIT.ScriptComponent {
+        private static _MUSIC;
+        static get MUSIC(): PROJECT.SoundManager;
+        private static _SFX;
+        static get SFX(): PROJECT.SoundManager;
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected start(): void;
+    }
+}
+declare namespace PROJECT {
+    /**
+    * Babylon Script Component
+    * @class SoundManager
+    */
+    class SoundManager extends TOOLKIT.ScriptComponent {
+        private groupName;
+        private cachedVolume;
+        private volumeProperty;
+        getGroupName(): string;
+        protected m_soundMap: Map<string, TOOLKIT.AudioSource>;
+        protected m_soundList: TOOLKIT.AudioSource[];
+        constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+        protected awake(): void;
+        protected start(): void;
+        protected update(): void;
+        protected destroy(): void;
+        /**
+         * Is the sound track currently playing
+         * @param name The name of the sound track to check is playing
+         */
+        isPlaying(name: string): boolean;
+        /**
+         * Is the sound track currently paused
+         * @param name The name of the sound track to check is paused
+         */
+        isPaused(name: string): boolean;
+        /**
+         * Play the sound track by name
+         * @param name The name of the sound track to play
+         * @param time (optional) Start the sound after X seconds. Start immediately (0) by default.
+         * @param offset (optional) Start the sound at a specific time in seconds
+         * @param length (optional) Sound duration (in seconds)
+         */
+        playTrack(name: string, time?: number, offset?: number, length?: number): Promise<boolean>;
+        /**
+         * Pause the sound track by name
+         * @param name The name of the sound track to play
+         */
+        pauseTrack(name: string): boolean;
+        /**
+         * Pause the sound for all tracks in the group
+         */
+        pauseAllTracks(): void;
+        /**
+         * Stop the sound track by name
+         * @param name The name of the sound track to play
+         * @param time (optional) Start the sound after X seconds. Start immediately (0) by default.
+         */
+        stopTrack(name: string, time?: number): boolean;
+        /**
+         * Stop the sound for all tracks in the group
+         * @param time (optional) Stop the sound after X seconds. Stop immediately (0) by default.
+         */
+        stopAllTracks(time?: number): void;
+        /**
+         * Mute the sound track by name
+         * @param name The name of the sound track to play
+         * @param time (optional) Start the sound after X seconds. Start immediately (0) by default.
+         */
+        muteTrack(name: string, time?: number): boolean;
+        /**
+         * Unmute the sound track by name
+         * @param name The name of the sound track to play
+         * @param time (optional) Start the sound after X seconds. Start immediately (0) by default.
+         */
+        unmuteTrack(name: string, time?: number): boolean;
+        /**
+         * Mutes the volume for all sound tracks in the group
+         * @param time Define time for gradual change to new volume
+         */
+        muteAllTracks(time?: number): void;
+        /**
+         * Unmutes the volume for all sound tracks in the group
+         * @param time Define time for gradual change to new volume
+         */
+        unmuteAllTracks(time?: number): void;
+        /**
+         * Sets the volume for all sound tracks in the group
+         * @param volume Define the new volume of the sound
+         * @param time Define time for gradual change to new volume
+         */
+        setGroupVolume(volume: number, time?: number): void;
+        /**
+         * Get a sound source by name
+         * @param name The name of the sound track to play
+         */
+        getAudioSource(name: string): TOOLKIT.AudioSource;
+    }
+}
+declare namespace TOOLKIT {
+    /**
+     * Babylon windows platform pro class
+     * @class WindowsPlatform - All rights reserved (c) 2020 Mackey Kinard
+     */
+    class WindowsPlatform {
+        /** Is xbox live user signed in if platform services enabled. (WinRT) */
+        static IsXboxLiveUserSignedIn(systemUser?: Windows.System.User, player?: TOOLKIT.PlayerNumber): boolean;
+        /** Validated sign in xbox live user if platform services available. (WinRT) */
+        static XboxLiveUserSignIn(player?: TOOLKIT.PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.System.SignInResult) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): void;
+        /** Silent sign in xbox live user if platform services available. (WinRT) */
+        static XboxLiveUserSilentSignIn(player?: TOOLKIT.PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.System.SignInResult) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): Windows.Foundation.Projections.Promise<void>;
+        /** Dialog sign in xbox live user if platform services available. (WinRT) */
+        static XboxLiveUserDialogSignIn(player?: TOOLKIT.PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.System.SignInResult) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): Windows.Foundation.Projections.Promise<void>;
+        /** Loads a xbox live user profile if platform services available. (WinRT) */
+        static LoadXboxLiveUserProfile(player?: TOOLKIT.PlayerNumber, oncomplete?: (result: Microsoft.Xbox.Services.Social.XboxUserProfile) => void, onerror?: (error: any) => void, onprogress?: (progress: any) => void): Windows.Foundation.Projections.Promise<void>;
+        /** Get xbox live user if platform services available. (WinRT) */
+        static GetXboxLiveUser(player?: TOOLKIT.PlayerNumber): Microsoft.Xbox.Services.System.XboxLiveUser;
+        /** Get xbox live user if platform services available. (WinRT) */
+        static GetXboxLiveSystemUser(systemUser: Windows.System.User, player?: TOOLKIT.PlayerNumber): Microsoft.Xbox.Services.System.XboxLiveUser;
+        /** Get xbox live user context if platform services available. (WinRT) */
+        static GetXboxLiveUserContext(player?: TOOLKIT.PlayerNumber): Microsoft.Xbox.Services.XboxLiveContext;
+        /** Resets xbox live user context if platform services available. (WinRT) */
+        static ResetXboxLiveUserContext(player?: TOOLKIT.PlayerNumber): void;
+        /** Get xbox live context property if platform services available. (WinRT) */
+        static GetXboxLiveContextProperty(name: any): any;
+        /** Get xbox live context property if platform services available. (WinRT) */
+        static SetXboxLiveContextProperty(name: any, property: any): void;
+        /** Resets xbox live property context bag if platform services available. (WinRT) */
+        static ResetXboxLivePropertyContexts(): void;
+        /** Sets the Xbox User Sign Out Complete Handler (WinRT) */
+        static SetXboxLiveSignOutHandler(handler?: (result: Microsoft.Xbox.Services.System.SignOutCompletedEventArgs) => void): void;
+    }
+}
 /** Babylon Toolkit Namespace */
 declare namespace TOOLKIT {
     interface KeymapState {
@@ -7653,6 +10422,7 @@ declare namespace TOOLKIT {
         addPreloaderTasks(assetsManager: TOOLKIT.PreloadAssetsManager): void;
     }
 }
+export as namespace PROJECT;
 declare var SM: typeof TOOLKIT.SceneManager;
 declare var WM: typeof TOOLKIT.WindowManager;
 declare var UI: typeof TOOLKIT.UserInterface;