@babylonjs-toolkit/next 9.0.1

package/lib/treebranchmaterial.js

@@ -0,0 +1,369 @@
+import { Vector4, Vector3 } from '@babylonjs/core/Maths/math.vector';
+import { CustomShaderMaterial, SceneManager, CustomShaderMaterialPlugin } from './scenemanager';
+import { ShaderLanguage } from '@babylonjs/core/Materials';
+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;
+    }
+}

package/lib/triggervolume.d.ts

@@ -0,0 +1,6 @@
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+export declare class TriggerVolume {
+    mesh: AbstractMesh;
+    state: number;
+}
+//# sourceMappingURL=triggervolume.d.ts.map

package/lib/triggervolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggervolume.d.ts","sourceRoot":"","sources":["../src/triggervolume.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAEnE,qBAAa,aAAa;IACX,IAAI,EAAE,YAAY,CAAQ;IAC1B,KAAK,EAAE,MAAM,CAAK;CAC5B"}

package/lib/triggervolume.js

@@ -0,0 +1,6 @@
+export class TriggerVolume {
+    constructor() {
+        this.mesh = null;
+        this.state = 0;
+    }
+}

package/lib/unitydropdownmenu.d.ts

@@ -0,0 +1,20 @@
+import { AdvancedDynamicTexture } from '@babylonjs/gui/2D/advancedDynamicTexture';
+import { Container } from '@babylonjs/gui/2D/controls/container';
+export declare class UnityDropdownMenu extends Container {
+    private _button;
+    private _popup;
+    private _options;
+    private _selectedIndex;
+    constructor(name?: string);
+    get selectedIndex(): number;
+    set selectedIndex(v: number);
+    set options(opts: Array<{
+        text: string;
+        imageSource?: string;
+    }>);
+    private _updateSelectedText;
+    private _rebuildOptions;
+    serialize(): any;
+    static Parse(parsedData: any, adt: AdvancedDynamicTexture, urlRewriter?: (url: string) => string): UnityDropdownMenu;
+}
+//# sourceMappingURL=unitydropdownmenu.d.ts.map

package/lib/unitydropdownmenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unitydropdownmenu.d.ts","sourceRoot":"","sources":["../src/unitydropdownmenu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAElF,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAMjE,qBAAa,iBAAkB,SAAQ,SAAS;IACxC,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,QAAQ,CAAqD;IACrE,OAAO,CAAC,cAAc,CAAa;gBAEvB,IAAI,CAAC,EAAE,MAAM;IAmEzB,IAAW,aAAa,IAAI,MAAM,CAAgC;IAClE,IAAW,aAAa,CAAC,CAAC,EAAE,MAAM,EAA0D;IAE5F,IAAW,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAGrE;IAED,OAAO,CAAC,mBAAmB;IAS3B,OAAO,CAAC,eAAe;IAyChB,SAAS,IAAI,GAAG;WAcT,KAAK,CAAC,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,sBAAsB,EAAE,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,iBAAiB;CAY9H"}

package/lib/unitydropdownmenu.js

