@babylonjs-toolkit/next 9.0.1 → 9.5.0

package/lib/scenemanager.js

@@ -40,7 +40,7 @@ import { Skeleton } from '@babylonjs/core/Bones/skeleton';
 import { Control } from '@babylonjs/gui/2D/controls/control';
 import { TextBlock } from '@babylonjs/gui/2D/controls/textBlock';
 import { Image } from '@babylonjs/gui/2D/controls/image';
-import { PhysicsBody, PhysicsShape, PhysicsShapeCapsule, PhysicsRaycastResult, PhysicsMotionType, PhysicsShapeContainer, ShapeCastResult, PhysicsShapeSphere, PhysicsShapeMesh, PhysicsShapeConvexHull, PhysicsShapeBox, PhysicsShapeCylinder, PhysicsMaterialCombineMode, PhysicsShapeType } from '@babylonjs/core/Physics';
+import { PhysicsBody, PhysicsShape, PhysicsShapeCapsule, PhysicsRaycastResult, PhysicsMotionType, PhysicsShapeContainer, ShapeCastResult, PhysicsShapeMesh, PhysicsShapeConvexHull, PhysicsShapeBox, PhysicsShapeSphere, PhysicsShapeCylinder, PhysicsMaterialCombineMode, PhysicsShapeType } from '@babylonjs/core/Physics';
 import { HavokPlugin } from '@babylonjs/core/Physics/v2/Plugins/havokPlugin';
 import { GLTFLoader, ArrayItem } from '@babylonjs/loaders/glTF/2.0/glTFLoader';
 import { Texture } from '@babylonjs/core/Materials/Textures/texture';
@@ -75,13 +75,11 @@ import { GPUParticleSystem } from '@babylonjs/core/Particles/gpuParticleSystem';
 import { AdvancedDynamicTexture } from '@babylonjs/gui/2D/advancedDynamicTexture';
 import { InputText } from '@babylonjs/gui/2D/controls/inputText';
 import { VideoTexture } from '@babylonjs/core/Materials/Textures/videoTexture';
