@babylonjs-toolkit/next 9.16.1 → 9.20.1

package/lib/project.js

@@ -2024,6 +2024,9 @@ export class StandardCarController extends ScriptComponent {
         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) {
@@ -4121,6 +4124,480 @@ StandardCarController.DEFAULT_SPEED_FACTOR = 1.0;
 StandardCarController.DEFAULT_DONUT_FACTOR = 1.0;
 StandardCarController.DEFAULT_BRAKE_DEADZONE = 0.5;
 StandardCarController.SimplexNoise2D = SimplexNoise.createNoise2D();
+export 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 BABYLON.Vector3(0, 1, 0);
+        this._groundForward = new BABYLON.Vector3(0, 0, 1);
+        this._velocity = new BABYLON.Vector3();
+        this._angular = new BABYLON.Vector3();
+        this._travel = new BABYLON.Vector3();
+        this._scratchA = new BABYLON.Vector3();
+        this._scratchB = new BABYLON.Vector3();
+        this._worldMatrix = new BABYLON.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 = BABYLON.Scalar.Clamp(throttle, -1, 1);
+        this._throttle = t > 0 ? t : 0;
+        this._brake = t < 0 ? -t : 0;
+        this._steerRequest = BABYLON.Scalar.Clamp(steering, -1, 1);
+        this._driftRequest = drifting === true;
+        this._externalBoost = BABYLON.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(BABYLON.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 = BABYLON.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 = BABYLON.Scalar.Clamp(this.driftTargetAngle * System.Deg2Rad, 0, limit);
+            const next = StandardKartController.MoveTowards(outward, target, this.driftAngleRampRate * System.Deg2Rad * dt);
+            this._driftAngle = -this._driftDirection * BABYLON.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;
+        BABYLON.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 = BABYLON.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 = BABYLON.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;
 export class VehicleCameraManager extends ScriptComponent {
     constructor(transform, scene, properties = {}, alias = "VehicleCameraManager") {
         super(transform, scene, properties, alias);
@@ -10490,5 +10967,5 @@ SceneManager.RegisterClass("SoundManager", SoundManager);
 if (typeof window !== 'undefined') {
     if (!window.TOOLKIT)
         window.TOOLKIT = Object.assign({}, _ToolkitRef);
-    window.PROJECT = Object.assign(window.PROJECT || {}, { CheckpointManager, RoutePoint, PlayerRaceStats, RaceTrackManager, RemoteCarController, SideCameraController, SkidMarkSection, SkidMarkManager, StandardCarController, VehicleCameraManager, VehicleInputController, VehicleNetworkLabel, DoubleSided, VertexSplat, VertexSplatPlugin, DefaultCameraSystem, DebugInformation, AssetExporter, AssetPreloader, NodeMaterialInstance, NodeMaterialParticle, NodeMaterialProcess, NodeMaterialTexture, MobileInputController, FreeCameraTouchJoystickInput, MobileOccludeMaterial, MobileShadowMaterial, BallSocketJoint, DistanceJoint, FixedHingeJoint, LockedJoint, PrismaticJoint, SixdofJoint, SliderJoint, RemotePlayerController, StandardPlayerController, PlayerInputControl, PlayerMoveDirection, ActionAnimationType, ThirdPersonPlayerController, ThirdPersonControl, FxParticleSystem, SkyMaterialSystem, WaterMaterialSystem, SnapshotManager, SnapshotRenderer, DefaultMuteButton, SceneSoundSystem, SoundManager });
+    window.PROJECT = Object.assign(window.PROJECT || {}, { CheckpointManager, RoutePoint, PlayerRaceStats, RaceTrackManager, RemoteCarController, SideCameraController, SkidMarkSection, SkidMarkManager, StandardCarController, StandardKartController, VehicleCameraManager, VehicleInputController, VehicleNetworkLabel, DoubleSided, VertexSplat, VertexSplatPlugin, DefaultCameraSystem, DebugInformation, AssetExporter, AssetPreloader, NodeMaterialInstance, NodeMaterialParticle, NodeMaterialProcess, NodeMaterialTexture, MobileInputController, FreeCameraTouchJoystickInput, MobileOccludeMaterial, MobileShadowMaterial, BallSocketJoint, DistanceJoint, FixedHingeJoint, LockedJoint, PrismaticJoint, SixdofJoint, SliderJoint, RemotePlayerController, StandardPlayerController, PlayerInputControl, PlayerMoveDirection, ActionAnimationType, ThirdPersonPlayerController, ThirdPersonControl, FxParticleSystem, SkyMaterialSystem, WaterMaterialSystem, SnapshotManager, SnapshotRenderer, DefaultMuteButton, SceneSoundSystem, SoundManager });
 }

package/lib/scenemanager.d.ts

@@ -814,6 +814,8 @@ export declare class CVTOOLS_unity_metadata implements IGLTFLoaderExtension {
     static readonly IBL_PROBE_FACTOR: number;
     static SuppressReflectionProbeDiffuse(texture: BaseTexture): void;
     static ApplyGlobalReflectionProbeDiffuse(texture: BaseTexture, scene: Scene, createPolynomialsFromFaces?: boolean): void;
+    private static readonly NonColorDataSamplers;
+    static IsNonColorDataSampler(samplerName: string): boolean;
     private static _boxProjectionShaderPatched;
     enabled: boolean;
     private _webgpu;