@babylonjs-toolkit/next 9.0.1

package/lib/simplexnoise.d.ts

@@ -0,0 +1,21 @@
+import { RandomFn } from './randomfn';
+import { NoiseFunction2D } from './noisefunction2d';
+import { NoiseFunction3D } from './noisefunction3d';
+import { NoiseFunction4D } from './noisefunction4d';
+export declare class SimplexNoise {
+    private static readonly F2;
+    private static readonly G2;
+    private static readonly F3;
+    private static readonly G3;
+    private static readonly F4;
+    private static readonly G4;
+    private static readonly grad2;
+    private static readonly grad3;
+    private static readonly grad4;
+    private static fastFloor;
+    static createNoise2D(random?: RandomFn): NoiseFunction2D;
+    static createNoise3D(random?: RandomFn): NoiseFunction3D;
+    static createNoise4D(random?: RandomFn): NoiseFunction4D;
+    static buildPermutationTable(random: RandomFn): Uint8Array;
+}
+//# sourceMappingURL=simplexnoise.d.ts.map

package/lib/simplexnoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplexnoise.d.ts","sourceRoot":"","sources":["../src/simplexnoise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,YAAY;IAErB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA8C;IACxE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA8C;IACxE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAa;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAa;IACvC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA8C;IACxE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAA+C;IAEzE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAcnB;IAIV,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAcf;IAGd,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAO8B;IAK3D,OAAO,CAAC,MAAM,CAAC,SAAS;WASV,aAAa,CAAC,MAAM,GAAE,QAAsB,GAAG,eAAe;WA+E9D,aAAa,CAAC,MAAM,GAAE,QAAsB,GAAG,eAAe;WAqI9D,aAAa,CAAC,MAAM,GAAE,QAAsB,GAAG,eAAe;WA0I9D,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,UAAU;CAiBlE"}

package/lib/simplexnoise.js