@@ -0,0 +1,144 @@
+import { Button } from '@babylonjs/gui/2D/controls/button';
+import { Container } from '@babylonjs/gui/2D/controls/container';
+import { Control } from '@babylonjs/gui/2D/controls/control';
+import { TextBlock } from '@babylonjs/gui/2D/controls/textBlock';
+import { StackPanel } from '@babylonjs/gui/2D/controls/stackPanel';
+export class UnityDropdownMenu extends Container {
+    constructor(name) {
+        super(name || "dropdownMenu");
+        this._button = null;
+        this._popup = null;
+        this._options = [];
+        this._selectedIndex = 0;
+        this.width = "150px";
+        this.height = "30px";
+        this.thickness = 1;
+        this.cornerRadius = 3;
+        this.color = "#333333";
+        this.background = "transparent";
+        console.warn("DropdownMenu is a custom control and may not be fully supported in all environments.");
+        this._button = Button.CreateSimpleButton((this.name || "") + "_btn", "");
+        this._button.width = "100%";
+        this._button.height = "100%";
+        this._button.horizontalAlignment = Control.HORIZONTAL_ALIGNMENT_LEFT;
+        this._button.verticalAlignment = Control.VERTICAL_ALIGNMENT_CENTER;
+        this._button.cornerRadius = 3;
+        this._button.thickness = 0;
+        this._button.color = "#000000";
+        this._button.background = "#ffffff00";
+        const textBlock = new TextBlock((this.name || "") + "_label", "");
+        textBlock.textHorizontalAlignment = Control.HORIZONTAL_ALIGNMENT_LEFT;
+        textBlock.paddingLeft = "8px";
+        textBlock.resizeToFit = false;
+        textBlock.text = "";
+        textBlock.color = "#000000";
+        textBlock.fontSize = "14px";
+        textBlock.textWrapping = true;
+        this._button.addControl(textBlock);
+        const arrow = new TextBlock((this.name || "") + "_arrow", "▼");
+        arrow.width = "24px";
+        arrow.textHorizontalAlignment = Control.HORIZONTAL_ALIGNMENT_CENTER;
+        arrow.horizontalAlignment = Control.HORIZONTAL_ALIGNMENT_RIGHT;
+        arrow.paddingRight = "6px";
+        arrow.color = "#222222";
+        this._button.addControl(arrow);
+        this._popup = new Container((this.name || "") + "_popup");
+        this._popup.width = "150px";
+        this._popup.isVisible = false;
+        this._popup.background = "#ffffff";
+        this._popup.thickness = 1;
+        this._popup.cornerRadius = 3;
+        this._popup.zIndex = 1000;
+        this._popup.verticalAlignment = Control.VERTICAL_ALIGNMENT_TOP;
+        const stack = new StackPanel((this.name || "") + "_stack");
+        stack.isVertical = true;
+        this._popup.addControl(stack);
+        this._button.onPointerUpObservable.add(() => {
+            if (!this._popup)
+                return;
+            this._popup.isVisible = !this._popup.isVisible;
+        });
+        this.addControl(this._button);
+        this.addControl(this._popup);
+    }
+    get selectedIndex() { return this._selectedIndex; }
+    set selectedIndex(v) { this._selectedIndex = v; this._updateSelectedText(); }
+    set options(opts) {
+        this._options = opts || [];
+        this._rebuildOptions();
+    }
+    _updateSelectedText() {
+        if (!this._button)
+            return;
+        const label = this._button.getChildByName((this.name || "") + "_label");
+        if (label) {
+            const opt = this._options[this._selectedIndex];
+            label.text = opt ? opt.text : "";
+        }
+    }
+    _rebuildOptions() {
+        if (!this._popup)
+            return;
+        this._popup.dispose();
+        this._popup = new Container((this.name || "") + "_popup");
+        this._popup.width = "150px";
+        this._popup.isVisible = false;
+        this._popup.background = "#ffffff";
+        this._popup.thickness = 1;
+        this._popup.cornerRadius = 3;
+        this._popup.zIndex = 1000;
+        this._popup.verticalAlignment = Control.VERTICAL_ALIGNMENT_TOP;
+        const stack = new StackPanel((this.name || "") + "_stack");
+        stack.isVertical = true;
+        this._popup.addControl(stack);
+        for (let i = 0; i < this._options.length; i++) {
+            const o = this._options[i];
+            const btn = Button.CreateSimpleButton((this.name || "") + "_opt_" + i, o.text || "");
+            btn.width = "100%";
+            btn.height = "28px";
+            btn.thickness = 0;
+            btn.cornerRadius = 0;
+            btn.color = "#000000";
+            btn.horizontalAlignment = Control.HORIZONTAL_ALIGNMENT_LEFT;
+            btn.onPointerUpObservable.add(() => {
+                this.selectedIndex = i;
+                if (this._popup)
+                    this._popup.isVisible = false;
+                this.onSelectionChanged && this.onSelectionChanged(i);
+            });
+            stack.addControl(btn);
+        }
+        this.addControl(this._popup);
+        this._updateSelectedText();
+    }
+    serialize() {
+        let base = {};
+        try {
+            const protoSerialize = Container.prototype.serialize;
+            if (typeof protoSerialize === 'function')
+                base = protoSerialize.call(this) || {};
+        }
+        catch (e) {
+            base = {};
+        }
+        base = base || {};
+        base.className = "UnityDropdownMenu";
+        base.options = this._options.map(o => ({ text: o.text, imageSource: o.imageSource }));
+        base.selectedIndex = this._selectedIndex;
+        return base;
+    }
+    static Parse(parsedData, adt, urlRewriter) {
+        const ctrl = new UnityDropdownMenu(parsedData.name || "dropdownMenu");
+        try {
+            if (Array.isArray(parsedData.options)) {
+                ctrl.options = parsedData.options.map((o) => ({ text: o.text || "", imageSource: o.imageSource }));
+            }
+            if (typeof parsedData.selectedIndex === 'number')
+                ctrl.selectedIndex = parsedData.selectedIndex;
+        }
+        catch (e) {
+            console.warn(e);
+        }
+        return ctrl;
+    }
+}

