@babylonjs-toolkit/next 9.20.0 → 9.20.1

package/lib/scenemanager.js

@@ -98,7 +98,7 @@ import { ShadowOnlyMaterial } from '@babylonjs/materials/shadowOnly/shadowOnlyMa
 import { SkyMaterial } from '@babylonjs/materials/sky/skyMaterial';
 import { WaterMaterial } from '@babylonjs/materials/water/waterMaterial';
 export class SceneManager {
-    static get Version() { return "9.20.0 - R1"; }
+    static get Version() { return "9.20.1 - R1"; }
     static get Copyright() { return "All rights reserved (c) 2024 Mackey Kinard"; }
     static GetEngine(scene) {
         let result = null;
@@ -2658,7 +2658,7 @@ SceneManager.DirectionalLightIntensity = 1.0;
 SceneManager.FogExpDensityScale = 1.0;
 SceneManager.FogExp2DensityScale = 1.0;
 SceneManager.FogLinearDensityScale = 1.0;
-SceneManager.TerrainColorCorrection = 2.2;
+SceneManager.TerrainColorCorrection = 1.0;
 SceneManager.AllowCameraMovement = true;
 SceneManager.AllowCameraRotation = true;
 SceneManager.VirtualJoystickEnabled = false;
@@ -3378,6 +3378,7 @@ export class SceneController extends ScriptComponent {
             SceneManager.ScenePlaying = true;
             if (this.autoHideSplashScreen)
                 SceneManager.HideSplashScreen(this.scene, this.scenePrewarmDurationMs);
+            SceneManager.FocusRenderCanvas(this.scene);
         }
     }
 }
@@ -3819,6 +3820,9 @@ export class CVTOOLS_unity_metadata {
             internal._sphericalPolynomialComputed = true;
         }
     }