@@ -0,0 +1,362 @@
+export class SimplexNoise {
+    static fastFloor(x) {
+        return Math.floor(x) | 0;
+    }
+    static createNoise2D(random = Math.random) {
+        const perm = SimplexNoise.buildPermutationTable(random);
+        const permGrad2x = new Float64Array(perm).map(v => SimplexNoise.grad2[(v % 12) * 2]);
+        const permGrad2y = new Float64Array(perm).map(v => SimplexNoise.grad2[(v % 12) * 2 + 1]);
+        return function noise2D(x, y) {
+            let n0 = 0;
+            let n1 = 0;
+            let n2 = 0;
+            const s = (x + y) * SimplexNoise.F2;
+            const i = SimplexNoise.fastFloor(x + s);
+            const j = SimplexNoise.fastFloor(y + s);
+            const t = (i + j) * SimplexNoise.G2;
+            const X0 = i - t;
+            const Y0 = j - t;
+            const x0 = x - X0;
+            const y0 = y - Y0;
+            let i1, j1;
+            if (x0 > y0) {
+                i1 = 1;
+                j1 = 0;
+            }
+            else {
+                i1 = 0;
+                j1 = 1;
+            }
+            const x1 = x0 - i1 + SimplexNoise.G2;
+            const y1 = y0 - j1 + SimplexNoise.G2;
+            const x2 = x0 - 1.0 + 2.0 * SimplexNoise.G2;
+            const y2 = y0 - 1.0 + 2.0 * SimplexNoise.G2;
+            const ii = i & 255;
+            const jj = j & 255;
+            let t0 = 0.5 - x0 * x0 - y0 * y0;
+            if (t0 >= 0) {
+                const gi0 = ii + perm[jj];
+                const g0x = permGrad2x[gi0];
+                const g0y = permGrad2y[gi0];
+                t0 *= t0;
+                n0 = t0 * t0 * (g0x * x0 + g0y * y0);
+            }
+            let t1 = 0.5 - x1 * x1 - y1 * y1;
+            if (t1 >= 0) {
+                const gi1 = ii + i1 + perm[jj + j1];
+                const g1x = permGrad2x[gi1];
+                const g1y = permGrad2y[gi1];
+                t1 *= t1;
+                n1 = t1 * t1 * (g1x * x1 + g1y * y1);
+            }
+            let t2 = 0.5 - x2 * x2 - y2 * y2;
+            if (t2 >= 0) {
+                const gi2 = ii + 1 + perm[jj + 1];
+                const g2x = permGrad2x[gi2];
+                const g2y = permGrad2y[gi2];
+                t2 *= t2;
+                n2 = t2 * t2 * (g2x * x2 + g2y * y2);
+            }
+            return 70.0 * (n0 + n1 + n2);
+        };
+    }
+    static createNoise3D(random = Math.random) {
+        const perm = SimplexNoise.buildPermutationTable(random);
+        const permGrad3x = new Float64Array(perm).map(v => SimplexNoise.grad3[(v % 12) * 3]);
+        const permGrad3y = new Float64Array(perm).map(v => SimplexNoise.grad3[(v % 12) * 3 + 1]);
+        const permGrad3z = new Float64Array(perm).map(v => SimplexNoise.grad3[(v % 12) * 3 + 2]);
+        return function noise3D(x, y, z) {
+            let n0, n1, n2, n3;
+            const s = (x + y + z) * SimplexNoise.F3;
+            const i = SimplexNoise.fastFloor(x + s);
+            const j = SimplexNoise.fastFloor(y + s);
+            const k = SimplexNoise.fastFloor(z + s);
+            const t = (i + j + k) * SimplexNoise.G3;
+            const X0 = i - t;
+            const Y0 = j - t;
+            const Z0 = k - t;
+            const x0 = x - X0;
+            const y0 = y - Y0;
+            const z0 = z - Z0;
+            let i1, j1, k1;
+            let i2, j2, k2;
+            if (x0 >= y0) {
+                if (y0 >= z0) {
+                    i1 = 1;
+                    j1 = 0;
+                    k1 = 0;
+                    i2 = 1;
+                    j2 = 1;
+                    k2 = 0;
+                }
+                else if (x0 >= z0) {
+                    i1 = 1;
+                    j1 = 0;
+                    k1 = 0;
+                    i2 = 1;
+                    j2 = 0;
+                    k2 = 1;
+                }
+                else {
+                    i1 = 0;
+                    j1 = 0;
+                    k1 = 1;
+                    i2 = 1;
+                    j2 = 0;
+                    k2 = 1;
+                }
+            }
+            else {
+                if (y0 < z0) {
+                    i1 = 0;
+                    j1 = 0;
+                    k1 = 1;
+                    i2 = 0;
+                    j2 = 1;
+                    k2 = 1;
+                }
+                else if (x0 < z0) {
+                    i1 = 0;
+                    j1 = 1;
+                    k1 = 0;
+                    i2 = 0;
+                    j2 = 1;
+                    k2 = 1;
+                }
+                else {
+                    i1 = 0;
+                    j1 = 1;
+                    k1 = 0;
+                    i2 = 1;
+                    j2 = 1;
+                    k2 = 0;
+                }
+            }
+            const x1 = x0 - i1 + SimplexNoise.G3;
+            const y1 = y0 - j1 + SimplexNoise.G3;
+            const z1 = z0 - k1 + SimplexNoise.G3;
+            const x2 = x0 - i2 + 2.0 * SimplexNoise.G3;
+            const y2 = y0 - j2 + 2.0 * SimplexNoise.G3;
+            const z2 = z0 - k2 + 2.0 * SimplexNoise.G3;
+            const x3 = x0 - 1.0 + 3.0 * SimplexNoise.G3;
+            const y3 = y0 - 1.0 + 3.0 * SimplexNoise.G3;
+            const z3 = z0 - 1.0 + 3.0 * SimplexNoise.G3;
+            const ii = i & 255;
+            const jj = j & 255;
+            const kk = k & 255;
+            let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+            if (t0 < 0)
+                n0 = 0.0;
+            else {
+                const gi0 = ii + perm[jj + perm[kk]];
+                t0 *= t0;
+                n0 = t0 * t0 * (permGrad3x[gi0] * x0 + permGrad3y[gi0] * y0 + permGrad3z[gi0] * z0);
+            }
+            let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+            if (t1 < 0)
+                n1 = 0.0;
+            else {
+                const gi1 = ii + i1 + perm[jj + j1 + perm[kk + k1]];
+                t1 *= t1;
+                n1 = t1 * t1 * (permGrad3x[gi1] * x1 + permGrad3y[gi1] * y1 + permGrad3z[gi1] * z1);
+            }
+            let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+            if (t2 < 0)
+                n2 = 0.0;
+            else {
+                const gi2 = ii + i2 + perm[jj + j2 + perm[kk + k2]];
+                t2 *= t2;
+                n2 = t2 * t2 * (permGrad3x[gi2] * x2 + permGrad3y[gi2] * y2 + permGrad3z[gi2] * z2);
+            }
+            let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+            if (t3 < 0)
+                n3 = 0.0;
+            else {
+                const gi3 = ii + 1 + perm[jj + 1 + perm[kk + 1]];
+                t3 *= t3;
+                n3 = t3 * t3 * (permGrad3x[gi3] * x3 + permGrad3y[gi3] * y3 + permGrad3z[gi3] * z3);
+            }
+            return 32.0 * (n0 + n1 + n2 + n3);
+        };
+    }
+    static createNoise4D(random = Math.random) {
+        const perm = SimplexNoise.buildPermutationTable(random);
+        const permGrad4x = new Float64Array(perm).map(v => SimplexNoise.grad4[(v % 32) * 4]);
+        const permGrad4y = new Float64Array(perm).map(v => SimplexNoise.grad4[(v % 32) * 4 + 1]);
+        const permGrad4z = new Float64Array(perm).map(v => SimplexNoise.grad4[(v % 32) * 4 + 2]);
+        const permGrad4w = new Float64Array(perm).map(v => SimplexNoise.grad4[(v % 32) * 4 + 3]);
+        return function noise4D(x, y, z, w) {
+            let n0, n1, n2, n3, n4;
+            const s = (x + y + z + w) * SimplexNoise.F4;
+            const i = SimplexNoise.fastFloor(x + s);
+            const j = SimplexNoise.fastFloor(y + s);
+            const k = SimplexNoise.fastFloor(z + s);
+            const l = SimplexNoise.fastFloor(w + s);
+            const t = (i + j + k + l) * SimplexNoise.G4;
+            const X0 = i - t;
+            const Y0 = j - t;
+            const Z0 = k - t;
+            const W0 = l - t;
+            const x0 = x - X0;
+            const y0 = y - Y0;
+            const z0 = z - Z0;
+            const w0 = w - W0;
+            let rankx = 0;
+            let ranky = 0;
+            let rankz = 0;
+            let rankw = 0;
+            if (x0 > y0)
+                rankx++;
+            else
+                ranky++;
+            if (x0 > z0)
+                rankx++;
+            else
+                rankz++;
+            if (x0 > w0)
+                rankx++;
+            else
+                rankw++;
+            if (y0 > z0)
+                ranky++;
+            else
+                rankz++;
+            if (y0 > w0)
+                ranky++;
+            else
+                rankw++;
+            if (z0 > w0)
+                rankz++;
+            else
+                rankw++;
+            const i1 = rankx >= 3 ? 1 : 0;
+            const j1 = ranky >= 3 ? 1 : 0;
+            const k1 = rankz >= 3 ? 1 : 0;
+            const l1 = rankw >= 3 ? 1 : 0;
+            const i2 = rankx >= 2 ? 1 : 0;
+            const j2 = ranky >= 2 ? 1 : 0;
+            const k2 = rankz >= 2 ? 1 : 0;
+            const l2 = rankw >= 2 ? 1 : 0;
+            const i3 = rankx >= 1 ? 1 : 0;
+            const j3 = ranky >= 1 ? 1 : 0;
+            const k3 = rankz >= 1 ? 1 : 0;
+            const l3 = rankw >= 1 ? 1 : 0;
+            const x1 = x0 - i1 + SimplexNoise.G4;
+            const y1 = y0 - j1 + SimplexNoise.G4;
+            const z1 = z0 - k1 + SimplexNoise.G4;
+            const w1 = w0 - l1 + SimplexNoise.G4;
+            const x2 = x0 - i2 + 2.0 * SimplexNoise.G4;
+            const y2 = y0 - j2 + 2.0 * SimplexNoise.G4;
+            const z2 = z0 - k2 + 2.0 * SimplexNoise.G4;
+            const w2 = w0 - l2 + 2.0 * SimplexNoise.G4;
+            const x3 = x0 - i3 + 3.0 * SimplexNoise.G4;
+            const y3 = y0 - j3 + 3.0 * SimplexNoise.G4;
+            const z3 = z0 - k3 + 3.0 * SimplexNoise.G4;
+            const w3 = w0 - l3 + 3.0 * SimplexNoise.G4;
+            const x4 = x0 - 1.0 + 4.0 * SimplexNoise.G4;
+            const y4 = y0 - 1.0 + 4.0 * SimplexNoise.G4;
+            const z4 = z0 - 1.0 + 4.0 * SimplexNoise.G4;
+            const w4 = w0 - 1.0 + 4.0 * SimplexNoise.G4;
+            const ii = i & 255;
+            const jj = j & 255;
+            const kk = k & 255;
+            const ll = l & 255;
+            let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+            if (t0 < 0)
+                n0 = 0.0;
+            else {
+                const gi0 = ii + perm[jj + perm[kk + perm[ll]]];
+                t0 *= t0;
+                n0 = t0 * t0 * (permGrad4x[gi0] * x0 + permGrad4y[gi0] * y0 + permGrad4z[gi0] * z0 + permGrad4w[gi0] * w0);
+            }
+            let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+            if (t1 < 0)
+                n1 = 0.0;
+            else {
+                const gi1 = ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]];
+                t1 *= t1;
+                n1 = t1 * t1 * (permGrad4x[gi1] * x1 + permGrad4y[gi1] * y1 + permGrad4z[gi1] * z1 + permGrad4w[gi1] * w1);
+            }
+            let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+            if (t2 < 0)
+                n2 = 0.0;
+            else {
+                const gi2 = ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]];
+                t2 *= t2;
+                n2 = t2 * t2 * (permGrad4x[gi2] * x2 + permGrad4y[gi2] * y2 + permGrad4z[gi2] * z2 + permGrad4w[gi2] * w2);
+            }
+            let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+            if (t3 < 0)
+                n3 = 0.0;
+            else {
+                const gi3 = ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]];
+                t3 *= t3;
+                n3 = t3 * t3 * (permGrad4x[gi3] * x3 + permGrad4y[gi3] * y3 + permGrad4z[gi3] * z3 + permGrad4w[gi3] * w3);
+            }
+            let t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+            if (t4 < 0)
+                n4 = 0.0;
+            else {
+                const gi4 = ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]];
+                t4 *= t4;
+                n4 = t4 * t4 * (permGrad4x[gi4] * x4 + permGrad4y[gi4] * y4 + permGrad4z[gi4] * z4 + permGrad4w[gi4] * w4);
+            }
+            return 27.0 * (n0 + n1 + n2 + n3 + n4);
+        };
+    }
+    static buildPermutationTable(random) {
+        const tableSize = 512;
+        const p = new Uint8Array(tableSize);
+        for (let i = 0; i < tableSize / 2; i++) {
+            p[i] = i;
+        }
+        for (let i = 0; i < tableSize / 2 - 1; i++) {
+            const r = i + ~~(random() * (256 - i));
+            const aux = p[i];
+            p[i] = p[r];
+            p[r] = aux;
+        }
+        for (let i = 256; i < tableSize; i++) {
+            p[i] = p[i - 256];
+        }
+        return p;
+    }
+}
+SimplexNoise.F2 = 0.5 * (Math.sqrt(3.0) - 1.0);
+SimplexNoise.G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
+SimplexNoise.F3 = 1.0 / 3.0;
+SimplexNoise.G3 = 1.0 / 6.0;
+SimplexNoise.F4 = (Math.sqrt(5.0) - 1.0) / 4.0;
+SimplexNoise.G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
+SimplexNoise.grad2 = new Float64Array([1, 1,
+    -1, 1,
+    1, -1,
+    -1, -1,
+    1, 0,
+    -1, 0,
+    1, 0,
+    -1, 0,
+    0, 1,
+    0, -1,
+    0, 1,
+    0, -1]);
+SimplexNoise.grad3 = new Float64Array([1, 1, 0,
+    -1, 1, 0,
+    1, -1, 0,
+    -1, -1, 0,
+    1, 0, 1,
+    -1, 0, 1,
+    1, 0, -1,
+    -1, 0, -1,
+    0, 1, 1,
+    0, -1, 1,
+    0, 1, -1,
+    0, -1, -1]);
+SimplexNoise.grad4 = new Float64Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1,
+    0, -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1,
+    1, 0, 1, 1, 1, 0, 1, -1, 1, 0, -1, 1, 1, 0, -1, -1,
+    -1, 0, 1, 1, -1, 0, 1, -1, -1, 0, -1, 1, -1, 0, -1, -1,
+    1, 1, 0, 1, 1, 1, 0, -1, 1, -1, 0, 1, 1, -1, 0, -1,
+    -1, 1, 0, 1, -1, 1, 0, -1, -1, -1, 0, 1, -1, -1, 0, -1,
+    1, 1, 1, 0, 1, 1, -1, 0, 1, -1, 1, 0, 1, -1, -1, 0,
+    -1, 1, 1, 0, -1, 1, -1, 0, -1, -1, 1, 0, -1, -1, -1, 0]);