package/lib/unityscrollbar.d.ts

@@ -0,0 +1,11 @@
+import { AdvancedDynamicTexture } from '@babylonjs/gui/2D/advancedDynamicTexture';
+import { ScrollBar } from '@babylonjs/gui/2D/controls/sliders/scrollBar';
+export declare class UnityScrollBar extends ScrollBar {
+    private _direction;
+    get direction(): string;
+    set direction(value: string);
+    protected _getThumbPosition(): number;
+    serialize(serializationObject: any): void;
+    _parseFromContent(serializationObject: any, host: AdvancedDynamicTexture): void;
+}
+//# sourceMappingURL=unityscrollbar.d.ts.map

package/lib/unityscrollbar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unityscrollbar.d.ts","sourceRoot":"","sources":["../src/unityscrollbar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,MAAM,8CAA8C,CAAC;AAEzE,qBAAa,cAAe,SAAQ,SAAS;IACrC,OAAO,CAAC,UAAU,CAAyB;IAE3C,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED,IAAW,SAAS,CAAC,KAAK,EAAE,MAAM,EAGjC;IAED,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAkBrB,SAAS,CAAC,mBAAmB,EAAE,GAAG;IAKlC,iBAAiB,CAAC,mBAAmB,EAAE,GAAG,EAAE,IAAI,EAAE,sBAAsB;CAM3F"}

package/lib/unityscrollbar.js

@@ -0,0 +1,38 @@
+import { ScrollBar } from '@babylonjs/gui/2D/controls/sliders/scrollBar';
+export class UnityScrollBar extends ScrollBar {
+    constructor() {
+        super(...arguments);
+        this._direction = "LeftToRight";
+    }
+    get direction() {
+        return this._direction;
+    }
+    set direction(value) {
+        this._direction = value;
+        this._markAsDirty();
+    }
+    _getThumbPosition() {
+        const normalizedValue = (this.value - this.minimum) / (this.maximum - this.minimum);
+        const maxPosition = this.isVertical ?
+            this._currentMeasure.height - this._effectiveThumbThickness :
+            this._currentMeasure.width - this._effectiveThumbThickness;
+        let position = normalizedValue * maxPosition;
+        if (this._direction === "RightToLeft" && !this.isVertical) {
+            position = maxPosition - position;
+        }
+        else if (this._direction === "TopToBottom" && this.isVertical) {
+            position = maxPosition - position;
+        }
+        return position;
+    }
+    serialize(serializationObject) {
+        super.serialize(serializationObject);
+        serializationObject.direction = this._direction;
+    }
+    _parseFromContent(serializationObject, host) {
+        super._parseFromContent(serializationObject, host);
+        if (serializationObject.direction) {
+            this._direction = serializationObject.direction;
+        }
+    }
+}

package/lib/unityslider.d.ts

@@ -0,0 +1,4 @@
+import { Slider } from '@babylonjs/gui/2D/controls/sliders/slider';
+export declare class UnitySlider extends Slider {
+}
+//# sourceMappingURL=unityslider.d.ts.map

package/lib/unityslider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unityslider.d.ts","sourceRoot":"","sources":["../src/unityslider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,qBAAa,WAAY,SAAQ,MAAM;CAElC"}

package/lib/unityslider.js

@@ -0,0 +1,3 @@
+import { Slider } from '@babylonjs/gui/2D/controls/sliders/slider';
+export class UnitySlider extends Slider {
+}

package/lib/universalcharactercontroller.d.ts

@@ -0,0 +1,3 @@
+import { SimpleCharacterController, RecastCharacterController, CharacterController } from './scenemanager';
+export type UniversalCharacterController = CharacterController | SimpleCharacterController | RecastCharacterController;
+//# sourceMappingURL=universalcharactercontroller.d.ts.map

package/lib/universalcharactercontroller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universalcharactercontroller.d.ts","sourceRoot":"","sources":["../src/universalcharactercontroller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE3G,MAAM,MAAM,4BAA4B,GAAG,mBAAmB,GAAG,yBAAyB,GAAG,yBAAyB,CAAC"}

package/lib/universalcharactercontroller.js

@@ -0,0 +1 @@
+export {};