+    static IsNonColorDataSampler(samplerName) {
+        return CVTOOLS_unity_metadata.NonColorDataSamplers.indexOf(samplerName) >= 0;
+    }
     constructor(loader) {
         this.name = SceneManager.CVTOOLS_NAME;
         this.enabled = false;
@@ -5377,6 +5381,8 @@ export class CVTOOLS_unity_metadata {
                     for (const tkey in commonConstant.customTextures) {
                         const tvalue = commonConstant.customTextures[tkey];
                         if (tvalue != null) {
+                            if (CVTOOLS_unity_metadata.IsNonColorDataSampler(tkey))
+                                tvalue.nonColorData = true;
                             universalMaterial.checkSampler(tkey);
                             promises.push(this._loader.loadTextureInfoAsync(context + "/" + tkey, tvalue, (texture) => {
                                 if (tkey === "detailsSampler" || tkey === "normalsSampler") {
@@ -5420,6 +5426,8 @@ export class CVTOOLS_unity_metadata {
                     for (const tkey in commonConstant.customTextures) {
                         const tvalue = commonConstant.customTextures[tkey];
                         if (tvalue != null && Utilities.HasOwnProperty(commonMaterial, tkey)) {
+                            if (CVTOOLS_unity_metadata.IsNonColorDataSampler(tkey))
+                                tvalue.nonColorData = true;
                             promises.push(this._loader.loadTextureInfoAsync(context + "/" + tkey, tvalue, (texture) => {
                                 if (tkey === "detailsSampler" || tkey === "normalsSampler") {
                                     texture.name = `${sourceMaterial.name} (Atlas)`;
@@ -5633,6 +5641,7 @@ export class CVTOOLS_unity_metadata {
 CVTOOLS_unity_metadata.IBL_TINY_VALUE = 0.001;
 CVTOOLS_unity_metadata.IBL_SPEC_FACTOR = 1.0;
 CVTOOLS_unity_metadata.IBL_PROBE_FACTOR = 1.0;
+CVTOOLS_unity_metadata.NonColorDataSamplers = ["normalsSampler", "splatmapSampler"];
 CVTOOLS_unity_metadata._boxProjectionShaderPatched = false;
 CVTOOLS_unity_metadata.ScriptBundleCache = {};
 export class CVTOOLS_babylon_mesh {
@@ -33948,6 +33957,9 @@ var PROJECT;
             if (this._engineAudioSource == null)
                 SceneManager.LogWarning("No engine audio source manager found for: " + this.transform.name);
             this._rigidbody = this.getComponent("RigidbodyPhysics");
+            if (this._rigidbody == null) {
+                SceneManager.LogWarning("No rigidbody physics component found for: " + this.transform.name + " - vehicle control is disabled. If this transform was set up in code, check that its components were not constructed with _registerComponentAlias set to false.");
+            }
             if (this._rigidbody != null) {
                 this.raycastVehicle = RaycastVehicle.GetInstance(this.scene, this._rigidbody);
                 if (this.transform.physicsBody != null && this._rigidbody != null && this.raycastVehicle != null) {
@@ -36047,6 +36059,483 @@ var PROJECT;
     StandardCarController.SimplexNoise2D = SimplexNoise.createNoise2D();
     PROJECT.StandardCarController = StandardCarController;
 })(PROJECT || (PROJECT = {}));
+(function (PROJECT) {
+    class StandardKartController extends ScriptComponent {
+        constructor() {
+            super(...arguments);
+            this.chassisTransform = null;
+            this.exhaustLeftTransform = null;
+            this.exhaustRightTransform = null;
+            this.frontLeftWheelTrans = null;
+            this.frontRightWheelTrans = null;
+            this.backLeftWheelTrans = null;
+            this.backRightWheelTrans = null;
+            this.frontLeftWheelCollider = null;
+            this.frontRightWheelCollider = null;
+            this.backLeftWheelCollider = null;
+            this.backRightWheelCollider = null;
+            this.frontLeftWheelMesh = null;
+            this.frontRightWheelMesh = null;
+            this.backLeftWheelMesh = null;
+            this.backRightWheelMesh = null;
+            this.topSpeed = 25.0;
+            this.accelerationTime = 2.2;
+            this.coastDeceleration = 6.0;
+            this.brakeDeceleration = 18.0;
+            this.gravitationalForce = 2.2;
+            this.steeringYawRate = 1.1;
+            this.steeringRamp = 0.18;
+            this.maxSteeringAngle = 28.0;
+            this.driftEnabled = true;
+            this.driftYawRate = 1.658;
+            this.driftStickShare = 0.5;
+            this.driftBaseShare = 0.5;
+            this.driftTargetAngle = 45.0;
+            this.driftMaxAngle = 60.0;
+            this.driftAngleRampRate = 223.0;
+            this.driftAngleUnwindRate = 48.0;
+            this.hopDuration = 0.25;
+            this.hopImpulse = 4.5;
+            this.minimumDriftSpeed = 13.75;
+            this.driftLatchThreshold = 0.2;
+            this.driftSpeedRetention = 1.0;
+            this.driftFrictionSlip = 0.05;
+            this.miniTurboEnabled = true;
+            this.miniTurboTime = 0.6;
+            this.superMiniTurboTime = 1.6;
+            this.ultraMiniTurboTime = 2.8;
+            this.boostSpeedFactor = 1.35;
+            this.boostDurationMini = 0.6;
+            this.boostDurationSuper = 1.1;
+            this.boostDurationUltra = 1.8;
+            this._rigidbody = null;
+            this._raycastVehicle = null;
+            this._engineAudioSource = null;
+            this.FRONT_LEFT = -1;
+            this.FRONT_RIGHT = -1;
+            this.BACK_LEFT = -1;
+            this.BACK_RIGHT = -1;
+            this._defaultFriction = 10.0;
+            this._steer = 0;
+            this._throttle = 0;
+            this._brake = 0;
+            this._driftHeld = false;
+            this._driftWasHeld = false;
+            this._steerRequest = 0;
+            this._driftRequest = false;
+            this._externalBoost = 0;
+            this._driftState = 0;
+            this._driftDirection = 0;
+            this._driftStage = 0;
+            this._driftTime = 0;
+            this._hopTime = 0;
+            this._hopSteer = 0;
+            this._hopPending = false;
+            this._driftAngle = 0;
+            this._yawRate = 0;
+            this._planarSpeed = 0;
+            this._groundedWheels = 0;
+            this._airborneTime = 0;
+            this._boostTimer = 0;
+            this._boostFactor = 1.0;
+            this._groundNormal = new Vector3(0, 1, 0);
+            this._groundForward = new Vector3(0, 0, 1);
+            this._velocity = new Vector3();
+            this._angular = new Vector3();
+            this._travel = new Vector3();
+            this._scratchA = new Vector3();
+            this._scratchB = new Vector3();
+            this._worldMatrix = new Matrix();
+        }
+        get currentSpeed() { return this._planarSpeed; }
+        get slideAngle() { return this._driftAngle; }
+        get driftState() { return this._driftState; }
+        get driftDirection() { return this._driftDirection; }
+        get driftStage() { return this._driftStage; }
+        get isAirborne() { return this._groundedWheels <= 0; }
+        awake() { this.awakeKartState(); }
+        start() { this.initKartState(); }
+        update() { this.updateKartState(); }
+        step() { this.stepKartState(); }
+        destroy() { this.destroyKartState(); }
+        awakeKartState() {
+            this.topSpeed = this.getProperty("topSpeed", this.topSpeed);
+            this.accelerationTime = this.getProperty("accelerationTime", this.accelerationTime);
+            this.coastDeceleration = this.getProperty("coastDeceleration", this.coastDeceleration);
+            this.brakeDeceleration = this.getProperty("brakeDeceleration", this.brakeDeceleration);
+            this.gravitationalForce = this.getProperty("gravitationalForce", this.gravitationalForce);
+            this.steeringYawRate = this.getProperty("steeringYawRate", this.steeringYawRate);
+            this.steeringRamp = this.getProperty("steeringRamp", this.steeringRamp);
+            this.maxSteeringAngle = this.getProperty("maxSteeringAngle", this.maxSteeringAngle);
+            this.driftEnabled = this.getProperty("driftEnabled", this.driftEnabled);
+            this.driftYawRate = this.getProperty("driftYawRate", this.driftYawRate);
+            this.driftStickShare = this.getProperty("driftStickShare", this.driftStickShare);
+            this.driftBaseShare = this.getProperty("driftBaseShare", this.driftBaseShare);
+            this.driftTargetAngle = this.getProperty("driftTargetAngle", this.driftTargetAngle);
+            this.driftMaxAngle = this.getProperty("driftMaxAngle", this.driftMaxAngle);
+            this.driftAngleRampRate = this.getProperty("driftAngleRampRate", this.driftAngleRampRate);
+            this.driftAngleUnwindRate = this.getProperty("driftAngleUnwindRate", this.driftAngleUnwindRate);
+            this.hopDuration = this.getProperty("hopDuration", this.hopDuration);
+            this.hopImpulse = this.getProperty("hopImpulse", this.hopImpulse);
+            this.minimumDriftSpeed = this.getProperty("minimumDriftSpeed", this.minimumDriftSpeed);
+            this.driftLatchThreshold = this.getProperty("driftLatchThreshold", this.driftLatchThreshold);
+            this.driftSpeedRetention = this.getProperty("driftSpeedRetention", this.driftSpeedRetention);
+            this.driftFrictionSlip = this.getProperty("driftFrictionSlip", this.driftFrictionSlip);
+            this.miniTurboEnabled = this.getProperty("miniTurboEnabled", this.miniTurboEnabled);
+            this.miniTurboTime = this.getProperty("miniTurboTime", this.miniTurboTime);
+            this.superMiniTurboTime = this.getProperty("superMiniTurboTime", this.superMiniTurboTime);
+            this.ultraMiniTurboTime = this.getProperty("ultraMiniTurboTime", this.ultraMiniTurboTime);
+            this.boostSpeedFactor = this.getProperty("boostSpeedFactor", this.boostSpeedFactor);
+            this.boostDurationMini = this.getProperty("boostDurationMini", this.boostDurationMini);
+            this.boostDurationSuper = this.getProperty("boostDurationSuper", this.boostDurationSuper);
+            this.boostDurationUltra = this.getProperty("boostDurationUltra", this.boostDurationUltra);
+            this.frontLeftWheelTrans = this.getProperty("frontLeftWheel");
+            this.frontRightWheelTrans = this.getProperty("frontRightWheel");
+            this.backLeftWheelTrans = this.getProperty("backLeftWheel");
+            this.backRightWheelTrans = this.getProperty("backRightWheel");
+            this.frontLeftWheelCollider = this.getProperty("frontLeftCollider");
+            this.frontRightWheelCollider = this.getProperty("frontRightCollider");
+            this.backLeftWheelCollider = this.getProperty("backLeftCollider");
+            this.backRightWheelCollider = this.getProperty("backRightCollider");
+        }
+        initKartState() {
+            const chassis = this.getProperty("chassisTransform");
+            if (chassis != null && chassis.name != null && chassis.name !== "") {
+                this.chassisTransform = this.getChildNode(chassis.name, SearchType.IndexOf, false);
+            }
+            const exhaustL = this.getProperty("exhaustLeftTransform");
+            if (exhaustL != null && exhaustL.name != null && exhaustL.name !== "") {
+                this.exhaustLeftTransform = this.getChildNode(exhaustL.name, SearchType.IndexOf, false);
+            }
+            const exhaustR = this.getProperty("exhaustRightTransform");
+            if (exhaustR != null && exhaustR.name != null && exhaustR.name !== "") {
+                this.exhaustRightTransform = this.getChildNode(exhaustR.name, SearchType.IndexOf, false);
+            }
+            this._engineAudioSource = this.getComponent("AudioSource");
+            this._rigidbody = this.getComponent("RigidbodyPhysics");
+            if (this._rigidbody == null) {
+                SceneManager.LogWarning("No rigidbody physics component found for: " + this.transform.name + " - kart control is disabled. If this transform was set up in code, check that its components were not constructed with _registerComponentAlias set to false.");
+                return;
+            }
+            this._raycastVehicle = RaycastVehicle.GetInstance(this.scene, this._rigidbody);
+            if (this._raycastVehicle == null || this.transform.physicsBody == null) {
+                SceneManager.LogWarning("StandardKartController: no raycast vehicle on " + this.transform.name);
+                return;
+            }
+            this.transform.physicsBody.setGravityFactor(this.gravitationalForce);
+            this.resolveWheelIndexes();
+            this.captureDefaultFriction();
+        }
+        resolveWheelIndexes() {
+            const nameOf = (o) => (o != null && o.name != null && o.name !== "") ? o.name : null;
+            const fl = nameOf(this.frontLeftWheelCollider);
+            const fr = nameOf(this.frontRightWheelCollider);
+            const bl = nameOf(this.backLeftWheelCollider);
+            const br = nameOf(this.backRightWheelCollider);
+            if (fl != null)
+                this.FRONT_LEFT = this._raycastVehicle.getWheelIndexByName(fl);
+            if (fr != null)
+                this.FRONT_RIGHT = this._raycastVehicle.getWheelIndexByName(fr);
+            if (bl != null)
+                this.BACK_LEFT = this._raycastVehicle.getWheelIndexByName(bl);
+            if (br != null)
+                this.BACK_RIGHT = this._raycastVehicle.getWheelIndexByName(br);
+            const bind = (trans, index) => {
+                if (trans == null || trans.name == null || trans.name === "" || index < 0)
+                    return null;
+                const mesh = this.getChildNode(trans.name, SearchType.IndexOf, false);
+                if (mesh != null)
+                    this._raycastVehicle.setWheelTransformMesh(index, mesh);
+                return mesh;
+            };
+            this.frontLeftWheelMesh = bind(this.frontLeftWheelTrans, this.FRONT_LEFT);
+            this.frontRightWheelMesh = bind(this.frontRightWheelTrans, this.FRONT_RIGHT);
+            this.backLeftWheelMesh = bind(this.backLeftWheelTrans, this.BACK_LEFT);
+            this.backRightWheelMesh = bind(this.backRightWheelTrans, this.BACK_RIGHT);
+        }
+        captureDefaultFriction() {
+            const count = this._raycastVehicle.getNumWheels();
+            for (let i = 0; i < count; i++) {
+                const info = this._raycastVehicle.getWheelInfo(i);
+                if (info != null && info.frictionSlip != null) {
+                    this._defaultFriction = info.frictionSlip;
+                    break;
+                }
+            }
+        }
+        destroyKartState() {
+            this.restoreFriction();
+            this._raycastVehicle = null;
+            this._rigidbody = null;
+            this._engineAudioSource = null;
+        }
+        updateKartState() {
+            if (this._raycastVehicle == null)
+                return;
+            const dt = this.getDeltaSeconds();
+            if (!(dt > 0))
+                return;
+            this.readInput(dt);
+            this.readGroundFrame();
+            this.advanceMachine(dt);
+            this.integrateDriftAngle(dt);
+            this.applyFrictionOwnership();
+            this.updateBoost(dt);
+            this.updateWheelVisuals();
+        }
+        drive(throttle, steering, drifting, booster = 0) {
+            const t = Scalar.Clamp(throttle, -1, 1);
+            this._throttle = t > 0 ? t : 0;
+            this._brake = t < 0 ? -t : 0;
+            this._steerRequest = Scalar.Clamp(steering, -1, 1);
+            this._driftRequest = drifting === true;
+            this._externalBoost = Scalar.Clamp(booster, 0, 1);
+        }
+        readInput(dt) {
+            const rate = this.steeringRamp > 0 ? dt / this.steeringRamp : Number.POSITIVE_INFINITY;
+            this._steer = StandardKartController.MoveTowards(this._steer, this._steerRequest, rate);
+            this._driftWasHeld = this._driftHeld;
+            this._driftHeld = this._driftRequest;
+        }
+        readGroundFrame() {
+            const count = this._raycastVehicle.getNumWheels();
+            this._groundedWheels = 0;
+            this._scratchA.setAll(0);
+            for (let i = 0; i < count; i++) {
+                const info = this._raycastVehicle.getWheelInfo(i);
+                if (info == null || info.raycastInfo == null)
+                    continue;
+                if (info.raycastInfo.isInContact !== true)
+                    continue;
+                this._groundedWheels++;
+                this._scratchA.addInPlace(info.raycastInfo.contactNormalWS);
+            }
+            if (this._groundedWheels > 0 && this._scratchA.lengthSquared() > 1e-8) {
+                this._groundNormal.copyFrom(this._scratchA).normalize();
+                this._airborneTime = 0;
+            }
+            else {
+                this._airborneTime += this.getDeltaSeconds();
+                this.transform.computeWorldMatrix(true);
+                this._worldMatrix.copyFrom(this.transform.getWorldMatrix());
+                this._groundNormal.set(this._worldMatrix.m[4], this._worldMatrix.m[5], this._worldMatrix.m[6]).normalize();
+            }
+            this.transform.computeWorldMatrix(true);
+            this._worldMatrix.copyFrom(this.transform.getWorldMatrix());
+            this._groundForward.set(this._worldMatrix.m[8], this._worldMatrix.m[9], this._worldMatrix.m[10]);
+            this._scratchB.copyFrom(this._groundNormal).scaleInPlace(Vector3.Dot(this._groundForward, this._groundNormal));
+            this._groundForward.subtractInPlace(this._scratchB);
+            if (this._groundForward.lengthSquared() > 1e-8)
+                this._groundForward.normalize();
+            if (this.transform.physicsBody != null) {
+                this.transform.physicsBody.getLinearVelocityToRef(this._velocity);
+                const vertical = Vector3.Dot(this._velocity, this._groundNormal);
+                this._scratchB.copyFrom(this._groundNormal).scaleInPlace(vertical);
+                this._planarSpeed = this._velocity.subtract(this._scratchB).length();
+            }
+        }
+        advanceMachine(dt) {
+            const pressed = this._driftHeld === true && this._driftWasHeld !== true;
+            const grounded = this._groundedWheels > 0;
+            if (this._driftState === 1) {
+                this._hopTime += dt;
+                this._yawRate = this._hopSteer * this.steeringYawRate * StandardKartController.HOP_TURN_BOOST;
+                if (this._hopTime >= this.hopDuration && grounded === true) {
+                    const latched = this._driftHeld === true
+                        && Math.abs(this._steer) >= this.driftLatchThreshold
+                        && this._planarSpeed >= this.minimumDriftSpeed;
+                    if (latched === true) {
+                        this._driftDirection = this._steer > 0 ? 1 : -1;
+                        this._driftState = 2;
+                        this._driftTime = 0;
+                        this._driftStage = 0;
+                    }
+                    else {
+                        this._driftState = 0;
+                        this._driftDirection = 0;
+                    }
+                }
+                return;
+            }
+            if (this._driftState === 2) {
+                if (this._driftHeld !== true || this._planarSpeed < this.minimumDriftSpeed) {
+                    this.releaseDrift();
+                    return;
+                }
+                this._driftTime += dt;
+                const realTurn = this.driftStickShare * this._steer + this.driftBaseShare * this._driftDirection;
+                this._yawRate = realTurn * this.driftYawRate;
+                if (this.miniTurboEnabled === true)
+                    this.updateDriftStage();
+                return;
+            }
+            this._yawRate = this._steer * this.steeringYawRate;
+            if (this.driftEnabled === true && pressed === true && grounded === true
+                && this._planarSpeed >= this.minimumDriftSpeed) {
+                this._driftState = 1;
+                this._hopTime = 0;
+                this._hopPending = true;
+                this._hopSteer = Math.abs(this._steer) >= this.driftLatchThreshold ? (this._steer > 0 ? 1 : -1) : 0;
+            }
+        }
+        updateDriftStage() {
+            let stage = 0;
+            if (this._driftTime >= this.ultraMiniTurboTime)
+                stage = 3;
+            else if (this._driftTime >= this.superMiniTurboTime)
+                stage = 2;
+            else if (this._driftTime >= this.miniTurboTime)
+                stage = 1;
+            this._driftStage = stage;
+        }
+        releaseDrift() {
+            if (this.miniTurboEnabled === true && this._driftStage > 0) {
+                this._boostFactor = this.boostSpeedFactor;
+                this._boostTimer = this._driftStage === 3 ? this.boostDurationUltra
+                    : this._driftStage === 2 ? this.boostDurationSuper
+                        : this.boostDurationMini;
+            }
+            this._driftState = 0;
+            this._driftDirection = 0;
+            this._driftStage = 0;
+            this._driftTime = 0;
+        }
+        integrateDriftAngle(dt) {
+            if (this._airborneTime > StandardKartController.AIRBORNE_ANGLE_HOLD)
+                return;
+            const limit = this.driftMaxAngle * System.Deg2Rad;
+            if (this._driftState === 2 && this._driftDirection !== 0) {
+                const outward = -this._driftDirection * this._driftAngle;
+                const target = Scalar.Clamp(this.driftTargetAngle * System.Deg2Rad, 0, limit);
+                const next = StandardKartController.MoveTowards(outward, target, this.driftAngleRampRate * System.Deg2Rad * dt);
+                this._driftAngle = -this._driftDirection * Scalar.Clamp(next, -limit, limit);
+                return;
+            }
+            this._driftAngle = StandardKartController.MoveTowards(this._driftAngle, 0, this.driftAngleUnwindRate * System.Deg2Rad * dt);
+        }
+        ownsGroundPlane() {
+            if (this._driftState !== 0)
+                return true;
+            return Math.abs(this._driftAngle) > 0.0017;
+        }
+        applyFrictionOwnership() {
+            const owns = this.ownsGroundPlane();
+            const target = owns === true ? this.driftFrictionSlip : this._defaultFriction;
+            const count = this._raycastVehicle.getNumWheels();
+            for (let i = 0; i < count; i++) {
+                const info = this._raycastVehicle.getWheelInfo(i);
+                if (info != null)
+                    info.frictionSlip = target;
+            }
+        }
+        updateBoost(dt) {
+            if (this._boostTimer > 0) {
+                this._boostTimer -= dt;
+                if (this._boostTimer <= 0)
+                    this._boostFactor = 1.0;
+            }
+        }
+        stepKartState() {
+            if (this._raycastVehicle == null || this.transform.physicsBody == null)
+                return;
+            const body = this.transform.physicsBody;
+            const dt = this.getDeltaSeconds();
+            if (!(dt > 0))
+                return;
+            if (this._hopPending === true) {
+                this._hopPending = false;
+                this._scratchA.copyFrom(this._groundNormal).scaleInPlace(this.hopImpulse);
+                body.applyImpulse(this._scratchA, this.transform.getAbsolutePosition());
+            }
+            if (this._groundedWheels <= 0)
+                return;
+            this.integratePace(dt);
+            this.applyTravelDirection(body, dt);
+            this.applyYawRate(body);
+        }
+        integratePace(dt) {
+            const top = this.topSpeed * this._boostFactor * (1 + this._externalBoost * (this.boostSpeedFactor - 1));
+            if (this._brake > 0) {
+                this._planarSpeed = Math.max(0, this._planarSpeed - this.brakeDeceleration * this._brake * dt);
+            }
+            else if (this._throttle > 0) {
+                const accel = this.accelerationTime > 0 ? this.topSpeed / this.accelerationTime : top;
+                this._planarSpeed = Math.min(top, this._planarSpeed + accel * this._throttle * dt);
+            }
+            else {
+                this._planarSpeed = Math.max(0, this._planarSpeed - this.coastDeceleration * dt);
+            }
+            if (this._driftState === 2 && this.driftSpeedRetention < 1) {
+                this._planarSpeed *= Math.pow(this.driftSpeedRetention, dt);
+            }
+        }
+        applyTravelDirection(body, dt) {
+            if (this.ownsGroundPlane() !== true)
+                return;
+            if (this._planarSpeed <= StandardKartController.RESTING_SPEED)
+                return;
+            Vector3.CrossToRef(this._groundNormal, this._groundForward, this._scratchA);
+            this._travel.copyFrom(this._groundForward).scaleInPlace(Math.cos(this._driftAngle));
+            this._scratchA.scaleInPlace(Math.sin(this._driftAngle));
+            this._travel.addInPlace(this._scratchA);
+            if (this._travel.lengthSquared() <= 1e-8)
+                return;
+            this._travel.normalize();
+            body.getLinearVelocityToRef(this._velocity);
+            const vertical = Vector3.Dot(this._velocity, this._groundNormal);
+            this._scratchB.copyFrom(this._groundNormal).scaleInPlace(vertical);
+            this._velocity.copyFrom(this._travel).scaleInPlace(this._planarSpeed).addInPlace(this._scratchB);
+            body.setLinearVelocity(this._velocity);
+        }
+        applyYawRate(body) {
+            body.getAngularVelocityToRef(this._angular);
+            const spin = Vector3.Dot(this._angular, this._groundNormal);
+            this._scratchA.copyFrom(this._groundNormal).scaleInPlace(this._yawRate - spin);
+            this._angular.addInPlace(this._scratchA);
+            body.setAngularVelocity(this._angular);
+        }
+        updateWheelVisuals() {
+            const angle = this._steer * this.maxSteeringAngle * System.Deg2Rad;
+            if (this.frontLeftWheelMesh != null)
+                this.frontLeftWheelMesh.rotation.y = angle;
+            if (this.frontRightWheelMesh != null)
+                this.frontRightWheelMesh.rotation.y = angle;
+        }
+        restoreFriction() {
+            if (this._raycastVehicle == null)
+                return;
+            const count = this._raycastVehicle.getNumWheels();
+            for (let i = 0; i < count; i++) {
+                const info = this._raycastVehicle.getWheelInfo(i);
+                if (info != null)
+                    info.frictionSlip = this._defaultFriction;
+            }
+        }
+        clearDrift() {
+            this._driftState = 0;
+            this._driftDirection = 0;
+            this._driftStage = 0;
+            this._driftTime = 0;
+            this._driftAngle = 0;
+            this._hopPending = false;
+            this.restoreFriction();
+        }
+        static MoveTowards(current, target, maxDelta) {
+            if (!(maxDelta > 0))
+                return target;
+            const d = target - current;
+            if (d > maxDelta)
+                return current + maxDelta;
+            if (d < -maxDelta)
+                return current - maxDelta;
+            return target;
+        }
+    }
+    StandardKartController.HOP_TURN_BOOST = 1.4;
+    StandardKartController.AIRBORNE_ANGLE_HOLD = 0.083;
+    StandardKartController.RESTING_SPEED = 1e-4;
+    PROJECT.StandardKartController = StandardKartController;
+})(PROJECT || (PROJECT = {}));
 (function (PROJECT) {
     class VehicleCameraManager extends ScriptComponent {
         constructor(transform, scene, properties = {}, alias = "VehicleCameraManager") {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@babylonjs-toolkit/next",
-    "version": "9.20.0",
+    "version": "9.20.1",
     "description": "Babylon Toolkit Runtime Library (ES6)",
     "author": "MackeyK24 <mackeyk24@gmail.com>",
     "main": "lib/index.js",