package/lib/touchjoystickhandler.d.ts

@@ -0,0 +1,39 @@
+import { TouchMouseButton } from './touchmousebutton';
+export declare class TouchJoystickHandler {
+    private isFixed;
+    private touchId;
+    private pointerId;
+    private dragStart;
+    private mouseButton;
+    private maxDistance;
+    private deadZone;
+    private xvalue;
+    private yvalue;
+    private stick;
+    private base;
+    private active;
+    enabled: boolean;
+    updateElements: boolean;
+    preventDefault: boolean;
+    stopPropagation: boolean;
+    baseElementOpacity: string;
+    stickElementOpacity: string;
+    onHandleDown: (event: any) => void;
+    onHandleMove: (event: any) => void;
+    onHandleUp: (event: any) => void;
+    constructor(stickid: string, maxdistance: number, deadzone: number, fixed?: boolean, button?: TouchMouseButton, baseid?: string);
+    dispose(): void;
+    isActive(): boolean;
+    getValueX(): number;
+    getValueY(): number;
+    getMouseButton(): TouchMouseButton;
+    getBaseElement(): HTMLElement;
+    getStickElement(): HTMLElement;
+    isFixedJoystick(): boolean;
+    protected handleDown(event: any): void;
+    protected handleMove(event: any): void;
+    protected handleUp(event: any): void;
+    protected showBaseElement(event: any): void;
+    hideBaseElement(): void;
+}
+//# sourceMappingURL=touchjoystickhandler.d.ts.map