-import { UniversalTerrainMaterial, UniversalTerrainMaterialPlugin } from './universalterrainmaterial';
-import { TreeBranchMaterial, TreeBranchMaterialPlugin } from './treebranchmaterial';
 import { UnitySlider } from './unityslider';
 import { UnityScrollBar } from './unityscrollbar';
 import { UnityDropdownMenu } from './unitydropdownmenu';
 export class SceneManager {
-    static get Version() { return "9.0.1 - R1"; }
+    static get Version() { return "9.5.0 - R1"; }
     static get Copyright() { return "All rights reserved (c) 2024 Mackey Kinard"; }
     static GetEngine(scene) {
         let result = null;
@@ -117,16 +115,17 @@ export class SceneManager {
     }
     static get PlaygroundCdn() { return "https://cdn.jsdelivr.net/gh/BabylonJS/BabylonToolkit@master/Runtime/"; }
     static get PlaygroundRepo() { return "https://www.babylontoolkit.com/playground/"; }
-    static async InitializePlayground(engine, options = null) {
-        return SceneManager.InitializeRuntime(engine, options);
+    static async InitializePlayground(engine, options = null, scene = null, inputOptions = null) {
+        return SceneManager.InitializeRuntime(engine, options, scene, inputOptions);
     }
-    static async InitializeRuntime(engine, options = null) {
+    static async InitializeRuntime(engine, options = null, scene = null, inputOptions = null) {
         Tools.Log("Babylon.js Toolkit v" + SceneManager.Version);
         if (AudioSource.IsLegacyEngine())
             Tools.Log("Legacy audio engine detected");
         const hardwareScalingLevel = (options != null && options.hardwareScalingLevel != null) ? options.hardwareScalingLevel : WindowManager.GetHardwareScalingLevel();
         const initSceneFileLoaders = (options != null && options.initSceneFileLoaders != null) ? options.initSceneFileLoaders : true;
         const loadAsyncRuntimeLibs = (options != null && options.loadAsyncRuntimeLibs != null) ? options.loadAsyncRuntimeLibs : true;
+        const enableUserInput = (options != null && options.enableUserInput != null) ? options.enableUserInput : false;
         const defaultProjectScriptBundle = (SceneManager.PlaygroundCdn + "default.playground.js");
         const loadProjectScriptBundle = (options != null && options.loadProjectScriptBundle != null) ? options.loadProjectScriptBundle : false;
         const projectScriptBundleUrl = (options != null && options.projectScriptBundleUrl != null) ? options.projectScriptBundleUrl : defaultProjectScriptBundle;
@@ -137,6 +136,8 @@ export class SceneManager {
             SceneManager.ShowLoadingScreen(engine, hideLoadingUIWithEngine, defaultLoadingUIMarginTop);
         if (hardwareScalingLevel != null && hardwareScalingLevel > 0)
             engine.setHardwareScalingLevel(hardwareScalingLevel);
+        if (enableUserInput === true)
+            InputController.EnableUserInput(engine, scene, inputOptions);
         SceneManager.UniversalModuleDefinition = false;
         try {
             SceneManager.InitializeSceneLoaderPlugin();
@@ -369,38 +370,6 @@ export class SceneManager {
             }
         });
     }
-    static NavigateTo(scene, route, options = null, useWindowLocation = false) {
-        if (useWindowLocation === true) {
-            if (options?.replace === true) {
-                window.location.replace(route);
-            }
-            else {
-                window.location.assign(route);
-            }
-            return;
-        }
-        if (scene.reactNavigationFunction != null) {
-            const navOptions = { ...options, state: { ...(options?.state || {}), fromApp: true } };
-            scene.reactNavigationFunction(route, navOptions);
-        }
-        else {
-            console.warn("React navigation hook is not set on the scene.");
-        }
-    }
-    static SetReactNavigationHook(scene, navigateToFunction) {
-        scene.reactNavigationFunction = navigateToFunction;
-    }
-    static DeleteReactNavigationHook(scene) {
-        if (scene.reactNavigationFunction != null) {
-            scene.reactNavigationFunction = null;
-            try {
-                delete scene.reactNavigationFunction;
-            }
-            catch (e) {
-                console.warn(e);
-            }
-        }
-    }
     static EnableSceneParsing(enabled) {
         SceneManager.SceneParsingEnabled = enabled;
     }
@@ -3213,6 +3182,11 @@ export class ScriptComponent {
         return result;
     }
 }
+export class GameModeController extends ScriptComponent {
+    constructor(transform, scene, properties = {}, alias = null) {
+        super(transform, scene, properties, alias);
+    }
+}
 export var System;
 (function (System) {
     System[System["Deg2Rad"] = (Math.PI * 2 / 360)] = "Deg2Rad";
@@ -9263,6 +9237,643 @@ Utilities.LoadingState = -1;
 Utilities.OnPreloaderProgress = null;
 Utilities.OnPreloaderComplete = null;
 Utilities.LoaderItemsMarkedForDisposal = [];
+export class UniversalTerrainMaterial extends CustomShaderMaterial {
+    constructor(name, scene) {
+        super(name, scene);
+        this.terrainInfo = null;
+        this.shader = this.getShaderName();
+        this.plugin = new UniversalTerrainMaterialPlugin(this, this.shader);
+    }
+    awake() {
+    }
+    update() {
+    }
+    getShaderName() {
+        return "UniversalTerrainMaterial";
+    }
+    getTerrainInfo() {
+        return this.terrainInfo;
+    }
+}
+export class UniversalTerrainMaterialPlugin extends CustomShaderMaterialPlugin {
+    constructor(customMaterial, shaderName) {
+        super(customMaterial, shaderName, 100, { UNIVERSALTERRAINMATERIAL: false }, true, true, false);
+        this.colorName = "surfaceAlbedo";
+        this.splatmapSampler = "splatmapSampler";
+        this.detailsSampler = "detailsSampler";
+        this.normalsSampler = "normalsSampler";
+        this.GLSL_CustomFragment = null;
+        this.GLSL_CustomVertex = null;
+        this.GLSL_VertexMainEnd = null;
+        this.GLSL_FragmentUpdateColor = null;
+        this.WGSL_CustomFragment = null;
+        this.WGSL_CustomVertex = null;
+        this.WGSL_VertexMainEnd = null;
+        this.WGSL_FragmentUpdateColor = null;
+    }
+    isCompatible(shaderLanguage) {
+        return (shaderLanguage === ShaderLanguage.WGSL || shaderLanguage === ShaderLanguage.GLSL);
+    }
+    getClassName() {
+        return "UniversalTerrainMaterialPlugin";
+    }
+    getCustomCode(shaderType, shaderLanguage) {
+        const terrainInfo = this.getCustomShaderMaterial().getTerrainInfo();
+        if (shaderType === "vertex") {
+            if (shaderLanguage === ShaderLanguage.WGSL) {
+                if (this.WGSL_CustomVertex == null)
+                    this.WGSL_CustomVertex = this.WGSL_FormatTerrainVertexDefintions(terrainInfo);
+                if (this.WGSL_VertexMainEnd == null)
+                    this.WGSL_VertexMainEnd = this.WGSL_FormatTerrainVertexMainEnd(terrainInfo);
+                return {
+                    CUSTOM_VERTEX_DEFINITIONS: this.WGSL_CustomVertex,
+                    CUSTOM_VERTEX_MAIN_END: this.WGSL_VertexMainEnd,
+                };
+            }
+            else if (shaderLanguage === ShaderLanguage.GLSL) {
+                if (this.GLSL_CustomVertex == null)
+                    this.GLSL_CustomVertex = this.GLSL_FormatTerrainVertexDefintions(terrainInfo);
+                if (this.GLSL_VertexMainEnd == null)
+                    this.GLSL_VertexMainEnd = this.GLSL_FormatTerrainVertexMainEnd(terrainInfo);
+                return {
+                    CUSTOM_VERTEX_DEFINITIONS: this.GLSL_CustomVertex,
+                    CUSTOM_VERTEX_MAIN_END: this.GLSL_VertexMainEnd,
+                };
+            }
+        }
+        else if (shaderType === "fragment") {
+            if (shaderLanguage === ShaderLanguage.WGSL) {
+                if (this.WGSL_CustomFragment == null)
+                    this.WGSL_CustomFragment = this.WGSL_FormatTerrainFragmentDefintions(terrainInfo, this.splatmapSampler, this.detailsSampler, this.normalsSampler);
+                if (this.WGSL_FragmentUpdateColor == null)
+                    this.WGSL_FragmentUpdateColor = this.WGSL_FormatTerrainFragmentUpdateColor(terrainInfo, this.colorName, this.splatmapSampler, this.detailsSampler, this.normalsSampler, SceneManager.TerrainColorCorrection);
+                return {
+                    CUSTOM_FRAGMENT_DEFINITIONS: this.WGSL_CustomFragment,
+                    CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.WGSL_FragmentUpdateColor,
+                };
+            }
+            else if (shaderLanguage === ShaderLanguage.GLSL) {
+                if (this.GLSL_CustomFragment == null)
+                    this.GLSL_CustomFragment = this.GLSL_FormatTerrainFragmentDefintions(terrainInfo, this.splatmapSampler, this.detailsSampler, this.normalsSampler);
+                if (this.GLSL_FragmentUpdateColor == null)
+                    this.GLSL_FragmentUpdateColor = this.GLSL_FormatTerrainFragmentUpdateColor(terrainInfo, this.colorName, this.splatmapSampler, this.detailsSampler, this.normalsSampler, SceneManager.TerrainColorCorrection);
+                return {
+                    CUSTOM_FRAGMENT_DEFINITIONS: this.GLSL_CustomFragment,
+                    CUSTOM_FRAGMENT_BEFORE_LIGHTS: this.GLSL_FragmentUpdateColor,
+                };
+            }
+        }
+        return null;
+    }
+    getUniforms(shaderLanguage) {
+        const wgsl = (shaderLanguage === ShaderLanguage.WGSL);
+        this.vertexDefinitions = this.getCustomShaderMaterial().getCustomVertexCode(wgsl);
+        this.fragmentDefinitions = (wgsl === true) ? this.getCustomShaderMaterial().getCustomFragmentCode(wgsl) : null;
+        return this.getCustomShaderMaterial().getCustomUniforms(wgsl);
+    }
+    getSamplers(samplers) {
+        const customSamplers = this.getCustomShaderMaterial().getCustomSamplers();
+        if (customSamplers != null && customSamplers.length > 0)
+            samplers.push(...customSamplers);
+    }
+    getAttributes(attributes, scene, mesh) {
+        const customAttributes = this.getCustomShaderMaterial().getCustomAttributes();
+        if (customAttributes != null && customAttributes.length > 0)
+            attributes.push(...customAttributes);
+    }
+    prepareDefines(defines, scene, mesh) {
+        if (!this.getIsEnabled())
+            return;
+        this.getCustomShaderMaterial().prepareCustomDefines(defines);
+    }
+    bindForSubMesh(uniformBuffer, scene, engine, subMesh) {
+        if (!this.getIsEnabled())
+            return;
+        this.getCustomShaderMaterial().updateCustomBindings(uniformBuffer);
+    }
+    WGSL_FormatTerrainVertexDefintions(terrainInfo) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_VERTEX_DEFINITIONS\r\n\r\n"
+                + "#define TERRAIN_VERTEX_DEFINITIONS\r\n\r\n"
+                + "varying vSplatmapUV: vec2<f32>;\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    WGSL_FormatTerrainVertexMainEnd(terrainInfo) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_VERTEX_MAIN_END\r\n\r\n"
+                + "#define TERRAIN_VERTEX_MAIN_END\r\n\r\n"
+                + "#ifdef UV1\r\n"
+                + "vertexOutputs.vSplatmapUV = uvUpdated;\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    WGSL_FormatTerrainFragmentDefintions(terrainInfo, splatmapSampler, detailsSampler, normalsSampler) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_FRAGMENT_DEFNITIONS\r\n\r\n"
+                + "#define TERRAIN_FRAGMENT_DEFNITIONS\r\n\r\n"
+                + "varying vSplatmapUV: vec2<f32>;\r\n"
+                + "\r\n"
+                + "fn srgb_to_linear(c: vec3<f32>) -> vec3<f32>\r\n"
+                + "{\r\n"
+                + "    return pow(c, vec3<f32>(2.2));\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "fn linear_to_srgb(c: vec3<f32>) -> vec3<f32>\r\n"
+                + "{\r\n"
+                + "    return pow(c, vec3<f32>(1.0 / 2.2));\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "fn calculateMipmapLevel(uvs: vec2<f32>, size: vec2<f32>) -> f32\r\n"
+                + "{\r\n"
+                + "    let dx: vec2<f32> = dpdx(uvs * size.x);\r\n"
+                + "    let dy: vec2<f32> = dpdy(uvs * size.y);\r\n"
+                + "    let d: f32 = max(dot(dx, dx), dot(dy, dy));\r\n"
+                + "    return (0.4 * log2(d));\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "fn sampleTextureAtlas2D(atlas: texture_2d<f32>, sampler: sampler, gamma: f32, tile: vec2<f32>, rect: vec4<f32>, uvs: vec2<f32>, lod: f32) -> vec4<f32>\r\n"
+                + "{\r\n"
+                + "    var level: f32 = lod;\r\n"
+                + "    if (level < 0.0) {\r\n"
+                + "        level = clamp(calculateMipmapLevel(uvs, vec2(tile.x, tile.x)), 0.0, tile.y);\r\n"
+                + "    }\r\n"
+                + "    let size: f32 = pow(2.0, tile.y - level);\r\n"
+                + "    let sizex: f32 = size / rect.z;\r\n"
+                + "    let sizey: f32 = size / rect.w;\r\n"
+                + "    var uv: vec2<f32> = fract(uvs);\r\n"
+                + "    uv.x = uv.x * ((sizex * rect.z - 1.0) / sizex) + 0.5 / sizex + rect.z * rect.x;\r\n"
+                + "    uv.y = uv.y * ((sizey * rect.w - 1.0) / sizey) + 0.5 / sizey + rect.w * rect.y;\r\n"
+                + "    var color: vec4<f32> = textureSampleLevel(atlas, sampler, uv, level);\r\n"
+                + "    if (gamma != 1.0) {\r\n"
+                + "        color.r = pow(color.r, gamma);\r\n"
+                + "        color.g = pow(color.g, gamma);\r\n"
+                + "        color.b = pow(color.b, gamma);\r\n"
+                + "    }\r\n"
+                + "    return color;\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "fn sampleSplatmapAtlas2D(atlas: texture_2d<f32>, sampler: sampler, tile: vec2<f32>, rect: vec4<f32>, uvs: vec2<f32>) -> vec4<f32>\r\n"
+                + "{\r\n"
+                + "    let size: f32 = pow(2.0, tile.y);\r\n"
+                + "	   let sizex: f32 = size / rect.z;\r\n"
+                + "	   let sizey: f32 = size / rect.w;\r\n"
+                + "	   var uv: vec2<f32> = uvs;\r\n"
+                + "	   uv.x = uv.x * ((sizex * rect.z - 1.0) / sizex) + 0.5 / sizex + rect.z * rect.x;\r\n"
+                + "	   uv.y = uv.y * ((sizey * rect.w - 1.0) / sizey) + 0.5 / sizey + rect.w * rect.y;\r\n"
+                + "    return textureSample(atlas, sampler, uv);\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "fn blendSplatmapAtlasColors(splatmap: vec4<f32>, color1: vec4<f32>, color2: vec4<f32>, color3: vec4<f32>, color4: vec4<f32>, mixbuffer: vec3<f32>) -> vec3<f32>\r\n"
+                + "{\r\n"
+                + "    let buffer1: vec3<f32> = mix(mixbuffer, color1.rgb, splatmap.r);\r\n"
+                + "    let buffer2: vec3<f32> = mix(buffer1, color2.rgb, splatmap.g);\r\n"
+                + "    let buffer3: vec3<f32> = mix(buffer2, color3.rgb, splatmap.b);\r\n"
+                + "    return mix(buffer3, color4.rgb, splatmap.a);\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "fn perturbNormalSamplerColor(cotangentFrame: mat3x3<f32>, samplerColor: vec3<f32>, scale: f32) -> vec3<f32>\r\n"
+                + "{\r\n"
+                + "    var map: vec3<f32> = samplerColor.xyz;\r\n"
+                + "    map = map * 2.00787402 - 1.00787402;\r\n"
+                + "    #ifdef NORMALXYSCALE\r\n"
+                + "        map = normalize(map * vec3<f32>(scale, scale, 1.0));\r\n"
+                + "    #endif\r\n"
+                + "    return normalize(cotangentFrame * map);\r\n"
+                + "}\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    WGSL_FormatTerrainFragmentUpdateColor(terrainInfo, colorName, splatmapSampler, detailsSampler, normalsSampler, colorCorrection = 1.0) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_FRAGMENT_UPDATE_COLOR\r\n\r\n"
+                + "#define TERRAIN_FRAGMENT_UPDATE_COLOR\r\n\r\n"
+                + "var normalsColor: vec3<f32> = vec3<f32>(0.5, 0.5, 1.0);\r\n"
+                + "var normalsBuffer: vec3<f32> = normalW.rgb;\r\n"
+                + "var splatmapBuffer: vec3<f32> = " + colorName + ".rgb;\r\n"
+                + "var autoMipMapLevel: f32 = -1.0;\r\n"
+                + "var normalCorrection: f32 = 1.0;\r\n"
+                + "var detailCorrection: f32 = " + colorCorrection.toFixed(4) + ";\r\n"
+                + "\r\n"
+                + "#if defined(ALBEDO) && defined(" + splatmapSampler.toUpperCase() + ") && defined(" + detailsSampler.toUpperCase() + ")\r\n"
+                + "\r\n"
+                + "// Reset Normal Values\r\n"
+                + "#if defined(BUMP) || defined(PARALLAX) || defined(ANISOTROPIC)\r\n"
+                + "    uvOffset = vec2<f32>(0.0, 0.0);\r\n"
+                + "    #ifdef NORMAL\r\n"
+                + "        normalW = normalize(input.vNormalW);\r\n"
+                + "    #else\r\n"
+                + "        normalW = normalize(cross(dpdx(input.vPositionW), dpdy(input.vPositionW))) * scene.vEyePosition.w;\r\n"
+                + "    #endif\r\n"
+                + "    #ifdef CLEARCOAT\r\n"
+                + "        clearCoatNormalW = normalW;\r\n"
+                + "    #endif\r\n"
+                + "    #if defined(BUMP) || defined(PARALLAX)\r\n"
+                + "        #if defined(CLEARCOAT_BUMP) && defined(TANGENT) && defined(NORMAL)\r\n"
+                + "            TBN = vTBN;\r\n"
+                + "        #else\r\n"
+                + "            TBN = cotangent_frame(normalW, input.vPositionW, fragmentInputs.vSplatmapUV, vec2<f32>(1.0, 1.0));\r\n"
+                + "        #endif\r\n"
+                + "    #elif defined(ANISOTROPIC)\r\n"
+                + "        #if defined(CLEARCOAT_BUMP) && defined(TANGENT) && defined(NORMAL)\r\n"
+                + "            TBN = vTBN;\r\n"
+                + "        #else\r\n"
+                + "            TBN = cotangent_frame(normalW, input.vPositionW, fragmentInputs.vSplatmapUV, vec2<f32>(1.0, 1.0));\r\n"
+                + "        #endif\r\n"
+                + "    #endif\r\n"
+                + "    #ifdef PARALLAX\r\n"
+                + "        invTBN = transposeMat3(TBN);\r\n"
+                + "    #endif\r\n"
+                + "    normalW = perturbNormalSamplerColor(TBN, normalsColor, 1.0);\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "// Global Atlas Values\r\n"
+                + "let splatTileSize: f32 = " + terrainInfo.splatmapAtlas[2].toFixed(4) + ";\r\n"
+                + "let splatTileBits: f32 = " + terrainInfo.splatmapAtlas[3].toFixed(4) + ";\r\n"
+                + "let detailTileSize: f32 = " + terrainInfo.textureAtlas[2].toFixed(4) + ";\r\n"
+                + "let detailTileBits: f32 = " + terrainInfo.textureAtlas[3].toFixed(4) + ";\r\n"
+                + "\r\n"
+                + "// Sample splatmap textures\r\n");
+            if (terrainInfo.splatmapCount > 0) {
+                let counter = 0;
+                result += "normalsBuffer = vec3<f32>(0.0,0.0,0.0);\r\n";
+                for (let index = 0; index < terrainInfo.splatmapCount; index++) {
+                    counter = (index * 4);
+                    const splatmapRect = terrainInfo["splatmapRect" + index];
+                    result += "var splatmapRect" + index + ": vec4<f32> = vec4<f32>(" + splatmapRect[0].toFixed(4) + ", " + splatmapRect[1].toFixed(4) + ", " + splatmapRect[2].toFixed(4) + ", " + splatmapRect[3].toFixed(4) + ");\r\n";
+                    result += "var splatmapAlbedo" + index + ": vec4<f32> = sampleSplatmapAtlas2D(" + splatmapSampler + ", " + splatmapSampler + "Sampler, vec2<f32>(splatTileSize, splatTileBits), splatmapRect" + index + ", (fragmentInputs.vSplatmapUV + uvOffset));\r\n";
+                    result += "var textureAlbedo" + (counter + 0) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "var textureAlbedo" + (counter + 1) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "var textureAlbedo" + (counter + 2) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "var textureAlbedo" + (counter + 3) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    if (terrainInfo["textureRect" + (counter + 0)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 0)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 0)];
+                        result += "var textureRect" + (counter + 0) + ": vec4<f32> = vec4<f32>(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "var textureScale" + (counter + 0) + ": vec2<f32> = vec2<f32>(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "var textureOffset" + (counter + 0) + ": vec2<f32> = vec2<f32>(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "var textureTileUV" + (counter + 0) + ": vec2<f32> = ((fragmentInputs.vSplatmapUV + textureOffset" + (counter + 0) + ") * textureScale" + (counter + 0) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 0) + " = sampleTextureAtlas2D(" + detailsSampler + ", " + detailsSampler + "Sampler, detailCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 0) + ", textureTileUV" + (counter + 0) + ", autoMipMapLevel);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 1)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 1)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 1)];
+                        result += "var textureRect" + (counter + 1) + ": vec4<f32> = vec4<f32>(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "var textureScale" + (counter + 1) + ": vec2<f32> = vec2<f32>(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "var textureOffset" + (counter + 1) + ": vec2<f32> = vec2<f32>(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "var textureTileUV" + (counter + 1) + ": vec2<f32> = ((fragmentInputs.vSplatmapUV + textureOffset" + (counter + 1) + ") * textureScale" + (counter + 1) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 1) + " = sampleTextureAtlas2D(" + detailsSampler + ", " + detailsSampler + "Sampler, detailCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 1) + ", textureTileUV" + (counter + 1) + ", autoMipMapLevel);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 2)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 2)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 2)];
+                        result += "var textureRect" + (counter + 2) + ": vec4<f32> = vec4<f32>(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "var textureScale" + (counter + 2) + ": vec2<f32> = vec2<f32>(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "var textureOffset" + (counter + 2) + ": vec2<f32> = vec2<f32>(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "var textureTileUV" + (counter + 2) + ": vec2<f32> = ((fragmentInputs.vSplatmapUV + textureOffset" + (counter + 2) + ") * textureScale" + (counter + 2) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 2) + " = sampleTextureAtlas2D(" + detailsSampler + ", " + detailsSampler + "Sampler, detailCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 2) + ", textureTileUV" + (counter + 2) + ", autoMipMapLevel);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 3)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 3)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 3)];
+                        result += "var textureRect" + (counter + 3) + ": vec4<f32> = vec4<f32>(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "var textureScale" + (counter + 3) + ": vec2<f32> = vec2<f32>(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "var textureOffset" + (counter + 3) + ": vec2<f32> = vec2<f32>(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "var textureTileUV" + (counter + 3) + ": vec2<f32> = ((fragmentInputs.vSplatmapUV + textureOffset" + (counter + 3) + ") * textureScale" + (counter + 3) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 3) + " = sampleTextureAtlas2D(" + detailsSampler + ", " + detailsSampler + "Sampler, detailCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 3) + ", textureTileUV" + (counter + 3) + ", autoMipMapLevel);\r\n";
+                    }
+                    result += "splatmapBuffer = blendSplatmapAtlasColors(splatmapAlbedo" + index + ", textureAlbedo" + (counter + 0) + ", textureAlbedo" + (counter + 1) + ", textureAlbedo" + (counter + 2) + ", textureAlbedo" + (counter + 3) + ", splatmapBuffer);\r\n";
+                    result += "#if defined(BUMP) || defined(PARALLAX) || defined(ANISOTROPIC)\r\n";
+                    result += "    #if defined(" + normalsSampler.toUpperCase() + ")\r\n";
+                    result += "        var normalColor" + (counter + 0) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "        var normalColor" + (counter + 1) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "        var normalColor" + (counter + 2) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "        var normalColor" + (counter + 3) + ": vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 1.0);\r\n";
+                    if (terrainInfo["textureRect" + (counter + 0)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 0)];
+                        result += "        var normalScale" + (counter + 0) + ": f32 = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 0) + " = sampleTextureAtlas2D(" + normalsSampler + ", " + normalsSampler + "Sampler, normalCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 0) + ", textureTileUV" + (counter + 0) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 0) + " = vec4<f32>(perturbNormalSamplerColor(TBN, normalColor" + (counter + 0) + ".rgb, normalScale" + (counter + 0) + "), 1.0);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 1)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 1)];
+                        result += "        var normalScale" + (counter + 1) + ": f32 = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 1) + " = sampleTextureAtlas2D(" + normalsSampler + ", " + normalsSampler + "Sampler, normalCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 1) + ", textureTileUV" + (counter + 1) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 1) + " = vec4<f32>(perturbNormalSamplerColor(TBN, normalColor" + (counter + 1) + ".rgb, normalScale" + (counter + 1) + "), 1.0);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 2)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 2)];
+                        result += "        var normalScale" + (counter + 2) + ": f32 = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 2) + " = sampleTextureAtlas2D(" + normalsSampler + ", " + normalsSampler + "Sampler, normalCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 2) + ", textureTileUV" + (counter + 2) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 2) + " = vec4<f32>(perturbNormalSamplerColor(TBN, normalColor" + (counter + 2) + ".rgb, normalScale" + (counter + 2) + "), 1.0);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 3)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 3)];
+                        result += "        var normalScale" + (counter + 3) + ": f32 = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 3) + " = sampleTextureAtlas2D(" + normalsSampler + ", " + normalsSampler + "Sampler, normalCorrection, vec2<f32>(detailTileSize, detailTileBits), textureRect" + (counter + 3) + ", textureTileUV" + (counter + 3) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 3) + " = vec4<f32>(perturbNormalSamplerColor(TBN, normalColor" + (counter + 3) + ".rgb, normalScale" + (counter + 3) + "), 1.0);\r\n";
+                    }
+                    result += "        normalsBuffer = blendSplatmapAtlasColors(splatmapAlbedo" + index + ", normalColor" + (counter + 0) + ", normalColor" + (counter + 1) + ", normalColor" + (counter + 2) + ", normalColor" + (counter + 3) + ", normalsBuffer);\r\n";
+                    result += "    #endif\r\n";
+                    result += "#endif\r\n";
+                    result += "\r\n";
+                }
+            }
+            result += ("// Update Color Values\r\n"
+                + colorName + " = splatmapBuffer.rgb;\r\n"
+                + "#if defined(BUMP) || defined(PARALLAX) || defined(ANISOTROPIC)\r\n"
+                + "    #if defined(" + normalsSampler.toUpperCase() + ")\r\n"
+                + "        normalW = normalsBuffer.rgb;\r\n"
+                + "    #endif\r\n"
+                + "    #if defined(FORCENORMALFORWARD) && defined(NORMAL)\r\n"
+                + "        var faceNormal: vec3<f32> = normalize(cross(dpdx(input.vPositionW), dpdy(input.vPositionW))) * scene.vEyePosition.w;\r\n"
+                + "        #if defined(TWOSIDEDLIGHTING)\r\n"
+                + "            faceNormal = select(-faceNormal, faceNormal, fragmentInputs.frontFacing)\r\n"
+                + "        #endif\r\n"
+                + "        normalW *= sign(dot(normalW, faceNormal));\r\n"
+                + "    #endif\r\n"
+                + "    #if defined(TWOSIDEDLIGHTING) && defined(NORMAL)\r\n"
+                + "        normalW = select(-normalW, normalW, fragmentInputs.frontFacing);\r\n"
+                + "    #endif\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    GLSL_FormatTerrainVertexDefintions(terrainInfo) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_VERTEX_DEFINITIONS\r\n\r\n"
+                + "#define TERRAIN_VERTEX_DEFINITIONS\r\n\r\n"
+                + "varying vec2 vSplatmapUV;\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    GLSL_FormatTerrainVertexMainEnd(terrainInfo) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_VERTEX_MAIN_END\r\n\r\n"
+                + "#define TERRAIN_VERTEX_MAIN_END\r\n\r\n"
+                + "#ifdef UV1\r\n"
+                + "vSplatmapUV = uv;\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    GLSL_FormatTerrainFragmentDefintions(terrainInfo, splatmapSampler, detailsSampler, normalsSampler) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_FRAGMENT_DEFNITIONS\r\n\r\n"
+                + "#define TERRAIN_FRAGMENT_DEFNITIONS\r\n\r\n"
+                + "varying vec2 vSplatmapUV;\r\n"
+                + "\r\n"
+                + "vec3 srgb_to_linear(const in vec3 c)\r\n"
+                + "{\r\n"
+                + "    return pow(c, vec3(2.2));\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "vec3 linear_to_srgb(const in vec3 c)\r\n"
+                + "{\r\n"
+                + "    return pow(c, vec3(1.0 / 2.2));\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "float calculateMipmapLevel(const in vec2 uvs, const in vec2 size)\r\n"
+                + "{\r\n"
+                + "    vec2 dx = dFdx(uvs * size.x);\r\n"
+                + "    vec2 dy = dFdy(uvs * size.y);\r\n"
+                + "    float d = max(dot(dx, dx), dot(dy, dy));\r\n"
+                + "    return 0.4 * log2(d);\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "vec4 sampleTextureAtlas2D(const in sampler2D atlas, const in float gamma, const in vec2 tile, const in vec4 rect, in vec2 uvs, in float lod)\r\n"
+                + "{\r\n"
+                + "    if (lod < 0.0) lod = clamp(calculateMipmapLevel(uvs, vec2(tile.x, tile.x)), 0.0, tile.y);   // Tile Info (tile.xy)\r\n"
+                + "    float size = pow(2.0, tile.y - lod);                                                        // Tile Bits (tile.y)\r\n"
+                + "    float sizex = size / rect.z;                                                                // Tile Width (rect.z)\r\n"
+                + "    float sizey = size / rect.w;                                                                // Tile Height (rect.w)\r\n"
+                + "    uvs = fract(uvs);                                                                           // Perfrom Tiling (fract)\r\n"
+                + "    uvs.x = uvs.x * ((sizex * rect.z - 1.0) / sizex) + 0.5 / sizex + rect.z * rect.x;           // Tile Position X (rect.x)\r\n"
+                + "    uvs.y = uvs.y * ((sizey * rect.w - 1.0) / sizey) + 0.5 / sizey + rect.w * rect.y;           // Tile Position Y (rect.y)\r\n"
+                + "    vec4 color = texture2DLodEXT(atlas, uvs, lod);\r\n"
+                + "    if (gamma != 1.0) {\r\n"
+                + "        color.r = pow(color.r, gamma);\r\n"
+                + "        color.g = pow(color.g, gamma);\r\n"
+                + "        color.b = pow(color.b, gamma);\r\n"
+                + "    }\r\n"
+                + "    return color;\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "vec4 sampleSplatmapAtlas2D(const in sampler2D atlas, const in vec2 tile, const in vec4 rect, in vec2 uvs)\r\n"
+                + "{\r\n"
+                + "    float size = pow(2.0, tile.y);                                                              // Tile Bits (tile.y)\r\n"
+                + "	   float sizex = size / rect.z;                                                                // Tile Width (rect.z)\r\n"
+                + "	   float sizey = size / rect.w;                                                                // Tile Height (rect.w)\r\n"
+                + "	   uvs.x = uvs.x * ((sizex * rect.z - 1.0) / sizex) + 0.5 / sizex + rect.z * rect.x;           // Tile Position X (rect.x)\r\n"
+                + "	   uvs.y = uvs.y * ((sizey * rect.w - 1.0) / sizey) + 0.5 / sizey + rect.w * rect.y;           // Tile Position Y (rect.y)\r\n"
+                + "    return texture2D(atlas, uvs);\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "vec3 blendSplatmapAtlasColors(const in vec4 splatmap, in vec4 color1, in vec4 color2, in vec4 color3, in vec4 color4, in vec3 mixbuffer)\r\n"
+                + "{\r\n"
+                + "    vec3 buffer1 = mix(mixbuffer, color1.rgb, splatmap.r);\r\n"
+                + "    vec3 buffer2 = mix(buffer1, color2.rgb, splatmap.g);\r\n"
+                + "    vec3 buffer3 = mix(buffer2, color3.rgb, splatmap.b);\r\n"
+                + "    return mix(buffer3, color4.rgb, splatmap.a);\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "vec3 perturbNormalSamplerColor(mat3 cotangentFrame, vec3 samplerColor, float scale)\r\n"
+                + "{\r\n"
+                + "    vec3 map = samplerColor.xyz;\r\n"
+                + "    map = map * 2.00787402 - 1.00787402;\r\n"
+                + "    #ifdef NORMALXYSCALE\r\n"
+                + "        map = normalize(map * vec3(scale, scale, 1.0));\r\n"
+                + "    #endif\r\n"
+                + "    return normalize(cotangentFrame * map);\r\n"
+                + "}\r\n"
+                + "\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+    GLSL_FormatTerrainFragmentUpdateColor(terrainInfo, colorName, splatmapSampler, detailsSampler, normalsSampler, colorCorrection = 1.0) {
+        let result = "";
+        if (terrainInfo != null && terrainInfo.textureAtlas != null && terrainInfo.splatmapAtlas != null && terrainInfo.splatmapCount > 0) {
+            result = ("\r\n#ifndef TERRAIN_FRAGMENT_UPDATE_COLOR\r\n\r\n"
+                + "#define TERRAIN_FRAGMENT_UPDATE_COLOR\r\n\r\n"
+                + "vec3 normalsColor = vec3(0.5, 0.5, 1.0);\r\n"
+                + "vec3 normalsBuffer = normalW.rgb;\r\n"
+                + "vec3 splatmapBuffer = " + colorName + ".rgb;\r\n"
+                + "float autoMipMapLevel = -1.0;\r\n"
+                + "float normalCorrection = 1.0;\r\n"
+                + "float detailCorrection = " + colorCorrection.toFixed(4) + ";\r\n"
+                + "\r\n"
+                + "#if defined(ALBEDO) && defined(" + splatmapSampler.toUpperCase() + ") && defined(" + detailsSampler.toUpperCase() + ")\r\n"
+                + "\r\n"
+                + "// Reset Normal Values\r\n"
+                + "#if defined(BUMP) || defined(PARALLAX) || defined(ANISOTROPIC)\r\n"
+                + "    uvOffset = vec2(0.0, 0.0);\r\n"
+                + "    #ifdef NORMAL\r\n"
+                + "        normalW = normalize(vNormalW);\r\n"
+                + "    #else\r\n"
+                + "        normalW = normalize(cross(dFdx(vPositionW), dFdy(vPositionW))) * vEyePosition.w;\r\n"
+                + "    #endif\r\n"
+                + "    #ifdef CLEARCOAT\r\n"
+                + "        clearCoatNormalW = normalW;\r\n"
+                + "    #endif\r\n"
+                + "    #if defined(BUMP) || defined(PARALLAX)\r\n"
+                + "        #if defined(TANGENT) && defined(NORMAL)\r\n"
+                + "            TBN = vTBN;\r\n"
+                + "        #else\r\n"
+                + "            TBN = cotangent_frame(normalW, vPositionW, vSplatmapUV);\r\n"
+                + "        #endif\r\n"
+                + "    #elif defined(ANISOTROPIC)\r\n"
+                + "        #if defined(TANGENT) && defined(NORMAL)\r\n"
+                + "            TBN = vTBN;\r\n"
+                + "        #else\r\n"
+                + "            TBN = cotangent_frame(normalW, vPositionW, vSplatmapUV, vec2(1.0, 1.0));\r\n"
+                + "        #endif\r\n"
+                + "    #endif\r\n"
+                + "    #ifdef PARALLAX\r\n"
+                + "        invTBN = transposeMat3(TBN);\r\n"
+                + "    #endif\r\n"
+                + "    normalW = perturbNormalSamplerColor(TBN, normalsColor, 1.0);\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "// Global Atlas Values\r\n"
+                + "float splatTileSize = " + terrainInfo.splatmapAtlas[2].toFixed(4) + ";\r\n"
+                + "float splatTileBits = " + terrainInfo.splatmapAtlas[3].toFixed(4) + ";\r\n"
+                + "float detailTileSize = " + terrainInfo.textureAtlas[2].toFixed(4) + ";\r\n"
+                + "float detailTileBits = " + terrainInfo.textureAtlas[3].toFixed(4) + ";\r\n"
+                + "\r\n"
+                + "// Sample splatmap textures\r\n");
+            if (terrainInfo.splatmapCount > 0) {
+                let counter = 0;
+                result += "normalsBuffer = vec3(0.0,0.0,0.0);\r\n";
+                for (let index = 0; index < terrainInfo.splatmapCount; index++) {
+                    counter = (index * 4);
+                    const splatmapRect = terrainInfo["splatmapRect" + index];
+                    result += "vec4 splatmapRect" + index + " = vec4(" + splatmapRect[0].toFixed(4) + ", " + splatmapRect[1].toFixed(4) + ", " + splatmapRect[2].toFixed(4) + ", " + splatmapRect[3].toFixed(4) + ");\r\n";
+                    result += "vec4 splatmapAlbedo" + index + " = sampleSplatmapAtlas2D(" + splatmapSampler + ", vec2(splatTileSize, splatTileBits), splatmapRect" + index + ", (vSplatmapUV + uvOffset));\r\n";
+                    result += "vec4 textureAlbedo" + (counter + 0) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "vec4 textureAlbedo" + (counter + 1) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "vec4 textureAlbedo" + (counter + 2) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "vec4 textureAlbedo" + (counter + 3) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    if (terrainInfo["textureRect" + (counter + 0)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 0)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 0)];
+                        result += "vec4 textureRect" + (counter + 0) + " = vec4(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureScale" + (counter + 0) + " = vec2(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "vec2 textureOffset" + (counter + 0) + " = vec2(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureTileUV" + (counter + 0) + " = ((vSplatmapUV + textureOffset" + (counter + 0) + ") * textureScale" + (counter + 0) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 0) + " = sampleTextureAtlas2D(" + detailsSampler + ", detailCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 0) + ", textureTileUV" + (counter + 0) + ", autoMipMapLevel);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 1)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 1)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 1)];
+                        result += "vec4 textureRect" + (counter + 1) + " = vec4(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureScale" + (counter + 1) + " = vec2(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "vec2 textureOffset" + (counter + 1) + " = vec2(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureTileUV" + (counter + 1) + " = ((vSplatmapUV + textureOffset" + (counter + 1) + ") * textureScale" + (counter + 1) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 1) + " = sampleTextureAtlas2D(" + detailsSampler + ", detailCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 1) + ", textureTileUV" + (counter + 1) + ", autoMipMapLevel);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 2)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 2)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 2)];
+                        result += "vec4 textureRect" + (counter + 2) + " = vec4(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureScale" + (counter + 2) + " = vec2(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "vec2 textureOffset" + (counter + 2) + " = vec2(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureTileUV" + (counter + 2) + " = ((vSplatmapUV + textureOffset" + (counter + 2) + ") * textureScale" + (counter + 2) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 2) + " = sampleTextureAtlas2D(" + detailsSampler + ", detailCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 2) + ", textureTileUV" + (counter + 2) + ", autoMipMapLevel);\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 3)]) {
+                        const textureRect = terrainInfo["textureRect" + (counter + 3)];
+                        const textureInfo = terrainInfo["textureInfo" + (counter + 3)];
+                        result += "vec4 textureRect" + (counter + 3) + " = vec4(" + textureRect[0].toFixed(4) + ", " + textureRect[1].toFixed(4) + ", " + textureRect[2].toFixed(4) + ", " + textureRect[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureScale" + (counter + 3) + " = vec2(" + textureInfo[0].toFixed(4) + ", " + textureInfo[1].toFixed(4) + ");\r\n";
+                        result += "vec2 textureOffset" + (counter + 3) + " = vec2(" + textureInfo[2].toFixed(4) + ", " + textureInfo[3].toFixed(4) + ");\r\n";
+                        result += "vec2 textureTileUV" + (counter + 3) + " = ((vSplatmapUV + textureOffset" + (counter + 3) + ") * textureScale" + (counter + 3) + ");\r\n";
+                        result += "textureAlbedo" + (counter + 3) + " = sampleTextureAtlas2D(" + detailsSampler + ", detailCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 3) + ", textureTileUV" + (counter + 3) + ", autoMipMapLevel);\r\n";
+                    }
+                    result += "splatmapBuffer = blendSplatmapAtlasColors(splatmapAlbedo" + index + ", textureAlbedo" + (counter + 0) + ", textureAlbedo" + (counter + 1) + ", textureAlbedo" + (counter + 2) + ", textureAlbedo" + (counter + 3) + ", splatmapBuffer);\r\n";
+                    result += "#if defined(BUMP) || defined(PARALLAX) || defined(ANISOTROPIC)\r\n";
+                    result += "    #if defined(" + normalsSampler.toUpperCase() + ")\r\n";
+                    result += "        vec4 normalColor" + (counter + 0) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "        vec4 normalColor" + (counter + 1) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "        vec4 normalColor" + (counter + 2) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    result += "        vec4 normalColor" + (counter + 3) + " = vec4(0.0, 0.0, 0.0, 1.0);\r\n";
+                    if (terrainInfo["textureRect" + (counter + 0)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 0)];
+                        result += "        float normalScale" + (counter + 0) + " = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 0) + " = sampleTextureAtlas2D(" + normalsSampler + ", normalCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 0) + ", textureTileUV" + (counter + 0) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 0) + ".rgb = perturbNormalSamplerColor(TBN, normalColor" + (counter + 0) + ".rgb, normalScale" + (counter + 0) + ");\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 1)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 1)];
+                        result += "        float normalScale" + (counter + 1) + " = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 1) + " = sampleTextureAtlas2D(" + normalsSampler + ", normalCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 1) + ", textureTileUV" + (counter + 1) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 1) + ".rgb = perturbNormalSamplerColor(TBN, normalColor" + (counter + 1) + ".rgb, normalScale" + (counter + 1) + ");\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 2)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 2)];
+                        result += "        float normalScale" + (counter + 2) + " = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 2) + " = sampleTextureAtlas2D(" + normalsSampler + ", normalCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 2) + ", textureTileUV" + (counter + 2) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 2) + ".rgb = perturbNormalSamplerColor(TBN, normalColor" + (counter + 2) + ".rgb, normalScale" + (counter + 2) + ");\r\n";
+                    }
+                    if (terrainInfo["textureRect" + (counter + 3)]) {
+                        const normalScale = terrainInfo["normalsScale" + (counter + 3)];
+                        result += "        float normalScale" + (counter + 3) + " = " + normalScale.toFixed(4) + ";\r\n";
+                        result += "        normalColor" + (counter + 3) + " = sampleTextureAtlas2D(" + normalsSampler + ", normalCorrection, vec2(detailTileSize, detailTileBits), textureRect" + (counter + 3) + ", textureTileUV" + (counter + 3) + ", autoMipMapLevel);\r\n";
+                        result += "        normalColor" + (counter + 3) + ".rgb = perturbNormalSamplerColor(TBN, normalColor" + (counter + 3) + ".rgb, normalScale" + (counter + 3) + ");\r\n";
+                    }
+                    result += "        normalsBuffer = blendSplatmapAtlasColors(splatmapAlbedo" + index + ", normalColor" + (counter + 0) + ", normalColor" + (counter + 1) + ", normalColor" + (counter + 2) + ", normalColor" + (counter + 3) + ", normalsBuffer);\r\n";
+                    result += "    #endif\r\n";
+                    result += "#endif\r\n";
+                    result += "\r\n";
+                }
+            }
+            result += ("// Update Color Values\r\n"
+                + colorName + " = splatmapBuffer.rgb;\r\n"
+                + "#if defined(BUMP) || defined(PARALLAX) || defined(ANISOTROPIC)\r\n"
+                + "    #if defined(" + normalsSampler.toUpperCase() + ")\r\n"
+                + "        normalW = normalsBuffer.rgb;\r\n"
+                + "    #endif\r\n"
+                + "    #if defined(FORCENORMALFORWARD) && defined(NORMAL)\r\n"
+                + "        vec3 faceNormal = normalize(cross(dFdx(vPositionW), dFdy(vPositionW))) * vEyePosition.w;\r\n"
+                + "        #if defined(TWOSIDEDLIGHTING)\r\n"
+                + "            faceNormal = gl_FrontFacing ? faceNormal : -faceNormal;\r\n"
+                + "        #endif\r\n"
+                + "        normalW *= sign(dot(normalW, faceNormal));\r\n"
+                + "    #endif\r\n"
+                + "    #if defined(TWOSIDEDLIGHTING) && defined(NORMAL)\r\n"
+                + "        normalW = gl_FrontFacing ? normalW : -normalW;\r\n"
+                + "    #endif\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "#endif\r\n"
+                + "\r\n"
+                + "#endif\r\n\r\n");
+        }
+        return result;
+    }
+}
 export class GrassStandardMaterial extends StandardShaderMaterial {
     constructor(name, scene) {
         super(name, scene);
@@ -10365,6 +10976,372 @@ export class GrassBillboardMaterialPlugin extends StandardShaderMaterialPlugin {
         this.getCustomShaderMaterial().updateCustomBindings(uniformBuffer);
     }
 }
+export class TreeBranchMaterial extends CustomShaderMaterial {
+    constructor(name, scene) {
+        super(name, scene);
+        this._windTimeAccum = 0.0;
+        this.shader = this.getShaderName();
+        this.plugin = new TreeBranchMaterialPlugin(this, this.shader);
+        this.addFloatUniform("g_windTime", 0.0);
+        this.addFloatUniform("g_windAmount", 0.5);
+        this.addFloatUniform("g_windSpeed", 1.0);
+        this.addFloatUniform("g_windStrength", 0.5);
+        this.addVector4Uniform("g_windDirection", new Vector4(1.0, 0.0, 0.0, 0.0));
+        this.addFloatUniform("g_branchRootY", 0.0);
+        this.addFloatUniform("g_branchMaxAngle", 0.35);
+        this.addFloatUniform("g_branchMaxHeight", 2.0);
+        this.addFloatUniform("g_useVertexColorMask", 1.0);
+        this.addFloatUniform("g_spatialFrequency", 0.15);
+        this._windTimeAccum = 0.0;
+    }
+    awake() {
+    }
+    update() {
+        try {
+            const rawDt = SceneManager.GetDeltaSeconds(this.getScene());
+            const dt = Math.min(rawDt, 1 / 30);
+            const speed = this.getFloatValue("g_windSpeed") ?? 0;
+            if (speed > 0) {
+                this._windTimeAccum += dt;
+                this.setFloatValue("g_windTime", this._windTimeAccum);
+            }
+        }
+        catch (e) {
+        }
+    }
+    getShaderName() {
+        return "TreeBranchMaterial";
+    }
+    setWindDirection(x, y, z) {
+        const v = new Vector3(x, y, z);
+        if (v.lengthSquared() < 1e-8) {
+            this.setVector4Value("g_windDirection", new Vector4(1, 0, 0, 0));
+            return;
+        }
+        v.normalize();
+        this.setVector4Value("g_windDirection", new Vector4(v.x, v.y, v.z, 0.0));
+    }
+    getWindDirection() {
+        return this.getVector4Value("g_windDirection");
+    }
+}
+export class TreeBranchMaterialPlugin extends CustomShaderMaterialPlugin {
+    constructor(customMaterial, shaderName) {
+        super(customMaterial, shaderName, 110, { TREEBRANCHMATERIAL: false });
+    }
+    isCompatible(shaderLanguage) {
+        return (shaderLanguage === ShaderLanguage.WGSL || shaderLanguage === ShaderLanguage.GLSL);
+    }
+    getCustomCode(shaderType, shaderLanguage) {
+        if (shaderType === "vertex") {
+            if (shaderLanguage === ShaderLanguage.WGSL) {
+                return {
+                    CUSTOM_VERTEX_MAIN_END: `
+                        // -------------------------
+                        // TreeBranch wind bending (local-space)
+                        // Authoring (recommended):
+                        //   vertexColor.r = bend weight (0 trunk .. 1 tips)
+                        //   vertexColor.g = phase offset noise (0..1)
+                        // Falls back to height-based weight if vertex color missing/disabled.
+                        // -------------------------
+
+                        fn safeNormalize(v: vec3f) -> vec3f {
+                          let lsq = dot(v, v);
+                          if (lsq < 1e-8) { return vec3f(1.0, 0.0, 0.0); }
+                          return v * inverseSqrt(lsq);
+                        }
+
+                        fn rotateRodrigues(p: vec3f, axis: vec3f, angle: f32) -> vec3f {
+                          let a = safeNormalize(axis);
+                          let c = cos(angle);
+                          let s = sin(angle);
+                          return p * c + cross(a, p) * s + a * dot(a, p) * (1.0 - c);
+                        }
+
+                        // Local position & normal (preferred: use normalUpdated if present in shader)
+                        var pL: vec3f = positionUpdated;
+
+                        // If COLOR attribute exists, Babylon usually provides vertexInputs.color.
+                        // If not available, these will be 1,1,1,1 (depending on pipeline) — we guard with g_useVertexColorMask.
+                        var bendMask: f32 = 1.0;
+                        var phaseNoise: f32 = 0.0;
+                        if (uniforms.g_useVertexColorMask > 0.5) {
+                          bendMask = clamp(vertexInputs.color.r, 0.0, 1.0);
+                          phaseNoise = vertexInputs.color.g; // 0..1
+                        }
+
+                        // Height-based fallback weight (normalized between rootY..maxHeight)
+                        let denom = max(uniforms.g_branchMaxHeight - uniforms.g_branchRootY, 1e-3);
+                        let h01 = clamp((pL.y - uniforms.g_branchRootY) / denom, 0.0, 1.0);
+
+                        // Final per-vertex weight:
+                        // - If using vertex colors: bendMask * smooth tip emphasis
+                        // - Else: height-based
+                        var w: f32 = h01;
+                        if (uniforms.g_useVertexColorMask > 0.5) {
+                          w = bendMask * (h01 * h01 * (3.0 - 2.0 * h01)); // smoothstep(h01)
+                        } else {
+                          w = h01 * h01; // a bit stiffer near base
+                        }
+
+                        // Wind direction in LOCAL space:
+                        // We transform windDirWorld by inverse world matrix rotation (approx using finalWorld columns).
+                        // finalWorld transforms local->world. For direction, inverse rotation is transpose of 3x3 if no shear.
+                        let windW = safeNormalize(uniforms.g_windDirection.xyz);
+                        let rightW = safeNormalize(finalWorld[0].xyz);
+                        let upW = safeNormalize(finalWorld[1].xyz);
+                        let fwdW = safeNormalize(finalWorld[2].xyz);
+
+                        // Convert world dir to local by dot with basis
+                        let windL = safeNormalize(vec3f(dot(windW, rightW), dot(windW, upW), dot(windW, fwdW)));
+
+                        // Bend axis: perpendicular to up and wind, in LOCAL space
+                        var axisL = safeNormalize(cross(vec3f(0.0, 1.0, 0.0), windL));
+                        if (dot(axisL, axisL) < 1e-6) { axisL = vec3f(1.0, 0.0, 0.0); }
+
+                        // Spatially varying phase so whole tree doesn't move as a rigid sheet
+                        // Use local xz for coherence; optionally mod by vertexColor.g
+                        let spatial = (pL.x + pL.z) * uniforms.g_spatialFrequency;
+                        let phase = uniforms.g_windTime * uniforms.g_windSpeed
+                                  + spatial * uniforms.g_windStrength
+                                  + phaseNoise * 6.28318;
+
+                        // Two-wave composite like Unity-ish wind
+                        let base = sin(phase);
+                        let gust = 0.5 * sin(phase * 1.7 + 1.2);
+                        let sway = (base + gust) * uniforms.g_windAmount;
+
+                        // Convert sway to angle (clamped)
+                        var angle = sway * w * uniforms.g_branchMaxAngle;
+                        angle = clamp(angle, -uniforms.g_branchMaxAngle, uniforms.g_branchMaxAngle);
+
+                        // Pivot in local space
+                        let pivotL = vec3f(0.0, uniforms.g_branchRootY, 0.0);
+                        let relL = pL - pivotL;
+                        let bentRelL = rotateRodrigues(relL, axisL, angle);
+                        let bentPL = pivotL + bentRelL;
+
+                        // Transform to world using finalWorld (keeps proper anchoring)
+                        let branchWorld = (finalWorld * vec4f(bentPL, 1.0)).xyz;
+
+                        // Rotate normal similarly (only if NORMAL is active)
+                        #ifdef NORMAL
+                          // Babylon WGSL PBR usually provides normalUpdated in local/object space
+                          var nL: vec3f = normalize(normalUpdated);
+                          let bentNL = rotateRodrigues(nL, axisL, angle);
+                          // Convert to world by world 3x3
+                          let nW = normalize(vec3f(
+                              dot(bentNL, vec3f(finalWorld[0].x, finalWorld[0].y, finalWorld[0].z)),
+                              dot(bentNL, vec3f(finalWorld[1].x, finalWorld[1].y, finalWorld[1].z)),
+                              dot(bentNL, vec3f(finalWorld[2].x, finalWorld[2].y, finalWorld[2].z))
+                          ));
+                          vertexOutputs.vNormalW = nW;
+                        #endif
+
+                        #if defined(POSITION) || defined(BUMP)
+                          vertexOutputs.vPositionW = branchWorld;
+                        #endif
+
+                        vertexOutputs.position = scene.viewProjection * vec4f(branchWorld, 1.0);
+                        `
+                };
+            }
+            else {
+                return {
+                    CUSTOM_VERTEX_DEFINITIONS: `
+                          uniform float g_windTime;
+                          uniform float g_windAmount;
+                          uniform float g_windSpeed;
+                          uniform float g_windStrength;
+                          uniform vec4  g_windDirection;
+
+                          uniform float g_branchRootY;
+                          uniform float g_branchMaxAngle;
+                          uniform float g_branchMaxHeight;
+                          uniform float g_useVertexColorMask;
+                          uniform float g_spatialFrequency;
+
+                          vec3 safeNormalize(vec3 v) {
+                            float lsq = dot(v, v);
+                            if (lsq < 1e-8) return vec3(1.0, 0.0, 0.0);
+                            return v * inversesqrt(lsq);
+                          }
+
+                          vec3 rotateRodrigues(vec3 p, vec3 axis, float angle) {
+                            vec3 a = safeNormalize(axis);
+                            float c = cos(angle);
+                            float s = sin(angle);
+                            return p * c + cross(a, p) * s + a * dot(a, p) * (1.0 - c);
+                          }
+                      `,
+                    CUSTOM_VERTEX_MAIN_END: `
+                          // Local/object position
+                          vec3 pL = positionUpdated;
+
+                          // Vertex color mask (recommended authoring)
+                          float bendMask = 1.0;
+                          float phaseNoise = 0.0;
+                          #ifdef VERTEXCOLOR
+                            if (g_useVertexColorMask > 0.5) {
+                              bendMask = clamp(color.r, 0.0, 1.0);
+                              phaseNoise = color.g;
+                            }
+                          #endif
+
+                          float denom = max(g_branchMaxHeight - g_branchRootY, 1e-3);
+                          float h01 = clamp((pL.y - g_branchRootY) / denom, 0.0, 1.0);
+
+                          float w = h01;
+                          if (g_useVertexColorMask > 0.5) {
+                            // smoothstep(h01)
+                            w = bendMask * (h01 * h01 * (3.0 - 2.0 * h01));
+                          } else {
+                            w = h01 * h01;
+                          }
+
+                          // Convert wind world dir to local using world basis (transpose approx)
+                          vec3 windW = safeNormalize(g_windDirection.xyz);
+                          vec3 rightW = safeNormalize(finalWorld[0].xyz);
+                          vec3 upW    = safeNormalize(finalWorld[1].xyz);
+                          vec3 fwdW   = safeNormalize(finalWorld[2].xyz);
+                          vec3 windL  = safeNormalize(vec3(dot(windW, rightW), dot(windW, upW), dot(windW, fwdW)));
+
+                          vec3 axisL = safeNormalize(cross(vec3(0.0, 1.0, 0.0), windL));
+                          if (dot(axisL, axisL) < 1e-6) axisL = vec3(1.0, 0.0, 0.0);
+
+                          float spatial = (pL.x + pL.z) * g_spatialFrequency;
+                          float phase = g_windTime * g_windSpeed
+                                      + spatial * g_windStrength
+                                      + phaseNoise * 6.2831853;
+
+                          float base = sin(phase);
+                          float gust = 0.5 * sin(phase * 1.7 + 1.2);
+                          float sway = (base + gust) * g_windAmount;
+
+                          float angle = clamp(sway * w * g_branchMaxAngle, -g_branchMaxAngle, g_branchMaxAngle);
+
+                          vec3 pivotL = vec3(0.0, g_branchRootY, 0.0);
+                          vec3 relL = pL - pivotL;
+                          vec3 bentPL = pivotL + rotateRodrigues(relL, axisL, angle);
+
+                          vec3 branchWorld = (finalWorld * vec4(bentPL, 1.0)).xyz;
+
+                          #if defined(POSITION) || defined(BUMP)
+                            vPositionW = branchWorld;
+                          #endif
+
+                          #ifdef NORMAL
+                            // normalUpdated is local/object normal
+                            vec3 nL = normalize(normalUpdated);
+                            vec3 bentNL = rotateRodrigues(nL, axisL, angle);
+
+                            // world normal from world basis (approx; assumes no non-uniform scale/shear)
+                            vec3 nW = normalize(bentNL.x * rightW + bentNL.y * upW + bentNL.z * fwdW);
+                            vNormalW = nW;
+                          #endif
+
+                          gl_Position = viewProjection * vec4(branchWorld, 1.0);
+                      `
+                };
+            }
+        }
+        if (shaderType === "fragment") {
+            if (shaderLanguage === ShaderLanguage.WGSL) {
+                return {
+                    CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: `
+                          // no-op
+                      `
+                };
+            }
+            else {
+                return {
+                    CUSTOM_FRAGMENT_BEFORE_FINALCOLORCOMPOSITION: `
+                          // no-op
+                      `
+                };
+            }
+        }
+        return null;
+    }
+    getUniforms(shaderLanguage) {
+        const wgsl = (shaderLanguage === ShaderLanguage.WGSL);
+        this.vertexDefinitions = this.getCustomShaderMaterial().getCustomVertexCode(wgsl);
+        this.fragmentDefinitions = (wgsl === true) ? this.getCustomShaderMaterial().getCustomFragmentCode(wgsl) : null;
+        return this.getCustomShaderMaterial().getCustomUniforms(wgsl);
+    }
+    getSamplers(samplers) {
+        const customSamplers = this.getCustomShaderMaterial().getCustomSamplers();
+        if (customSamplers && customSamplers.length > 0)
+            samplers.push(...customSamplers);
+    }
+    getAttributes(attributes, scene, mesh) {
+        const customAttributes = this.getCustomShaderMaterial().getCustomAttributes();
+        if (customAttributes && customAttributes.length > 0)
+            attributes.push(...customAttributes);
+        if (attributes.indexOf("color") === -1)
+            attributes.push("color");
+    }
+    prepareDefines(defines, scene, mesh) {
+        if (!this.getIsEnabled())
+            return;
+        this.getCustomShaderMaterial().prepareCustomDefines(defines);
+    }
+    bindForSubMesh(uniformBuffer, scene, engine, subMesh) {
+        if (!this.getIsEnabled())
+            return;
+        this.getCustomShaderMaterial().updateCustomBindings(uniformBuffer);
+    }
+    static ExtractWindZoneOverride(properties, terrainTransform, builderInstance) {
+        const candidates = [];
+        if (properties)
+            candidates.push(properties);
+        if (properties && properties.properties)
+            candidates.push(properties.properties);
+        const meta = terrainTransform?.metadata;
+        if (meta)
+            candidates.push(meta);
+        if (meta && meta.toolkit)
+            candidates.push(meta.toolkit);
+        if (meta && meta.properties)
+            candidates.push(meta.properties);
+        const bmeta = builderInstance?.metadata;
+        if (bmeta)
+            candidates.push(bmeta);
+        if (bmeta && bmeta.toolkit)
+            candidates.push(bmeta.toolkit);
+        const tmeta = builderInstance?.transform?.metadata;
+        if (tmeta)
+            candidates.push(tmeta);
+        if (tmeta && tmeta.toolkit)
+            candidates.push(tmeta.toolkit);
+        let zones = null;
+        for (const c of candidates) {
+            if (!c)
+                continue;
+            if (Array.isArray(c.windzones)) {
+                zones = c.windzones;
+                break;
+            }
+        }
+        if (!zones || zones.length === 0)
+            return null;
+        let best = null;
+        let bestScore = -1e9;
+        for (const z of zones) {
+            if (!z)
+                continue;
+            const t = ((z.type != null) ? z.type : (z.mode != null ? z.mode : "")).toString().toLowerCase();
+            const isDirectional = (t.indexOf("direction") >= 0);
+            const main = (z.windMain != null) ? z.windMain : 0.0;
+            const score = (isDirectional ? 1000.0 : 0.0) + main;
+            if (score > bestScore) {
+                bestScore = score;
+                best = z;
+            }
+        }
+        return best;
+    }
+}
 export class VertexAnimationMaterial extends CustomShaderMaterial {
     constructor(name, scene) {
         super(name, scene);
@@ -15070,7 +16047,7 @@ export class WindowManager {
             printer.style.left = "6px";
             printer.style.bottom = "3px";
             printer.style.fontSize = "12px";
-            printer.style.zIndex = "10000";
+            printer.style.zIndex = "9001";
             printer.style.color = "#0c0";
             printer.style.pointerEvents = "none";
             document.body.appendChild(printer);
@@ -15845,9 +16822,6 @@ export class AnimationState extends ScriptComponent {
         if (this.onAnimationAwakeObservable && this.onAnimationAwakeObservable.hasObservers()) {
             this.onAnimationAwakeObservable.notifyObservers(this.transform);
         }
-        console.warn("Animation State Mahine: " + this.transform.name);
-        console.log(this);
-        SceneManager.SetWindowState(this.transform.name, this);
     }
     updateStateMachine(deltaTime = null) {
         if (this.delayUpdateUntilReady === false || (this.delayUpdateUntilReady === true && this.isReady())) {
@@ -18797,44 +19771,6 @@ export class btRaycastVehicle {
         this.isArcadeHandBrakeActive = false;
         this.isArcadeWheelSkidActive = false;
         this.isArcadeYawAssistActive = false;
-        this.arcadeYawAssistDebugLogEnabled = false;
-        this.arcadeYawAssistDebugLogIntervalFrames = 30;
-        this.arcadeYawAssistDebugLogEdgeEvents = true;
-        this.arcadeHandbrakeKickStrengthDegPerSec = 120.0;
-        this.arcadeHandbrakeKickFrames = 6;
-        this.arcadeHandbrakeYawAuthority = 1.8;
-        this.arcadeHandbrakeMaxYawRateDegPerSec = 180.0;
-        this.arcadeHandbrakeReferenceSpeedKmh = 90.0;
-        this.arcadeHandbrakeSpeedGateEnabled = true;
-        this.arcadeHandbrakeLowSpeedShape = 2.0;
-        this.arcadeHandbrakeDirectYawEnabled = true;
-        this.arcadeHandbrakeDirectYawDegPerSec = 60.0;
-        this.arcadeHandbrakeDirectYawDurationMs = 0;
-        this.arcadeHandbrakeDirectYawFadeMs = 200;
-        this.arcadeDonutDirectYawEnabled = true;
-        this.arcadeDonutDirectYawDegPerSec = 5.0;
-        this.arcadeDonutDirectYawDurationMs = 0;
-        this.arcadeDonutDirectYawFadeMs = 200;
-        this.arcadeHandbrakeMaxSlideAngleDeg = 220.0;
-        this.arcadeHandbrakeCounterSteerClampEnabled = true;
-        this.arcadeHandbrakeCounterSteerYawThresholdDegPerSec = 10.0;
-        this.arcadeHandbrakeClampReleaseFadeMs = 250;
-        this.arcadeHandbrakeSteerSlewLimitEnabled = false;
-        this.arcadeHandbrakeSteerSlewLimitDegPerSec = 360.0;
-        this._wasArcadeHandBrakeActive = false;
-        this._wasArcadeYawAssistApplyingForce = false;
-        this._handbrakeKickJzRemaining = 0;
-        this._handbrakeKickFramesRemaining = 0;
-        this._arcadeHandbrakeLatchedDriveSign = 0;
-        this._arcadeHandbrakeHoldElapsedSec = 0;
-        this._arcadeHandbrakeSlewedSteerRad = 0;
-        this._arcadeHandbrakeClampReleaseFadeSec = 999;
-        this._arcadeDonutHoldElapsedSec = 0;
-        this._arcadeYawAssistDebugFrameCounter = 0;
-        this._arcadeYawAssistLastKickRad = 0;
-        this._arcadeYawAssistLastIaddPerWheel = 0;
-        this._arcadeYawAssistLastClampScalar = 1.0;
-        this._arcadeYawAssistLastLeverSum = 0;
         this.burnoutFrictionFloor = 1.0;
         this.frictionRestoreSpeed = 8.0;
         this.arcadeBurnoutWheelSpinGain = 1.0;
@@ -18847,16 +19783,20 @@ export class btRaycastVehicle {
         this.arcadeWheelSpinMaxAngularVelocity = 160.0;
         this.arcadeStationaryBurnoutWheelSpinGain = 3.25;
         this.arcadeStationaryBurnoutMinAngularVelocity = 65.0;
+        this.arcadeHandbrakeYawCapMultiplier = 1.85;
+        this.arcadeBurnoutYawCapMultiplier = 1.25;
+        this.arcadeDonutYawCapMultiplier = 1.15;
         this.arcadeSkidFadeInSpeed = 18.0;
         this.arcadeSkidFadeOutSpeed = 6.0;
-        this.arcadeYawCapMultiplier = 1.5;
         this.wheelAtRestSpeedThresholdKmh = 1.0;
-        this.wheelSpinDebugLogEnabled = false;
-        this.wheelSpinDebugLogIntervalFrames = 6;
-        this._wheelSpinDebugLogCounter = 0;
-        this._postHandbrakeLogFrames = 0;
-        this._postHandbrakeLogCounter = 0;
-        this._wasAnyArcadeModeActive = false;
+        this.arcadeHandbrakeAssistEnabled = true;
+        this.currentSteeringInput = 0;
+        this.arcadeDonutDirectYawEnabled = true;
+        this.arcadeDonutDirectYawDegPerSec = 60.0;
+        this.arcadeDonutDirectYawDurationMs = 0;
+        this.arcadeDonutDirectYawFadeMs = 120;
+        this._arcadeDonutHoldElapsedSec = 0;
+        this._arcadeDonutDirectionSign = 0;
         this._forwardWS = [];
         this._axle = [];
         this._forwardImpulse = [];
@@ -18864,6 +19804,11 @@ export class btRaycastVehicle {
         this._arcadeSkidInfo = [];
         this._arcadePreviousWheelSpin = [];
         this.sideFrictionStiffness = 1.0;
+        this.arcadeSideSlipSaturationEnabled = true;
+        this.arcadeSideSlipPeakDeg = 8.0;
+        this.arcadeSideSlipFalloffDeg = 45.0;
+        this.arcadeSideSlipFalloffFactor = 0.4;
+        this.arcadeSideSlipMinSpeedMps = 1.5;
         this._chassisMass = 0;
         this._chassisInvMass = 0;
         this._chassisTransform = Matrix.Identity();
@@ -18988,6 +19933,9 @@ export class btRaycastVehicle {
         return this.isArcadeBurnoutModeActive;
     }
     setIsArcadeDonutActive(active) {
+        if (active !== true) {
+            this._arcadeDonutDirectionSign = 0;
+        }
         this.isArcadeDonutModeActive = active;
     }
     getIsArcadeDonutActive() {
@@ -19608,29 +20556,6 @@ export class btRaycastVehicle {
         const chassisAtRest = (this.wheelAtRestSpeedThresholdKmh > 0
             && Math.abs(this._currentVehicleSpeedKmHour) < this.wheelAtRestSpeedThresholdKmh
             && (!arcadeModeActiveAny || !anyWheelEngineForceActive));
-        let wheelSpinLogThisTick = false;
-        if (this.wheelSpinDebugLogEnabled === true) {
-            this._wheelSpinDebugLogCounter++;
-            const intv = (this.wheelSpinDebugLogIntervalFrames > 0)
-                ? this.wheelSpinDebugLogIntervalFrames : 1;
-            if ((this._wheelSpinDebugLogCounter % intv) === 0) {
-                wheelSpinLogThisTick = true;
-            }
-        }
-        let chassisAngVelY = 0;
-        if (wheelSpinLogThisTick === true) {
-            this._chassisBody.getAngularVelocityToRef(this._sv8);
-            chassisAngVelY = this._sv8.y;
-            console.log("[HavokVehicle.wheelSpin] tick=" + this._wheelSpinDebugLogCounter
-                + " speedKmh=" + this._currentVehicleSpeedKmHour.toFixed(3)
-                + " yawRadPerSec=" + chassisAngVelY.toFixed(4)
-                + " atRest=" + chassisAtRest
-                + " arcadeAny=" + arcadeModeActiveAny
-                + " burn=" + this.isArcadeBurnoutModeActive
-                + " donut=" + this.isArcadeDonutModeActive
-                + " hand=" + this.isArcadeHandBrakeActive
-                + " skid=" + this.isArcadeWheelSkidActive);
-        }
         for (var i = 0; i < numWheels; i++) {
             var wheel = this._wheelInfo[i];
             var groundAngularVelocity = 0.0;
@@ -19646,29 +20571,12 @@ export class btRaycastVehicle {
             if (chassisAtRest === true) {
                 wheel.rotationBoost = 0;
                 wheel.deltaRotation = 0;
-                if (wheelSpinLogThisTick === true) {
-                    console.log("  wheel[" + i + "] SUPPRESSED"
-                        + " contact=" + wheel.raycastInfo.isInContact
-                        + " groundAngVel=" + groundAngularVelocity.toFixed(4)
-                        + " rotation=" + wheel.rotation.toFixed(4));
-                }
                 continue;
             }
             var wheelAngularVelocity = this.getWheelAngularVelocity(i, groundAngularVelocity, step, wheel.raycastInfo.isInContact);
             wheel.deltaRotation = wheelAngularVelocity * step;
             wheel.rotation += wheel.deltaRotation;
             wheel.deltaRotation *= 0.99;
-            if (wheelSpinLogThisTick === true) {
-                console.log("  wheel[" + i + "]"
-                    + " contact=" + wheel.raycastInfo.isInContact
-                    + " groundAngVel=" + groundAngularVelocity.toFixed(4)
-                    + " rotBoost=" + wheel.rotationBoost.toFixed(4)
-                    + " wheelAngVel=" + wheelAngularVelocity.toFixed(4)
-                    + " deltaRot=" + wheel.deltaRotation.toFixed(5)
-                    + " rotation=" + wheel.rotation.toFixed(4)
-                    + " engineForce=" + wheel.engineForce.toFixed(2)
-                    + " brake=" + wheel.brake.toFixed(2));
-            }
         }
         this.clampChassisYawRate(step);
     }
@@ -19719,9 +20627,20 @@ export class btRaycastVehicle {
             }
         }
     }
+    getSteeringAuthorityInput() {
+        var steeringInput = Scalar.Clamp(this.currentSteeringInput, -1.0, 1.0);
+        if (Math.abs(steeringInput) > 0.001)
+            return steeringInput;
+        var signedFrontSteer = this.getSignedFrontSteeringAngleRad();
+        return Scalar.Clamp(signedFrontSteer / 0.6, -1.0, 1.0);
+    }
+    getSteeringMagnitude() {
+        return Math.abs(this.getSteeringAuthorityInput());
+    }
     applyEasyDonutYawAssist(timeStep, absSpeedKmh, signedSpeedKmh) {
         if (this.isArcadeDonutModeActive !== true) {
             this._arcadeDonutHoldElapsedSec = 0;
+            this._arcadeDonutDirectionSign = 0;
             return;
         }
         if (this.arcadeDonutDirectYawEnabled !== true) {
@@ -19734,14 +20653,6 @@ export class btRaycastVehicle {
             this._arcadeDonutHoldElapsedSec += timeStep;
             return;
         }
-        var L = this.getApproxWheelbaseMeters();
-        if (L < 0.5)
-            L = 2.5;
-        var Iz = 0.22 * this._chassisMass * L * L;
-        if (Iz <= 0 || this._chassisMass <= 0) {
-            this._arcadeDonutHoldElapsedSec += timeStep;
-            return;
-        }
         var durSec = this.arcadeDonutDirectYawDurationMs > 0 ? this.arcadeDonutDirectYawDurationMs / 1000.0 : 0;
         var fadeSec = this.arcadeDonutDirectYawFadeMs > 0 ? this.arcadeDonutDirectYawFadeMs / 1000.0 : 0;
         var elapsed = this._arcadeDonutHoldElapsedSec;
@@ -19770,337 +20681,76 @@ export class btRaycastVehicle {
         chassisUp.set(cm[ui * 4], cm[ui * 4 + 1], cm[ui * 4 + 2]);
         this._chassisBody.getLinearVelocityToRef(this._sv8);
         var signedVxMps = Vector3.Dot(this._sv8, chassisForward);
-        var driveSign = Math.abs(signedVxMps) > 0.25 ? (signedVxMps >= 0 ? 1 : -1) : 1;
         var steerSign = signedFrontSteerRad >= 0 ? 1 : -1;
-        var extraRad = Tools.ToRadians(this.arcadeDonutDirectYawDegPerSec)
-            * driveSign * steerSign
-            * fade * this.arcadeSteeringAssist;
-        var donutYawJz = Iz * extraRad * timeStep;
-        if (Math.abs(donutYawJz) <= 1e-6) {
-            this._arcadeDonutHoldElapsedSec += timeStep;
-            return;
+        if (this._arcadeDonutDirectionSign === 0) {
+            this._arcadeDonutDirectionSign = Math.abs(signedVxMps) > 0.25 ? (signedVxMps >= 0 ? 1 : -1) : steerSign;
         }
-        this._chassisBody.getObjectCenterWorldToRef(this._sv1);
-        var leverSum = 0;
-        var rearIdxList = [];
-        var rearLeverList = [];
-        for (var w = 0; w < this._wheelInfo.length; w++) {
-            var wi = this._wheelInfo[w];
-            if (!wi.isFrontWheel && wi.raycastInfo.groundObject) {
-                wi.raycastInfo.contactPointWS.subtractToRef(this._sv1, this._sv2);
-                Vector3.CrossToRef(this._sv2, this._axle[w], this._sv3);
-                var lever_w = Vector3.Dot(this._sv3, chassisUp);
-                rearIdxList.push(w);
-                rearLeverList.push(lever_w);
-                leverSum += lever_w;
-            }
-        }
-        if (rearIdxList.length === 0 || Math.abs(leverSum) <= MIN_LEVER_EPS) {
+        var targetYawRad = Tools.ToRadians(this.arcadeDonutDirectYawDegPerSec)
+            * this._arcadeDonutDirectionSign * steerSign
+            * fade * this.arcadeSteeringAssist;
+        if (Math.abs(targetYawRad) <= 1e-5) {
             this._arcadeDonutHoldElapsedSec += timeStep;
             return;
         }
-        var IaddPerWheel = donutYawJz / leverSum;
-        for (var ii = 0; ii < rearIdxList.length; ii++) {
-            var w2 = rearIdxList[ii];
-            var wi2 = this._wheelInfo[w2];
-            this._axle[w2].scaleToRef(IaddPerWheel, this._sv2);
-            this._chassisBody.applyImpulse(this._sv2, wi2.raycastInfo.contactPointWS);
-        }
+        this._chassisBody.getAngularVelocityToRef(this._sv9);
+        var currentYawRad = Vector3.Dot(this._sv9, chassisUp);
+        var lockRate = 14.0;
+        var lockBlend = Scalar.Clamp(1.0 - Math.exp(-lockRate * timeStep), 0.0, 1.0);
+        var nextYawRad = currentYawRad + (targetYawRad - currentYawRad) * lockBlend;
+        var minHoldYawRad = Math.abs(targetYawRad) * 0.55;
+        if (Math.sign(nextYawRad) !== Math.sign(targetYawRad) || Math.abs(nextYawRad) < minHoldYawRad) {
+            nextYawRad = Math.sign(targetYawRad) * minHoldYawRad;
+        }
+        chassisUp.scaleToRef(currentYawRad, this._sv1);
+        this._sv9.subtractToRef(this._sv1, this._sv2);
+        chassisUp.scaleToRef(nextYawRad, this._sv3);
+        this._sv2.addToRef(this._sv3, this._sv9);
+        this._chassisBody.setAngularVelocity(this._sv9);
         this._arcadeDonutHoldElapsedSec += timeStep;
     }
     applyHandbrakeYawAssist(timeStep, absSpeedKmh, signedSpeedKmh) {
         this.isArcadeYawAssistActive = false;
-        if (this.isArcadeHandBrakeActive === false) {
-            this._wasArcadeHandBrakeActive = false;
-            this._wasArcadeYawAssistApplyingForce = false;
-            this._handbrakeKickJzRemaining = 0;
-            this._handbrakeKickFramesRemaining = 0;
-            this._arcadeHandbrakeLatchedDriveSign = 0;
-            this._arcadeHandbrakeHoldElapsedSec = 0;
-            this._arcadeHandbrakeSlewedSteerRad = 0;
-            this._arcadeHandbrakeClampReleaseFadeSec = 999;
+        if (!this.arcadeHandbrakeAssistEnabled)
             return;
-        }
-        const TAU_RESPONSE = 0.18;
-        const V_ENGAGE_MIN_KMH = 7.0;
-        const V_ENGAGE_FULL_KMH = 65.0;
-        const V_KICK_FULL_KMH = 65.0;
-        const I_Z_FACTOR = 0.22;
-        const MIN_STEER_RAD = 0.02;
-        const MIN_LEVER_EPS = 0.001;
-        const ASSIST_MIN_NM = 25.0;
-        const SLIDE_TAPER_RANGE_RAD = Math.PI / 4;
-        const K_ASSIST = this.arcadeHandbrakeYawAuthority;
-        const R_MAX_DEG_PER_SEC = this.arcadeHandbrakeMaxYawRateDegPerSec;
-        const K_KICK_DEG_PER_SEC = this.arcadeHandbrakeKickStrengthDegPerSec;
-        const V_REF_MPS = this.arcadeHandbrakeReferenceSpeedKmh / 3.6;
-        const MAX_SLIDE_ANGLE_RAD = Tools.ToRadians(this.arcadeHandbrakeMaxSlideAngleDeg);
-        const KICK_FRAMES = Math.max(1, this.arcadeHandbrakeKickFrames | 0);
-        this._arcadeYawAssistDebugFrameCounter++;
-        var debugEnabled = this.arcadeYawAssistDebugLogEnabled === true;
-        var debugIntervalHit = debugEnabled && this.arcadeYawAssistDebugLogIntervalFrames > 0 && (this._arcadeYawAssistDebugFrameCounter % this.arcadeYawAssistDebugLogIntervalFrames) === 0;
-        var signedFrontSteerRad = this.getSignedFrontSteeringAngleRad();
-        var steeringMagnitude = Math.abs(signedFrontSteerRad);
-        var eligible = this.isArcadeHandBrakeActive === true && this.arcadeSteeringAssist > 0 && steeringMagnitude > MIN_STEER_RAD && absSpeedKmh > V_ENGAGE_MIN_KMH;
-        var risingEdge = this.isArcadeHandBrakeActive === true && this._wasArcadeHandBrakeActive === false;
-        if (this.arcadeHandbrakeSteerSlewLimitEnabled === true && !risingEdge) {
-            var slewMaxRad = Tools.ToRadians(this.arcadeHandbrakeSteerSlewLimitDegPerSec) * timeStep;
-            var steerDelta = signedFrontSteerRad - this._arcadeHandbrakeSlewedSteerRad;
-            if (steerDelta > slewMaxRad)
-                steerDelta = slewMaxRad;
-            else if (steerDelta < -slewMaxRad)
-                steerDelta = -slewMaxRad;
-            this._arcadeHandbrakeSlewedSteerRad += steerDelta;
-        }
-        else {
-            this._arcadeHandbrakeSlewedSteerRad = signedFrontSteerRad;
-        }
-        var effectiveSteerRad = this._arcadeHandbrakeSlewedSteerRad;
-        const cm = this._chassisTransform.m;
+        var steeringMagnitude = this.getSteeringMagnitude();
+        var steeringAuthorityInput = this.getSteeringAuthorityInput();
+        if (!this.isArcadeHandBrakeActive || steeringMagnitude < 0.02)
+            return;
+        var speedMps = Math.max(0.0, absSpeedKmh / 3.6);
+        var speedScale = Scalar.Clamp((speedMps - 0.5) / 3.0, 0.0, 1.0);
+        if (speedScale <= 0.0)
+            return;
+        const m = this._chassisTransform.m;
+        const ri = this._indexRightAxis;
         const ui = this._indexUpAxis;
         const fi = this._indexForwardAxis;
-        const ri = this._indexRightAxis;
-        const chassisUp = this._sv5;
-        const chassisForward = this._sv6;
-        const chassisRight = this._sv9;
-        chassisUp.set(cm[ui * 4], cm[ui * 4 + 1], cm[ui * 4 + 2]);
-        chassisForward.set(cm[fi * 4], cm[fi * 4 + 1], cm[fi * 4 + 2]);
-        chassisRight.set(cm[ri * 4], cm[ri * 4 + 1], cm[ri * 4 + 2]);
-        this._chassisBody.getLinearVelocityToRef(this._sv8);
-        var signedVxMps = Vector3.Dot(this._sv8, chassisForward);
-        var velRightMps = Vector3.Dot(this._sv8, chassisRight);
-        var speedMagMps = Math.sqrt(this._sv8.x * this._sv8.x + this._sv8.y * this._sv8.y + this._sv8.z * this._sv8.z);
-        var slipAngleRad = (speedMagMps > 0.1) ? Math.atan2(velRightMps, signedVxMps) : 0;
-        var driveSign = this._arcadeHandbrakeLatchedDriveSign !== 0
-            ? this._arcadeHandbrakeLatchedDriveSign
-            : (signedVxMps >= 0 ? 1 : -1);
-        var relSlipRad;
-        if (driveSign > 0) {
-            relSlipRad = slipAngleRad;
-        }
-        else {
-            relSlipRad = slipAngleRad >= 0 ? slipAngleRad - Math.PI : slipAngleRad + Math.PI;
-        }
-        var relSlipAbs = Math.abs(relSlipRad);
-        var relSlipSign = relSlipAbs > 1e-3 ? (relSlipRad > 0 ? 1 : -1) : 0;
-        var L = this.getApproxWheelbaseMeters();
-        if (L < 0.5)
-            L = 2.5;
-        var Iz = I_Z_FACTOR * this._chassisMass * L * L;
-        var rTarget = 0;
-        var currentYawRate = 0;
-        var gate = 0;
-        var slideTaper = 1.0;
-        var desiredMz = 0;
-        this._chassisBody.getAngularVelocityToRef(this._sv4);
-        currentYawRate = Vector3.Dot(this._sv4, chassisUp);
-        if (eligible) {
-            var gateRange = V_ENGAGE_FULL_KMH - V_ENGAGE_MIN_KMH;
-            var gateRaw = gateRange > 0 ? (absSpeedKmh - V_ENGAGE_MIN_KMH) / gateRange : 1.0;
-            gate = Scalar.Clamp(gateRaw, 0, 1);
-            gate = gate * gate * (3.0 - 2.0 * gate);
-            var vForTarget = driveSign * Math.min(speedMagMps, V_REF_MPS);
-            var rTargetRaw = K_ASSIST * vForTarget * effectiveSteerRad / L;
-            var rMaxLinear = Scalar.Clamp(speedMagMps / V_REF_MPS, 0, 1);
-            var lowSpeedShape = this.arcadeHandbrakeLowSpeedShape > 0 ? this.arcadeHandbrakeLowSpeedShape : 1.0;
-            var rMaxSpeedFactor = this.arcadeHandbrakeSpeedGateEnabled ? Math.pow(rMaxLinear, lowSpeedShape) : 1.0;
-            var rMax = Tools.ToRadians(R_MAX_DEG_PER_SEC) * rMaxSpeedFactor;
-            if (rTargetRaw > rMax)
-                rTargetRaw = rMax;
-            else if (rTargetRaw < -rMax)
-                rTargetRaw = -rMax;
-            rTarget = rTargetRaw * gate * this.arcadeSteeringAssist;
-            var counterSteerClampActive = false;
-            if (this.arcadeHandbrakeCounterSteerClampEnabled === true) {
-                var yawThresholdRadPerSec = Tools.ToRadians(this.arcadeHandbrakeCounterSteerYawThresholdDegPerSec);
-                if (Math.abs(currentYawRate) > yawThresholdRadPerSec && rTarget * currentYawRate < 0) {
-                    rTarget = 0;
-                    counterSteerClampActive = true;
-                }
-            }
-            var releaseFadeMs = this.arcadeHandbrakeClampReleaseFadeMs;
-            var clampFadeActive = false;
-            var clampFadeMul = 1.0;
-            if (counterSteerClampActive) {
-                this._arcadeHandbrakeClampReleaseFadeSec = 0;
-            }
-            else {
-                this._arcadeHandbrakeClampReleaseFadeSec += timeStep;
-                if (releaseFadeMs > 0) {
-                    var fadeSec = releaseFadeMs / 1000.0;
-                    if (this._arcadeHandbrakeClampReleaseFadeSec < fadeSec) {
-                        var fadeT = this._arcadeHandbrakeClampReleaseFadeSec / fadeSec;
-                        clampFadeMul = fadeT * fadeT * (3.0 - 2.0 * fadeT);
-                        rTarget *= clampFadeMul;
-                        clampFadeActive = true;
-                    }
-                }
-            }
-            if (relSlipAbs > MAX_SLIDE_ANGLE_RAD) {
-                var pastMax = (relSlipAbs - MAX_SLIDE_ANGLE_RAD) / SLIDE_TAPER_RANGE_RAD;
-                if (pastMax > 1.0)
-                    pastMax = 1.0;
-                slideTaper = 1.0 - pastMax;
-                rTarget *= slideTaper;
-            }
-            if (rTarget > rMax)
-                rTarget = rMax;
-            else if (rTarget < -rMax)
-                rTarget = -rMax;
-            desiredMz = Iz * (rTarget - currentYawRate) / TAU_RESPONSE;
-        }
-        var newMz;
-        if (eligible) {
-            newMz = desiredMz;
+        this._stb1.set(m[ri * 4], m[ri * 4 + 1], m[ri * 4 + 2]);
+        this._stb2.set(m[ui * 4], m[ui * 4 + 1], m[ui * 4 + 2]);
+        this._stb3.set(m[fi * 4], m[fi * 4 + 1], m[fi * 4 + 2]);
+        this._chassisBody.getAngularVelocityToRef(this._sv9);
+        var localRoll = Vector3.Dot(this._sv9, this._stb1);
+        var localYaw = Vector3.Dot(this._sv9, this._stb2);
+        var localPitch = Vector3.Dot(this._sv9, this._stb3);
+        var signedFrontSteerRad = this.getSignedFrontSteeringAngleRad();
+        var wheelbaseMeters = this.getApproxWheelbaseMeters();
+        var bicycleYawRate = 0.0;
+        if (wheelbaseMeters > 0.5 && speedMps > 0.2 && Math.abs(signedFrontSteerRad) > 1e-4) {
+        }
+        var minimumYawRate = steeringAuthorityInput * this.arcadeSteeringAssist * (0.25 + steeringMagnitude * 1.0) * speedScale;
+        var desiredYawBoost = Math.abs(bicycleYawRate) > Math.abs(minimumYawRate) ? bicycleYawRate : minimumYawRate;
+        var sameDir = (desiredYawBoost * localYaw) >= 0.0;
+        if (sameDir && Math.abs(localYaw) >= Math.abs(desiredYawBoost)) {
+            this.isArcadeYawAssistActive = true;
+            return;
         }
-        else {
-            newMz = 0;
-        }
-        var assistApplyingForce = Math.abs(newMz) > ASSIST_MIN_NM;
-        if (eligible && this._wasArcadeHandBrakeActive === false) {
-            this._arcadeHandbrakeLatchedDriveSign = signedVxMps >= 0 ? 1 : -1;
-            driveSign = this._arcadeHandbrakeLatchedDriveSign;
-            this._arcadeHandbrakeHoldElapsedSec = 0;
-            var kickRange = V_KICK_FULL_KMH - V_ENGAGE_MIN_KMH;
-            var kickRaw = kickRange > 0 ? (absSpeedKmh - V_ENGAGE_MIN_KMH) / kickRange : 1.0;
-            var kickGate = Scalar.Clamp(kickRaw, 0, 1);
-            kickGate = kickGate * kickGate * (3.0 - 2.0 * kickGate);
-            var steerSign = signedFrontSteerRad >= 0 ? 1 : -1;
-            var velSign = signedVxMps >= 0 ? 1 : -1;
-            var kickLinear = Scalar.Clamp(speedMagMps / V_REF_MPS, 0, 1);
-            var kickShape = this.arcadeHandbrakeLowSpeedShape > 0 ? this.arcadeHandbrakeLowSpeedShape : 1.0;
-            var kickSpeedFactor = this.arcadeHandbrakeSpeedGateEnabled ? Math.pow(kickLinear, kickShape) : 1.0;
-            var kickRadTotal = Tools.ToRadians(K_KICK_DEG_PER_SEC) * steerSign * velSign * kickGate * kickSpeedFactor * this.arcadeSteeringAssist;
-            var kickSuppressed = false;
-            if (this.arcadeHandbrakeCounterSteerClampEnabled === true) {
-                var kickYawThresholdRadPerSec = Tools.ToRadians(this.arcadeHandbrakeCounterSteerYawThresholdDegPerSec);
-                if (Math.abs(currentYawRate) > kickYawThresholdRadPerSec && kickRadTotal * currentYawRate < 0) {
-                    kickRadTotal = 0;
-                    kickSuppressed = true;
-                }
-            }
-            this._handbrakeKickJzRemaining = Iz * kickRadTotal;
-            this._handbrakeKickFramesRemaining = kickSuppressed ? 0 : KICK_FRAMES;
-        }
-        var kickAngularImpulseJz = 0;
-        var kickRad = 0;
-        if (eligible && this._handbrakeKickFramesRemaining > 0) {
-            var thisFrameKick = this._handbrakeKickJzRemaining / this._handbrakeKickFramesRemaining;
-            kickAngularImpulseJz += thisFrameKick;
-            this._handbrakeKickJzRemaining -= thisFrameKick;
-            this._handbrakeKickFramesRemaining--;
-        }
-        else if (!eligible) {
-            this._handbrakeKickJzRemaining = 0;
-            this._handbrakeKickFramesRemaining = 0;
-        }
-        if (Iz > 0)
-            kickRad = kickAngularImpulseJz / Iz;
-        var directYawJz = 0;
-        if (eligible && this.arcadeHandbrakeDirectYawEnabled === true && Iz > 0) {
-            var directDurSec = this.arcadeHandbrakeDirectYawDurationMs > 0 ? this.arcadeHandbrakeDirectYawDurationMs / 1000.0 : 0;
-            var directFadeSec = this.arcadeHandbrakeDirectYawFadeMs > 0 ? this.arcadeHandbrakeDirectYawFadeMs / 1000.0 : 0;
-            var elapsed = this._arcadeHandbrakeHoldElapsedSec;
-            var fadeIn = directFadeSec > 0 ? Scalar.Clamp(elapsed / directFadeSec, 0, 1) : 1.0;
-            var fadeOut = 1.0;
-            if (directDurSec > 0) {
-                var timeLeft = directDurSec - elapsed;
-                if (timeLeft <= 0) {
-                    fadeOut = 0;
-                }
-                else if (directFadeSec > 0 && timeLeft < directFadeSec) {
-                    fadeOut = timeLeft / directFadeSec;
-                }
-            }
-            var directFade = Math.min(fadeIn, fadeOut);
-            if (directFade > 0) {
-                var dyLinear = Scalar.Clamp(speedMagMps / V_REF_MPS, 0, 1);
-                var dyShape = this.arcadeHandbrakeLowSpeedShape > 0 ? this.arcadeHandbrakeLowSpeedShape : 1.0;
-                var dySpeedFactor = this.arcadeHandbrakeSpeedGateEnabled ? Math.pow(dyLinear, dyShape) : 1.0;
-                var dySteerSign = signedFrontSteerRad >= 0 ? 1 : -1;
-                var dyExtraRad = Tools.ToRadians(this.arcadeHandbrakeDirectYawDegPerSec)
-                    * driveSign * dySteerSign
-                    * gate * dySpeedFactor
-                    * directFade * this.arcadeSteeringAssist;
-                directYawJz = Iz * dyExtraRad * timeStep;
-            }
-        }
-        if (eligible) {
-            this._arcadeHandbrakeHoldElapsedSec += timeStep;
-        }
-        var leverSum = 0;
-        var rearGroundedCount = 0;
-        var IaddCtrlDesired = 0;
-        var IaddCtrlAppliedSum = 0;
-        var IaddKickPerWheel = 0;
-        var IaddKickAppliedSum = 0;
-        var IaddDirectPerWheel = 0;
-        var IaddDirectAppliedSum = 0;
-        var Jz_through_tires = 0;
-        var minCtrlClamp = 1.0;
-        var perWheelLog = "";
-        var rearIdxList = [];
-        var rearLeverList = [];
-        var hasController = Math.abs(newMz) > 0;
-        var hasKick = Math.abs(kickAngularImpulseJz) > 0;
-        var hasDirect = Math.abs(directYawJz) > 0;
-        if ((hasController || hasKick || hasDirect) && this._chassisMass > 0) {
-            this._chassisBody.getObjectCenterWorldToRef(this._sv1);
-            for (var w = 0; w < this._wheelInfo.length; w++) {
-                var wi = this._wheelInfo[w];
-                if (!wi.isFrontWheel && wi.raycastInfo.groundObject) {
-                    wi.raycastInfo.contactPointWS.subtractToRef(this._sv1, this._sv2);
-                    Vector3.CrossToRef(this._sv2, this._axle[w], this._sv3);
-                    var lever_w = Vector3.Dot(this._sv3, chassisUp);
-                    rearIdxList.push(w);
-                    rearLeverList.push(lever_w);
-                    leverSum += lever_w;
-                    rearGroundedCount++;
-                }
-            }
-            if (rearGroundedCount > 0 && Math.abs(leverSum) > MIN_LEVER_EPS) {
-                if (hasController)
-                    IaddCtrlDesired = (newMz * timeStep) / leverSum;
-                if (hasKick)
-                    IaddKickPerWheel = kickAngularImpulseJz / leverSum;
-                if (hasDirect)
-                    IaddDirectPerWheel = directYawJz / leverSum;
-                for (var ii = 0; ii < rearIdxList.length; ii++) {
-                    var w2 = rearIdxList[ii];
-                    var lever_w2 = rearLeverList[ii];
-                    var wi2 = this._wheelInfo[w2];
-                    var IaddCtrlW = hasController ? IaddCtrlDesired : 0;
-                    var IaddTotalW = IaddCtrlW + IaddKickPerWheel + IaddDirectPerWheel;
-                    if (IaddTotalW !== 0) {
-                        this._axle[w2].scaleToRef(IaddTotalW, this._sv2);
-                        this._chassisBody.applyImpulse(this._sv2, wi2.raycastInfo.contactPointWS);
-                        IaddCtrlAppliedSum += IaddCtrlW;
-                        IaddKickAppliedSum += IaddKickPerWheel;
-                        IaddDirectAppliedSum += IaddDirectPerWheel;
-                        Jz_through_tires += lever_w2 * IaddTotalW;
-                    }
-                    if (debugEnabled) {
-                        perWheelLog += " w" + w2
-                            + "{maximp=" + (wi2.suspensionForce * timeStep * wi2.frictionSlip).toFixed(1)
-                            + " side=" + this._sideImpulse[w2].toFixed(1)
-                            + " fwd=" + (this._forwardImpulse[w2] * 0.5).toFixed(1)
-                            + " ctrlDes=" + IaddCtrlDesired.toFixed(1)
-                            + " ctrl=" + IaddCtrlW.toFixed(1)
-                            + " kick=" + IaddKickPerWheel.toFixed(1)
-                            + " direct=" + IaddDirectPerWheel.toFixed(1)
-                            + " tot=" + IaddTotalW.toFixed(1) + "}";
-                    }
-                }
-            }
-        }
-        this._arcadeYawAssistLastKickRad = kickRad;
-        this._arcadeYawAssistLastIaddPerWheel = IaddCtrlDesired + IaddKickPerWheel + IaddDirectPerWheel;
-        this._arcadeYawAssistLastClampScalar = minCtrlClamp;
-        this._arcadeYawAssistLastLeverSum = leverSum;
-        var assistActiveThisFrame = eligible || assistApplyingForce;
-        this.isArcadeYawAssistActive = assistActiveThisFrame;
-        this._wasArcadeHandBrakeActive = this.isArcadeHandBrakeActive;
-        this._wasArcadeYawAssistApplyingForce = assistApplyingForce;
+        var yawDeltaMax = (0.15 + steeringMagnitude * 0.35) * speedScale;
+        var yawDelta = Scalar.Clamp(desiredYawBoost * (2.0 + steeringMagnitude * 4.0) * timeStep, -yawDeltaMax, yawDeltaMax);
+        if (Math.abs(yawDelta) < 1e-6)
+            return;
+        localYaw += yawDelta;
+        this._sv9.set(this._stb1.x * localRoll + this._stb2.x * localYaw + this._stb3.x * localPitch, this._stb1.y * localRoll + this._stb2.y * localYaw + this._stb3.y * localPitch, this._stb1.z * localRoll + this._stb2.z * localYaw + this._stb3.z * localPitch);
+        this._chassisBody.setAngularVelocity(this._sv9);
+        this.isArcadeYawAssistActive = true;
     }
     resolveWheelSpinDirection(wheelIndex, requestedDriveImpulse, appliedDriveImpulse) {
         if (Math.abs(requestedDriveImpulse) > 0.0001) {
@@ -20298,6 +20948,24 @@ export class btRaycastVehicle {
                 this._forwardWS[i].normalize();
                 this._sideImpulse[i] = this.resolveSingleBilateral(this._chassisBody, wheel.raycastInfo.contactPointWS, this._axle[i]);
                 this._sideImpulse[i] *= this.sideFrictionStiffness;
+                if (this.arcadeSideSlipSaturationEnabled && this._sideImpulse[i] !== 0) {
+                    this.velocityAtWorldPoint(this._chassisBody, wheel.raycastInfo.contactPointWS, this._sv8);
+                    var vLat = Vector3.Dot(this._axle[i], this._sv8);
+                    var vFwd = Vector3.Dot(this._forwardWS[i], this._sv8);
+                    var wheelSpeedSqr = vLat * vLat + vFwd * vFwd;
+                    var minSpeed = this.arcadeSideSlipMinSpeedMps;
+                    if (wheelSpeedSqr > minSpeed * minSpeed) {
+                        var slipRad = Math.atan2(Math.abs(vLat), Math.max(Math.abs(vFwd), 1e-3));
+                        var peakRad = Tools.ToRadians(Math.max(this.arcadeSideSlipPeakDeg, 0.1));
+                        if (slipRad > peakRad) {
+                            var holdFactor = Math.sin(peakRad) / Math.max(Math.sin(slipRad), 1e-3);
+                            var falloffSpan = Math.max(this.arcadeSideSlipFalloffDeg - this.arcadeSideSlipPeakDeg, 0.1);
+                            var t = Math.min(Math.max((Tools.ToDegrees(slipRad) - this.arcadeSideSlipPeakDeg) / falloffSpan, 0.0), 1.0);
+                            var rolloff = Scalar.Lerp(1.0, this.arcadeSideSlipFalloffFactor, t);
+                            this._sideImpulse[i] *= holdFactor * rolloff;
+                        }
+                    }
+                }
             }
         }
         var sideFactor = 1.0;
@@ -20423,12 +21091,6 @@ export class btRaycastVehicle {
                 this._wheelInfo[wheel_i].skidInfo = Math.min(this._wheelInfo[wheel_i].skidInfo, arcadeSkidInfo);
             }
         }
-        var isAnyArcadeModeActiveNow = this.isArcadeHandBrakeActive || this.isArcadeWheelSkidActive || this.isArcadeBurnoutModeActive || this.isArcadeDonutModeActive;
-        if (this._wasAnyArcadeModeActive && !isAnyArcadeModeActiveNow) {
-            this._postHandbrakeLogFrames = 180;
-            this._postHandbrakeLogCounter = 0;
-        }
-        this._wasAnyArcadeModeActive = isAnyArcadeModeActiveNow;
         if (sliding) {
             for (var wheel_i = 0; wheel_i < numWheels; wheel_i++) {
                 if (this._sideImpulse[wheel_i] !== 0) {
@@ -20452,7 +21114,8 @@ export class btRaycastVehicle {
             avgSideImpulse /= groundedSideCount;
         var sideBlendToCoM = 0;
         var absSpeedKmh = Math.abs(this._currentVehicleSpeedKmHour);
-        if (this.sideToSideStabilityEnabled && absSpeedKmh > this.sideToSideStabilityStartKmh) {
+        var arcadeSlideActive = this.isArcadeHandBrakeActive || this.isArcadeWheelSkidActive || this.isArcadeBurnoutModeActive || this.isArcadeDonutModeActive;
+        if (!arcadeSlideActive && this.sideToSideStabilityEnabled && absSpeedKmh > this.sideToSideStabilityStartKmh) {
             var sideBlendRange = this.sideToSideStabilityFullKmh - this.sideToSideStabilityStartKmh;
             if (sideBlendRange > 0) {
                 sideBlendToCoM = 0.7 * Math.min((absSpeedKmh - this.sideToSideStabilityStartKmh) / sideBlendRange, 1.0);
@@ -20521,12 +21184,22 @@ export class btRaycastVehicle {
     clampChassisYawRate(deltaTime) {
         if (this.maximumYawRateLow <= 0 && this.maximumYawRateHigh <= 0)
             return;
-        const arcadeActive = (this.isArcadeHandBrakeActive === true || this.isArcadeBurnoutModeActive === true || this.isArcadeDonutModeActive === true || this.isArcadeWheelSkidActive === true);
-        if (arcadeActive === true && this.arcadeYawCapMultiplier <= 0)
+        const arcadeActive = (this.isArcadeHandBrakeActive === true || this.isArcadeBurnoutModeActive === true || this.isArcadeDonutModeActive === true);
+        if (arcadeActive === true && this.isArcadeHandBrakeActive === true && this.arcadeHandbrakeYawCapMultiplier <= 0)
+            return;
+        if (arcadeActive === true && this.isArcadeBurnoutModeActive === true && this.arcadeBurnoutYawCapMultiplier <= 0)
+            return;
+        if (arcadeActive === true && this.isArcadeDonutModeActive === true && this.arcadeDonutYawCapMultiplier <= 0)
             return;
         let capDeg = Scalar.Lerp(this.maximumYawRateLow, this.maximumYawRateHigh, this.smoothedGradientSpeed);
-        if (arcadeActive === true)
-            capDeg *= this.arcadeYawCapMultiplier;
+        if (arcadeActive === true) {
+            if (this.isArcadeHandBrakeActive === true)
+                capDeg *= this.arcadeHandbrakeYawCapMultiplier;
+            if (this.isArcadeBurnoutModeActive === true)
+                capDeg *= this.arcadeBurnoutYawCapMultiplier;
+            if (this.isArcadeDonutModeActive === true)
+                capDeg *= this.arcadeDonutYawCapMultiplier;
+        }
         if (capDeg <= 0)
             return;
         const capRad = Tools.ToRadians(capDeg);
@@ -22189,81 +22862,59 @@ export class RaycastVehicle {
             this.m_vehicle.arcadeSteeringAssist = value;
         }
     }
-    getArcadeDonutDirectYawDegPerSec() {
-        if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeDonutDirectYawDegPerSec;
-        }
-        return 1.0;
-    }
-    setArcadeDonutDirectYawDegPerSec(value) {
-        if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeDonutDirectYawDegPerSec = value;
-        }
-    }
-    getArcadeHandbrakeDirectYawDegPerSec() {
-        if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeHandbrakeDirectYawDegPerSec;
-        }
-        return 1.0;
-    }
-    setArcadeHandbrakeDirectYawDegPerSec(value) {
-        if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeHandbrakeDirectYawDegPerSec = value;
-        }
-    }
-    getArcadeHandbrakeMaxSlideAngleDeg() {
+    getArcadeDonutDirectYawEnabled() {
         if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeHandbrakeMaxSlideAngleDeg;
+            return this.m_vehicle.arcadeDonutDirectYawEnabled;
         }
-        return 1.0;
+        return false;
     }
-    setArcadeHandbrakeMaxSlideAngleDeg(value) {
+    setArcadeDonutDirectYawEnabled(value) {
         if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeHandbrakeMaxSlideAngleDeg = value;
+            this.m_vehicle.arcadeDonutDirectYawEnabled = value;
         }
     }
-    getArcadeHandbrakeBicycleYawAuthority() {
+    getArcadeDonutDirectYawDegPerSec() {
         if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeHandbrakeYawAuthority;
+            return this.m_vehicle.arcadeDonutDirectYawDegPerSec;
         }
         return 1.0;
     }
-    setArcadeHandbrakeBicycleYawAuthority(value) {
+    setArcadeDonutDirectYawDegPerSec(value) {
         if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeHandbrakeYawAuthority = value;
+            this.m_vehicle.arcadeDonutDirectYawDegPerSec = value;
         }
     }
-    getArcadeHandbrakeMaxYawRateDegPerSec() {
+    getArcadeHandbrakeYawCapMultiplier() {
         if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeHandbrakeMaxYawRateDegPerSec;
+            return this.m_vehicle.arcadeHandbrakeYawCapMultiplier;
         }
         return 1.0;
     }
-    setArcadeHandbrakeMaxYawRateDegPerSec(value) {
+    setArcadeHandbrakeYawCapMultiplier(value) {
         if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeHandbrakeMaxYawRateDegPerSec = value;
+            this.m_vehicle.arcadeHandbrakeYawCapMultiplier = value;
         }
     }
-    getArcadeHandbrakeReferenceSpeedKmh() {
+    getArcadeBurnoutYawCapMultiplier() {
         if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeHandbrakeReferenceSpeedKmh;
+            return this.m_vehicle.arcadeBurnoutYawCapMultiplier;
         }
         return 1.0;
     }
-    setArcadeHandbrakeReferenceSpeedKmh(value) {
+    setArcadeBurnoutYawCapMultiplier(value) {
         if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeHandbrakeReferenceSpeedKmh = value;
+            this.m_vehicle.arcadeBurnoutYawCapMultiplier = value;
         }
     }
-    getArcadeHandbrakeKickStrengthDegPerSec() {
+    getArcadeDonutYawCapMultiplier() {
         if (this.m_vehicle != null) {
-            return this.m_vehicle.arcadeHandbrakeKickStrengthDegPerSec;
+            return this.m_vehicle.arcadeDonutYawCapMultiplier;
         }
         return 1.0;
     }
-    setArcadeHandbrakeKickStrengthDegPerSec(value) {
+    setArcadeDonutYawCapMultiplier(value) {
         if (this.m_vehicle != null) {
-            this.m_vehicle.arcadeHandbrakeKickStrengthDegPerSec = value;
+            this.m_vehicle.arcadeDonutYawCapMultiplier = value;
         }
     }
     getArcadeBurnoutActive() {
@@ -22525,22 +23176,6 @@ export class RaycastVehicle {
             this.m_vehicle.wheelAtRestSpeedThresholdKmh = value;
         }
     }
-    setWheelSpinDebugLogEnabled(enabled) {
-        if (this.m_vehicle != null) {
-            this.m_vehicle.wheelSpinDebugLogEnabled = enabled;
-        }
-    }
-    getWheelSpinDebugLogEnabled() {
-        if (this.m_vehicle != null) {
-            return this.m_vehicle.wheelSpinDebugLogEnabled;
-        }
-        return false;
-    }
-    setWheelSpinDebugLogIntervalFrames(frames) {
-        if (this.m_vehicle != null) {
-            this.m_vehicle.wheelSpinDebugLogIntervalFrames = frames;
-        }
-    }
     updateWheelInformation() {
         const wheels = this.getNumWheels();
         if (wheels > 0) {