@babylonjs-toolkit/next 9.10.1

package/lib/project.d.ts

@@ -0,0 +1,2283 @@
+import type * as BABYLON from "@babylonjs/core/Legacy/legacy";
+declare const BABYLON: any;
+import { ScriptComponent, IUnityVector3, IUnityVector4, IUnityColor, AnimationState, AudioSource, RigidbodyPhysics, RaycastVehicle, btWheelInfo, PlayerNumber, CustomShaderMaterial, CustomShaderMaterialPlugin, PreloadAssetsManager, IAssetPreloader, CharacterController } from './scenemanager';
+import { LocalMessageBus } from './localmessagebus';
+import { NoiseFunction2D } from './noisefunction2d';
+import { TouchJoystickHandler } from './touchjoystickhandler';
+export declare class CheckpointManager extends 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;
+}
+export interface ITrackNode {
+    radius: number;
+    position: IUnityVector3;
+    rotation: IUnityVector4;
+    localPosition: BABYLON.Vector3;
+    localRotation: BABYLON.Quaternion;
+    localDistance: number;
+}
+export interface IControlPoint {
+    speed: number;
+    tvalue: number;
+    position: IUnityVector3;
+}
+export declare class RoutePoint {
+    position: BABYLON.Vector3;
+    direction: BABYLON.Vector3;
+}
+export declare class PlayerRaceStats {
+    id: number;
+    name: string;
+    position: number;
+}
+export declare class RaceTrackManager extends 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(): LocalMessageBus;
+    drawDebugLines: boolean;
+    getTrackNodes(): ITrackNode[];
+    getControlPoints(line: number): 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): RoutePoint;
+    getRoutePointToRef(distance: number, result: RoutePoint): void;
+    getRoutePosition(distance: number): BABYLON.Vector3;
+    getRoutePositionToRef(distance: number, result: BABYLON.Vector3): void;
+    static GetCheckpointTag(): string;
+    static GetCheckpointList(): BABYLON.AbstractMesh[];
+    static GetCheckpointCount(): number;
+    private static GetCheckpointDistance;
+    static RegisterVehicle(vehicle: BABYLON.TransformNode): void;
+    static GetPlayerVehicles(): BABYLON.TransformNode[];
+    static RegisterPlayer(id: number, name: string): void;
+    static UpdateLeaderboard(id: number, lap: number, checkpoint: number, position: BABYLON.Vector3): void;
+    static GetLeaderboardPosition(id: number): number;
+    static GetLeaderboardPositionList(): PlayerRaceStats[];
+    private static SortLeaderboardPositionList;
+}
+export declare class RemoteCarController extends 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;
+}
+export declare class SideCameraController extends 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;
+}
+export declare class SkidMarkSection {
+    Pos: BABYLON.Vector3;
+    Normal: BABYLON.Vector3;
+    Tangent: BABYLON.Vector4;
+    Posl: BABYLON.Vector3;
+    Posr: BABYLON.Vector3;
+    Intensity: number;
+    LastIndex: number;
+}
+export declare class SkidMarkManager extends 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;
+}
+export declare class StandardCarController extends 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: NoiseFunction2D;
+    MIN_RPM: number;
+    MAX_RPM: number;
+    private _animator;
+    private _rigidbody;
+    private _engineAudioSource;
+    private _skidAudioSource;
+    private _nosAudioSource;
+    private _positionLocked;
+    private _prevHandBrakeRequested;
+    private _donutEngineScale;
+    private _donutEntryBlend;
+    private _donutEntrySpeedMps;
+    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(): RigidbodyPhysics;
+    getRaycastVehicle(): 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;
+    lockStartPosition(): void;
+    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;
+    donutSlipAngle: number;
+    donutEntryTime: 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;
+    skidSlideEnabled: boolean;
+    skidSlideMinAngle: number;
+    skidSlideMaxAngle: number;
+    skidSlideMinSpeed: number;
+    skidRecoverDuration: number;
+    skidRecoverCurve: number;
+    debugSkidSlide: boolean;
+    debugSkidSlideEveryNFrames: number;
+    skidReleaseBrakeFadeTime: 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: btWheelInfo;
+    protected m_frontRightWheel: btWheelInfo;
+    protected m_backLeftWheel: btWheelInfo;
+    protected m_backRightWheel: 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 _skidRecoverActive;
+    private _skidRecoverElapsed;
+    private _skidRecoverFrontStart;
+    private _skidRecoverRearStart;
+    private _skidSlideLogCounter;
+    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;
+    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 computeSlideSkid;
+    private logSkidSlide;
+    private updateCurrentContactMask;
+    private hasPenaltyContactMask;
+    private updateCurrentBrakeDamping;
+    private updateCurrentRotationDelta;
+    private updateCurrentRotationBoost;
+    private clearWheelRotationBoost;
+    private hasBurnoutResidualState;
+    private resetBurnoutFrictionForStopOrLaunch;
+    private resetSkidFrictionForStopOrLaunch;
+    private restoreWheelFrictionToDefault;
+    private isWheelFrictionAtDefault;
+    private updateSkidFrictionRecovery;
+    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;
+}
+export declare class VehicleCameraManager extends 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: VehicleInputController;
+    protected m_standardController: 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: PlayerNumber): void;
+    togglePlayerCamera(): void;
+    firstPersonCamera(): void;
+    thirdPersonCamera(): void;
+}
+export interface ISteeringWheelDevice {
+    deviceName: string;
+    forwardButton: number;
+    backwardButton: number;
+    leftHandBrake: number;
+    rightHandBrake: number;
+    leftBurnoutBoost: number;
+    rightBurnoutBoost: number;
+    leftDonutBoost: number;
+    rightDonutBoost: number;
+}
+export declare class VehicleInputController extends 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: 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: ITrackNode[];
+    protected m_circuitRaceLine_1: IControlPoint[];
+    protected m_circuitRaceLine_2: IControlPoint[];
+    protected m_circuitRaceLine_3: IControlPoint[];
+    protected m_circuitRaceLine_4: IControlPoint[];
+    protected m_circuitRaceLine_5: IControlPoint[];
+    protected m_rigidbodyPhysics: RigidbodyPhysics;
+    protected m_checkpointManager: CheckpointManager;
+    protected m_standardCarController: 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): ITrackNode;
+    protected getCurrentControlPoint(lane: number, index: number): IControlPoint;
+    protected getRandomNumber(min: number, max: number): number;
+    protected generateRandonNumber(min: number, max: number, decimals?: number): number;
+    protected destroyVehicleController(): void;
+}
+export declare class VehicleNetworkLabel extends 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;
+    static GetFullscreenUI(scene: BABYLON.Scene, sampling?: number): BABYLON.GUI.AdvancedDynamicTexture;
+}
+export declare class DoubleSided extends CustomShaderMaterial {
+    constructor(name: string, scene: BABYLON.Scene);
+    awake(): void;
+    update(): void;
+    getShaderName(): string;
+}
+export declare class VertexSplat extends CustomShaderMaterial {
+    constructor(name: string, scene: BABYLON.Scene);
+    awake(): void;
+    update(): void;
+    getShaderName(): string;
+    getCustomVertexCode(wgsl: boolean): string;
+}
+export declare class VertexSplatPlugin extends CustomShaderMaterialPlugin {
+    constructor(customMaterial: CustomShaderMaterial, shaderName: string);
+    isCompatible(shaderLanguage: BABYLON.ShaderLanguage): boolean;
+    getCustomCode(shaderType: string, shaderLanguage: BABYLON.ShaderLanguage): any;
+    getUniforms(shaderLanguage: BABYLON.ShaderLanguage): any;
+    getSamplers(samplers: string[]): void;
+    getAttributes(attributes: string[], scene: BABYLON.Scene, mesh: BABYLON.AbstractMesh): void;
+    prepareDefines(defines: BABYLON.MaterialDefines, scene: BABYLON.Scene, mesh: BABYLON.AbstractMesh): void;
+    bindForSubMesh(uniformBuffer: BABYLON.UniformBuffer, scene: BABYLON.Scene, engine: BABYLON.AbstractEngine, subMesh: BABYLON.SubMesh): void;
+}
+export declare class DefaultCameraSystem extends 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;
+    static OnXRExperienceHelperObservable: any;
+    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;
+    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;
+    static GetWebXR(): BABYLON.WebXRDefaultExperience;
+    static IsInWebXR(): boolean;
+    private static SetupNavigationWebXR;
+    static GetMainCamera(scene: BABYLON.Scene, detach?: boolean): BABYLON.FreeCamera;
+    static GetPlayerCamera(scene: BABYLON.Scene, player?: PlayerNumber, detach?: boolean): BABYLON.FreeCamera;
+    static GetCameraTransform(scene: BABYLON.Scene, player?: PlayerNumber): BABYLON.TransformNode;
+    static IsStereoCameras(): boolean;
+    static IsMultiPlayerView(): boolean;
+    static GetMultiPlayerCount(): number;
+    static ActivateMultiPlayerCameras(scene: BABYLON.Scene): boolean;
+    static DisposeMultiPlayerCameras(): void;
+    static SetMultiPlayerViewLayout(scene: BABYLON.Scene, totalNumPlayers: number): boolean;
+}
+export interface IEditorArcRtotate {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: IUnityVector3;
+}
+export interface IEditorPostProcessing {
+    usePostProcessing: boolean;
+    highDynamicRange: boolean;
+    screenAntiAliasing: IEditorAntiAliasing;
+    focalDepthOfField: IEditorDepthOfField;
+    chromaticAberration: IEditorChromaticAberration;
+    glowLayerProperties: IEditorGlowLayer;
+    grainEffectProperties: IEditorGrainEffect;
+    sharpEffectProperties: IEditorSharpenEffect;
+    bloomEffectProperties: IEditorBloomProcessing;
+    imageProcessingConfig: IEditorImageProcessing;
+    screenSpaceRendering: IEditorScreenSpace;
+}
+export interface IEditorScreenSpace {
+    SSAO: boolean;
+    SSAORatio: number;
+    combineRatio: number;
+    totalStrength: number;
+    radius: number;
+    area: number;
+    fallOff: number;
+    baseValue: number;
+}
+export interface IEditorAntiAliasing {
+    msaaSamples: number;
+    fxaaEnabled: boolean;
+    fxaaScaling: boolean;
+    fxaaSamples: number;
+}
+export interface IEditorDepthOfField {
+    depthOfField: boolean;
+    blurLevel: number;
+    focalStop: number;
+    focalLength: number;
+    focusDistance: number;
+    maxLensSize: number;
+}
+export interface IEditorChromaticAberration {
+    aberrationEnabled: boolean;
+    aberrationAmount: number;
+    adaptScaleViewport: boolean;
+    alphaMode: number;
+    alwaysForcePOT: boolean;
+    pixelPerfectMode: boolean;
+    fullscreenViewport: boolean;
+}
+export interface IEditorGlowLayer {
+    glowEnabled: boolean;
+    glowIntensity: number;
+    blurKernelSize: number;
+}
+export interface IEditorGrainEffect {
+    grainEnabled: boolean;
+    grainAnimated: boolean;
+    grainIntensity: number;
+    adaptScaleViewport: boolean;
+}
+export interface IEditorSharpenEffect {
+    sharpenEnabled: boolean;
+    sharpEdgeAmount: number;
+    sharpColorAmount: number;
+    adaptScaleViewport: boolean;
+}
+export interface IEditorBloomProcessing {
+    bloomEnabled: boolean;
+    bloomKernel: number;
+    bloomScale: number;
+    bloomWeight: number;
+    bloomThreshold: number;
+}
+export 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;
+}
+export 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: IUnityColor;
+    useColorGrading: boolean;
+    setGradingTexture: any;
+    imagingColorCurves: IEditorColorCurves;
+}
+export declare class DebugInformation extends ScriptComponent {
+    static GetVersion(): string;
+    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;
+    static _RequestFullscreen(element: HTMLElement): void;
+    static _ExitFullscreen(): void;
+}
+export declare class AssetExporter extends 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;
+}
+export declare class AssetPreloader extends ScriptComponent implements IAssetPreloader {
+    private parentMeshes;
+    private importMeshes;
+    private assetContainers;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected destroy(): void;
+    addPreloaderTasks(assetsManager: PreloadAssetsManager): void;
+}
+export declare class NodeMaterialInstance extends 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;
+}
+export declare class NodeMaterialParticle extends 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;
+}
+export declare class NodeMaterialProcess extends 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;
+}
+export declare class NodeMaterialTexture extends 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;
+}
+export declare class MobileInputController extends ScriptComponent {
+    static get Instance(): 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: TouchJoystickHandler;
+    protected m_rightStick: TouchJoystickHandler;
+    protected m_mobileDevice: boolean;
+    getLeftStick(): TouchJoystickHandler;
+    getRightStick(): 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;
+}
+export declare class FreeCameraTouchJoystickInput implements BABYLON.ICameraInput<BABYLON.FreeCamera> {
+    camera: BABYLON.FreeCamera;
+    controller: BABYLON.Nullable<MobileInputController>;
+    joystickAngularSensibility: number;
+    joystickMoveSensibility: number;
+    deadzoneDelta: number;
+    private _yAxisScale;
+    get invertYAxis(): boolean;
+    set invertYAxis(value: boolean);
+    private LSValues;
+    private RSValues;
+    private _cameraTransform;
+    private _deltaTransform;
+    private _vector3;
+    private _vector2;
+    private _attached;
+    attachControl(): void;
+    detachControl(): void;
+    checkInputs(): void;
+    getClassName(): string;
+    getSimpleName(): string;
+}
+export declare class MobileOccludeMaterial extends ScriptComponent {
+    private applyToMaterial;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+}
+export declare class MobileShadowMaterial extends ScriptComponent {
+    private createNewMaterial;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected destroy(): void;
+}
+export declare class BallSocketJoint extends 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;
+}
+export declare class DistanceJoint extends 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;
+}
+export declare class FixedHingeJoint extends 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;
+}
+export declare class LockedJoint extends 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;
+}
+export declare class PrismaticJoint extends 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;
+}
+export declare class SixdofJoint extends 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;
+}
+export declare class SliderJoint extends 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;
+}
+export declare class RemotePlayerController extends 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;
+}
+export declare class StandardPlayerController extends 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: 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(): AnimationState;
+    getVerticalVelocity(): number;
+    getCharacterController(): CharacterController;
+    getPlayerLookRotation(): BABYLON.Vector3;
+    getPlayerMoveDirection(): 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;
+    onPreUpdateObservable: any;
+    onBeforeMoveObservable: any;
+    onPostUpdateObservable: any;
+    onPlayerInputObservable: any;
+    onPlayerPositionObservable: any;
+    onUpdateActionObservable: any;
+    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;
+    setWorldPosition(x: number, y: number, z: number): void;
+    setPlayerControl(mode: PlayerInputControl): void;
+    togglePlayerControl(): void;
+    private showAvatarSkins;
+    attachPlayerCamera(player: 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;
+    enableCharacterController(state: boolean): void;
+    resetPlayerRotation(): void;
+    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;
+}
+export 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;
+}
+export declare enum PlayerInputControl {
+    FirstPersonStrafing = 0,
+    ThirdPersonStrafing = 1
+}
+export declare enum PlayerMoveDirection {
+    Stationary = 0,
+    Forward = 1,
+    ForwardLeft = 2,
+    ForwardRight = 3,
+    Backward = 4,
+    BackwardLeft = 5,
+    BackwardRight = 6,
+    StrafingLeft = 7,
+    StrafingRight = 8
+}
+export declare enum ActionAnimationType {
+    Neutral = 0,
+    StepUp = 1,
+    JumpUp = 2,
+    ClimbUp = 3,
+    VaultOver = 4
+}
+export declare class ThirdPersonPlayerController extends 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: 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(): AnimationState;
+    getVerticalVelocity(): number;
+    getCharacterController(): CharacterController;
+    getPlayerLookRotation(): BABYLON.Vector3;
+    getPlayerMoveDirection(): 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;
+    boomPosition: BABYLON.Vector3;
+    onPreUpdateObservable: any;
+    onBeforeMoveObservable: any;
+    onPostUpdateObservable: any;
+    onPlayerInputObservable: any;
+    onPlayerPositionObservable: any;
+    onUpdateActionObservable: any;
+    onAnimationStateObservable: any;
+    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;
+    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;
+    enableCharacterController(state: boolean): void;
+    resetPlayerJumpingState(): void;
+    private awakePlayerController;
+    private startPlayerController;
+    private updatePlayerPosition;
+    private updatePlayerController;
+    private afterPlayerController;
+    private updateCharacterController;
+    private castPhysicsClimbingVolumeRay;
+    private castPhysicsHeightCheckVolumeRay;
+    private getCheckedVerticalVelocity;
+    private destroyPlayerController;
+    private validateAnimationStateParams;
+}
+export declare enum ThirdPersonControl {
+    ThirdPersonTurning = 0,
+    ThirdPersonForward = 1
+}
+export declare class FxParticleSystem extends 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;
+}
+export declare class SkyMaterialSystem extends 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;
+    setSkyboxTintColor(color: BABYLON.Color3): void;
+}
+export declare class WaterMaterialSystem extends 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;
+}
+export declare class SnapshotManager extends ScriptComponent {
+    static IsSnapshotRenderingEnabled(): boolean;
+    static EnableSnapshotRendering(): void;
+    static DisableSnapshotRendering(): void;
+    static ResetSnapshotHelper(scene: BABYLON.Scene): void;
+    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;
+}
+export declare class SnapshotRenderer extends ScriptComponent {
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected start(): void;
+}
+export declare class DefaultMuteButton extends 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;
+}
+export declare class SceneSoundSystem extends ScriptComponent {
+    private static _MUSIC;
+    static get MUSIC(): SoundManager;
+    private static _SFX;
+    static get SFX(): SoundManager;
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected start(): void;
+}
+export declare class SoundManager extends ScriptComponent {
+    private groupName;
+    private cachedVolume;
+    private volumeProperty;
+    getGroupName(): string;
+    protected m_soundMap: Map<string, AudioSource>;
+    protected m_soundList: AudioSource[];
+    constructor(transform: BABYLON.TransformNode, scene: BABYLON.Scene, properties?: any, alias?: string);
+    protected awake(): void;
+    protected start(): void;
+    protected update(): void;
+    protected destroy(): void;
+    isPlaying(name: string): boolean;
+    isPaused(name: string): boolean;
+    playTrack(name: string, time?: number, offset?: number, length?: number): Promise<boolean>;
+    pauseTrack(name: string): boolean;
+    pauseAllTracks(): void;
+    stopTrack(name: string, time?: number): boolean;
+    stopAllTracks(time?: number): void;
+    muteTrack(name: string, time?: number): boolean;
+    unmuteTrack(name: string, time?: number): boolean;
+    muteAllTracks(time?: number): void;
+    unmuteAllTracks(time?: number): void;
+    setGroupVolume(volume: number, time?: number): void;
+    getAudioSource(name: string): AudioSource;
+}
+declare global {
+    interface Window {
+        PROJECT: Record<string, unknown>;
+    }
+}
+export {};
+//# sourceMappingURL=project.d.ts.map