package/lib/touchjoystickhandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchjoystickhandler.d.ts","sourceRoot":"","sources":["../src/touchjoystickhandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAItD,qBAAa,oBAAoB;IACzB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,SAAS,CAAyC;IAC1D,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,IAAI,CAA4B;IACxC,OAAO,CAAC,MAAM,CAAkB;IACzB,OAAO,EAAE,OAAO,CAAQ;IACxB,cAAc,EAAE,OAAO,CAAQ;IAC/B,cAAc,EAAE,OAAO,CAAQ;IAC/B,eAAe,EAAE,OAAO,CAAQ;IAChC,kBAAkB,EAAE,MAAM,CAAO;IACjC,mBAAmB,EAAE,MAAM,CAAO;IAClC,YAAY,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAQ;IAC1C,YAAY,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAQ;IAC1C,UAAU,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAQ;gBAEnC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,OAAc,EAAE,MAAM,GAAE,gBAAqB,EAAE,MAAM,GAAE,MAAa;IAyBxI,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,OAAO;IACnB,SAAS,IAAI,MAAM;IACnB,SAAS,IAAI,MAAM;IACnB,cAAc,IAAI,gBAAgB;IAClC,cAAc,IAAI,WAAW;IAC7B,eAAe,IAAI,WAAW;IAC9B,eAAe,IAAI,OAAO;IAEjC,SAAS,CAAC,UAAU,CAAC,KAAK,KAAA,GAAG,IAAI;IA0BjC,SAAS,CAAC,UAAU,CAAC,KAAK,KAAA,GAAG,IAAI;IAuCjC,SAAS,CAAC,QAAQ,CAAC,KAAK,KAAA,GAAG,IAAI;IAuB/B,SAAS,CAAC,eAAe,CAAC,KAAK,KAAA,GAAG,IAAI;IAgB/B,eAAe,IAAI,IAAI;CAYjC"}

package/lib/touchjoystickhandler.js

@@ -0,0 +1,175 @@
+import { TouchMouseButton } from './touchmousebutton';
+export class TouchJoystickHandler {
+    constructor(stickid, maxdistance, deadzone, fixed = true, button = -1, baseid = null) {
+        this.isFixed = true;
+        this.touchId = null;
+        this.pointerId = null;
+        this.dragStart = null;
+        this.mouseButton = -1;
+        this.maxDistance = 48;
+        this.deadZone = 2;
+        this.xvalue = 0;
+        this.yvalue = 0;
+        this.stick = null;
+        this.base = null;
+        this.active = false;
+        this.enabled = true;
+        this.updateElements = true;
+        this.preventDefault = true;
+        this.stopPropagation = true;
+        this.baseElementOpacity = "1";
+        this.stickElementOpacity = "1";
+        this.onHandleDown = null;
+        this.onHandleMove = null;
+        this.onHandleUp = null;
+        this.isFixed = fixed;
+        this.deadZone = deadzone;
+        this.maxDistance = maxdistance;
+        this.mouseButton = button;
+        if (baseid)
+            this.base = document.getElementById(baseid);
+        if (stickid)
+            this.stick = document.getElementById(stickid);
+        if (this.base)
+            this.base.oncontextmenu = (e) => false;
+        if (this.stick)
+            this.stick.oncontextmenu = (e) => false;
+        if (this.isFixed) {
+            if (this.stick) {
+                this.stick.addEventListener("pointerdown", (e) => this.handleDown(e));
+            }
+            else {
+                console.warn("Failed to locate fixed joystick element: " + stickid);
+            }
+        }
+        else {
+            if (this.base)
+                this.base.style.opacity = "0";
+            if (this.stick)
+                this.stick.style.opacity = "0";
+            document.documentElement.addEventListener("pointerdown", (e) => this.handleDown(e));
+        }
+        document.documentElement.addEventListener("pointermove", (e) => this.handleMove(e), { passive: false });
+        document.documentElement.addEventListener("pointerup", (e) => this.handleUp(e));
+    }
+    dispose() {
+    }
+    isActive() { return this.active; }
+    getValueX() { return this.xvalue; }
+    getValueY() { return this.yvalue; }
+    getMouseButton() { return this.mouseButton; }
+    getBaseElement() { return this.base; }
+    getStickElement() { return this.stick; }
+    isFixedJoystick() { return this.isFixed; }
+    handleDown(event) {
+        if (!this.enabled)
+            return;
+        const leftButtonDown = (event.buttons & 1) === 1;
+        const rightButtonDown = (event.buttons & 2) === 2;
+        if (this.mouseButton === TouchMouseButton.Left && !leftButtonDown)
+            return;
+        if (this.mouseButton === TouchMouseButton.Right && !rightButtonDown)
+            return;
+        this.active = true;
+        this.pointerId = event.pointerId;
+        this.showBaseElement(event);
+        if (this.stick)
+            this.stick.style.transition = "0s";
+        if (this.active && this.preventDefault)
+            event.preventDefault();
+        if (event.changedTouches) {
+            this.dragStart = { x: event.changedTouches[0].clientX, y: event.changedTouches[0].clientY };
+            this.touchId = event.changedTouches[0].identifier;
+        }
+        else {
+            this.dragStart = { x: event.clientX, y: event.clientY };
+        }
+        if (this.onHandleDown)
+            this.onHandleDown(event);
+        if (this.stopPropagation)
+            event.stopPropagation();
+    }
+    handleMove(event) {
+        if (!this.enabled || !this.active || event.pointerId !== this.pointerId)
+            return;
+        if (event.changedTouches) {
+            let touchmoveId = null;
+            for (let i = 0; i < event.changedTouches.length; i++) {
+                if (this.touchId === event.changedTouches[i].identifier) {
+                    touchmoveId = i;
+                    event.clientX = event.changedTouches[i].clientX;
+                    event.clientY = event.changedTouches[i].clientY;
+                }
+            }
+            if (touchmoveId === null)
+                return;
+        }
+        const xDiff = event.clientX - this.dragStart.x;
+        const yDiff = event.clientY - this.dragStart.y;
+        const angle = Math.atan2(yDiff, xDiff);
+        const distance = Math.min(this.maxDistance, Math.hypot(xDiff, yDiff));
+        const xPosition = distance * Math.cos(angle);
+        const yPosition = distance * Math.sin(angle);
+        if (this.stick)
+            this.stick.style.transform = `translate3d(${xPosition}px, ${yPosition}px, 0px)`;
+        const distance2 = (distance < this.deadZone) ? 0 : this.maxDistance / (this.maxDistance - this.deadZone) * (distance - this.deadZone);
+        const xPosition2 = distance2 * Math.cos(angle);
+        const yPosition2 = distance2 * Math.sin(angle);
+        const xPercent = parseFloat((xPosition2 / this.maxDistance).toFixed(4));
+        const yPercent = parseFloat((yPosition2 / this.maxDistance).toFixed(4));
+        this.xvalue = xPercent;
+        this.yvalue = yPercent;
+        if (this.onHandleMove)
+            this.onHandleMove(event);
+        if (this.stopPropagation)
+            event.stopPropagation();
+    }
+    handleUp(event) {
+        if (!this.enabled || !this.active || event.pointerId !== this.pointerId)
+            return;
+        if (event.changedTouches && this.touchId !== event.changedTouches[0].identifier)
+            return;
+        if (this.stick) {
+            this.stick.style.transition = ".2s";
+            this.stick.style.transform = `translate3d(0px, 0px, 0px)`;
+        }
+        this.xvalue = 0;
+        this.yvalue = 0;
+        this.touchId = null;
+        this.pointerId = null;
+        this.active = false;
+        this.hideBaseElement();
+        if (this.onHandleUp)
+            this.onHandleUp(event);
+        if (this.stopPropagation)
+            event.stopPropagation();
+    }
+    showBaseElement(event) {
+        if (!this.isFixed && this.updateElements) {
+            if (this.base && this.base.style.opacity !== this.baseElementOpacity) {
+                const baseRect = this.base.getBoundingClientRect();
+                this.base.style.left = event.clientX - baseRect.width / 2 + "px";
+                this.base.style.top = event.clientY - baseRect.height / 2 + "px";
+                this.base.style.opacity = this.baseElementOpacity;
+            }
+            if (this.stick && this.stick.style.opacity !== this.stickElementOpacity) {
+                this.stick.style.opacity = this.stickElementOpacity;
+            }
+        }
+        else if (!this.isFixed && !this.updateElements) {
+            this.hideBaseElement();
+        }
+    }
+    hideBaseElement() {
+        if (!this.isFixed) {
+            if (this.base && this.base.style.opacity !== "0") {
+                this.base.style.opacity = "0";
+                this.base.style.left = "-1000px";
+                this.base.style.top = "-1000px";
+            }
+            if (this.stick && this.stick.style.opacity !== "0") {
+                this.stick.style.opacity = "0";
+            }
+        }
+    }
+}

package/lib/touchmousebutton.d.ts

@@ -0,0 +1,6 @@
+export declare enum TouchMouseButton {
+    Any = -1,
+    Left = 0,
+    Right = 1
+}
+//# sourceMappingURL=touchmousebutton.d.ts.map

package/lib/touchmousebutton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchmousebutton.d.ts","sourceRoot":"","sources":["../src/touchmousebutton.ts"],"names":[],"mappings":"AAEA,oBAAY,gBAAgB;IACpB,GAAG,KAAK;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACZ"}

package/lib/touchmousebutton.js

@@ -0,0 +1,6 @@
+export var TouchMouseButton;
+(function (TouchMouseButton) {
+    TouchMouseButton[TouchMouseButton["Any"] = -1] = "Any";
+    TouchMouseButton[TouchMouseButton["Left"] = 0] = "Left";
+    TouchMouseButton[TouchMouseButton["Right"] = 1] = "Right";
+})(TouchMouseButton || (TouchMouseButton = {}));

package/lib/treebranchmaterial.d.ts

@@ -0,0 +1,31 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Vector4 } from '@babylonjs/core/Maths/math.vector';
+import { CustomShaderMaterial, CustomShaderMaterialPlugin } from './scenemanager';
+import { ShaderLanguage } from '@babylonjs/core/Materials';
+import { MaterialDefines } from '@babylonjs/core/Materials/materialDefines';
+import { UniformBuffer } from '@babylonjs/core/Materials/uniformBuffer';
+import { SubMesh } from '@babylonjs/core/Meshes/subMesh';
+import { TransformNode } from '@babylonjs/core/Meshes/transformNode';
+import { AbstractMesh } from '@babylonjs/core/Meshes/abstractMesh';
+import { AbstractEngine } from '@babylonjs/core/Engines/abstractEngine';
+export declare class TreeBranchMaterial extends CustomShaderMaterial {
+    private _windTimeAccum;
+    constructor(name: string, scene: Scene);
+    awake(): void;
+    update(): void;
+    getShaderName(): string;
+    setWindDirection(x: number, y: number, z: number): void;
+    getWindDirection(): Vector4;
+}
+export declare class TreeBranchMaterialPlugin extends CustomShaderMaterialPlugin {
+    constructor(customMaterial: CustomShaderMaterial, shaderName: string);
+    isCompatible(shaderLanguage: ShaderLanguage): boolean;
+    getCustomCode(shaderType: string, shaderLanguage: ShaderLanguage): any;
+    getUniforms(shaderLanguage: ShaderLanguage): any;
+    getSamplers(samplers: string[]): void;
+    getAttributes(attributes: string[], scene: Scene, mesh: AbstractMesh): void;
+    prepareDefines(defines: MaterialDefines, scene: Scene, mesh: AbstractMesh): void;
+    bindForSubMesh(uniformBuffer: UniformBuffer, scene: Scene, engine: AbstractEngine, subMesh: SubMesh): void;
+    static ExtractWindZoneOverride(properties: any, terrainTransform: TransformNode, builderInstance?: any): any | null;
+}
+//# sourceMappingURL=treebranchmaterial.d.ts.map

package/lib/treebranchmaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treebranchmaterial.d.ts","sourceRoot":"","sources":["../src/treebranchmaterial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAW,MAAM,mCAAmC,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAgB,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAChG,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAExE,qBAAa,kBAAmB,SAAQ,oBAAoB;IACpD,OAAO,CAAC,cAAc,CAAe;gBAElB,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;IAsBtC,KAAK,IAAI,IAAI;IAIb,MAAM,IAAI,IAAI;IAcd,aAAa,IAAI,MAAM;IAIvB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAUvD,gBAAgB,IAAI,OAAO;CAGrC;AAEL,qBAAa,wBAAyB,SAAQ,0BAA0B;gBAC7C,cAAc,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM;IAIpE,YAAY,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO;IAIrD,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,GAAG,GAAG;IAyOtE,WAAW,CAAC,cAAc,EAAE,cAAc,GAAG,GAAG;IAOhD,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;IAKrC,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IAS3E,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IAKhF,cAAc,CAAC,aAAa,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI;WAYnG,uBAAuB,CAAC,UAAU,EAAE,GAAG,EAAE,gBAAgB,EAAE,aAAa,EAAE,eAAe,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI;CA+C7H"}