@1pizzateam/roostr 0.0.0-stage → 0.8.0

package/dist/roostr.js

@@ -0,0 +1,3650 @@
+/*
+MIT License
+
+Copyright (c) 2015 Ludovic CLUBER
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+https://github.com/1pizzateam/RoostR.js
+*/
+
+import { Mat4x3, Vec3, Frustum, Vec2, Utils, Time, Mat4, Ray3, Trigo, Quat, Mat3, Box, Sphere as Sphere$1, Rect } from '@1pizzateam/spock';
+export { Accumulator, Bezier, Box as BoundingBox, Sphere as BoundingSphere, Circ, Frustum, Grid, Mat3, Mat4, Mat4x3, NumArray, Quat, Rand, Ray3 as Ray, Ray2, Rect, RollingAverage, Plane as SpatialPlane, Time, Trigo, Utils, Vec2, Vec3 } from '@1pizzateam/spock';
+
+class GLState {
+    program = null;
+    arrayBuffer = null;
+    elementBuffer = null;
+    attributeMask = null;
+    maxAttributes = 0;
+    frameOfProgram = new WeakMap();
+    materialOfProgram = new WeakMap();
+    materialVersionOfProgram = new WeakMap();
+    invalidate() {
+        this.program = null;
+        this.arrayBuffer = null;
+        this.elementBuffer = null;
+        this.attributeMask = null;
+    }
+    reset() {
+        this.invalidate();
+        this.maxAttributes = 0;
+        this.frameOfProgram = new WeakMap();
+        this.materialOfProgram = new WeakMap();
+        this.materialVersionOfProgram = new WeakMap();
+    }
+}
+const states = new WeakMap();
+function getGLState(context) {
+    let state = states.get(context);
+    if (!state) {
+        state = new GLState();
+        states.set(context, state);
+    }
+    return state;
+}
+
+class SceneRenderer {
+    context;
+    blendKey = '';
+    blendEnabled = null;
+    depthWrite = null;
+    constructor(context) {
+        this.context = context;
+        this.defaultSettings();
+    }
+    invalidateState() {
+        getGLState(this.context).invalidate();
+        this.blendKey = '';
+        this.blendEnabled = null;
+        this.depthWrite = null;
+    }
+    reset() {
+        getGLState(this.context).reset();
+        this.blendKey = '';
+        this.blendEnabled = null;
+        this.depthWrite = null;
+        this.defaultSettings();
+    }
+    defaultSettings() {
+        this.setDepthFunc('LEQUAL');
+        this.enableDepthTest();
+        this.disableBlendMode();
+    }
+    enable(capability) {
+        if (capability === 'BLEND')
+            this.blendEnabled = true;
+        this.context.enable(this.context[capability]);
+    }
+    disable(capability) {
+        if (capability === 'BLEND')
+            this.blendEnabled = false;
+        this.context.disable(this.context[capability]);
+    }
+    setDepthFunc(mode) {
+        this.context.depthFunc(this.context[mode]);
+    }
+    setBlendFunction(sourceFactor, destinationFactor) {
+        this.context.blendFunc(this.context[sourceFactor], this.context[destinationFactor]);
+    }
+    setBlendEquation(mode) {
+        this.context.blendEquation(this.context[mode]);
+    }
+    enableDepthTest() {
+        this.enable('DEPTH_TEST');
+        this.depthWrite = true;
+        this.context.depthMask(true);
+    }
+    disableDepthTest() {
+        this.disable('DEPTH_TEST');
+        this.depthWrite = false;
+        this.context.depthMask(false);
+    }
+    enableBlendMode(equation, source, destination) {
+        const key = `${equation}|${source}|${destination}`;
+        if (key !== this.blendKey) {
+            this.setBlendEquation(equation);
+            this.setBlendFunction(source, destination);
+            this.blendKey = key;
+        }
+        if (this.blendEnabled !== true)
+            this.enable('BLEND');
+    }
+    disableBlendMode() {
+        if (this.blendEnabled !== false)
+            this.disable('BLEND');
+    }
+    setDepthWrite(enabled) {
+        if (this.depthWrite === enabled)
+            return;
+        this.depthWrite = enabled;
+        this.context.depthMask(enabled);
+    }
+    getParameter(parameterName) {
+        return this.context.getParameter(parameterName);
+    }
+}
+
+class SceneGraph {
+    model;
+    nbModel;
+    modelStackTop;
+    constructor() {
+        this.model = [new Mat4x3()];
+        this.model[0].identity();
+        this.nbModel = this.model.length;
+        this.modelStackTop = 0;
+    }
+    pushModelMatrix(modelMatrix) {
+        this.modelStackTop++;
+        if (this.modelStackTop === this.nbModel) {
+            this.model.push(new Mat4x3());
+            this.nbModel++;
+        }
+        this.model[this.modelStackTop].copy(modelMatrix);
+    }
+    popModelMatrix() {
+        if (this.modelStackTop > 0)
+            this.modelStackTop--;
+    }
+    getWorldMatrix() {
+        return this.model[this.modelStackTop];
+    }
+}
+
+const scratchAmbient = new Vec3();
+function clearFlatArrays(flatArrays) {
+    flatArrays.position.length = 0;
+    flatArrays.diffuse.length = 0;
+    flatArrays.specular.length = 0;
+    flatArrays.constantAttenuation.length = 0;
+    flatArrays.linearAttenuation.length = 0;
+    flatArrays.quadraticAttenuation.length = 0;
+    flatArrays.cutoff.length = 0;
+    flatArrays.exponent.length = 0;
+    flatArrays.direction.length = 0;
+    flatArrays.type.length = 0;
+}
+function ensureLightBuffers(flatArrays, count) {
+    if (flatArrays.floatPosition && flatArrays.floatPosition.length === count * 3)
+        return;
+    flatArrays.floatPosition = new Float32Array(count * 3);
+    flatArrays.floatDiffuse = new Float32Array(count * 3);
+    flatArrays.floatSpecular = new Float32Array(count * 3);
+    flatArrays.floatDirection = new Float32Array(count * 3);
+    flatArrays.floatAttenuation = new Float32Array(count * 3);
+    flatArrays.floatCutoff = new Float32Array(count);
+    flatArrays.floatExponent = new Float32Array(count);
+    flatArrays.floatType = new Float32Array(count);
+    flatArrays.packedPosition = new Float32Array(count * 4);
+    flatArrays.packedDiffuse = new Float32Array(count * 4);
+    flatArrays.packedSpecular = new Float32Array(count * 4);
+}
+function pushLight(flatArrays, index, kind, light) {
+    const o = index * 3;
+    const isSpot = kind === 'spot';
+    const isDirectional = kind === 'directional';
+    const att = isDirectional ? null : light;
+    light.position.toArray(flatArrays.floatPosition, o);
+    light.diffuse.toArray(flatArrays.floatDiffuse, o);
+    light.specular.toArray(flatArrays.floatSpecular, o);
+    if (isDirectional)
+        light.direction.toArray(flatArrays.floatDirection, o);
+    else if (isSpot)
+        light.direction.toArray(flatArrays.floatDirection, o);
+    else
+        flatArrays.floatDirection.fill(0, o, o + 3);
+    const constant = att ? att.constantAttenuation : 1;
+    const linear = att ? att.linearAttenuation : 0;
+    const quadratic = att ? att.quadraticAttenuation : 0;
+    flatArrays.floatAttenuation[o] = constant;
+    flatArrays.floatAttenuation[o + 1] = linear;
+    flatArrays.floatAttenuation[o + 2] = quadratic;
+    flatArrays.floatCutoff[index] = isSpot ? light.cutoff : 0;
+    flatArrays.floatExponent[index] = isSpot ? light.exponent : 0;
+    flatArrays.floatType[index] = isDirectional ? 0 : isSpot ? 2 : 1;
+    const q = index * 4;
+    light.position.toArray(flatArrays.packedPosition, q);
+    flatArrays.packedPosition[q + 3] = flatArrays.floatType[index];
+    light.diffuse.toArray(flatArrays.packedDiffuse, q);
+    flatArrays.packedDiffuse[q + 3] = flatArrays.floatCutoff[index];
+    light.specular.toArray(flatArrays.packedSpecular, q);
+    flatArrays.packedSpecular[q + 3] = flatArrays.floatExponent[index];
+    const dir = isDirectional || isSpot ? light.direction : null;
+    flatArrays.position.push(light.position.x, light.position.y, light.position.z);
+    flatArrays.diffuse.push(light.diffuse.x, light.diffuse.y, light.diffuse.z);
+    flatArrays.specular.push(light.specular.x, light.specular.y, light.specular.z);
+    if (dir)
+        flatArrays.direction.push(dir.x, dir.y, dir.z);
+    else
+        flatArrays.direction.push(0, 0, 0);
+    flatArrays.constantAttenuation.push(constant);
+    flatArrays.linearAttenuation.push(linear);
+    flatArrays.quadraticAttenuation.push(quadratic);
+    flatArrays.cutoff.push(isSpot ? light.cutoff : 0);
+    flatArrays.exponent.push(isSpot ? light.exponent : 0);
+    flatArrays.type.push(kind);
+}
+function packLights(directionals, points, spots, ambients, flatArrays, maxLights, extraAmbient) {
+    clearFlatArrays(flatArrays);
+    const total = spots.length + points.length + directionals.length;
+    const count = Math.min(total, maxLights);
+    ensureLightBuffers(flatArrays, count);
+    let index = 0;
+    for (let i = 0; i < spots.length && index < count; i++)
+        pushLight(flatArrays, index++, 'spot', spots[i]);
+    for (let i = 0; i < points.length && index < count; i++)
+        pushLight(flatArrays, index++, 'point', points[i]);
+    for (let i = 0; i < directionals.length && index < count; i++)
+        pushLight(flatArrays, index++, 'directional', directionals[i]);
+    const ambient = scratchAmbient.setScalar(0, 0, 0);
+    if (extraAmbient)
+        ambient.add(extraAmbient);
+    for (let i = 0; i < ambients.length; i++)
+        ambient.addScaledVector(ambients[i].diffuse, ambients[i].intensity);
+    if (!flatArrays.floatAmbient)
+        flatArrays.floatAmbient = new Float32Array(3);
+    ambient.toArray(flatArrays.floatAmbient);
+    flatArrays.ambient = [ambient.x, ambient.y, ambient.z];
+    return flatArrays;
+}
+
+const MAX_LIGHTS = 8;
+class Lights {
+    warnedOverflow = false;
+    directionals;
+    points;
+    spots;
+    ambients;
+    nbDirectionals;
+    nbPoints;
+    nbSpots;
+    nbAmbients;
+    flatArrays;
+    constructor() {
+        this.directionals = [];
+        this.points = [];
+        this.spots = [];
+        this.ambients = [];
+        this.nbDirectionals = 0;
+        this.nbPoints = 0;
+        this.nbSpots = 0;
+        this.nbAmbients = 0;
+        this.flatArrays = {
+            position: [],
+            diffuse: [],
+            specular: [],
+            constantAttenuation: [],
+            linearAttenuation: [],
+            quadraticAttenuation: [],
+            cutoff: [],
+            exponent: [],
+            direction: [],
+            type: [],
+            ambient: [0, 0, 0]
+        };
+    }
+    addLight(light) {
+        switch (light.type) {
+            case 'directional':
+                this.directionals.push(light);
+                this.nbDirectionals++;
+                break;
+            case 'point':
+                this.points.push(light);
+                this.nbPoints++;
+                break;
+            case 'spot':
+                this.spots.push(light);
+                this.nbSpots++;
+                break;
+            case 'ambient':
+                this.ambients.push(light);
+                this.nbAmbients++;
+                break;
+        }
+    }
+    removeLight(light) {
+        let idx;
+        switch (light.type) {
+            case 'directional':
+                idx = this.directionals.indexOf(light);
+                if (idx !== -1) {
+                    this.directionals.splice(idx, 1);
+                    this.nbDirectionals--;
+                    return true;
+                }
+                return false;
+            case 'point':
+                idx = this.points.indexOf(light);
+                if (idx !== -1) {
+                    this.points.splice(idx, 1);
+                    this.nbPoints--;
+                    return true;
+                }
+                return false;
+            case 'spot':
+                idx = this.spots.indexOf(light);
+                if (idx !== -1) {
+                    this.spots.splice(idx, 1);
+                    this.nbSpots--;
+                    return true;
+                }
+                return false;
+            case 'ambient':
+                idx = this.ambients.indexOf(light);
+                if (idx !== -1) {
+                    this.ambients.splice(idx, 1);
+                    this.nbAmbients--;
+                    return true;
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    flatten(extraAmbient) {
+        const total = this.nbSpots + this.nbPoints + this.nbDirectionals;
+        if (total > MAX_LIGHTS && !this.warnedOverflow) {
+            this.warnedOverflow = true;
+            console.warn(`Lights: ${total} lights added, only the first ${MAX_LIGHTS} (spots, points, then directionals) are used.`);
+        }
+        return packLights(this.directionals, this.points, this.spots, this.ambients, this.flatArrays, MAX_LIGHTS, extraAmbient);
+    }
+    clear() {
+        this.directionals = [];
+        this.points = [];
+        this.spots = [];
+        this.ambients = [];
+        this.nbDirectionals = 0;
+        this.nbPoints = 0;
+        this.nbSpots = 0;
+        this.nbAmbients = 0;
+        clearFlatArrays(this.flatArrays);
+    }
+    getFlatArray(property) {
+        if (this.flatArrays.hasOwnProperty(property))
+            return this.flatArrays[property];
+        return undefined;
+    }
+}
+
+function raycastScene(meshes, traversalStamp, ray, precise = false) {
+    const hits = [];
+    const visit = (mesh) => {
+        if (!mesh.isActive())
+            return;
+        const hit = mesh.raycast(ray, precise);
+        if (hit)
+            hits.push({ mesh, distance: hit.distance, point: hit.point });
+        for (const child of mesh.children)
+            visit(child);
+    };
+    for (const mesh of meshes)
+        if (mesh.traversalStamp !== traversalStamp)
+            visit(mesh);
+    hits.sort((a, b) => a.distance - b.distance);
+    return hits;
+}
+
+class SceneCollector {
+    opaqueList = [];
+    blendedList = [];
+    scratchFrustum = new Frustum();
+    scratchVec = new Vec3();
+    collect(meshes, camera, frustum, opaque, blended, stamp) {
+        this.opaqueList.length = 0;
+        this.blendedList.length = 0;
+        const visit = (mesh) => {
+            if (!mesh.isActive())
+                return;
+            const wanted = mesh.blendMode ? blended : opaque;
+            if (wanted && !(frustum && !frustum.intersectsSphere(mesh.computeBoundingSphere()))) {
+                if (mesh.blendMode) {
+                    mesh.sortKey = mesh.getWorldPosition(this.scratchVec).getDistance(camera.position, true);
+                    this.blendedList.push(mesh);
+                }
+                else
+                    this.opaqueList.push(mesh);
+            }
+            for (const child of mesh.children)
+                visit(child);
+        };
+        for (const mesh of meshes)
+            if (mesh.traversalStamp !== stamp)
+                visit(mesh);
+    }
+    drawBlended(scene, camera, time, flatLights, frame) {
+        const list = this.blendedList;
+        if (list.length === 0)
+            return 0;
+        if (list.length > 1)
+            list.sort((a, b) => b.sortKey - a.sortKey);
+        const projMatrix = camera.getProjectionMatrix();
+        const viewMatrix = camera.getViewMatrix();
+        const camPos = camera.position;
+        for (const mesh of list) {
+            const blend = mesh.blendOptions;
+            scene.enableBlendMode(blend.equation, blend.source, blend.destination);
+            scene.renderer.setDepthWrite(mesh.depthWrite);
+            mesh.renderSelf(projMatrix, viewMatrix, flatLights, time, true, camPos, scene.fog, frame);
+        }
+        scene.disableBlendMode();
+        scene.renderer.setDepthWrite(true);
+        return list.length;
+    }
+}
+
+class Scene {
+    meshes;
+    nbMeshes;
+    lights;
+    ambientColor;
+    fog;
+    enableFrustumCulling;
+    context;
+    renderer;
+    graph;
+    collector;
+    resolution;
+    frame = { id: 0 };
+    frameCounter = 0;
+    traversalStamp = 0;
+    constructor(contextOrOptions) {
+        this.meshes = [];
+        this.nbMeshes = 0;
+        this.lights = new Lights();
+        this.ambientColor = new Vec3(0, 0, 0);
+        this.fog = null;
+        this.enableFrustumCulling = false;
+        this.collector = new SceneCollector();
+        let ctx = null;
+        let opts = null;
+        if (contextOrOptions && typeof contextOrOptions.createBuffer === 'function')
+            ctx = contextOrOptions;
+        else if (contextOrOptions && typeof contextOrOptions === 'object') {
+            opts = contextOrOptions;
+            if (opts.context)
+                ctx = opts.context;
+            else if (opts.canvasId)
+                ctx = Scene.contextFromCanvas(opts.canvasId);
+            if (opts.ambientColor)
+                this.setAmbientColor(opts.ambientColor);
+            if (opts.fog)
+                this.fog = opts.fog;
+            if (opts.enableFrustumCulling !== undefined)
+                this.enableFrustumCulling = opts.enableFrustumCulling;
+        }
+        else
+            ctx = contextOrOptions;
+        if (!ctx)
+            throw new Error('Scene requires a WebGL context or a canvasId.');
+        this.context = ctx;
+        this.resolution = new Vec2(ctx.drawingBufferWidth || 0, ctx.drawingBufferHeight || 0);
+        this.renderer = new SceneRenderer(this.context);
+        this.graph = new SceneGraph();
+        if (opts && this.context) {
+            if (opts.viewport) {
+                if (opts.viewport instanceof Vec2)
+                    this.setViewport(opts.viewport);
+                else
+                    this.setViewport(opts.viewport.size, opts.viewport.position);
+            }
+            if (opts.clearColor)
+                this.setClearColor(opts.clearColor);
+            if (opts.depthTest !== false && this.context.DEPTH_TEST) {
+                this.context.enable(this.context.DEPTH_TEST);
+                if (this.context.LEQUAL)
+                    this.context.depthFunc(this.context.LEQUAL);
+            }
+            if (opts.cullFace && opts.cullFace !== 'NONE' && this.context.CULL_FACE) {
+                this.context.enable(this.context.CULL_FACE);
+                const mode = this.context[opts.cullFace] || this.context.BACK;
+                if (mode)
+                    this.context.cullFace(mode);
+            }
+            if (opts.frontFace && this.context.frontFace) {
+                const mode = this.context[opts.frontFace] || this.context.CCW;
+                if (mode)
+                    this.context.frontFace(mode);
+            }
+        }
+    }
+    static contextFromCanvas(canvasId) {
+        const canvas = typeof canvasId === 'string' ? document.getElementById(canvasId) : canvasId;
+        if (!canvas)
+            return null;
+        return (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
+    }
+    setViewport(size, position) {
+        const x = position?.x ?? 0;
+        const y = position?.y ?? 0;
+        const w = size.x;
+        const h = size.y;
+        this.resolution.x = w;
+        this.resolution.y = h;
+        if (this.context && this.context.viewport)
+            this.context.viewport(x, y, w, h);
+    }
+    getSize(target = new Vec2()) {
+        target.copy(this.resolution);
+        return target;
+    }
+    setClearColor(color, alpha = 1.0) {
+        if (!this.context)
+            return;
+        this.context.clearColor(Utils.clamp(color.x, 0, 1), Utils.clamp(color.y, 0, 1), Utils.clamp(color.z, 0, 1), Utils.clamp(alpha, 0, 1));
+    }
+    setSize(size) {
+        if (this.context && this.context.canvas) {
+            const canvas = this.context.canvas;
+            canvas.width = size.x;
+            canvas.height = size.y;
+        }
+        this.setViewport(size);
+    }
+    clear(color = true, depth = true) {
+        if (!this.context)
+            return;
+        let mask = 0;
+        if (color)
+            mask |= this.context.COLOR_BUFFER_BIT;
+        if (depth)
+            mask |= this.context.DEPTH_BUFFER_BIT;
+        if (mask)
+            this.context.clear(mask);
+    }
+    addMesh(mesh) {
+        if (this.meshes.indexOf(mesh) === -1) {
+            this.meshes.push(mesh);
+            this.nbMeshes++;
+        }
+    }
+    removeMesh(mesh) {
+        const index = this.meshes.indexOf(mesh);
+        if (index !== -1) {
+            this.meshes.splice(index, 1);
+            this.nbMeshes--;
+            return true;
+        }
+        return false;
+    }
+    addLight(light) {
+        this.lights.addLight(light);
+    }
+    removeLight(light) {
+        return this.lights.removeLight(light);
+    }
+    setAmbientColor(color) {
+        this.ambientColor.copy(color);
+        return this;
+    }
+    setFog(color, near, far = 1000) {
+        this.fog = {
+            color: new Vec3(color.x, color.y, color.z),
+            near,
+            far
+        };
+        return this;
+    }
+    clearFog() {
+        this.fog = null;
+        return this;
+    }
+    clearMeshes() {
+        this.meshes = [];
+        this.nbMeshes = 0;
+    }
+    clearLights() {
+        this.lights.clear();
+    }
+    restore() {
+        this.renderer.reset();
+        for (const mesh of this.meshes)
+            mesh.restore();
+    }
+    destroy(destroyMeshes = true) {
+        if (destroyMeshes)
+            for (const mesh of this.meshes)
+                mesh.destroy();
+        this.clearMeshes();
+        this.clearLights();
+        this.clearFog();
+    }
+    getLightsProperty(property) {
+        return this.lights.getFlatArray(property);
+    }
+    enableBlendMode(equation, source, destination) {
+        this.renderer.enableBlendMode(equation, source, destination);
+    }
+    disableBlendMode() {
+        this.renderer.disableBlendMode();
+    }
+    getRendererBlendMode() {
+        return this.renderer.getParameter(this.context.BLEND);
+    }
+    raycast(ray, precise = false) {
+        this.computeWorldMatrices();
+        return raycastScene(this.meshes, this.traversalStamp, ray, precise);
+    }
+    render(camera, time = Time.now()) {
+        this.computeWorldMatrices();
+        const flatLights = this.lights.flatten(this.ambientColor);
+        const frustum = this.enableFrustumCulling
+            ? this.collector.scratchFrustum.setFromProjectionViewMatrix(camera.getProjectionViewMatrix())
+            : null;
+        this.collector.collect(this.meshes, camera, frustum, true, true, this.traversalStamp);
+        const frame = this.beginFrame();
+        this.disableBlendMode();
+        const projMatrix = camera.getProjectionMatrix();
+        const viewMatrix = camera.getViewMatrix();
+        const camPos = camera.position;
+        let renderedCount = 0;
+        for (const mesh of this.collector.opaqueList) {
+            this.renderer.setDepthWrite(mesh.depthWrite);
+            mesh.renderSelf(projMatrix, viewMatrix, flatLights, time, false, camPos, this.fog, frame);
+            renderedCount++;
+        }
+        renderedCount += this.collector.drawBlended(this, camera, time, flatLights, frame);
+        this.renderer.setDepthWrite(true);
+        return renderedCount;
+    }
+    markDescendants() {
+        const stamp = ++this.traversalStamp;
+        const mark = (mesh) => {
+            for (const child of mesh.children) {
+                child.traversalStamp = stamp;
+                mark(child);
+            }
+        };
+        for (const mesh of this.meshes)
+            mark(mesh);
+        return stamp;
+    }
+    computeWorldMatrices() {
+        const stamp = this.markDescendants();
+        for (const mesh of this.meshes)
+            if (mesh.traversalStamp !== stamp)
+                mesh.computeWorldMatrix(this.graph);
+    }
+    beginFrame() {
+        this.renderer.invalidateState();
+        this.frame.id = ++this.frameCounter;
+        this.frame.resolution = this.resolution;
+        return this.frame;
+    }
+    renderBlended(camera, time = Time.now(), flatLights = this.lights.flatten(this.ambientColor), frustum = null) {
+        this.collector.collect(this.meshes, camera, frustum, false, true, this.markDescendants());
+        return this.collector.drawBlended(this, camera, time, flatLights, this.beginFrame());
+    }
+}
+
+const Shader = {
+    create(context, str, type) {
+        const shader = context.createShader(context[type]);
+        if (!shader)
+            return null;
+        context.shaderSource(shader, str);
+        context.compileShader(shader);
+        if (!context.getShaderParameter(shader, context.COMPILE_STATUS)) {
+            console.error(`${type} compilation failed:`, context.getShaderInfoLog(shader));
+            context.deleteShader(shader);
+            return null;
+        }
+        return shader;
+    }
+};
+
+const caches = new WeakMap();
+const owners = new WeakMap();
+const Program = {
+    create(context, vertexShader, fragmentShader) {
+        const program = context.createProgram();
+        if (program) {
+            const vshader = Shader.create(context, vertexShader, 'VERTEX_SHADER');
+            const fshader = Shader.create(context, fragmentShader, 'FRAGMENT_SHADER');
+            if (!vshader || !fshader) {
+                if (vshader)
+                    context.deleteShader(vshader);
+                if (fshader)
+                    context.deleteShader(fshader);
+                context.deleteProgram(program);
+                return null;
+            }
+            context.attachShader(program, vshader);
+            context.attachShader(program, fshader);
+            context.linkProgram(program);
+            if (!context.getProgramParameter(program, context.LINK_STATUS)) {
+                console.error('Program link failed:', context.getProgramInfoLog(program));
+                context.deleteShader(vshader);
+                context.deleteShader(fshader);
+                context.deleteProgram(program);
+                return null;
+            }
+            context.detachShader(program, vshader);
+            context.detachShader(program, fshader);
+            context.deleteShader(vshader);
+            context.deleteShader(fshader);
+        }
+        return program;
+    },
+    acquire(context, vertexShader, fragmentShader) {
+        let cache = caches.get(context);
+        if (!cache) {
+            cache = new Map();
+            caches.set(context, cache);
+        }
+        const key = `${vertexShader}\u0000${fragmentShader}`;
+        let entry = cache.get(key);
+        if (!entry) {
+            const program = Program.create(context, vertexShader, fragmentShader);
+            if (!program)
+                return null;
+            entry = { program, key, refs: 0 };
+            cache.set(key, entry);
+            owners.set(program, entry);
+        }
+        entry.refs++;
+        return entry.program;
+    },
+    release(context, program) {
+        const entry = owners.get(program);
+        if (!entry) {
+            context.deleteProgram(program);
+            return;
+        }
+        if (--entry.refs > 0)
+            return;
+        const cache = caches.get(context);
+        if (cache?.get(entry.key) === entry)
+            cache.delete(entry.key);
+        owners.delete(program);
+        context.deleteProgram(program);
+    },
+    sources(program) {
+        const entry = owners.get(program);
+        if (!entry)
+            return null;
+        const [vertex, fragment] = entry.key.split('\u0000');
+        return { vertex, fragment };
+    },
+    reset(context) {
+        caches.delete(context);
+    }
+};
+
+class Renderer {
+    canvas;
+    context;
+    isContextLost = false;
+    options;
+    onContextLostBound;
+    onContextRestoredBound;
+    constructor(canvasID, options = {}) {
+        this.options = options;
+        this.onContextLostBound = (e) => {
+            e.preventDefault();
+            this.isContextLost = true;
+            this.options.onContextLost?.();
+        };
+        this.onContextRestoredBound = () => {
+            this.isContextLost = false;
+            if (this.context) {
+                Program.reset(this.context);
+                getGLState(this.context).reset();
+            }
+            this.defaultSettings();
+            this.options.onContextRestored?.();
+        };
+        this.canvas = typeof canvasID === 'string' ? this.findById(canvasID) : canvasID;
+        this.context = null;
+        if (this.canvas) {
+            const size = options.size ?? new Vec2(1280, 720);
+            this.canvas.width = size.x;
+            this.canvas.height = size.y;
+            const attributes = { alpha: false, ...options.contextAttributes };
+            this.context = (this.canvas.getContext("webgl", attributes) ||
+                this.canvas.getContext("experimental-webgl", attributes)) || null;
+            if (this.context) {
+                if (typeof this.canvas.addEventListener === 'function') {
+                    this.canvas.addEventListener('webglcontextlost', this.onContextLostBound);
+                    this.canvas.addEventListener('webglcontextrestored', this.onContextRestoredBound);
+                }
+                this.defaultSettings();
+            }
+        }
+    }
+    dispose() {
+        if (this.canvas && typeof this.canvas.removeEventListener === 'function') {
+            this.canvas.removeEventListener('webglcontextlost', this.onContextLostBound);
+            this.canvas.removeEventListener('webglcontextrestored', this.onContextRestoredBound);
+        }
+    }
+    defaultSettings() {
+        if (!this.context)
+            return;
+        this.context.getExtension('OES_standard_derivatives');
+        this.setFrontFace('CW');
+        this.enable('CULL_FACE');
+        this.setCullFace('BACK');
+        this.setViewport(new Vec2(this.context.drawingBufferWidth, this.context.drawingBufferHeight));
+        this.setClearColor(new Vec3(0.0, 0.0, 0.0), 1.0);
+    }
+    setFrontFace(mode) {
+        if (this.context)
+            this.context.frontFace(this.context[mode]);
+    }
+    enable(capability) {
+        if (this.context)
+            this.context.enable(this.context[capability]);
+    }
+    disable(capability) {
+        if (this.context)
+            this.context.disable(this.context[capability]);
+    }
+    setCullFace(mode) {
+        if (this.context)
+            this.context.cullFace(this.context[mode]);
+    }
+    setViewport(size) {
+        if (this.context)
+            this.context.viewport(0, 0, size.x, size.y);
+    }
+    setClearColor(color, alpha = 1.0) {
+        if (!this.context)
+            return;
+        this.context.clearColor(Utils.clamp(color.x, 0, 1), Utils.clamp(color.y, 0, 1), Utils.clamp(color.z, 0, 1), Utils.clamp(alpha, 0, 1));
+    }
+    clearFrame() {
+        if (this.context)
+            this.context.clear(this.context.COLOR_BUFFER_BIT | this.context.DEPTH_BUFFER_BIT);
+    }
+    getContext() {
+        return this.context;
+    }
+    getCanvas() {
+        return this.canvas;
+    }
+    setSize(size) {
+        if (this.canvas) {
+            this.canvas.width = size.x;
+            this.canvas.height = size.y;
+        }
+        this.setViewport(size);
+    }
+    getSize(target = new Vec2()) {
+        if (this.canvas) {
+            target.x = this.canvas.width;
+            target.y = this.canvas.height;
+        }
+        return target;
+    }
+    findById(id) {
+        return document.getElementById(id);
+    }
+}
+
+class RenderTarget {
+    width;
+    height;
+    context;
+    framebuffer;
+    texture;
+    depthBuffer;
+    constructor(size, context) {
+        this.width = size.x;
+        this.height = size.y;
+        this.context = context;
+        this.framebuffer = null;
+        this.texture = null;
+        this.depthBuffer = null;
+        this.init();
+    }
+    restore() {
+        this.init();
+    }
+    init() {
+        const gl = this.context;
+        this.framebuffer = gl.createFramebuffer();
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        this.texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, this.texture);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, this.width, this.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.texture, 0);
+        this.depthBuffer = gl.createRenderbuffer();
+        gl.bindRenderbuffer(gl.RENDERBUFFER, this.depthBuffer);
+        gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, this.width, this.height);
+        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, this.depthBuffer);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    }
+    bind() {
+        const gl = this.context;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        gl.viewport(0, 0, this.width, this.height);
+    }
+    unbind(viewportSize) {
+        const gl = this.context;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        if (viewportSize)
+            gl.viewport(0, 0, viewportSize.x, viewportSize.y);
+    }
+    getSize(target = new Vec2()) {
+        target.x = this.width;
+        target.y = this.height;
+        return target;
+    }
+    setSize(size) {
+        const w = size.x;
+        const h = size.y;
+        if (this.width === w && this.height === h)
+            return;
+        this.width = w;
+        this.height = h;
+        const gl = this.context;
+        if (this.texture) {
+            gl.bindTexture(gl.TEXTURE_2D, this.texture);
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, this.width, this.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+            gl.bindTexture(gl.TEXTURE_2D, null);
+        }
+        if (this.depthBuffer) {
+            gl.bindRenderbuffer(gl.RENDERBUFFER, this.depthBuffer);
+            gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, this.width, this.height);
+            gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+        }
+    }
+    dispose() {
+        const gl = this.context;
+        if (this.framebuffer) {
+            gl.deleteFramebuffer(this.framebuffer);
+            this.framebuffer = null;
+        }
+        if (this.texture) {
+            gl.deleteTexture(this.texture);
+            this.texture = null;
+        }
+        if (this.depthBuffer) {
+            gl.deleteRenderbuffer(this.depthBuffer);
+            this.depthBuffer = null;
+        }
+    }
+}
+
+class Camera {
+    viewMatrix;
+    projectionMatrix;
+    position;
+    target;
+    up;
+    cachedViewMatrix;
+    cachedProjectionMatrix;
+    projectionViewMatrix = new Mat4();
+    inverseProjectionViewMatrix = new Mat4();
+    isProjectionViewDirty = true;
+    isInverseDirty = true;
+    static _scratchNear = new Vec3();
+    static _scratchFar = new Vec3();
+    static _scratchDir = new Vec3();
+    static _scratchNdc = new Vec3();
+    constructor(position, target, up) {
+        this.viewMatrix = new Mat4x3();
+        this.projectionMatrix = new Mat4();
+        this.viewMatrix.identity();
+        this.projectionMatrix.identity();
+        this.cachedViewMatrix = new Float32Array(16);
+        this.cachedProjectionMatrix = new Float32Array(16);
+        this.viewMatrix.toArray(this.cachedViewMatrix);
+        this.projectionMatrix.toArray(this.cachedProjectionMatrix);
+        this.position = position;
+        this.target = target;
+        this.up = up;
+    }
+    setViewMatrix() {
+        this.viewMatrix.lookAtRH(this.position, this.target, this.up);
+        this.viewMatrix.toArray(this.cachedViewMatrix);
+        this.invalidateProjectionView();
+    }
+    setProjectionMatrix() {
+        this.projectionMatrix.toArray(this.cachedProjectionMatrix);
+        this.invalidateProjectionView();
+    }
+    invalidateProjectionView() {
+        this.isProjectionViewDirty = true;
+        this.isInverseDirty = true;
+    }
+    getProjectionViewMatrix() {
+        if (this.isProjectionViewDirty) {
+            this.projectionViewMatrix.copy(this.projectionMatrix).multiplyAffine(this.viewMatrix);
+            this.isProjectionViewDirty = false;
+        }
+        return this.projectionViewMatrix.toArray();
+    }
+    getInverseProjectionViewMatrix() {
+        if (this.isInverseDirty) {
+            this.getProjectionViewMatrix();
+            this.inverseProjectionViewMatrix.copy(this.projectionViewMatrix).invert();
+            this.isInverseDirty = false;
+        }
+        return this.inverseProjectionViewMatrix;
+    }
+    setPosition(position) {
+        this.position.copy(position);
+        this.setViewMatrix();
+    }
+    setTarget(target) {
+        this.target.copy(target);
+        this.setViewMatrix();
+    }
+    setUp(up) {
+        this.up.copy(up);
+        this.setViewMatrix();
+    }
+    lookAt(target) {
+        this.setTarget(target);
+    }
+    getViewDirection(target = new Vec3()) {
+        return target.subVectors(this.target, this.position).normalize();
+    }
+    getDistance() {
+        return this.position.getDistance(this.target);
+    }
+    dolly(amount) {
+        this.position.lerp(this.target, amount);
+        this.setViewMatrix();
+    }
+    getViewMatrix() {
+        return this.cachedViewMatrix;
+    }
+    getProjectionMatrix() {
+        return this.cachedProjectionMatrix;
+    }
+    getViewMatrixObject() {
+        return this.viewMatrix;
+    }
+    getProjectionMatrixObject() {
+        return this.projectionMatrix;
+    }
+    getRay(ndc, targetRay = new Ray3()) {
+        const inverse = this.getInverseProjectionViewMatrix();
+        const near = inverse.transformPoint(Camera._scratchNdc.setScalar(ndc.x, ndc.y, -1), Camera._scratchNear);
+        const far = inverse.transformPoint(Camera._scratchNdc.setScalar(ndc.x, ndc.y, 1.0), Camera._scratchFar);
+        const dir = Camera._scratchDir.subVectors(far, near).normalize();
+        targetRay.set(near, dir);
+        return targetRay;
+    }
+}
+
+class PerspectiveCamera extends Camera {
+    fov;
+    ratio;
+    zNear;
+    zFar;
+    constructor(fov, nearFar = new Vec2(0.1, 1000), context) {
+        super(new Vec3(), new Vec3(), new Vec3(0.0, 1.0, 0.0));
+        this.fov = fov;
+        this.ratio = 0;
+        this.zNear = nearFar.x;
+        this.zFar = nearFar.y;
+        let viewport = null;
+        if (context && typeof context.getParameter === 'function') {
+            const vp = context.getParameter(context.VIEWPORT);
+            if (vp && vp.length >= 4)
+                viewport = new Vec2(vp[2], vp[3]);
+        }
+        this.setProjectionMatrix(viewport);
+        super.setViewMatrix();
+    }
+    setProjectionMatrix(viewport) {
+        if (viewport)
+            this.ratio = viewport.x / Math.max(1, viewport.y);
+        else
+            this.ratio = this.ratio || 1;
+        this.projectionMatrix.perspective(this.fov, this.ratio, this.zNear, this.zFar);
+        super.setProjectionMatrix();
+    }
+    setFov(fov) {
+        this.fov = fov;
+        this.setProjectionMatrix();
+    }
+    setNearFar(nearFar) {
+        this.zNear = nearFar.x;
+        this.zFar = nearFar.y;
+        this.setProjectionMatrix();
+    }
+    getNearFar(target = new Vec2()) {
+        target.x = this.zNear;
+        target.y = this.zFar;
+        return target;
+    }
+}
+
+class OrthographicCamera extends Camera {
+    left;
+    right;
+    top;
+    bottom;
+    near;
+    far;
+    constructor(bounds, nearFar = new Vec2(-1e3, 1000)) {
+        super(new Vec3(), new Vec3(), new Vec3(0.0, 1.0, 0.0));
+        this.left = bounds.topLeftCorner.x;
+        this.right = bounds.bottomRightCorner.x;
+        this.bottom = bounds.topLeftCorner.y;
+        this.top = bounds.bottomRightCorner.y;
+        this.near = nearFar.x;
+        this.far = nearFar.y;
+        this.setProjectionMatrix();
+        super.setViewMatrix();
+    }
+    setProjectionMatrix() {
+        this.projectionMatrix.orthographic(this.left, this.right, this.top, this.bottom, this.near, this.far);
+        super.setProjectionMatrix();
+    }
+    setBounds(bounds, nearFar) {
+        this.left = bounds.topLeftCorner.x;
+        this.right = bounds.bottomRightCorner.x;
+        this.bottom = bounds.topLeftCorner.y;
+        this.top = bounds.bottomRightCorner.y;
+        if (nearFar) {
+            this.near = nearFar.x;
+            this.far = nearFar.y;
+        }
+        this.setProjectionMatrix();
+    }
+    getNearFar(target = new Vec2()) {
+        target.x = this.near;
+        target.y = this.far;
+        return target;
+    }
+}
+
+class OrbitControls {
+    camera;
+    domElement;
+    distance;
+    targetDistance;
+    azimuth;
+    targetAzimuth;
+    elevation;
+    targetElevation;
+    minDistance;
+    maxDistance;
+    minElevation;
+    maxElevation;
+    rotateSpeed;
+    zoomSpeed;
+    panSpeed;
+    enableDamping;
+    dampingFactor;
+    isDragging;
+    dragMode;
+    previousMouseX;
+    previousMouseY;
+    touchStartDistance;
+    activePointerId = null;
+    appliedPose = new Vec3(NaN, NaN, NaN);
+    appliedTarget = new Vec3(NaN, NaN, NaN);
+    onPointerDownBound;
+    onPointerMoveBound;
+    onPointerUpBound;
+    onWheelBound;
+    onContextMenuBound;
+    onTouchStartBound;
+    onTouchMoveBound;
+    onTouchEndBound;
+    constructor(camera, domElement) {
+        this.camera = camera;
+        this.domElement = domElement;
+        this.minDistance = 0.1;
+        this.maxDistance = 10000;
+        this.minElevation = -Trigo.halfpi + 0.01;
+        this.maxElevation = Trigo.halfpi - 0.01;
+        this.rotateSpeed = 1.0;
+        this.zoomSpeed = 1.0;
+        this.panSpeed = 1.0;
+        this.enableDamping = false;
+        this.dampingFactor = 0.05;
+        this.isDragging = false;
+        this.dragMode = null;
+        this.previousMouseX = 0;
+        this.previousMouseY = 0;
+        this.touchStartDistance = 0;
+        const spherical = OrbitControls._scratchSpherical.subVectors(this.camera.position, this.camera.target).getSpherical(OrbitControls._scratchSpherical);
+        this.distance = spherical.x || 10;
+        this.targetDistance = this.distance;
+        this.azimuth = spherical.y;
+        this.targetAzimuth = this.azimuth;
+        this.elevation = spherical.z;
+        this.targetElevation = this.elevation;
+        this.onPointerDownBound = this.onPointerDown.bind(this);
+        this.onPointerMoveBound = this.onPointerMove.bind(this);
+        this.onPointerUpBound = this.onPointerUp.bind(this);
+        this.onWheelBound = this.onWheel.bind(this);
+        this.onContextMenuBound = (e) => e.preventDefault();
+        this.onTouchStartBound = this.onTouchStart.bind(this);
+        this.onTouchMoveBound = this.onTouchMove.bind(this);
+        this.onTouchEndBound = this.onTouchEnd.bind(this);
+        this.attach();
+        this.update();
+    }
+    attach() {
+        if (!this.domElement || typeof this.domElement.addEventListener !== 'function')
+            return;
+        if (this.domElement.style)
+            this.domElement.style.touchAction = 'none';
+        this.domElement.addEventListener('pointerdown', this.onPointerDownBound);
+        if (typeof window !== 'undefined') {
+            window.addEventListener('pointermove', this.onPointerMoveBound);
+            window.addEventListener('pointerup', this.onPointerUpBound);
+        }
+        this.domElement.addEventListener('wheel', this.onWheelBound, { passive: false });
+        this.domElement.addEventListener('contextmenu', this.onContextMenuBound);
+        this.domElement.addEventListener('touchstart', this.onTouchStartBound, { passive: false });
+        this.domElement.addEventListener('touchmove', this.onTouchMoveBound, { passive: false });
+        this.domElement.addEventListener('touchend', this.onTouchEndBound);
+        this.domElement.addEventListener('touchcancel', this.onTouchEndBound);
+    }
+    dispose() {
+        if (!this.domElement || typeof this.domElement.removeEventListener !== 'function')
+            return;
+        this.domElement.removeEventListener('pointerdown', this.onPointerDownBound);
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('pointermove', this.onPointerMoveBound);
+            window.removeEventListener('pointerup', this.onPointerUpBound);
+        }
+        this.domElement.removeEventListener('wheel', this.onWheelBound);
+        this.domElement.removeEventListener('contextmenu', this.onContextMenuBound);
+        this.domElement.removeEventListener('touchstart', this.onTouchStartBound);
+        this.domElement.removeEventListener('touchmove', this.onTouchMoveBound);
+        this.domElement.removeEventListener('touchend', this.onTouchEndBound);
+        this.domElement.removeEventListener('touchcancel', this.onTouchEndBound);
+    }
+    onPointerDown(e) {
+        if (e.isPrimary === false)
+            return;
+        this.activePointerId = e.pointerId ?? null;
+        this.isDragging = true;
+        this.previousMouseX = e.clientX;
+        this.previousMouseY = e.clientY;
+        if (e.button === 2 || e.shiftKey)
+            this.dragMode = 'pan';
+        else
+            this.dragMode = 'rotate';
+    }
+    onPointerMove(e) {
+        if (!this.isDragging)
+            return;
+        if (this.activePointerId !== null && e.pointerId !== undefined && e.pointerId !== this.activePointerId)
+            return;
+        const deltaX = e.clientX - this.previousMouseX;
+        const deltaY = e.clientY - this.previousMouseY;
+        this.previousMouseX = e.clientX;
+        this.previousMouseY = e.clientY;
+        if (this.dragMode === 'rotate') {
+            const elementHeight = this.domElement.clientHeight || 500;
+            this.targetAzimuth -= (deltaX / elementHeight) * Trigo.pi * this.rotateSpeed;
+            this.targetElevation += (deltaY / elementHeight) * Trigo.pi * this.rotateSpeed;
+            this.targetElevation = Utils.clamp(this.targetElevation, this.minElevation, this.maxElevation);
+        }
+        else if (this.dragMode === 'pan')
+            this.pan(deltaX, deltaY);
+        if (!this.enableDamping) {
+            this.azimuth = this.targetAzimuth;
+            this.elevation = this.targetElevation;
+            this.update();
+        }
+    }
+    onPointerUp() {
+        this.isDragging = false;
+        this.activePointerId = null;
+        this.dragMode = null;
+    }
+    onWheel(e) {
+        e.preventDefault();
+        const factor = e.deltaY > 0 ? 1.1 : (1 / 1.1);
+        this.targetDistance *= Math.pow(factor, this.zoomSpeed);
+        this.targetDistance = Utils.clamp(this.targetDistance, this.minDistance, this.maxDistance);
+        if (!this.enableDamping) {
+            this.distance = this.targetDistance;
+            this.update();
+        }
+    }
+    onTouchStart(e) {
+        if (e.touches.length === 2) {
+            e.preventDefault();
+            this.touchStartDistance = OrbitControls.touchDistance(e.touches);
+        }
+    }
+    onTouchMove(e) {
+        if (e.touches.length === 2) {
+            e.preventDefault();
+            const currentDistance = OrbitControls.touchDistance(e.touches);
+            const factor = this.touchStartDistance / (currentDistance || 1);
+            this.touchStartDistance = currentDistance;
+            this.targetDistance *= factor;
+            this.targetDistance = Utils.clamp(this.targetDistance, this.minDistance, this.maxDistance);
+            if (!this.enableDamping) {
+                this.distance = this.targetDistance;
+                this.update();
+            }
+        }
+    }
+    onTouchEnd(e) {
+        if (e.touches.length < 2)
+            this.touchStartDistance = 0;
+    }
+    static _touchA = new Vec2();
+    static _touchB = new Vec2();
+    static touchDistance(touches) {
+        return OrbitControls._touchA.setScalar(touches[0].clientX, touches[0].clientY)
+            .getDistance(OrbitControls._touchB.setScalar(touches[1].clientX, touches[1].clientY));
+    }
+    static _scratchForward = new Vec3();
+    static _scratchRight = new Vec3();
+    static _scratchUp = new Vec3();
+    static _scratchPan = new Vec3();
+    static _scratchSpherical = new Vec3();
+    pan(deltaX, deltaY) {
+        const factor = (this.distance / 1000) * this.panSpeed;
+        const forward = this.camera.getViewDirection(OrbitControls._scratchForward);
+        const right = OrbitControls._scratchRight.crossVectors(forward, this.camera.up).normalize();
+        const up = OrbitControls._scratchUp.crossVectors(right, forward).normalize();
+        OrbitControls._scratchPan.setScalar(0, 0, 0)
+            .add(right.scale(-deltaX * factor))
+            .add(up.scale(deltaY * factor));
+        this.camera.target.add(OrbitControls._scratchPan);
+        this.camera.position.add(OrbitControls._scratchPan);
+    }
+    update(deltaTime) {
+        if (this.enableDamping) {
+            const t = deltaTime === undefined
+                ? this.dampingFactor
+                : 1 - Math.pow(1 - this.dampingFactor, deltaTime * 60);
+            const turn = Trigo.normalizeRadian(this.targetAzimuth - this.azimuth);
+            this.azimuth = Utils.lerp(this.azimuth, this.azimuth + turn, t);
+            this.elevation = Utils.lerp(this.elevation, this.targetElevation, t);
+            this.distance = Utils.lerp(this.distance, this.targetDistance, t);
+        }
+        const target = this.camera.target;
+        const pose = OrbitControls._scratchSpherical.setScalar(this.distance, this.azimuth, this.elevation);
+        if (pose.equals(this.appliedPose) && target.equals(this.appliedTarget))
+            return;
+        this.appliedPose.copy(pose);
+        this.appliedTarget.copy(target);
+        this.camera.position.setFromSpherical(this.distance, this.azimuth, this.elevation).add(target);
+        this.camera.setViewMatrix();
+    }
+}
+
+class Node {
+    position;
+    scale;
+    quaternion;
+    modelMatrix;
+    worldMatrix;
+    normalMatrix;
+    boundingBox;
+    boundingSphere;
+    localBoundingBox;
+    localBoundingSphere;
+    parent = null;
+    children = [];
+    traversalStamp = 0;
+    isBoundsDirty = true;
+    isNormalMatrixDirty = true;
+    isWorldDirty = true;
+    _rotation;
+    isRotationStale = false;
+    isTransformDirty = false;
+    static UP = new Vec3(0, 1, 0);
+    static scratchQuat = new Quat();
+    static scratchVec = new Vec3();
+    constructor() {
+        this.position = new Vec3();
+        this._rotation = new Vec3();
+        this.scale = new Vec3(1.0, 1.0, 1.0);
+        this.quaternion = new Quat();
+        this.modelMatrix = new Mat4x3();
+        this.worldMatrix = new Mat4x3();
+        this.normalMatrix = new Mat3();
+        this.modelMatrix.identity();
+        this.worldMatrix.identity();
+        this.normalMatrix.identity();
+        this.localBoundingBox = new Box();
+        this.localBoundingSphere = new Sphere$1();
+        this.boundingBox = new Box();
+        this.boundingSphere = new Sphere$1();
+    }
+    addChild(node) {
+        if (this.children.indexOf(node) === -1) {
+            if (node.parent && node.parent !== this)
+                node.parent.removeChild(node);
+            this.children.push(node);
+            node.parent = this;
+            node.isWorldDirty = true;
+        }
+    }
+    removeChild(node) {
+        const index = this.children.indexOf(node);
+        if (index !== -1) {
+            this.children.splice(index, 1);
+            node.parent = null;
+            node.isWorldDirty = true;
+            return true;
+        }
+        return false;
+    }
+    markDirty() {
+        this.isTransformDirty = true;
+        this.isBoundsDirty = true;
+        this.isNormalMatrixDirty = true;
+    }
+    get rotation() {
+        if (this.isRotationStale) {
+            this.quaternion.getEuler(this._rotation);
+            this.isRotationStale = false;
+        }
+        return this._rotation;
+    }
+    set rotation(euler) {
+        this.setRotation(euler);
+    }
+    rotationChanged() {
+        this.isRotationStale = true;
+        this.markDirty();
+    }
+    setPosition(position) {
+        this.position.copy(position);
+        this.markDirty();
+        return this;
+    }
+    setRotation(rotation) {
+        this._rotation.copy(rotation);
+        this.quaternion.setFromEuler(this._rotation);
+        this.isRotationStale = false;
+        this.markDirty();
+        return this;
+    }
+    setScale(scale) {
+        this.scale.copy(scale);
+        this.markDirty();
+        return this;
+    }
+    scaleBy(factor) {
+        this.scale.multiply(factor);
+        this.markDirty();
+        return this;
+    }
+    setQuaternion(q) {
+        this.quaternion.copy(q);
+        this.rotationChanged();
+        return this;
+    }
+    slerp(targetQuat, t) {
+        this.quaternion.slerp(targetQuat, t);
+        this.rotationChanged();
+        return this;
+    }
+    rotateX(angle) {
+        this.quaternion.rotateX(angle);
+        this.rotationChanged();
+        return this;
+    }
+    rotateY(angle) {
+        this.quaternion.rotateY(angle);
+        this.rotationChanged();
+        return this;
+    }
+    rotateZ(angle) {
+        this.quaternion.rotateZ(angle);
+        this.rotationChanged();
+        return this;
+    }
+    rotateOnAxis(axis, angle) {
+        this.quaternion.multiply(Node.scratchQuat.setAxisAngle(axis, angle));
+        this.rotationChanged();
+        return this;
+    }
+    translate(translation) {
+        this.position.add(translation);
+        this.markDirty();
+        return this;
+    }
+    lookAt(target, up = Node.UP) {
+        if (this.position.equals(target))
+            return this;
+        this.quaternion.lookAt(this.position, target, up);
+        this.rotationChanged();
+        return this;
+    }
+    updateModelMatrix() {
+        if (!this.isTransformDirty)
+            return false;
+        this.modelMatrix.compose(this.position, this.quaternion, this.scale);
+        this.isTransformDirty = false;
+        this.isBoundsDirty = true;
+        this.isNormalMatrixDirty = true;
+        return true;
+    }
+    computeNormalMatrix() {
+        if (!this.isNormalMatrixDirty)
+            return this.normalMatrix;
+        this.worldMatrix.toNormalMatrix(this.normalMatrix.toArray());
+        this.isNormalMatrixDirty = false;
+        return this.normalMatrix;
+    }
+    getWorldPosition(target = new Vec3()) {
+        return this.worldMatrix.getTranslation(target);
+    }
+    getWorldDirection(target = new Vec3()) {
+        return this.worldMatrix.getColumn(2, target).opposite().normalize();
+    }
+    distanceTo(target) {
+        const targetPos = target instanceof Vec3 ? target : target.getWorldPosition();
+        return this.getWorldPosition(Node.scratchVec).getDistance(targetPos);
+    }
+    isInsideBounds(box) {
+        return box.containsPoint(this.getWorldPosition(Node.scratchVec));
+    }
+    setLocalBounds(box) {
+        this.localBoundingBox.copy(box);
+        this.localBoundingBox.getCenter(Node.scratchVec);
+        this.localBoundingSphere.set(Node.scratchVec, box.min.getDistance(box.max) / 2);
+        this.isBoundsDirty = true;
+        return this;
+    }
+    computeBounds() {
+        if (!this.isBoundsDirty)
+            return;
+        if (!this.localBoundingBox.isEmpty()) {
+            this.boundingBox.copy(this.localBoundingBox).applyMatrix4(this.worldMatrix);
+            this.boundingSphere.copy(this.localBoundingSphere).applyMatrix4(this.worldMatrix);
+        }
+        else {
+            const pos = this.getWorldPosition(Node.scratchVec);
+            this.boundingBox.set(pos, pos);
+            this.boundingSphere.set(pos, 0);
+        }
+        this.isBoundsDirty = false;
+    }
+    computeBoundingBox() {
+        this.computeBounds();
+        return this.boundingBox;
+    }
+    computeBoundingSphere() {
+        this.computeBounds();
+        return this.boundingSphere;
+    }
+    setWorldMatrix(worldMatrix) {
+        this.worldMatrix.copy(worldMatrix).multiply(this.modelMatrix);
+        this.isBoundsDirty = true;
+        this.isNormalMatrixDirty = true;
+        this.isWorldDirty = false;
+    }
+    computeWorldMatrix(graph) {
+        const modelChanged = this.updateModelMatrix();
+        const changed = this.isWorldDirty || modelChanged;
+        if (changed)
+            this.setWorldMatrix(graph.getWorldMatrix());
+        graph.pushModelMatrix(this.worldMatrix);
+        for (const child of this.children) {
+            if (changed)
+                child.isWorldDirty = true;
+            child.computeWorldMatrix(graph);
+        }
+        graph.popModelMatrix();
+    }
+}
+
+const scratchInverse = new Mat4x3();
+const scratchRay = new Ray3();
+const scratchVec = new Vec3();
+const scratchDir = new Vec3();
+const scratchA = new Vec3();
+const scratchB = new Vec3();
+const scratchC = new Vec3();
+const scratchHit = new Vec3();
+const scratchWorldHit = new Vec3();
+function getVertex(targetMesh, index, target) {
+    const vertices = targetMesh.vertices;
+    const size = targetMesh.itemSize || 3;
+    const offset = (targetMesh.indices ? targetMesh.indices[index] : index) * size;
+    return target.setScalar(vertices[offset], vertices[offset + 1], size > 2 ? vertices[offset + 2] : 0);
+}
+function raycastTriangles(mesh, ray) {
+    const inverse = scratchInverse.copy(mesh.worldMatrix).invertAffine();
+    const localRay = scratchRay.set(inverse.transformPoint(ray.origin, scratchVec), inverse.transformDirection(ray.direction, scratchDir));
+    const strip = mesh.primitive === 'TRIANGLE_STRIP';
+    let best = null;
+    let bestDistance = Infinity;
+    for (const subMesh of mesh.subMeshes) {
+        const end = subMesh.start + subMesh.count;
+        for (let i = subMesh.start; i + 2 < end; i += strip ? 1 : 3) {
+            getVertex(mesh, i, scratchA);
+            if (strip && (i - subMesh.start) % 2 === 1) {
+                getVertex(mesh, i + 2, scratchB);
+                getVertex(mesh, i + 1, scratchC);
+            }
+            else {
+                getVertex(mesh, i + 1, scratchB);
+                getVertex(mesh, i + 2, scratchC);
+            }
+            const local = localRay.intersectTriangle(scratchA, scratchB, scratchC, false, scratchHit);
+            if (!local)
+                continue;
+            const world = mesh.worldMatrix.transformPoint(local, scratchWorldHit);
+            const distance = ray.origin.getDistance(world);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                best = (best ?? new Vec3()).copy(world);
+            }
+        }
+    }
+    return best ? { distance: bestDistance, point: best } : null;
+}
+
+const isPowerOfTwo = (n) => (n & (n - 1)) === 0;
+function canGenerateMipmaps(context, width, height) {
+    if (typeof WebGL2RenderingContext !== 'undefined' && context instanceof WebGL2RenderingContext)
+        return true;
+    return isPowerOfTwo(width) && isPowerOfTwo(height);
+}
+const Texture = {
+    create(source, context, options) {
+        const webGLTexture = context.createTexture();
+        if (!webGLTexture)
+            return null;
+        const flipY = options?.flipY !== undefined ? options.flipY : true;
+        const magFilter = options?.magFilter !== undefined ? options.magFilter : context.LINEAR;
+        const minFilter = options?.minFilter !== undefined ? options.minFilter : context.LINEAR;
+        const wrapS = options?.wrapS !== undefined ? options.wrapS : context.CLAMP_TO_EDGE;
+        const wrapT = options?.wrapT !== undefined ? options.wrapT : context.CLAMP_TO_EDGE;
+        context.bindTexture(context.TEXTURE_2D, webGLTexture);
+        context.pixelStorei(context.UNPACK_FLIP_Y_WEBGL, flipY ? 1 : 0);
+        context.texParameteri(context.TEXTURE_2D, context.TEXTURE_MAG_FILTER, magFilter);
+        context.texParameteri(context.TEXTURE_2D, context.TEXTURE_MIN_FILTER, minFilter);
+        context.texParameteri(context.TEXTURE_2D, context.TEXTURE_WRAP_S, wrapS);
+        context.texParameteri(context.TEXTURE_2D, context.TEXTURE_WRAP_T, wrapT);
+        if (source instanceof Uint8Array) {
+            const width = options?.size ? options.size.x : 1;
+            const height = options?.size ? options.size.y : 1;
+            context.texImage2D(context.TEXTURE_2D, 0, context.RGBA, width, height, 0, context.RGBA, context.UNSIGNED_BYTE, source);
+        }
+        else
+            context.texImage2D(context.TEXTURE_2D, 0, context.RGBA, context.RGBA, context.UNSIGNED_BYTE, source);
+        if (options?.generateMipmaps) {
+            const width = source instanceof Uint8Array ? (options?.size ? options.size.x : 1) : source.width;
+            const height = source instanceof Uint8Array ? (options?.size ? options.size.y : 1) : source.height;
+            if (canGenerateMipmaps(context, width, height))
+                context.generateMipmap(context.TEXTURE_2D);
+            else
+                console.warn('Texture: mipmaps skipped, WebGL1 requires power-of-two dimensions.');
+        }
+        context.bindTexture(context.TEXTURE_2D, null);
+        return webGLTexture;
+    },
+    load(url, context, options) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.crossOrigin = 'anonymous';
+            img.onload = () => resolve(Texture.create(img, context, options));
+            img.onerror = (err) => reject(err);
+            img.src = url;
+        });
+    },
+    update(texture, source, context, offset = new Vec2(), size, flipY = true) {
+        context.bindTexture(context.TEXTURE_2D, texture);
+        context.pixelStorei(context.UNPACK_FLIP_Y_WEBGL, flipY ? 1 : 0);
+        const xOffset = offset.x;
+        const yOffset = offset.y;
+        const width = size ? size.x : 1;
+        const height = size ? size.y : 1;
+        if (source instanceof Uint8Array)
+            context.texSubImage2D(context.TEXTURE_2D, 0, xOffset, yOffset, width, height, context.RGBA, context.UNSIGNED_BYTE, source);
+        else
+            context.texSubImage2D(context.TEXTURE_2D, 0, xOffset, yOffset, context.RGBA, context.UNSIGNED_BYTE, source);
+        context.bindTexture(context.TEXTURE_2D, null);
+    }
+};
+
+class Uniform {
+    type;
+    value;
+    constructor(type, value) {
+        this.type = type;
+        this.value = value;
+    }
+}
+function uploadUniform(context, location, uniform) {
+    const value = uniform.value;
+    const type = uniform.type;
+    if (value instanceof Vec3)
+        context.uniform3f(location, value.x, value.y, value.z);
+    else if (value instanceof Vec2)
+        context.uniform2f(location, value.x, value.y);
+    else if (value instanceof Quat)
+        context.uniform4f(location, value.vector.x, value.vector.y, value.vector.z, value.w);
+    else if (value instanceof Mat4 || value instanceof Mat4x3 || value instanceof Mat3) {
+        if (value instanceof Mat3)
+            context.uniformMatrix3fv(location, false, value.toArray());
+        else
+            context.uniformMatrix4fv(location, false, value.toArray());
+    }
+    else if (type.indexOf('Matrix') !== -1)
+        context[type](location, false, value);
+    else
+        context[type](location, value);
+}
+
+const scratchView = new Mat4x3();
+const scratchCamera = new Vec3();
+function lightTypeValue(type) {
+    return type === 'directional' ? 0 : type === 'point' ? 1 : 2;
+}
+function packVec4(xyz, w) {
+    const count = Math.floor(xyz.length / 3);
+    const packed = new Float32Array(count * 4);
+    for (let i = 0; i < count; i++) {
+        packed[i * 4] = xyz[i * 3];
+        packed[i * 4 + 1] = xyz[i * 3 + 1];
+        packed[i * 4 + 2] = xyz[i * 3 + 2];
+        packed[i * 4 + 3] = w[i] || 0;
+    }
+    return packed;
+}
+function uploadFrameUniforms(context, program, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame) {
+    if (program.projectionMatrix)
+        context.uniformMatrix4fv(program.projectionMatrix, false, projectionMatrix);
+    if (program.viewMatrix)
+        context.uniformMatrix4fv(program.viewMatrix, false, viewMatrix);
+    if (program.time)
+        context.uniform1f(program.time, time);
+    if (frame && frame.resolution && program.screenResolution)
+        context.uniform2f(program.screenResolution, frame.resolution.x, frame.resolution.y);
+    if (lights) {
+        if (program.nbLights && lights.type)
+            context.uniform1i(program.nbLights, lights.type.length);
+        if (program.lightPosition && lights.position && lights.position.length > 0)
+            context.uniform3fv(program.lightPosition, lights.floatPosition || new Float32Array(lights.position));
+        if (program.lightDiffuse && lights.diffuse && lights.diffuse.length > 0)
+            context.uniform3fv(program.lightDiffuse, lights.floatDiffuse || new Float32Array(lights.diffuse));
+        if (program.lightSpecular && lights.specular && lights.specular.length > 0)
+            context.uniform3fv(program.lightSpecular, lights.floatSpecular || new Float32Array(lights.specular));
+        if (program.lightDirection && lights.direction && lights.direction.length > 0)
+            context.uniform3fv(program.lightDirection, lights.floatDirection || new Float32Array(lights.direction));
+        if (program.lightAttenuation && (lights.floatAttenuation || lights.constantAttenuation?.length)) {
+            let attArr = lights.floatAttenuation;
+            if (!attArr) {
+                const att = [];
+                for (let k = 0; k < lights.constantAttenuation.length; k++)
+                    att.push(lights.constantAttenuation[k] || 0, lights.linearAttenuation[k] || 0, lights.quadraticAttenuation[k] || 0);
+                attArr = new Float32Array(att);
+            }
+            context.uniform3fv(program.lightAttenuation, attArr);
+        }
+        if (program.lightCutoff && lights.cutoff && lights.cutoff.length > 0)
+            context.uniform1fv(program.lightCutoff, lights.floatCutoff || new Float32Array(lights.cutoff));
+        if (program.lightExponent && lights.exponent && lights.exponent.length > 0)
+            context.uniform1fv(program.lightExponent, lights.floatExponent || new Float32Array(lights.exponent));
+        if (program.lightType && (lights.floatType || lights.type?.length)) {
+            let typeArr = lights.floatType;
+            if (!typeArr)
+                typeArr = new Float32Array(lights.type.map(t => t === 'directional' ? 0 : t === 'point' ? 1 : 2));
+            context.uniform1fv(program.lightType, typeArr);
+        }
+        if (program.lightPositionType && lights.position && lights.position.length > 0)
+            context.uniform4fv(program.lightPositionType, lights.packedPosition || packVec4(lights.position, (lights.type || []).map(lightTypeValue)));
+        if (program.lightDiffuseCutoff && lights.diffuse && lights.diffuse.length > 0)
+            context.uniform4fv(program.lightDiffuseCutoff, lights.packedDiffuse || packVec4(lights.diffuse, lights.cutoff || []));
+        if (program.lightSpecularExponent && lights.specular && lights.specular.length > 0)
+            context.uniform4fv(program.lightSpecularExponent, lights.packedSpecular || packVec4(lights.specular, lights.exponent || []));
+        if (program.ambientLight && lights.ambient)
+            context.uniform3fv(program.ambientLight, lights.floatAmbient || new Float32Array(lights.ambient));
+    }
+    if (program.cameraPosition) {
+        let camera = cameraPosition;
+        if (!camera && viewMatrix) {
+            scratchView.toArray().set(viewMatrix);
+            camera = scratchView.invertAffine().getTranslation(scratchCamera);
+        }
+        if (camera)
+            context.uniform3f(program.cameraPosition, camera.x, camera.y, camera.z);
+    }
+    if (program.hasFog) {
+        if (fog) {
+            context.uniform1i(program.hasFog, 1);
+            if (program.fogColor)
+                context.uniform3f(program.fogColor, fog.color.x, fog.color.y, fog.color.z);
+            if (program.fogNear)
+                context.uniform1f(program.fogNear, fog.near);
+            if (program.fogFar)
+                context.uniform1f(program.fogFar, fog.far);
+        }
+        else
+            context.uniform1i(program.hasFog, 0);
+    }
+}
+
+class MeshRenderer {
+    context;
+    state;
+    constructor(context) {
+        this.context = context;
+        this.state = getGLState(context);
+        this.defaultSettings();
+    }
+    defaultSettings() {
+    }
+    createBuffer(target, size, drawMethod) {
+        const buffer = this.context.createBuffer();
+        this.bindBuffer(target, buffer);
+        this.context.bufferData(this.context[target], size, this.context[drawMethod]);
+        return buffer;
+    }
+    useProgram(program) {
+        if (this.state.program === program)
+            return;
+        this.state.program = program;
+        this.context.useProgram(program);
+    }
+    bindBuffer(target, buffer) {
+        if (target === 'ARRAY_BUFFER') {
+            if (this.state.arrayBuffer === buffer)
+                return;
+            this.state.arrayBuffer = buffer;
+        }
+        else if (target === 'ELEMENT_ARRAY_BUFFER') {
+            if (this.state.elementBuffer === buffer)
+                return;
+            this.state.elementBuffer = buffer;
+        }
+        this.context.bindBuffer(this.context[target], buffer);
+    }
+    deleteBuffer(buffer) {
+        if (this.state.arrayBuffer === buffer)
+            this.state.arrayBuffer = null;
+        if (this.state.elementBuffer === buffer)
+            this.state.elementBuffer = null;
+        this.context.deleteBuffer(buffer);
+    }
+    setAttributeMask(mask) {
+        const previous = this.state.attributeMask;
+        if (previous === mask)
+            return;
+        if (this.state.maxAttributes === 0)
+            this.state.maxAttributes = Math.min(16, this.context.getParameter(this.context.MAX_VERTEX_ATTRIBS) || 8);
+        const changed = previous === null ? (1 << this.state.maxAttributes) - 1 : previous ^ mask;
+        for (let i = 0; i < this.state.maxAttributes && (changed >> i) !== 0; i++)
+            if ((changed >> i) & 1)
+                if ((mask >> i) & 1)
+                    this.context.enableVertexAttribArray(i);
+                else
+                    this.context.disableVertexAttribArray(i);
+        this.state.attributeMask = mask;
+    }
+    vertexAttribPointer(index, size, type, normalized, stride, offset) {
+        this.context.vertexAttribPointer(index, size, this.context[type], normalized, stride, offset);
+    }
+    drawElements(primitive, subMesh, indexType) {
+        const mode = typeof primitive === 'number' ? primitive : (this.context[primitive] ?? this.context.TRIANGLES);
+        const type = indexType ?? this.context.UNSIGNED_SHORT;
+        const bytes = type === this.context.UNSIGNED_SHORT ? 2 : 4;
+        this.context.drawElements(mode, subMesh.count, type, subMesh.start * bytes);
+    }
+    drawArrays(primitive, subMesh) {
+        const mode = typeof primitive === 'number' ? primitive : (this.context[primitive] ?? this.context.TRIANGLES);
+        this.context.drawArrays(mode, subMesh.start, subMesh.count);
+    }
+    drawMesh(mesh, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame) {
+        const context = this.context;
+        const state = this.state;
+        for (let i = 0; i < mesh.nbSubMeshes; i++) {
+            const program = mesh.programs[i] || mesh.programs[mesh.nbPrograms - 1];
+            this.useProgram(program);
+            if (!frame || state.frameOfProgram.get(program) !== frame.id) {
+                if (frame)
+                    state.frameOfProgram.set(program, frame.id);
+                uploadFrameUniforms(context, program, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame);
+            }
+            const material = mesh.materials[i] || mesh.materials[mesh.materials.length - 1];
+            if (material) {
+                material.updateUniforms();
+                if (state.materialOfProgram.get(program) !== material || state.materialVersionOfProgram.get(program) !== material.version) {
+                    state.materialOfProgram.set(program, material);
+                    state.materialVersionOfProgram.set(program, material.version);
+                    const materialUniforms = material.uniforms;
+                    for (const property in materialUniforms)
+                        if (materialUniforms.hasOwnProperty(property) && program[property])
+                            uploadUniform(context, program[property], materialUniforms[property]);
+                }
+            }
+            let attributeMask = 0;
+            if (mesh.indices)
+                this.bindBuffer('ELEMENT_ARRAY_BUFFER', mesh.indexBuffer);
+            if (program.vertexPosition !== -1 && program.vertexPosition !== undefined && mesh.vertexBuffer) {
+                this.bindBuffer('ARRAY_BUFFER', mesh.vertexBuffer);
+                this.vertexAttribPointer(program.vertexPosition, mesh.itemSize, 'FLOAT', false, 0, 0);
+                attributeMask |= 1 << program.vertexPosition;
+            }
+            if (mesh.normals && program.vertexNormal !== -1 && program.vertexNormal !== undefined) {
+                this.bindBuffer('ARRAY_BUFFER', mesh.normalBuffer);
+                this.vertexAttribPointer(program.vertexNormal, 3, 'FLOAT', false, 0, 0);
+                attributeMask |= 1 << program.vertexNormal;
+            }
+            if (mesh.uvs && program.textureCoord !== -1 && program.textureCoord !== undefined) {
+                this.bindBuffer('ARRAY_BUFFER', mesh.texCoordBuffer);
+                this.vertexAttribPointer(program.textureCoord, 2, 'FLOAT', false, 0, 0);
+                attributeMask |= 1 << program.textureCoord;
+            }
+            this.setAttributeMask(attributeMask);
+            if (mesh.WebGLTexture) {
+                context.activeTexture(context.TEXTURE0);
+                context.bindTexture(context.TEXTURE_2D, mesh.WebGLTexture);
+                if (program.sampler)
+                    context.uniform1i(program.sampler, 0);
+                if (program.hasTexture)
+                    context.uniform1i(program.hasTexture, 1);
+            }
+            else if (program.hasTexture)
+                context.uniform1i(program.hasTexture, 0);
+            if (program.modelMatrix)
+                context.uniformMatrix4fv(program.modelMatrix, false, mesh.worldMatrix.toArray());
+            if (program.normalMatrix) {
+                mesh.computeNormalMatrix();
+                context.uniformMatrix3fv(program.normalMatrix, false, mesh.normalMatrix.toArray());
+            }
+            for (const property in mesh.customUniforms)
+                if (mesh.customUniforms.hasOwnProperty(property) && program[property])
+                    uploadUniform(context, program[property], mesh.customUniforms[property]);
+            this[mesh.drawMethod](mesh.primitive, mesh.subMeshes[i], mesh.indexType);
+        }
+    }
+}
+
+class SubMesh {
+    start;
+    count;
+    constructor(start, count) {
+        this.start = start;
+        this.count = count;
+    }
+}
+
+class Material {
+    ambient;
+    diffuse;
+    specular;
+    shininess;
+    uniforms;
+    version = 0;
+    constructor(options) {
+        this.ambient = new Vec3(0.5, 0.5, 0.5);
+        this.diffuse = new Vec3(0.6, 0.6, 0.6);
+        this.specular = new Vec3(0.8, 0.8, 0.8);
+        this.shininess = 8.0;
+        this.uniforms = {
+            materialAmbient: new Uniform('uniform3fv', this.ambient.toArray()),
+            materialDiffuse: new Uniform('uniform3fv', this.diffuse.toArray()),
+            materialSpecular: new Uniform('uniform3fv', this.specular.toArray()),
+            materialShininess: new Uniform('uniform1f', this.shininess)
+        };
+        if (options) {
+            if (options.ambient)
+                this.setAmbient(options.ambient);
+            if (options.diffuse)
+                this.setDiffuse(options.diffuse);
+            if (options.specular)
+                this.setSpecular(options.specular);
+            if (options.shininess !== undefined)
+                this.setShininess(options.shininess);
+        }
+    }
+    setAmbient(ambient) {
+        this.ambient.copy(ambient).toArray(this.uniforms.materialAmbient.value);
+        this.version++;
+    }
+    setDiffuse(diffuse) {
+        this.diffuse.copy(diffuse).toArray(this.uniforms.materialDiffuse.value);
+        this.version++;
+    }
+    setSpecular(specular) {
+        this.specular.copy(specular).toArray(this.uniforms.materialSpecular.value);
+        this.version++;
+    }
+    setShininess(shininess) {
+        this.shininess = shininess;
+        this.uniforms.materialShininess.value = this.shininess;
+        this.version++;
+    }
+    updateUniforms() {
+        let changed = this.sync(this.ambient, this.uniforms.materialAmbient);
+        changed = this.sync(this.diffuse, this.uniforms.materialDiffuse) || changed;
+        changed = this.sync(this.specular, this.uniforms.materialSpecular) || changed;
+        if (this.uniforms.materialShininess.value !== this.shininess) {
+            this.uniforms.materialShininess.value = this.shininess;
+            changed = true;
+        }
+        if (changed)
+            this.version++;
+        return changed;
+    }
+    sync(vector, uniform) {
+        const value = uniform.value;
+        if (value[0] === vector.x && value[1] === vector.y && value[2] === vector.z)
+            return false;
+        vector.toArray(value);
+        return true;
+    }
+}
+
+const BasicShader = {
+    vertex: `
+attribute vec3 aVertexPosition;
+attribute vec2 aTextureCoord;
+
+uniform mat4 uModelMatrix;
+uniform mat4 uViewMatrix;
+uniform mat4 uProjectionMatrix;
+
+varying vec2 vTextureCoord;
+
+void main(void) {
+  vTextureCoord = aTextureCoord;
+  gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * vec4(aVertexPosition, 1.0);
+}
+`,
+    fragment: `
+precision mediump float;
+
+varying vec2 vTextureCoord;
+
+uniform sampler2D uSampler;
+uniform vec3 uMaterialDiffuse;
+uniform int uHasTexture;
+
+void main(void) {
+  vec4 color = vec4(uMaterialDiffuse, 1.0);
+  if (uHasTexture == 1) {
+    color *= texture2D(uSampler, vTextureCoord);
+  }
+  gl_FragColor = color;
+}
+`,
+    create(context) {
+        return Program.create(context, BasicShader.vertex, BasicShader.fragment);
+    }
+};
+
+const PhongShader = {
+    vertex: `
+attribute vec3 aVertexPosition;
+attribute vec3 aVertexNormal;
+attribute vec2 aTextureCoord;
+
+uniform mat4 uModelMatrix;
+uniform mat4 uViewMatrix;
+uniform mat4 uProjectionMatrix;
+uniform mat3 uNormalMatrix;
+
+varying vec3 vWorldPosition;
+varying vec3 vNormal;
+varying vec2 vTextureCoord;
+
+void main(void) {
+  vec4 worldPos = uModelMatrix * vec4(aVertexPosition, 1.0);
+  vWorldPosition = worldPos.xyz;
+  vNormal = normalize(uNormalMatrix * aVertexNormal);
+  vTextureCoord = aTextureCoord;
+  gl_Position = uProjectionMatrix * uViewMatrix * worldPos;
+}
+`,
+    fragment: `
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+varying vec3 vWorldPosition;
+varying vec3 vNormal;
+varying vec2 vTextureCoord;
+
+uniform vec3 uMaterialAmbient;
+uniform vec3 uMaterialDiffuse;
+uniform vec3 uMaterialSpecular;
+uniform float uMaterialShininess;
+
+uniform vec3 uAmbientLight;
+uniform vec3 uAmbientColor;
+
+const int MAX_LIGHTS = 8;
+uniform int uNbLights;
+// Packed: (position.xyz, type), (diffuse.rgb, cutoff), (specular.rgb, exponent)
+uniform vec4 uLightPositionType[MAX_LIGHTS];
+uniform vec4 uLightDiffuseCutoff[MAX_LIGHTS];
+uniform vec4 uLightSpecularExponent[MAX_LIGHTS];
+uniform vec3 uLightDirection[MAX_LIGHTS];
+uniform vec3 uLightAttenuation[MAX_LIGHTS];
+
+uniform sampler2D uSampler;
+uniform int uHasTexture;
+
+uniform vec3 uCameraPosition;
+
+uniform vec3 uFogColor;
+uniform float uFogNear;
+uniform float uFogFar;
+uniform int uHasFog;
+
+void main(void) {
+  vec3 normal = normalize(vNormal);
+  vec3 viewDir = normalize(uCameraPosition - vWorldPosition);
+
+  vec3 totalAmbient = (uAmbientLight + uAmbientColor) * uMaterialAmbient;
+  vec3 totalDiffuse = vec3(0.0);
+  vec3 totalSpecular = vec3(0.0);
+
+  for (int i = 0; i < MAX_LIGHTS; i++) {
+    if (i >= uNbLights) break;
+
+    vec4 positionType = uLightPositionType[i];
+    vec4 diffuseCutoff = uLightDiffuseCutoff[i];
+    vec4 specularExponent = uLightSpecularExponent[i];
+
+    vec3 lightDir;
+    float attenuation = 1.0;
+
+    if (positionType.w < 0.5) {
+      // Directional
+      lightDir = normalize(-uLightDirection[i]);
+    } else {
+      // Point or Spot
+      vec3 lightVec = positionType.xyz - vWorldPosition;
+      float d = length(lightVec);
+      lightDir = normalize(lightVec);
+
+      float c = uLightAttenuation[i].x;
+      float l = uLightAttenuation[i].y;
+      float q = uLightAttenuation[i].z;
+      attenuation = 1.0 / max(c + l * d + q * d * d, 1.0);
+
+      if (positionType.w > 1.5) {
+        // Spot
+        float spotEffect = dot(normalize(uLightDirection[i]), -lightDir);
+        float cutoffCos = cos(radians(diffuseCutoff.w));
+        if (spotEffect > cutoffCos) {
+          attenuation *= pow(spotEffect, max(specularExponent.w, 1.0));
+        } else {
+          attenuation = 0.0;
+        }
+      }
+    }
+
+    float NdotL = max(dot(normal, lightDir), 0.0);
+    totalDiffuse += diffuseCutoff.rgb * uMaterialDiffuse * NdotL * attenuation;
+
+    if (NdotL > 0.0) {
+      vec3 halfDir = normalize(lightDir + viewDir);
+      float NdotH = max(dot(normal, halfDir), 0.0);
+      float spec = pow(NdotH, max(uMaterialShininess, 1.0));
+      totalSpecular += specularExponent.rgb * uMaterialSpecular * spec * attenuation;
+    }
+  }
+
+  vec4 texColor = vec4(1.0);
+  if (uHasTexture == 1) {
+    texColor = texture2D(uSampler, vTextureCoord);
+  }
+
+  vec3 finalColor = (totalAmbient + totalDiffuse) * texColor.rgb + totalSpecular;
+
+  if (uHasFog == 1) {
+    float dist = length(uCameraPosition - vWorldPosition);
+    float fogFactor = clamp((uFogFar - dist) / max(uFogFar - uFogNear, 0.0001), 0.0, 1.0);
+    finalColor = mix(uFogColor, finalColor, fogFactor);
+  }
+
+  gl_FragColor = vec4(finalColor, texColor.a);
+}
+`,
+    create(context) {
+        return Program.create(context, PhongShader.vertex, PhongShader.fragment);
+    }
+};
+
+const NormalShader = {
+    vertex: `
+attribute vec3 aVertexPosition;
+attribute vec3 aVertexNormal;
+
+uniform mat4 uModelMatrix;
+uniform mat4 uViewMatrix;
+uniform mat4 uProjectionMatrix;
+uniform mat3 uNormalMatrix;
+
+varying vec3 vNormal;
+
+void main(void) {
+  vNormal = normalize(uNormalMatrix * aVertexNormal);
+  gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * vec4(aVertexPosition, 1.0);
+}
+`,
+    fragment: `
+precision mediump float;
+
+varying vec3 vNormal;
+
+void main(void) {
+  gl_FragColor = vec4(vNormal * 0.5 + 0.5, 1.0);
+}
+`,
+    create(context) {
+        return Program.create(context, NormalShader.vertex, NormalShader.fragment);
+    }
+};
+
+const initializedPrograms = new WeakSet();
+function ucfirst(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+function addProgramAttribute(context, program, name) {
+    program[name] = context.getAttribLocation(program, `a${ucfirst(name)}`);
+}
+function addProgramUniform(context, program, name) {
+    const ucName = `u${ucfirst(name)}`;
+    let loc = context.getUniformLocation(program, ucName);
+    if (loc === null)
+        loc = context.getUniformLocation(program, `${ucName}[0]`);
+    program[name] = loc;
+}
+function initProgramLocations(context, program, customUniforms, materials) {
+    if (!initializedPrograms.has(program)) {
+        initializedPrograms.add(program);
+        addProgramAttribute(context, program, 'vertexPosition');
+        addProgramAttribute(context, program, 'vertexNormal');
+        addProgramAttribute(context, program, 'textureCoord');
+        addProgramUniform(context, program, 'modelMatrix');
+        addProgramUniform(context, program, 'normalMatrix');
+        addProgramUniform(context, program, 'viewMatrix');
+        addProgramUniform(context, program, 'projectionMatrix');
+        addProgramUniform(context, program, 'time');
+        addProgramUniform(context, program, 'screenResolution');
+        addProgramUniform(context, program, 'sampler');
+        addProgramUniform(context, program, 'hasTexture');
+        addProgramUniform(context, program, 'nbLights');
+        addProgramUniform(context, program, 'lightPosition');
+        addProgramUniform(context, program, 'lightDiffuse');
+        addProgramUniform(context, program, 'lightSpecular');
+        addProgramUniform(context, program, 'lightDirection');
+        addProgramUniform(context, program, 'lightAttenuation');
+        addProgramUniform(context, program, 'lightCutoff');
+        addProgramUniform(context, program, 'lightExponent');
+        addProgramUniform(context, program, 'lightType');
+        addProgramUniform(context, program, 'lightPositionType');
+        addProgramUniform(context, program, 'lightDiffuseCutoff');
+        addProgramUniform(context, program, 'lightSpecularExponent');
+        addProgramUniform(context, program, 'ambientLight');
+        addProgramUniform(context, program, 'ambientColor');
+        addProgramUniform(context, program, 'cameraPosition');
+        addProgramUniform(context, program, 'hasFog');
+        addProgramUniform(context, program, 'fogColor');
+        addProgramUniform(context, program, 'fogNear');
+        addProgramUniform(context, program, 'fogFar');
+        if (program.screenResolution) {
+            context.useProgram(program);
+            const viewport = context.getParameter(context.VIEWPORT);
+            if (viewport && viewport.length >= 4)
+                context.uniform2f(program.screenResolution, viewport[2], viewport[3]);
+        }
+    }
+    for (const property in customUniforms)
+        if (customUniforms.hasOwnProperty(property) && program[property] === undefined)
+            addProgramUniform(context, program, property);
+    for (const mat of materials)
+        for (const property in mat.uniforms)
+            if (mat.uniforms.hasOwnProperty(property) && program[property] === undefined)
+                addProgramUniform(context, program, property);
+}
+function syncMaterialUniforms(context, programs, material) {
+    const materialUniforms = material.uniforms;
+    for (const property in materialUniforms)
+        if (materialUniforms.hasOwnProperty(property))
+            for (const program of programs)
+                if (program[property] === undefined)
+                    program[property] = context.getUniformLocation(program, `u${ucfirst(property)}`);
+}
+function syncCustomUniform(context, programs, name) {
+    for (const program of programs)
+        if (program[name] === undefined)
+            program[name] = context.getUniformLocation(program, `u${ucfirst(name)}`);
+}
+function syncTextureSampler(context, programs) {
+    for (const program of programs)
+        if (program.sampler === undefined)
+            program.sampler = context.getUniformLocation(program, 'uSampler');
+}
+
+var eDrawMethod;
+(function (eDrawMethod) {
+    eDrawMethod["drawElements"] = "drawElements";
+    eDrawMethod["drawArrays"] = "drawArrays";
+})(eDrawMethod || (eDrawMethod = {}));
+class Mesh extends Node {
+    vertices;
+    indices;
+    normals;
+    uvs;
+    itemSize;
+    subMeshes;
+    nbSubMeshes;
+    primitive;
+    customUniforms;
+    context;
+    renderer;
+    WebGLTexture;
+    vertexBuffer;
+    indexBuffer;
+    normalBuffer;
+    texCoordBuffer;
+    sortKey = 0;
+    ownsTexture = false;
+    textureSource = null;
+    textureOptions;
+    indexType;
+    static scratchHit = new Vec3();
+    active;
+    drawMethod;
+    programs;
+    nbPrograms;
+    materials;
+    blendMode;
+    blendOptions = { equation: 'FUNC_ADD', source: 'SRC_ALPHA', destination: 'ONE' };
+    depthWrite = true;
+    zOrder;
+    constructor(meshOrContext, contextOrMesh) {
+        super();
+        let mesh;
+        let context;
+        if (meshOrContext && ('drawingBufferWidth' in meshOrContext || typeof meshOrContext.createBuffer === 'function')) {
+            context = meshOrContext;
+            mesh = contextOrMesh;
+        }
+        else {
+            mesh = meshOrContext;
+            context = contextOrMesh;
+        }
+        this.vertices = mesh && mesh.vertices ? mesh.vertices : null;
+        this.indices = mesh && mesh.indices ? mesh.indices : null;
+        this.normals = mesh && mesh.normals ? mesh.normals : null;
+        this.uvs = mesh && mesh.uvs ? mesh.uvs : null;
+        this.itemSize = mesh && mesh.itemSize ? mesh.itemSize : null;
+        this.subMeshes = mesh && mesh.subMeshes ? mesh.subMeshes : [];
+        if (this.subMeshes.length === 0 && this.vertices && this.vertices.length > 0)
+            this.subMeshes = [new SubMesh(0, this.indices ? this.indices.length : this.vertices.length / (this.itemSize || 3))];
+        this.nbSubMeshes = this.subMeshes.length;
+        this.primitive = mesh && mesh.primitive ? mesh.primitive : null;
+        this.customUniforms = {};
+        this.context = context;
+        this.renderer = new MeshRenderer(this.context);
+        this.WebGLTexture = null;
+        this.vertexBuffer = null;
+        this.indexBuffer = null;
+        this.normalBuffer = null;
+        this.texCoordBuffer = null;
+        this.indexType = this.context.UNSIGNED_SHORT;
+        this.createBuffers();
+        if (this.vertices && this.vertices.length > 0) {
+            this.localBoundingBox.setFromPoints(this.vertices, this.itemSize || 3);
+            this.localBoundingSphere.setFromPoints(this.vertices, undefined, this.itemSize || 3);
+        }
+        this.active = true;
+        this.drawMethod = this.indices ? eDrawMethod.drawElements : eDrawMethod.drawArrays;
+        this.programs = [];
+        this.nbPrograms = 0;
+        this.materials = [];
+        this.blendMode = false;
+        this.zOrder = 0;
+    }
+    setActive() {
+        this.active = true;
+    }
+    setInactive() {
+        this.active = false;
+    }
+    toggleActive() {
+        this.active = !this.active;
+        return this.active;
+    }
+    isActive() {
+        return this.active;
+    }
+    addProgram(vertexShaderOrProgram, fragmentShaderOrMaterial, material) {
+        if (this.nbPrograms < this.nbSubMeshes) {
+            let program;
+            let mat;
+            if (typeof vertexShaderOrProgram !== 'string') {
+                program = vertexShaderOrProgram;
+                mat = (fragmentShaderOrMaterial instanceof Material) ? fragmentShaderOrMaterial : new Material();
+            }
+            else {
+                program = Program.acquire(this.context, vertexShaderOrProgram, fragmentShaderOrMaterial);
+                mat = (material instanceof Material) ? material : (fragmentShaderOrMaterial instanceof Material ? fragmentShaderOrMaterial : new Material());
+            }
+            if (!program)
+                return false;
+            this.programs.push(program);
+            this.addMaterial(mat);
+            this.createProgram();
+            return true;
+        }
+        return false;
+    }
+    clearPrograms() {
+        for (const program of this.programs)
+            Program.release(this.context, program);
+        this.programs = [];
+        this.nbPrograms = 0;
+        this.materials = [];
+    }
+    addMaterial(material) {
+        if (material && this.materials.length < this.nbSubMeshes) {
+            this.materials.push(material);
+            syncMaterialUniforms(this.context, this.programs, material);
+            return true;
+        }
+        return false;
+    }
+    raycast(ray, precise = false) {
+        if (!this.isActive())
+            return null;
+        const sphere = this.computeBoundingSphere();
+        const hitPoint = ray.intersectSphere(sphere, Mesh.scratchHit);
+        if (!hitPoint)
+            return null;
+        if (precise && this.vertices && (this.primitive === 'TRIANGLES' || this.primitive === 'TRIANGLE_STRIP'))
+            return raycastTriangles(this, ray);
+        return { distance: ray.origin.getDistance(hitPoint), point: new Vec3().copy(hitPoint) };
+    }
+    useBasicMaterial(options) {
+        const mat = new Material();
+        if (options?.color)
+            mat.setDiffuse(options.color);
+        this.addProgram(BasicShader.vertex, BasicShader.fragment, mat);
+        this.applyTextureOption(options?.texture);
+        return this;
+    }
+    usePhongMaterial(options) {
+        const mat = new Material();
+        if (options?.ambient)
+            mat.setAmbient(options.ambient);
+        if (options?.diffuse)
+            mat.setDiffuse(options.diffuse);
+        if (options?.specular)
+            mat.setSpecular(options.specular);
+        if (options?.shininess !== undefined)
+            mat.setShininess(options.shininess);
+        this.addProgram(PhongShader.vertex, PhongShader.fragment, mat);
+        this.applyTextureOption(options?.texture);
+        return this;
+    }
+    useNormalMaterial() {
+        this.addProgram(NormalShader.vertex, NormalShader.fragment, new Material());
+        return this;
+    }
+    applyTextureOption(texture) {
+        if (!texture)
+            return;
+        if (typeof WebGLTexture !== 'undefined' && texture instanceof WebGLTexture) {
+            this.releaseTexture();
+            this.WebGLTexture = texture;
+            this.ownsTexture = false;
+        }
+        else
+            this.setTexture(texture);
+    }
+    releaseTexture() {
+        if (this.WebGLTexture && this.ownsTexture)
+            this.context.deleteTexture(this.WebGLTexture);
+        this.WebGLTexture = null;
+        this.ownsTexture = false;
+        this.textureSource = null;
+        this.textureOptions = undefined;
+    }
+    setTexture(img, options) {
+        const texture = Texture.create(img, this.context, options);
+        if (!texture)
+            return;
+        this.releaseTexture();
+        this.WebGLTexture = texture;
+        this.ownsTexture = true;
+        this.textureSource = img;
+        this.textureOptions = options;
+        syncTextureSampler(this.context, this.programs);
+    }
+    addCustomUniform(name, type, value) {
+        if (!this.customUniforms.hasOwnProperty(name)) {
+            this.customUniforms[name] = new Uniform(type, value);
+            syncCustomUniform(this.context, this.programs, name);
+        }
+    }
+    setCustomUniform(name, value) {
+        if (this.customUniforms.hasOwnProperty(name))
+            this.customUniforms[name].value = value;
+    }
+    createIndexData(indices) {
+        let max = 0;
+        for (let i = 0; i < indices.length; i++)
+            if (indices[i] > max)
+                max = indices[i];
+        if (max > 65535) {
+            if (this.context.getExtension && this.context.getExtension('OES_element_index_uint')) {
+                this.indexType = this.context.UNSIGNED_INT;
+                return new Uint32Array(indices);
+            }
+            console.warn('Mesh: indices exceed 65535 but OES_element_index_uint is unavailable; geometry will be corrupted.');
+        }
+        return indices instanceof Uint16Array ? indices : new Uint16Array(indices);
+    }
+    createBuffers() {
+        this.vertexBuffer = this.vertices
+            ? this.renderer.createBuffer('ARRAY_BUFFER', this.vertices instanceof Float32Array ? this.vertices : new Float32Array(this.vertices), 'STATIC_DRAW')
+            : null;
+        this.indexType = this.context.UNSIGNED_SHORT;
+        this.indexBuffer = this.indices
+            ? this.renderer.createBuffer('ELEMENT_ARRAY_BUFFER', this.createIndexData(this.indices), 'STATIC_DRAW')
+            : null;
+        this.normalBuffer = this.normals
+            ? this.renderer.createBuffer('ARRAY_BUFFER', this.normals instanceof Float32Array ? this.normals : new Float32Array(this.normals), 'STATIC_DRAW')
+            : null;
+        this.texCoordBuffer = this.uvs
+            ? this.renderer.createBuffer('ARRAY_BUFFER', this.uvs instanceof Float32Array ? this.uvs : new Float32Array(this.uvs), 'STATIC_DRAW')
+            : null;
+    }
+    restore() {
+        this.createBuffers();
+        const sources = this.programs.map((program) => Program.sources(program));
+        this.programs = [];
+        this.nbPrograms = 0;
+        sources.forEach((source) => {
+            if (!source)
+                return;
+            const program = Program.acquire(this.context, source.vertex, source.fragment);
+            if (!program)
+                return;
+            this.programs.push(program);
+            this.createProgram();
+        });
+        if (this.programs.length !== sources.length)
+            this.setInactive();
+        if (this.ownsTexture && this.textureSource) {
+            const texture = Texture.create(this.textureSource, this.context, this.textureOptions);
+            this.WebGLTexture = texture;
+            this.ownsTexture = texture !== null;
+        }
+        for (const child of this.children)
+            child.restore();
+    }
+    createProgram() {
+        initProgramLocations(this.context, this.programs[this.nbPrograms], this.customUniforms, this.materials);
+        this.nbPrograms++;
+    }
+    activateBlendMode() {
+        this.blendMode = true;
+    }
+    deactivateBlendMode() {
+        this.blendMode = false;
+    }
+    setBlend(source = 'SRC_ALPHA', destination = 'ONE', equation = 'FUNC_ADD') {
+        this.blendOptions.equation = equation;
+        this.blendOptions.source = source;
+        this.blendOptions.destination = destination;
+        this.blendMode = true;
+        return this;
+    }
+    setDepthWrite(enabled) {
+        this.depthWrite = enabled;
+        return this;
+    }
+    render(projectionMatrix, viewMatrix, lights, time, blendMode, cameraPosition, fog, frame) {
+        if (!this.isActive())
+            return;
+        this.renderSelf(projectionMatrix, viewMatrix, lights, time, blendMode, cameraPosition, fog, frame);
+        for (const child of this.children)
+            child.render(projectionMatrix, viewMatrix, lights, time, blendMode, cameraPosition, fog, frame);
+    }
+    renderSelf(projectionMatrix, viewMatrix, lights, time, blendMode, cameraPosition, fog, frame) {
+        if (!this.isActive() || this.nbPrograms === 0 || this.blendMode !== blendMode)
+            return;
+        this.renderer.drawMesh(this, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame);
+    }
+    destroy() {
+        this.clearPrograms();
+        if (this.vertexBuffer)
+            this.renderer.deleteBuffer(this.vertexBuffer), this.vertexBuffer = null;
+        if (this.indexBuffer)
+            this.renderer.deleteBuffer(this.indexBuffer), this.indexBuffer = null;
+        if (this.normalBuffer)
+            this.renderer.deleteBuffer(this.normalBuffer), this.normalBuffer = null;
+        if (this.texCoordBuffer)
+            this.renderer.deleteBuffer(this.texCoordBuffer), this.texCoordBuffer = null;
+        this.releaseTexture();
+        for (const child of this.children) {
+            child.parent = null;
+            child.destroy();
+        }
+        this.children = [];
+    }
+}
+
+class BasicMesh {
+    vertices;
+    indices;
+    normals;
+    uvs;
+    subMeshes;
+    itemSize;
+    primitive;
+    constructor() {
+        this.vertices = null;
+        this.indices = null;
+        this.normals = null;
+        this.uvs = null;
+        this.subMeshes = [];
+        this.itemSize = 3;
+        this.primitive = 'TRIANGLES';
+    }
+}
+
+class Line extends BasicMesh {
+    thickness;
+    constructor(vertices = [], thickness = 2.0) {
+        super();
+        this.thickness = (thickness || 2.0) * 0.5;
+        this.itemSize = 3;
+        this.primitive = 'LINE_STRIP';
+        this.setPoints(vertices);
+    }
+    setPoints(vertices) {
+        const flat = [];
+        if (vertices)
+            for (const v of vertices)
+                flat.push(v.x, v.y, v.z);
+        this.vertices = flat;
+        this.subMeshes = [
+            new SubMesh(0, this.vertices.length / this.itemSize)
+        ];
+        return this;
+    }
+}
+
+class FullscreenQuad extends BasicMesh {
+    constructor() {
+        super();
+        this.vertices = [1.0, -1,
+            -1, -1,
+            1.0, 1.0,
+            -1, 1.0
+        ];
+        this.uvs = [1.0, 0.0,
+            0.0, 0.0,
+            1.0, 1.0,
+            0.0, 1.0
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 4)
+        ];
+        this.itemSize = 2;
+        this.primitive = 'TRIANGLE_STRIP';
+    }
+}
+
+class Quad extends BasicMesh {
+    constructor(size = new Vec2(2.0, 2.0)) {
+        super();
+        let width;
+        let h;
+        if (size instanceof Rect) {
+            width = size.size.x * 0.5;
+            h = size.size.y * 0.5;
+        }
+        else {
+            width = size.x * 0.5;
+            h = size.y * 0.5;
+        }
+        this.vertices = [width, -h, 0.0,
+            -width, -h, 0.0,
+            width, h, 0.0,
+            -width, h, 0.0
+        ];
+        this.uvs = [1.0, 0.0,
+            0.0, 0.0,
+            1.0, 1.0,
+            0.0, 1.0
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 4)
+        ];
+        this.itemSize = 3;
+        this.primitive = 'TRIANGLE_STRIP';
+    }
+}
+
+class MultiQuad extends BasicMesh {
+    quad;
+    constructor(size = new Vec2(2.0, 2.0)) {
+        super();
+        let width;
+        let h;
+        if (size instanceof Rect) {
+            width = size.size.x * 0.5;
+            h = size.size.y * 0.5;
+        }
+        else {
+            width = size.x * 0.5;
+            h = size.y * 0.5;
+        }
+        this.quad = {
+            vertices: new Float32Array([width, -h, 0.0,
+                -width, h, 0.0,
+                -width, -h, 0.0,
+                width, h, 0.0
+            ]),
+            indices: new Int32Array([0, 1, 2,
+                0, 3, 1
+            ]),
+            uvs: new Float32Array([1.0, 0.0,
+                0.0, 1.0,
+                0.0, 0.0,
+                1.0, 1.0
+            ])
+        };
+        this.vertices = [];
+        this.indices = [];
+        this.uvs = [];
+        this.subMeshes = [
+            new SubMesh(0, 4)
+        ];
+    }
+    createQuads(length) {
+        for (let i = 0; i < length; i++) {
+            this.vertices.push(...this.quad.vertices);
+            this.indices.push(...this.createIndices(i));
+            this.uvs.push(...this.quad.uvs);
+        }
+        if (this.subMeshes.length > 0 && length > 0)
+            this.subMeshes[0].count = this.indices.length;
+    }
+    createIndices(quadIndex) {
+        const indices = [];
+        for (let i = 0; i < 6; i++)
+            indices.push(this.quad.indices[i] + quadIndex * 4);
+        return indices;
+    }
+}
+
+class Cube extends BasicMesh {
+    constructor(size = new Vec3(2.0, 2.0, 2.0), flat = false) {
+        super();
+        const halfX = (size ? size.x : 2.0) * 0.5;
+        const halfY = (size ? size.y : 2.0) * 0.5;
+        const halfZ = (size ? size.z : 2.0) * 0.5;
+        const sx = halfX || 1.0;
+        const sy = halfY || 1.0;
+        const sz = halfZ || 1.0;
+        if (flat) {
+            this.vertices = [
+                -sx, -sy, sz, sx, -sy, sz, sx, sy, sz, -sx, sy, sz,
+                sx, -sy, -sz, -sx, -sy, -sz, -sx, sy, -sz, sx, sy, -sz,
+                -sx, sy, sz, sx, sy, sz, sx, sy, -sz, -sx, sy, -sz,
+                -sx, -sy, -sz, sx, -sy, -sz, sx, -sy, sz, -sx, -sy, sz,
+                sx, -sy, sz, sx, -sy, -sz, sx, sy, -sz, sx, sy, sz,
+                -sx, -sy, -sz, -sx, -sy, sz, -sx, sy, sz, -sx, sy, -sz
+            ];
+            this.normals = [
+                0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1,
+                0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1,
+                0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0,
+                0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0,
+                1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0,
+                -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0
+            ];
+            this.indices = [
+                0, 1, 2, 0, 2, 3,
+                4, 5, 6, 4, 6, 7,
+                8, 9, 10, 8, 10, 11,
+                12, 13, 14, 12, 14, 15,
+                16, 17, 18, 16, 18, 19,
+                20, 21, 22, 20, 22, 23
+            ];
+            this.subMeshes = [
+                new SubMesh(0, 36)
+            ];
+            return;
+        }
+        this.vertices = [sx, -sy, -sz,
+            -sx, -sy, sz,
+            sx, -sy, sz,
+            -sx, sy, sz,
+            sx, sy, -sz,
+            sx, sy, sz,
+            -sx, -sy, -sz,
+            -sx, sy, -sz
+        ];
+        this.indices = [2, 5, 3, 2, 3, 1,
+            4, 0, 6, 4, 6, 7,
+            3, 5, 4, 3, 4, 7,
+            0, 2, 1, 0, 1, 6,
+            5, 2, 0, 5, 0, 4,
+            6, 1, 3, 6, 3, 7
+        ];
+        this.normals = [0.5773, -0.5773, -0.5773,
+            -0.5773, -0.5773, 0.5773,
+            0.5773, -0.5773, 0.5773,
+            -0.5773, 0.5773, 0.5773,
+            0.5773, 0.5773, -0.5773,
+            0.5773, 0.5773, 0.5773,
+            -0.5773, -0.5773, -0.5773,
+            -0.5773, 0.5773, -0.5773
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 36)
+        ];
+    }
+}
+
+class Sphere extends BasicMesh {
+    constructor(scale = new Vec3(1.0, 1.0, 1.0)) {
+        super();
+        this.vertices = [-0.7071, -0.7071, 0, -0.5449, -0.8315, 0.1084, -0.5556, -0.8315, 0, -0.8315, 0.5556, 0, -0.9061, 0.3827, 0.1802, -0.9239, 0.3827, 0, -0.3753, -0.9239, 0.0747, -0.3827, -0.9239, 0, -0.9619, 0.1951, 0.1913, -0.9808, 0.1951, 0, -0.1913, -0.9808, 0.0381, -0.1951, -0.9808, 0, -0.9808, 0, 0.1951, -1, 0, 0, -0.1951, 0.9808, 0, 0, 1, 0, -0.1913, 0.9808, 0.0381, 0, -1, 0, -0.9619, -0.1951, 0.1913, -0.9808, -0.1951, 0, -0.3753, 0.9239, 0.0747, -0.3827, 0.9239, 0, -0.9239, -0.3827, 0, -0.9061, -0.3827, 0.1802, -0.5556, 0.8315, 0, -0.5449, 0.8315, 0.1084, -0.8155, -0.5556, 0.1622, -0.8315, -0.5556, 0, -0.6935, 0.7071, 0.1379, -0.7071, 0.7071, 0, -0.6935, -0.7071, 0.1379, -0.8155, 0.5556, 0.1622, -0.7682, -0.5556, 0.3182, -0.6533, -0.7071, 0.2706, -0.7682, 0.5556, 0.3182, -0.5133, -0.8315, 0.2126, -0.8536, 0.3827, 0.3536, -0.3536, -0.9239, 0.1464, -0.9061, 0.1951, 0.3753, -0.1802, -0.9808, 0.0747, -0.9239, 0, 0.3827, -0.1802, 0.9808, 0.0747, -0.9061, -0.1951, 0.3753, -0.3536, 0.9239, 0.1464, -0.8536, -0.3827, 0.3536, -0.5133, 0.8315, 0.2126, -0.6533, 0.7071, 0.2706, -0.1622, 0.9808, 0.1084, -0.1622, -0.9808, 0.1084, -0.8155, -0.1951, 0.5449, -0.3182, 0.9239, 0.2126, -0.7682, -0.3827, 0.5133, -0.4619, 0.8315, 0.3087, -0.6913, -0.5556, 0.4619, -0.5879, 0.7071, 0.3928, -0.5879, -0.7071, 0.3928, -0.6913, 0.5556, 0.4619, -0.4619, -0.8315, 0.3087, -0.7682, 0.3827, 0.5133, -0.3182, -0.9239, 0.2126, -0.8155, 0.1951, 0.5449, -0.8315, 0, 0.5556, -0.5879, 0.5556, 0.5879, -0.3928, -0.8315, 0.3928, -0.6533, 0.3827, 0.6533, -0.2706, -0.9239, 0.2706, -0.6935, 0.1951, 0.6935, -0.1379, -0.9808, 0.1379, -0.7071, 0, 0.7071, -0.1379, 0.9808, 0.1379, -0.6935, -0.1951, 0.6935, -0.2706, 0.9239, 0.2706, -0.6533, -0.3827, 0.6533, -0.3928, 0.8315, 0.3928, -0.5879, -0.5556, 0.5879, -0.5, 0.7071, 0.5, -0.5, -0.7071, 0.5, -0.5449, -0.1951, 0.8155, -0.2126, 0.9239, 0.3182, -0.5133, -0.3827, 0.7682, -0.3087, 0.8315, 0.4619, -0.4619, -0.5556, 0.6913, -0.3928, 0.7071, 0.5879, -0.3928, -0.7071, 0.5879, -0.4619, 0.5556, 0.6913, -0.3087, -0.8315, 0.4619, -0.5133, 0.3827, 0.7682, -0.2126, -0.9239, 0.3182, -0.5449, 0.1951, 0.8155, -0.1084, -0.9808, 0.1622, -0.5556, 0, 0.8315, -0.1084, 0.9808, 0.1622, -0.2126, -0.8315, 0.5133, -0.3536, 0.3827, 0.8536, -0.1464, -0.9239, 0.3536, -0.3753, 0.1951, 0.9061, -0.0747, -0.9808, 0.1802, -0.3827, 0, 0.9239, -0.0747, 0.9808, 0.1802, -0.3753, -0.1951, 0.9061, -0.1464, 0.9239, 0.3536, -0.3536, -0.3827, 0.8536, -0.2126, 0.8315, 0.5133, -0.3182, -0.5556, 0.7682, -0.2706, 0.7071, 0.6533, -0.2706, -0.7071, 0.6533, -0.3182, 0.5556, 0.7682, -0.1802, -0.3827, 0.9061, -0.1084, 0.8315, 0.5449, -0.1622, -0.5556, 0.8155, -0.1379, 0.7071, 0.6935, -0.1379, -0.7071, 0.6935, -0.1622, 0.5556, 0.8155, -0.1084, -0.8315, 0.5449, -0.1802, 0.3827, 0.9061, -0.0747, -0.9239, 0.3753, -0.1913, 0.1951, 0.9619, -0.0381, -0.9808, 0.1913, -0.1951, 0, 0.9808, -0.0381, 0.9808, 0.1913, -0.1913, -0.1951, 0.9619, -0.0747, 0.9239, 0.3753, 0, -0.8315, 0.5556, 0, -0.9239, 0.3827, 0, 0.3827, 0.9239, 0, 0.1951, 0.9808, 0, -0.9808, 0.1951, 0, 0, 1, 0, 0.9808, 0.1951, 0, -0.1951, 0.9808, 0, 0.9239, 0.3827, 0, -0.3827, 0.9239, 0, 0.8315, 0.5556, 0, -0.5556, 0.8315, 0, 0.7071, 0.7071, 0, -0.7071, 0.7071, 0, 0.5556, 0.8315, 0.1084, 0.8315, 0.5449, 0.1802, -0.3827, 0.9061, 0.1622, -0.5556, 0.8155, 0.138, 0.7071, 0.6935, 0.138, -0.7071, 0.6935, 0.1622, 0.5556, 0.8155, 0.1084, -0.8315, 0.5449, 0.1802, 0.3827, 0.9061, 0.0747, -0.9239, 0.3753, 0.1913, 0.1951, 0.9619, 0.0381, -0.9808, 0.1913, 0.1951, 0, 0.9808, 0.0381, 0.9808, 0.1913, 0.1913, -0.1951, 0.9619, 0.0747, 0.9239, 0.3753, 0.3536, 0.3827, 0.8536, 0.3753, 0.1951, 0.9061, 0.0747, -0.9808, 0.1802, 0.3827, 0, 0.9239, 0.0747, 0.9808, 0.1802, 0.3753, -0.1951, 0.9061, 0.1464, 0.9239, 0.3536, 0.3536, -0.3827, 0.8536, 0.2126, 0.8315, 0.5133, 0.3182, -0.5556, 0.7682, 0.2706, 0.7071, 0.6533, 0.2706, -0.7071, 0.6533, 0.3182, 0.5556, 0.7682, 0.2126, -0.8315, 0.5133, 0.1464, -0.9239, 0.3536, 0.5133, -0.3827, 0.7682, 0.4619, -0.5556, 0.6913, 0.3928, 0.7071, 0.5879, 0.3928, -0.7071, 0.5879, 0.4619, 0.5556, 0.6913, 0.3087, -0.8315, 0.4619, 0.5133, 0.3827, 0.7682, 0.2126, -0.9239, 0.3182, 0.5449, 0.1951, 0.8155, 0.1084, -0.9808, 0.1622, 0.5556, 0, 0.8315, 0.1084, 0.9808, 0.1622, 0.5449, -0.1951, 0.8155, 0.2126, 0.9239, 0.3182, 0.3087, 0.8315, 0.4619, 0.2706, -0.9239, 0.2706, 0.138, -0.9808, 0.1379, 0.7071, 0, 0.7071, 0.138, 0.9808, 0.1379, 0.6935, -0.1951, 0.6935, 0.2706, 0.9239, 0.2706, 0.6533, -0.3827, 0.6533, 0.3928, 0.8315, 0.3928, 0.5879, -0.5556, 0.5879, 0.5, 0.7071, 0.5, 0.5, -0.7071, 0.5, 0.5879, 0.5556, 0.5879, 0.3928, -0.8315, 0.3928, 0.6533, 0.3827, 0.6533, 0.6935, 0.1951, 0.6935, 0.4619, 0.8315, 0.3087, 0.5879, 0.7071, 0.3928, 0.5879, -0.7071, 0.3928, 0.6913, 0.5556, 0.4619, 0.4619, -0.8315, 0.3087, 0.7682, 0.3827, 0.5133, 0.3182, -0.9239, 0.2126, 0.8155, 0.1951, 0.5449, 0.1622, -0.9808, 0.1084, 0.8315, 0, 0.5556, 0.1622, 0.9808, 0.1084, 0.8155, -0.1951, 0.5449, 0.3182, 0.9239, 0.2126, 0.7682, -0.3827, 0.5133, 0.6913, -0.5556, 0.4619, 0.9239, 0, 0.3827, 0.1802, 0.9808, 0.0747, 0.1802, -0.9808, 0.0747, 0.9061, -0.1951, 0.3753, 0.3536, 0.9239, 0.1464, 0.8536, -0.3827, 0.3536, 0.5133, 0.8315, 0.2126, 0.7682, -0.5556, 0.3182, 0.6533, 0.7071, 0.2706, 0.6533, -0.7071, 0.2706, 0.7682, 0.5556, 0.3182, 0.5133, -0.8315, 0.2126, 0.8536, 0.3827, 0.3536, 0.3536, -0.9239, 0.1464, 0.9061, 0.1951, 0.3753, 0.6935, -0.7071, 0.1379, 0.8155, 0.5556, 0.1622, 0.5449, -0.8315, 0.1084, 0.9061, 0.3827, 0.1802, 0.3753, -0.9239, 0.0747, 0.9619, 0.1951, 0.1913, 0.1913, -0.9808, 0.0381, 0.9808, 0, 0.1951, 0.1913, 0.9808, 0.0381, 0.9619, -0.1951, 0.1913, 0.3753, 0.9239, 0.0747, 0.9061, -0.3827, 0.1802, 0.5449, 0.8315, 0.1084, 0.8155, -0.5556, 0.1622, 0.6935, 0.7071, 0.1379, 0.1951, -0.9808, 0, 0.9808, -0.1951, 0, 0.3827, 0.9239, 0, 0.9239, -0.3827, 0, 0.5556, 0.8315, 0, 0.8315, -0.5556, 0, 0.7071, 0.7071, 0, 0.7071, -0.7071, 0, 0.8315, 0.5556, 0, 0.5556, -0.8315, 0, 0.9239, 0.3827, 0, 0.3827, -0.9239, 0, 0.9808, 0.1951, 0, 1, 0, 0, 0.1951, 0.9808, 0, 0.5449, -0.8315, -0.1084, 0.9061, 0.3827, -0.1802, 0.3753, -0.9239, -0.0747, 0.9619, 0.1951, -0.1913, 0.1913, -0.9808, -0.0381, 0.9808, 0, -0.1951, 0.1913, 0.9808, -0.0381, 0.9619, -0.1951, -0.1913, 0.3753, 0.9239, -0.0747, 0.9061, -0.3827, -0.1802, 0.5449, 0.8315, -0.1084, 0.8155, -0.5556, -0.1622, 0.6935, 0.7071, -0.1379, 0.6935, -0.7071, -0.1379, 0.8155, 0.5556, -0.1622, 0.3536, 0.9239, -0.1464, 0.8536, -0.3827, -0.3536, 0.5133, 0.8315, -0.2126, 0.7682, -0.5556, -0.3182, 0.6533, 0.7071, -0.2706, 0.6533, -0.7071, -0.2706, 0.7682, 0.5556, -0.3182, 0.5133, -0.8315, -0.2126, 0.8536, 0.3827, -0.3536, 0.3536, -0.9239, -0.1464, 0.9061, 0.1951, -0.3753, 0.1802, -0.9808, -0.0747, 0.9239, 0, -0.3827, 0.1802, 0.9808, -0.0747, 0.9061, -0.1951, -0.3753, 0.7682, 0.3827, -0.5133, 0.3182, -0.9239, -0.2126, 0.8155, 0.1951, -0.5449, 0.1622, -0.9808, -0.1084, 0.8315, 0, -0.5556, 0.1622, 0.9808, -0.1084, 0.8155, -0.1951, -0.5449, 0.3182, 0.9239, -0.2126, 0.7682, -0.3827, -0.5133, 0.4619, 0.8315, -0.3087, 0.6913, -0.5556, -0.4619, 0.5879, 0.7071, -0.3928, 0.5879, -0.7071, -0.3928, 0.6913, 0.5556, -0.4619, 0.4619, -0.8315, -0.3087, 0.6533, -0.3827, -0.6533, 0.3928, 0.8315, -0.3928, 0.5879, -0.5556, -0.5879, 0.5, 0.7071, -0.5, 0.5, -0.7071, -0.5, 0.5879, 0.5556, -0.5879, 0.3928, -0.8315, -0.3928, 0.6533, 0.3827, -0.6533, 0.2706, -0.9239, -0.2706, 0.6935, 0.1951, -0.6935, 0.1379, -0.9808, -0.1379, 0.7071, 0, -0.7071, 0.138, 0.9808, -0.1379, 0.6935, -0.1951, -0.6935, 0.2706, 0.9239, -0.2706, 0.3087, -0.8315, -0.4619, 0.2126, -0.9239, -0.3182, 0.5133, 0.3827, -0.7682, 0.5449, 0.1951, -0.8155, 0.1084, -0.9808, -0.1622, 0.5556, 0, -0.8315, 0.1084, 0.9808, -0.1622, 0.5449, -0.1951, -0.8155, 0.2126, 0.9239, -0.3182, 0.5133, -0.3827, -0.7682, 0.3087, 0.8315, -0.4619, 0.4619, -0.5556, -0.6913, 0.3928, 0.7071, -0.5879, 0.3928, -0.7071, -0.5879, 0.4619, 0.5556, -0.6913, 0.2126, 0.8315, -0.5133, 0.3536, -0.3827, -0.8536, 0.3182, -0.5556, -0.7682, 0.2706, 0.7071, -0.6533, 0.2706, -0.7071, -0.6533, 0.3182, 0.5556, -0.7682, 0.2126, -0.8315, -0.5133, 0.3536, 0.3827, -0.8536, 0.1464, -0.9239, -0.3536, 0.3753, 0.1951, -0.9061, 0.0747, -0.9808, -0.1802, 0.3827, 0, -0.9239, 0.0747, 0.9808, -0.1802, 0.3753, -0.1951, -0.9061, 0.1464, 0.9239, -0.3536, 0.1802, 0.3827, -0.9061, 0.1913, 0.1951, -0.9619, 0.0381, -0.9808, -0.1913, 0.1951, 0, -0.9808, 0.0381, 0.9808, -0.1913, 0.1913, -0.1951, -0.9619, 0.0747, 0.9239, -0.3753, 0.1802, -0.3827, -0.9061, 0.1084, 0.8315, -0.5449, 0.1622, -0.5556, -0.8155, 0.1379, 0.7071, -0.6935, 0.1379, -0.7071, -0.6935, 0.1622, 0.5556, -0.8155, 0.1084, -0.8315, -0.5449, 0.0747, -0.9239, -0.3753, 0, -0.3827, -0.9239, 0, -0.5556, -0.8315, 0, 0.8315, -0.5556, 0, 0.7071, -0.7071, 0, -0.7071, -0.7071, 0, 0.5556, -0.8315, 0, -0.8315, -0.5556, 0, 0.3827, -0.9239, 0, -0.9239, -0.3827, 0, 0.1951, -0.9808, 0, -0.9808, -0.1951, 0, 0, -1, 0, 0.9808, -0.1951, 0, -0.1951, -0.9808, 0, 0.9239, -0.3827, -0.0381, -0.9808, -0.1913, -0.1951, 0, -0.9808, -0.0381, 0.9808, -0.1913, -0.1913, -0.1951, -0.9619, -0.0747, 0.9239, -0.3753, -0.1802, -0.3827, -0.9061, -0.1084, 0.8315, -0.5449, -0.1622, -0.5556, -0.8155, -0.1379, 0.7071, -0.6935, -0.1379, -0.7071, -0.6935, -0.1622, 0.5556, -0.8155, -0.1084, -0.8315, -0.5449, -0.1802, 0.3827, -0.9061, -0.0747, -0.9239, -0.3753, -0.1913, 0.1951, -0.9619, -0.2706, -0.7071, -0.6533, -0.3182, 0.5556, -0.7682, -0.2126, -0.8315, -0.5133, -0.3536, 0.3827, -0.8536, -0.1464, -0.9239, -0.3536, -0.3753, 0.1951, -0.9061, -0.0747, -0.9808, -0.1802, -0.3827, 0, -0.9239, -0.0747, 0.9808, -0.1802, -0.3753, -0.1951, -0.9061, -0.1464, 0.9239, -0.3536, -0.3536, -0.3827, -0.8536, -0.2126, 0.8315, -0.5133, -0.3182, -0.5556, -0.7682, -0.2706, 0.7071, -0.6533, -0.1084, 0.9808, -0.1622, -0.1084, -0.9808, -0.1622, -0.5556, 0, -0.8315, -0.5449, -0.1951, -0.8155, -0.2126, 0.9239, -0.3182, -0.5133, -0.3827, -0.7682, -0.3087, 0.8315, -0.4619, -0.4619, -0.5556, -0.6913, -0.3928, 0.7071, -0.5879, -0.3928, -0.7071, -0.5879, -0.4619, 0.5556, -0.6913, -0.3087, -0.8315, -0.4619, -0.5133, 0.3827, -0.7682, -0.2126, -0.9239, -0.3182, -0.5449, 0.1951, -0.8155, -0.5, 0.7071, -0.5, -0.5879, 0.5556, -0.5879, -0.3928, -0.8315, -0.3928, -0.6533, 0.3827, -0.6533, -0.2706, -0.9239, -0.2706, -0.6935, 0.1951, -0.6935, -0.1379, -0.9808, -0.1379, -0.7071, 0, -0.7071, -0.1379, 0.9808, -0.1379, -0.6935, -0.1951, -0.6935, -0.2706, 0.9239, -0.2706, -0.6533, -0.3827, -0.6533, -0.3928, 0.8315, -0.3928, -0.5879, -0.5556, -0.5879, -0.5, -0.7071, -0.5, -0.8155, -0.1951, -0.5449, -0.3182, 0.9239, -0.2126, -0.7682, -0.3827, -0.5133, -0.4619, 0.8315, -0.3087, -0.6913, -0.5556, -0.4619, -0.5879, 0.7071, -0.3928, -0.5879, -0.7071, -0.3928, -0.6913, 0.5556, -0.4619, -0.4619, -0.8315, -0.3087, -0.7682, 0.3827, -0.5133, -0.3182, -0.9239, -0.2126, -0.8155, 0.1951, -0.5449, -0.1622, -0.9808, -0.1084, -0.8315, 0, -0.5556, -0.1622, 0.9808, -0.1084, -0.5133, -0.8315, -0.2126, -0.8536, 0.3827, -0.3536, -0.3536, -0.9239, -0.1464, -0.9061, 0.1951, -0.3753, -0.1802, -0.9808, -0.0747, -0.9239, 0, -0.3827, -0.1802, 0.9808, -0.0747, -0.9061, -0.1951, -0.3753, -0.3536, 0.9239, -0.1464, -0.8536, -0.3827, -0.3536, -0.5133, 0.8315, -0.2126, -0.7682, -0.5556, -0.3182, -0.6533, 0.7071, -0.2706, -0.6533, -0.7071, -0.2706, -0.7682, 0.5556, -0.3182, -0.3753, 0.9239, -0.0747, -0.9061, -0.3827, -0.1802, -0.5449, 0.8315, -0.1084, -0.8155, -0.5556, -0.1622, -0.6935, 0.7071, -0.1379, -0.6935, -0.7071, -0.1379, -0.8155, 0.5556, -0.1622, -0.5449, -0.8315, -0.1084, -0.9061, 0.3827, -0.1802, -0.3753, -0.9239, -0.0747, -0.9619, 0.1951, -0.1913, -0.1913, -0.9808, -0.0381, -0.9808, 0, -0.1951, -0.1913, 0.9808, -0.0381, -0.9619, -0.1951, -0.1913
+        ];
+        this.indices = [0, 1, 2, 3, 4, 5, 2, 6, 7, 5, 8, 9, 7, 10, 11, 9, 12, 13, 14, 15, 16, 17, 11, 10, 13, 18, 19, 14, 20, 21, 22, 18, 23, 24, 20, 25, 22, 26, 27, 24, 28, 29, 0, 26, 30, 29, 31, 3, 30, 32, 33, 28, 34, 31, 30, 35, 1, 31, 36, 4, 1, 37, 6, 4, 38, 8, 6, 39, 10, 8, 40, 12, 16, 15, 41, 17, 10, 39, 18, 40, 42, 16, 43, 20, 23, 42, 44, 20, 45, 25, 23, 32, 26, 25, 46, 28, 41, 15, 47, 17, 39, 48, 40, 49, 42, 41, 50, 43, 42, 51, 44, 43, 52, 45, 32, 51, 53, 45, 54, 46, 33, 53, 55, 46, 56, 34, 33, 57, 35, 34, 58, 36, 35, 59, 37, 38, 58, 60, 37, 48, 39, 38, 61, 40, 54, 62, 56, 55, 63, 57, 56, 64, 58, 57, 65, 59, 58, 66, 60, 59, 67, 48, 61, 66, 68, 47, 15, 69, 17, 48, 67, 61, 70, 49, 47, 71, 50, 49, 72, 51, 50, 73, 52, 53, 72, 74, 52, 75, 54, 53, 76, 55, 68, 77, 70, 69, 78, 71, 70, 79, 72, 71, 80, 73, 74, 79, 81, 73, 82, 75, 74, 83, 76, 62, 82, 84, 63, 83, 85, 62, 86, 64, 65, 85, 87, 64, 88, 66, 65, 89, 67, 68, 88, 90, 69, 15, 91, 17, 67, 89, 83, 92, 85, 84, 93, 86, 87, 92, 94, 88, 93, 95, 87, 96, 89, 88, 97, 90, 91, 15, 98, 17, 89, 96, 90, 99, 77, 91, 100, 78, 77, 101, 79, 78, 102, 80, 81, 101, 103, 80, 104, 82, 83, 103, 105, 84, 104, 106, 99, 107, 101, 100, 108, 102, 103, 107, 109, 104, 108, 110, 105, 109, 111, 104, 112, 106, 105, 113, 92, 106, 114, 93, 92, 115, 94, 95, 114, 116, 96, 115, 117, 95, 118, 97, 98, 15, 119, 17, 96, 117, 97, 120, 99, 98, 121, 100, 115, 122, 123, 116, 124, 125, 117, 123, 126, 116, 127, 118, 119, 15, 128, 17, 117, 126, 120, 127, 129, 119, 130, 121, 120, 131, 107, 121, 132, 108, 109, 131, 133, 108, 134, 110, 109, 135, 111, 110, 136, 112, 113, 135, 122, 112, 124, 114, 130, 137, 132, 133, 138, 139, 132, 140, 134, 133, 141, 135, 136, 140, 142, 122, 141, 143, 136, 144, 124, 122, 145, 123, 125, 144, 146, 126, 145, 147, 125, 148, 127, 128, 15, 149, 17, 126, 147, 127, 150, 129, 130, 149, 151, 129, 138, 131, 146, 152, 153, 145, 154, 147, 146, 155, 148, 149, 15, 156, 17, 147, 154, 148, 157, 150, 149, 158, 151, 150, 159, 138, 137, 158, 160, 139, 159, 161, 137, 162, 140, 139, 163, 141, 140, 164, 142, 141, 165, 143, 142, 152, 144, 145, 165, 166, 161, 167, 168, 160, 169, 162, 161, 170, 163, 164, 169, 171, 165, 170, 172, 164, 173, 152, 165, 174, 166, 153, 173, 175, 166, 176, 154, 153, 177, 155, 156, 15, 178, 17, 154, 176, 157, 177, 179, 156, 180, 158, 157, 167, 159, 158, 181, 160, 176, 182, 183, 175, 184, 177, 178, 15, 185, 17, 176, 183, 177, 186, 179, 178, 187, 180, 179, 188, 167, 180, 189, 181, 167, 190, 168, 181, 191, 169, 168, 192, 170, 169, 193, 171, 172, 192, 194, 171, 195, 173, 172, 182, 174, 175, 195, 196, 191, 197, 198, 190, 199, 192, 193, 198, 200, 194, 199, 201, 193, 202, 195, 194, 203, 182, 196, 202, 204, 183, 203, 205, 196, 206, 184, 185, 15, 207, 17, 183, 205, 186, 206, 208, 185, 209, 187, 186, 210, 188, 187, 197, 189, 190, 210, 211, 204, 212, 206, 207, 15, 213, 17, 205, 214, 206, 215, 208, 207, 216, 209, 208, 217, 210, 197, 216, 218, 211, 217, 219, 197, 220, 198, 211, 221, 199, 198, 222, 200, 201, 221, 223, 200, 224, 202, 201, 225, 203, 204, 224, 226, 203, 214, 205, 219, 227, 221, 220, 228, 222, 221, 229, 223, 222, 230, 224, 223, 231, 225, 226, 230, 232, 214, 231, 233, 226, 234, 212, 213, 15, 235, 17, 214, 233, 212, 236, 215, 213, 237, 216, 215, 238, 217, 216, 239, 218, 219, 238, 240, 218, 241, 220, 17, 233, 242, 234, 243, 236, 235, 244, 237, 236, 245, 238, 239, 244, 246, 240, 245, 247, 241, 246, 248, 240, 249, 227, 241, 250, 228, 229, 249, 251, 228, 252, 230, 229, 253, 231, 232, 252, 254, 233, 253, 242, 232, 255, 234, 235, 15, 256, 249, 257, 251, 250, 258, 252, 251, 259, 253, 254, 258, 260, 253, 261, 242, 254, 262, 255, 256, 15, 263, 17, 242, 261, 255, 264, 243, 256, 265, 244, 243, 266, 245, 244, 267, 246, 247, 266, 268, 248, 267, 269, 247, 270, 249, 250, 269, 271, 263, 272, 265, 264, 273, 266, 265, 274, 267, 268, 273, 275, 269, 274, 276, 268, 277, 270, 271, 276, 278, 270, 279, 257, 271, 280, 258, 259, 279, 281, 260, 280, 282, 261, 281, 283, 260, 284, 262, 263, 15, 285, 17, 261, 283, 264, 284, 286, 278, 287, 280, 279, 288, 281, 282, 287, 289, 283, 288, 290, 282, 291, 284, 285, 15, 292, 17, 283, 290, 284, 293, 286, 285, 294, 272, 286, 295, 273, 272, 296, 274, 275, 295, 297, 274, 298, 276, 275, 299, 277, 278, 298, 300, 279, 299, 301, 293, 302, 295, 294, 303, 296, 297, 302, 304, 298, 303, 305, 297, 306, 299, 300, 305, 307, 299, 308, 301, 300, 309, 287, 301, 310, 288, 289, 309, 311, 288, 312, 290, 291, 311, 313, 292, 15, 314, 17, 290, 312, 291, 315, 293, 292, 316, 294, 310, 317, 318, 311, 319, 320, 310, 321, 312, 311, 322, 313, 314, 15, 323, 17, 312, 321, 313, 324, 315, 314, 325, 316, 315, 326, 302, 316, 327, 303, 304, 326, 328, 305, 327, 329, 304, 330, 306, 307, 329, 331, 306, 317, 308, 307, 319, 309, 325, 332, 327, 328, 333, 334, 329, 332, 335, 330, 334, 336, 331, 335, 337, 330, 338, 317, 331, 339, 319, 318, 338, 340, 320, 339, 341, 321, 340, 342, 320, 343, 322, 323, 15, 344, 17, 321, 342, 322, 345, 324, 323, 346, 325, 324, 333, 326, 341, 347, 348, 340, 349, 342, 341, 350, 343, 344, 15, 351, 17, 342, 349, 343, 352, 345, 346, 351, 353, 345, 354, 333, 346, 355, 332, 334, 354, 356, 335, 355, 357, 334, 358, 336, 337, 357, 359, 336, 360, 338, 337, 347, 339, 340, 360, 361, 356, 362, 363, 357, 364, 365, 356, 366, 358, 357, 367, 359, 360, 366, 368, 359, 369, 347, 361, 368, 370, 348, 369, 371, 361, 372, 349, 348, 373, 350, 351, 15, 374, 17, 349, 372, 352, 373, 375, 353, 374, 376, 352, 362, 354, 353, 364, 355, 370, 377, 372, 371, 378, 373, 374, 15, 379, 17, 372, 377, 375, 378, 380, 376, 379, 381, 375, 382, 362, 376, 383, 364, 363, 382, 384, 365, 383, 385, 363, 386, 366, 367, 385, 387, 366, 388, 368, 367, 389, 369, 370, 388, 390, 371, 389, 391, 384, 392, 386, 385, 393, 387, 386, 394, 388, 387, 395, 389, 390, 394, 396, 391, 395, 397, 390, 398, 377, 391, 399, 378, 379, 15, 400, 17, 377, 398, 378, 401, 380, 379, 402, 381, 380, 403, 382, 381, 404, 383, 384, 403, 405, 385, 404, 406, 400, 15, 407, 17, 398, 408, 401, 409, 410, 400, 411, 402, 401, 412, 403, 404, 411, 413, 405, 412, 414, 406, 413, 415, 405, 416, 392, 393, 415, 417, 392, 418, 394, 393, 419, 395, 396, 418, 420, 397, 419, 421, 396, 408, 398, 397, 409, 399, 417, 422, 423, 416, 424, 418, 417, 425, 419, 418, 426, 420, 421, 425, 427, 420, 428, 408, 421, 429, 409, 407, 15, 430, 17, 408, 428, 410, 429, 431, 407, 432, 411, 410, 433, 412, 411, 434, 413, 414, 433, 435, 413, 422, 415, 414, 436, 416, 429, 437, 431, 430, 438, 432, 431, 439, 433, 432, 440, 434, 435, 439, 441, 434, 442, 422, 435, 443, 436, 423, 442, 444, 424, 443, 445, 423, 446, 425, 424, 447, 426, 427, 446, 448, 426, 449, 428, 429, 448, 450, 430, 15, 451, 17, 428, 449, 443, 452, 445, 444, 453, 446, 445, 454, 447, 448, 453, 455, 447, 456, 449, 448, 457, 450, 451, 15, 458, 17, 449, 456, 450, 459, 437, 438, 458, 460, 437, 461, 439, 440, 460, 462, 441, 461, 463, 442, 462, 464, 441, 465, 443, 444, 464, 466, 458, 467, 460, 459, 468, 461, 460, 469, 462, 463, 468, 470, 462, 471, 464, 463, 472, 465, 466, 471, 473, 465, 474, 452, 466, 475, 453, 452, 476, 454, 455, 475, 477, 456, 476, 478, 455, 479, 457, 458, 15, 480, 17, 456, 478, 457, 481, 459, 475, 3, 5, 474, 7, 476, 477, 5, 9, 476, 11, 478, 479, 9, 13, 480, 15, 14, 17, 478, 11, 479, 19, 481, 467, 14, 21, 481, 22, 468, 469, 21, 24, 468, 27, 470, 471, 24, 29, 470, 0, 472, 473, 29, 3, 472, 2, 474, 0, 30, 1, 3, 31, 4, 2, 1, 6, 5, 4, 8, 7, 6, 10, 9, 8, 12, 13, 12, 18, 14, 16, 20, 22, 19, 18, 24, 21, 20, 22, 23, 26, 24, 25, 28, 0, 27, 26, 29, 28, 31, 30, 26, 32, 28, 46, 34, 30, 33, 35, 31, 34, 36, 1, 35, 37, 4, 36, 38, 6, 37, 39, 8, 38, 40, 18, 12, 40, 16, 41, 43, 23, 18, 42, 20, 43, 45, 23, 44, 32, 25, 45, 46, 40, 61, 49, 41, 47, 50, 42, 49, 51, 43, 50, 52, 32, 44, 51, 45, 52, 54, 33, 32, 53, 46, 54, 56, 33, 55, 57, 34, 56, 58, 35, 57, 59, 38, 36, 58, 37, 59, 48, 38, 60, 61, 54, 75, 62, 55, 76, 63, 56, 62, 64, 57, 63, 65, 58, 64, 66, 59, 65, 67, 61, 60, 66, 61, 68, 70, 47, 69, 71, 49, 70, 72, 50, 71, 73, 53, 51, 72, 52, 73, 75, 53, 74, 76, 68, 90, 77, 69, 91, 78, 70, 77, 79, 71, 78, 80, 74, 72, 79, 73, 80, 82, 74, 81, 83, 62, 75, 82, 63, 76, 83, 62, 84, 86, 65, 63, 85, 64, 86, 88, 65, 87, 89, 68, 66, 88, 83, 105, 92, 84, 106, 93, 87, 85, 92, 88, 86, 93, 87, 94, 96, 88, 95, 97, 90, 97, 99, 91, 98, 100, 77, 99, 101, 78, 100, 102, 81, 79, 101, 80, 102, 104, 83, 81, 103, 84, 82, 104, 99, 120, 107, 100, 121, 108, 103, 101, 107, 104, 102, 108, 105, 103, 109, 104, 110, 112, 105, 111, 113, 106, 112, 114, 92, 113, 115, 95, 93, 114, 96, 94, 115, 95, 116, 118, 97, 118, 120, 98, 119, 121, 115, 113, 122, 116, 114, 124, 117, 115, 123, 116, 125, 127, 120, 118, 127, 119, 128, 130, 120, 129, 131, 121, 130, 132, 109, 107, 131, 108, 132, 134, 109, 133, 135, 110, 134, 136, 113, 111, 135, 112, 136, 124, 130, 151, 137, 133, 131, 138, 132, 137, 140, 133, 139, 141, 136, 134, 140, 122, 135, 141, 136, 142, 144, 122, 143, 145, 125, 124, 144, 126, 123, 145, 125, 146, 148, 127, 148, 150, 130, 128, 149, 129, 150, 138, 146, 144, 152, 145, 166, 154, 146, 153, 155, 148, 155, 157, 149, 156, 158, 150, 157, 159, 137, 151, 158, 139, 138, 159, 137, 160, 162, 139, 161, 163, 140, 162, 164, 141, 163, 165, 142, 164, 152, 145, 143, 165, 161, 159, 167, 160, 181, 169, 161, 168, 170, 164, 162, 169, 165, 163, 170, 164, 171, 173, 165, 172, 174, 153, 152, 173, 166, 174, 176, 153, 175, 177, 157, 155, 177, 156, 178, 180, 157, 179, 167, 158, 180, 181, 176, 174, 182, 175, 196, 184, 177, 184, 186, 178, 185, 187, 179, 186, 188, 180, 187, 189, 167, 188, 190, 181, 189, 191, 168, 190, 192, 169, 191, 193, 172, 170, 192, 171, 193, 195, 172, 194, 182, 175, 173, 195, 191, 189, 197, 190, 211, 199, 193, 191, 198, 194, 192, 199, 193, 200, 202, 194, 201, 203, 196, 195, 202, 183, 182, 203, 196, 204, 206, 186, 184, 206, 185, 207, 209, 186, 208, 210, 187, 209, 197, 190, 188, 210, 204, 226, 212, 206, 212, 215, 207, 213, 216, 208, 215, 217, 197, 209, 216, 211, 210, 217, 197, 218, 220, 211, 219, 221, 198, 220, 222, 201, 199, 221, 200, 222, 224, 201, 223, 225, 204, 202, 224, 203, 225, 214, 219, 240, 227, 220, 241, 228, 221, 227, 229, 222, 228, 230, 223, 229, 231, 226, 224, 230, 214, 225, 231, 226, 232, 234, 212, 234, 236, 213, 235, 237, 215, 236, 238, 216, 237, 239, 219, 217, 238, 218, 239, 241, 234, 255, 243, 235, 256, 244, 236, 243, 245, 239, 237, 244, 240, 238, 245, 241, 239, 246, 240, 247, 249, 241, 248, 250, 229, 227, 249, 228, 250, 252, 229, 251, 253, 232, 230, 252, 233, 231, 253, 232, 254, 255, 249, 270, 257, 250, 271, 258, 251, 257, 259, 254, 252, 258, 253, 259, 261, 254, 260, 262, 255, 262, 264, 256, 263, 265, 243, 264, 266, 244, 265, 267, 247, 245, 266, 248, 246, 267, 247, 268, 270, 250, 248, 269, 263, 285, 272, 264, 286, 273, 265, 272, 274, 268, 266, 273, 269, 267, 274, 268, 275, 277, 271, 269, 276, 270, 277, 279, 271, 278, 280, 259, 257, 279, 260, 258, 280, 261, 259, 281, 260, 282, 284, 264, 262, 284, 278, 300, 287, 279, 301, 288, 282, 280, 287, 283, 281, 288, 282, 289, 291, 284, 291, 293, 285, 292, 294, 286, 293, 295, 272, 294, 296, 275, 273, 295, 274, 296, 298, 275, 297, 299, 278, 276, 298, 279, 277, 299, 293, 315, 302, 294, 316, 303, 297, 295, 302, 298, 296, 303, 297, 304, 306, 300, 298, 305, 299, 306, 308, 300, 307, 309, 301, 308, 310, 289, 287, 309, 288, 310, 312, 291, 289, 311, 291, 313, 315, 292, 314, 316, 310, 308, 317, 311, 309, 319, 310, 318, 321, 311, 320, 322, 313, 322, 324, 314, 323, 325, 315, 324, 326, 316, 325, 327, 304, 302, 326, 305, 303, 327, 304, 328, 330, 307, 305, 329, 306, 330, 317, 307, 331, 319, 325, 346, 332, 328, 326, 333, 329, 327, 332, 330, 328, 334, 331, 329, 335, 330, 336, 338, 331, 337, 339, 318, 317, 338, 320, 319, 339, 321, 318, 340, 320, 341, 343, 322, 343, 345, 323, 344, 346, 324, 345, 333, 341, 339, 347, 340, 361, 349, 341, 348, 350, 343, 350, 352, 346, 344, 351, 345, 352, 354, 346, 353, 355, 334, 333, 354, 335, 332, 355, 334, 356, 358, 337, 335, 357, 336, 358, 360, 337, 359, 347, 340, 338, 360, 356, 354, 362, 357, 355, 364, 356, 363, 366, 357, 365, 367, 360, 358, 366, 359, 367, 369, 361, 360, 368, 348, 347, 369, 361, 370, 372, 348, 371, 373, 352, 350, 373, 353, 351, 374, 352, 375, 362, 353, 376, 364, 370, 390, 377, 371, 391, 378, 375, 373, 378, 376, 374, 379, 375, 380, 382, 376, 381, 383, 363, 362, 382, 365, 364, 383, 363, 384, 386, 367, 365, 385, 366, 386, 388, 367, 387, 389, 370, 368, 388, 371, 369, 389, 384, 405, 392, 385, 406, 393, 386, 392, 394, 387, 393, 395, 390, 388, 394, 391, 389, 395, 390, 396, 398, 391, 397, 399, 378, 399, 401, 379, 400, 402, 380, 401, 403, 381, 402, 404, 384, 382, 403, 385, 383, 404, 401, 399, 409, 400, 407, 411, 401, 410, 412, 404, 402, 411, 405, 403, 412, 406, 404, 413, 405, 414, 416, 393, 406, 415, 392, 416, 418, 393, 417, 419, 396, 394, 418, 397, 395, 419, 396, 420, 408, 397, 421, 409, 417, 415, 422, 416, 436, 424, 417, 423, 425, 418, 424, 426, 421, 419, 425, 420, 426, 428, 421, 427, 429, 410, 409, 429, 407, 430, 432, 410, 431, 433, 411, 432, 434, 414, 412, 433, 413, 434, 422, 414, 435, 436, 429, 450, 437, 430, 451, 438, 431, 437, 439, 432, 438, 440, 435, 433, 439, 434, 440, 442, 435, 441, 443, 423, 422, 442, 424, 436, 443, 423, 444, 446, 424, 445, 447, 427, 425, 446, 426, 447, 449, 429, 427, 448, 443, 465, 452, 444, 466, 453, 445, 452, 454, 448, 446, 453, 447, 454, 456, 448, 455, 457, 450, 457, 459, 438, 451, 458, 437, 459, 461, 440, 438, 460, 441, 439, 461, 442, 440, 462, 441, 463, 465, 444, 442, 464, 458, 480, 467, 459, 481, 468, 460, 467, 469, 463, 461, 468, 462, 469, 471, 463, 470, 472, 466, 464, 471, 465, 472, 474, 466, 473, 475, 452, 474, 476, 455, 453, 475, 456, 454, 476, 455, 477, 479, 457, 479, 481, 475, 473, 3, 474, 2, 7, 477, 475, 5, 476, 7, 11, 479, 477, 9, 479, 13, 19, 467, 480, 14, 481, 19, 22, 469, 467, 21, 468, 22, 27, 471, 469, 24, 470, 27, 0, 473, 471, 29, 472, 0, 2
+        ];
+        this.normals = [-0.7101, -0.704, 0, -0.549, -0.8286, 0.1092, -0.5598, -0.8286, 0, -0.8333, 0.5528, 0, -0.907, 0.3805, 0.1804, -0.9247, 0.3805, 0, -0.3804, -0.9217, 0.0757, -0.3879, -0.9217, 0, -0.9622, 0.1939, 0.1914, -0.981, 0.1939, 0, -0.1971, -0.9796, 0.0392, -0.201, -0.9796, 0, -0.9808, 0, 0.1951, -1, 0, 0, -0.201, 0.9796, 0, 0, 1, 0, -0.1971, 0.9796, 0.0392, 0, -1, 0, -0.9622, -0.1939, 0.1914, -0.981, -0.1939, 0, -0.3804, 0.9217, 0.0757, -0.3879, 0.9217, 0, -0.9247, -0.3805, 0, -0.907, -0.3805, 0.1804, -0.5598, 0.8286, 0, -0.549, 0.8286, 0.1092, -0.8173, -0.5528, 0.1626, -0.8333, -0.5528, 0, -0.6965, 0.704, 0.1385, -0.7101, 0.704, 0, -0.6965, -0.704, 0.1385, -0.8173, 0.5528, 0.1626, -0.7699, -0.5528, 0.3189, -0.6561, -0.704, 0.2717, -0.7699, 0.5528, 0.3189, -0.5171, -0.8286, 0.2142, -0.8544, 0.3805, 0.3539, -0.3583, -0.9217, 0.1484, -0.9063, 0.1939, 0.3754, -0.1856, -0.9796, 0.0769, -0.9239, 0, 0.3827, -0.1856, 0.9796, 0.0769, -0.9063, -0.1939, 0.3754, -0.3583, 0.9217, 0.1484, -0.8544, -0.3805, 0.3539, -0.5171, 0.8286, 0.2142, -0.6561, 0.704, 0.2717, -0.1671, 0.9796, 0.1116, -0.1671, -0.9796, 0.1116, -0.8157, -0.1939, 0.545, -0.3225, 0.9217, 0.2155, -0.7689, -0.3805, 0.5137, -0.4654, 0.8286, 0.311, -0.6929, -0.5528, 0.463, -0.5904, 0.704, 0.3945, -0.5904, -0.704, 0.3945, -0.6929, 0.5528, 0.463, -0.4654, -0.8286, 0.311, -0.7689, 0.3805, 0.5137, -0.3225, -0.9217, 0.2155, -0.8157, 0.1939, 0.545, -0.8314, 0, 0.5556, -0.5893, 0.5528, 0.5893, -0.3958, -0.8286, 0.3958, -0.6539, 0.3805, 0.6539, -0.2743, -0.9217, 0.2743, -0.6937, 0.1939, 0.6937, -0.1421, -0.9796, 0.1421, -0.7071, 0, 0.7071, -0.1421, 0.9796, 0.1421, -0.6937, -0.1939, 0.6937, -0.2743, 0.9217, 0.2743, -0.6539, -0.3805, 0.6539, -0.3958, 0.8286, 0.3958, -0.5893, -0.5528, 0.5893, -0.5021, 0.704, 0.5021, -0.5021, -0.704, 0.5021, -0.545, -0.1939, 0.8157, -0.2155, 0.9217, 0.3225, -0.5137, -0.3805, 0.7689, -0.311, 0.8286, 0.4654, -0.463, -0.5528, 0.6929, -0.3945, 0.704, 0.5904, -0.3945, -0.704, 0.5904, -0.463, 0.5528, 0.6929, -0.311, -0.8286, 0.4654, -0.5137, 0.3805, 0.7689, -0.2155, -0.9217, 0.3225, -0.545, 0.1939, 0.8157, -0.1116, -0.9796, 0.1671, -0.5556, 0, 0.8314, -0.1116, 0.9796, 0.1671, -0.2142, -0.8286, 0.5171, -0.3539, 0.3805, 0.8544, -0.1484, -0.9217, 0.3583, -0.3754, 0.1939, 0.9063, -0.0769, -0.9796, 0.1856, -0.3827, 0, 0.9239, -0.0769, 0.9796, 0.1856, -0.3754, -0.1939, 0.9063, -0.1484, 0.9217, 0.3583, -0.3539, -0.3805, 0.8544, -0.2142, 0.8286, 0.5171, -0.3189, -0.5528, 0.7699, -0.2717, 0.704, 0.6561, -0.2717, -0.704, 0.6561, -0.3189, 0.5528, 0.7699, -0.1804, -0.3805, 0.907, -0.1092, 0.8286, 0.549, -0.1626, -0.5528, 0.8173, -0.1385, 0.704, 0.6965, -0.1385, -0.704, 0.6965, -0.1626, 0.5528, 0.8173, -0.1092, -0.8286, 0.549, -0.1804, 0.3805, 0.907, -0.0757, -0.9217, 0.3804, -0.1914, 0.1939, 0.9622, -0.0392, -0.9796, 0.1971, -0.1951, 0, 0.9808, -0.0392, 0.9796, 0.1971, -0.1914, -0.1939, 0.9622, -0.0757, 0.9217, 0.3804, 0, -0.8286, 0.5598, 0, -0.9217, 0.3879, 0, 0.3805, 0.9247, 0, 0.1939, 0.981, 0, -0.9796, 0.201, 0, 0, 1, 0, 0.9796, 0.201, 0, -0.1939, 0.981, 0, 0.9217, 0.3879, 0, -0.3805, 0.9247, 0, 0.8286, 0.5598, 0, -0.5528, 0.8333, 0, 0.704, 0.7101, 0, -0.704, 0.7101, 0, 0.5528, 0.8333, 0.1092, 0.8286, 0.549, 0.1804, -0.3805, 0.907, 0.1626, -0.5528, 0.8173, 0.1385, 0.704, 0.6965, 0.1385, -0.704, 0.6965, 0.1626, 0.5528, 0.8173, 0.1092, -0.8286, 0.549, 0.1804, 0.3805, 0.907, 0.0757, -0.9217, 0.3804, 0.1914, 0.1939, 0.9622, 0.0392, -0.9796, 0.1971, 0.1951, 0, 0.9808, 0.0392, 0.9796, 0.1971, 0.1914, -0.1939, 0.9622, 0.0757, 0.9217, 0.3804, 0.3539, 0.3805, 0.8544, 0.3754, 0.1939, 0.9063, 0.0769, -0.9796, 0.1856, 0.3827, 0, 0.9239, 0.0769, 0.9796, 0.1856, 0.3754, -0.1939, 0.9063, 0.1484, 0.9217, 0.3583, 0.3539, -0.3805, 0.8544, 0.2142, 0.8286, 0.5171, 0.3189, -0.5528, 0.7699, 0.2717, 0.704, 0.6561, 0.2717, -0.704, 0.6561, 0.3189, 0.5528, 0.7699, 0.2142, -0.8286, 0.5171, 0.1484, -0.9217, 0.3583, 0.5137, -0.3805, 0.7689, 0.463, -0.5528, 0.6929, 0.3945, 0.704, 0.5904, 0.3945, -0.704, 0.5904, 0.463, 0.5528, 0.6929, 0.311, -0.8286, 0.4654, 0.5137, 0.3805, 0.7689, 0.2155, -0.9217, 0.3225, 0.545, 0.1939, 0.8157, 0.1116, -0.9796, 0.1671, 0.5556, 0, 0.8314, 0.1116, 0.9796, 0.1671, 0.545, -0.1939, 0.8157, 0.2155, 0.9217, 0.3225, 0.311, 0.8286, 0.4654, 0.2743, -0.9217, 0.2743, 0.1421, -0.9796, 0.1421, 0.7071, 0, 0.7071, 0.1421, 0.9796, 0.1421, 0.6937, -0.1939, 0.6937, 0.2743, 0.9217, 0.2743, 0.6539, -0.3805, 0.6539, 0.3958, 0.8286, 0.3958, 0.5893, -0.5528, 0.5893, 0.5021, 0.704, 0.5021, 0.5021, -0.704, 0.5021, 0.5893, 0.5528, 0.5893, 0.3958, -0.8286, 0.3958, 0.6539, 0.3805, 0.6539, 0.6937, 0.1939, 0.6937, 0.4654, 0.8286, 0.311, 0.5904, 0.704, 0.3945, 0.5904, -0.704, 0.3945, 0.6929, 0.5528, 0.463, 0.4654, -0.8286, 0.311, 0.7689, 0.3805, 0.5137, 0.3225, -0.9217, 0.2155, 0.8157, 0.1939, 0.545, 0.1671, -0.9796, 0.1116, 0.8314, 0, 0.5556, 0.1671, 0.9796, 0.1116, 0.8157, -0.1939, 0.545, 0.3225, 0.9217, 0.2155, 0.7689, -0.3805, 0.5137, 0.6929, -0.5528, 0.463, 0.9239, 0, 0.3827, 0.1856, 0.9796, 0.0769, 0.1856, -0.9796, 0.0769, 0.9063, -0.1939, 0.3754, 0.3583, 0.9217, 0.1484, 0.8544, -0.3805, 0.3539, 0.5171, 0.8286, 0.2142, 0.7699, -0.5528, 0.3189, 0.6561, 0.704, 0.2717, 0.6561, -0.704, 0.2717, 0.7699, 0.5528, 0.3189, 0.5171, -0.8286, 0.2142, 0.8544, 0.3805, 0.3539, 0.3583, -0.9217, 0.1484, 0.9063, 0.1939, 0.3754, 0.6965, -0.704, 0.1385, 0.8173, 0.5528, 0.1626, 0.549, -0.8286, 0.1092, 0.907, 0.3805, 0.1804, 0.3804, -0.9217, 0.0757, 0.9622, 0.1939, 0.1914, 0.1971, -0.9796, 0.0392, 0.9808, 0, 0.1951, 0.1971, 0.9796, 0.0392, 0.9622, -0.1939, 0.1914, 0.3804, 0.9217, 0.0757, 0.907, -0.3805, 0.1804, 0.549, 0.8286, 0.1092, 0.8173, -0.5528, 0.1626, 0.6965, 0.704, 0.1385, 0.201, -0.9796, 0, 0.981, -0.1939, 0, 0.3879, 0.9217, 0, 0.9247, -0.3805, 0, 0.5598, 0.8286, 0, 0.8333, -0.5528, 0, 0.7101, 0.704, 0, 0.7101, -0.704, 0, 0.8333, 0.5528, 0, 0.5598, -0.8286, 0, 0.9247, 0.3805, 0, 0.3879, -0.9217, 0, 0.981, 0.1939, 0, 1, 0, 0, 0.201, 0.9796, 0, 0.549, -0.8286, -0.1092, 0.907, 0.3805, -0.1804, 0.3804, -0.9217, -0.0757, 0.9622, 0.1939, -0.1914, 0.1971, -0.9796, -0.0392, 0.9808, 0, -0.1951, 0.1971, 0.9796, -0.0392, 0.9622, -0.1939, -0.1914, 0.3804, 0.9217, -0.0757, 0.907, -0.3805, -0.1804, 0.549, 0.8286, -0.1092, 0.8173, -0.5528, -0.1626, 0.6965, 0.704, -0.1385, 0.6965, -0.704, -0.1385, 0.8173, 0.5528, -0.1626, 0.3583, 0.9217, -0.1484, 0.8544, -0.3805, -0.3539, 0.5171, 0.8286, -0.2142, 0.7699, -0.5528, -0.3189, 0.6561, 0.704, -0.2717, 0.6561, -0.704, -0.2717, 0.7699, 0.5528, -0.3189, 0.5171, -0.8286, -0.2142, 0.8544, 0.3805, -0.3539, 0.3583, -0.9217, -0.1484, 0.9063, 0.1939, -0.3754, 0.1856, -0.9796, -0.0769, 0.9239, 0, -0.3827, 0.1856, 0.9796, -0.0769, 0.9063, -0.1939, -0.3754, 0.7689, 0.3805, -0.5137, 0.3225, -0.9217, -0.2155, 0.8157, 0.1939, -0.545, 0.1671, -0.9796, -0.1116, 0.8314, 0, -0.5556, 0.1671, 0.9796, -0.1116, 0.8157, -0.1939, -0.545, 0.3225, 0.9217, -0.2155, 0.7689, -0.3805, -0.5137, 0.4654, 0.8286, -0.311, 0.6929, -0.5528, -0.463, 0.5904, 0.704, -0.3945, 0.5904, -0.704, -0.3945, 0.6929, 0.5528, -0.463, 0.4654, -0.8286, -0.311, 0.6539, -0.3805, -0.6539, 0.3958, 0.8286, -0.3958, 0.5893, -0.5528, -0.5893, 0.5021, 0.704, -0.5021, 0.5021, -0.704, -0.5021, 0.5893, 0.5528, -0.5893, 0.3958, -0.8286, -0.3958, 0.6539, 0.3805, -0.6539, 0.2743, -0.9217, -0.2743, 0.6937, 0.1939, -0.6937, 0.1421, -0.9796, -0.1421, 0.7071, 0, -0.7071, 0.1421, 0.9796, -0.1421, 0.6937, -0.1939, -0.6937, 0.2743, 0.9217, -0.2743, 0.311, -0.8286, -0.4654, 0.2155, -0.9217, -0.3225, 0.5137, 0.3805, -0.7689, 0.545, 0.1939, -0.8157, 0.1116, -0.9796, -0.1671, 0.5556, 0, -0.8314, 0.1116, 0.9796, -0.1671, 0.545, -0.1939, -0.8157, 0.2155, 0.9217, -0.3225, 0.5137, -0.3805, -0.7689, 0.311, 0.8286, -0.4654, 0.463, -0.5528, -0.6929, 0.3945, 0.704, -0.5904, 0.3945, -0.704, -0.5904, 0.463, 0.5528, -0.6929, 0.2142, 0.8286, -0.5171, 0.3539, -0.3805, -0.8544, 0.3189, -0.5528, -0.7699, 0.2717, 0.704, -0.6561, 0.2717, -0.704, -0.6561, 0.3189, 0.5528, -0.7699, 0.2142, -0.8286, -0.5171, 0.3539, 0.3805, -0.8544, 0.1484, -0.9217, -0.3583, 0.3754, 0.1939, -0.9063, 0.0769, -0.9796, -0.1856, 0.3827, 0, -0.9239, 0.0769, 0.9796, -0.1856, 0.3754, -0.1939, -0.9063, 0.1484, 0.9217, -0.3583, 0.1804, 0.3805, -0.907, 0.1914, 0.1939, -0.9622, 0.0392, -0.9796, -0.1971, 0.1951, 0, -0.9808, 0.0392, 0.9796, -0.1971, 0.1914, -0.1939, -0.9622, 0.0757, 0.9217, -0.3804, 0.1804, -0.3805, -0.907, 0.1092, 0.8286, -0.549, 0.1626, -0.5528, -0.8173, 0.1385, 0.704, -0.6965, 0.1385, -0.704, -0.6965, 0.1626, 0.5528, -0.8173, 0.1092, -0.8286, -0.549, 0.0757, -0.9217, -0.3804, 0, -0.3805, -0.9247, 0, -0.5528, -0.8333, 0, 0.8286, -0.5598, 0, 0.704, -0.7101, 0, -0.704, -0.7101, 0, 0.5528, -0.8333, 0, -0.8286, -0.5598, 0, 0.3805, -0.9247, 0, -0.9217, -0.3879, 0, 0.1939, -0.981, 0, -0.9796, -0.201, 0, 0, -1, 0, 0.9796, -0.201, 0, -0.1939, -0.981, 0, 0.9217, -0.3879, -0.0392, -0.9796, -0.1971, -0.1951, 0, -0.9808, -0.0392, 0.9796, -0.1971, -0.1914, -0.1939, -0.9622, -0.0757, 0.9217, -0.3804, -0.1804, -0.3805, -0.907, -0.1092, 0.8286, -0.549, -0.1626, -0.5528, -0.8173, -0.1385, 0.704, -0.6965, -0.1385, -0.704, -0.6965, -0.1626, 0.5528, -0.8173, -0.1092, -0.8286, -0.549, -0.1804, 0.3805, -0.907, -0.0757, -0.9217, -0.3804, -0.1914, 0.1939, -0.9622, -0.2717, -0.704, -0.6561, -0.3189, 0.5528, -0.7699, -0.2142, -0.8286, -0.5171, -0.3539, 0.3805, -0.8544, -0.1484, -0.9217, -0.3583, -0.3754, 0.1939, -0.9063, -0.0769, -0.9796, -0.1856, -0.3827, 0, -0.9239, -0.0769, 0.9796, -0.1856, -0.3754, -0.1939, -0.9063, -0.1484, 0.9217, -0.3583, -0.3539, -0.3805, -0.8544, -0.2142, 0.8286, -0.5171, -0.3189, -0.5528, -0.7699, -0.2717, 0.704, -0.6561, -0.1116, 0.9796, -0.1671, -0.1116, -0.9796, -0.1671, -0.5556, 0, -0.8314, -0.545, -0.1939, -0.8157, -0.2155, 0.9217, -0.3225, -0.5137, -0.3805, -0.7689, -0.311, 0.8286, -0.4654, -0.463, -0.5528, -0.6929, -0.3945, 0.704, -0.5904, -0.3945, -0.704, -0.5904, -0.463, 0.5528, -0.6929, -0.311, -0.8286, -0.4654, -0.5137, 0.3805, -0.7689, -0.2155, -0.9217, -0.3225, -0.545, 0.1939, -0.8157, -0.5021, 0.704, -0.5021, -0.5893, 0.5528, -0.5893, -0.3958, -0.8286, -0.3958, -0.6539, 0.3805, -0.6539, -0.2743, -0.9217, -0.2743, -0.6937, 0.1939, -0.6937, -0.1421, -0.9796, -0.1421, -0.7071, 0, -0.7071, -0.1421, 0.9796, -0.1421, -0.6937, -0.1939, -0.6937, -0.2743, 0.9217, -0.2743, -0.6539, -0.3805, -0.6539, -0.3958, 0.8286, -0.3958, -0.5893, -0.5528, -0.5893, -0.5021, -0.704, -0.5021, -0.8157, -0.1939, -0.545, -0.3225, 0.9217, -0.2155, -0.7689, -0.3805, -0.5137, -0.4654, 0.8286, -0.311, -0.6929, -0.5528, -0.463, -0.5904, 0.704, -0.3945, -0.5904, -0.704, -0.3945, -0.6929, 0.5528, -0.463, -0.4654, -0.8286, -0.311, -0.7689, 0.3805, -0.5137, -0.3225, -0.9217, -0.2155, -0.8157, 0.1939, -0.545, -0.1671, -0.9796, -0.1116, -0.8314, 0, -0.5556, -0.1671, 0.9796, -0.1116, -0.5171, -0.8286, -0.2142, -0.8544, 0.3805, -0.3539, -0.3583, -0.9217, -0.1484, -0.9063, 0.1939, -0.3754, -0.1856, -0.9796, -0.0769, -0.9239, 0, -0.3827, -0.1856, 0.9796, -0.0769, -0.9063, -0.1939, -0.3754, -0.3583, 0.9217, -0.1484, -0.8544, -0.3805, -0.3539, -0.5171, 0.8286, -0.2142, -0.7699, -0.5528, -0.3189, -0.6561, 0.704, -0.2717, -0.6561, -0.704, -0.2717, -0.7699, 0.5528, -0.3189, -0.3804, 0.9217, -0.0757, -0.907, -0.3805, -0.1804, -0.549, 0.8286, -0.1092, -0.8173, -0.5528, -0.1626, -0.6965, 0.704, -0.1385, -0.6965, -0.704, -0.1385, -0.8173, 0.5528, -0.1626, -0.549, -0.8286, -0.1092, -0.907, 0.3805, -0.1804, -0.3804, -0.9217, -0.0757, -0.9622, 0.1939, -0.1914, -0.1971, -0.9796, -0.0392, -0.9808, 0, -0.1951, -0.1971, 0.9796, -0.0392, -0.9622, -0.1939, -0.1914
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 2880)
+        ];
+        if (scale !== undefined) {
+            const sx = scale.x;
+            const sy = scale.y;
+            const sz = scale.z;
+            if (sx !== 1 || sy !== 1 || sz !== 1) {
+                for (let i = 0; i < this.vertices.length; i += 3) {
+                    this.vertices[i] *= sx;
+                    this.vertices[i + 1] *= sy;
+                    this.vertices[i + 2] *= sz;
+                }
+                if (sx !== sy || sy !== sz)
+                    for (let i = 0; i < this.normals.length; i += 3) {
+                        const nx = this.normals[i] / sx;
+                        const ny = this.normals[i + 1] / sy;
+                        const nz = this.normals[i + 2] / sz;
+                        const len = Math.hypot(nx, ny, nz) || 1.0;
+                        this.normals[i] = nx / len;
+                        this.normals[i + 1] = ny / len;
+                        this.normals[i + 2] = nz / len;
+                    }
+            }
+        }
+    }
+}
+
+class Hemisphere extends BasicMesh {
+    constructor() {
+        super();
+        this.vertices = [-0.5556, -0.8315, 0, -0.3753, -0.9239, 0.0747, -0.3827, -0.9239, 0, -0.9239, 0.3827, 0, -0.9619, 0.1951, 0.1913, -0.9808, 0.1951, 0, -0.1913, -0.9808, 0.0381, -0.1951, -0.9808, 0, -0.9808, 0, 0.1951, -1, 0, 0, -0.1951, 0.9808, 0, 0, 1, 0, -0.1913, 0.9808, 0.0381, 0, -1, 0, -0.9619, -0.1951, 0.1913, -0.9808, -0.1951, 0, -0.3753, 0.9239, 0.0747, -0.3827, 0.9239, 0, -0.9239, -0.3827, 0, -0.9061, -0.3827, 0.1802, -0.5556, 0.8315, 0, -0.5449, 0.8315, 0.1084, -0.8155, -0.5556, 0.1622, -0.8315, -0.5556, 0, -0.6935, 0.7071, 0.1379, -0.7071, 0.7071, 0, -0.7071, -0.7071, 0, -0.6935, -0.7071, 0.1379, -0.8155, 0.5556, 0.1622, -0.8315, 0.5556, 0, -0.5449, -0.8315, 0.1084, -0.9061, 0.3827, 0.1802, -0.5133, -0.8315, 0.2126, -0.8536, 0.3827, 0.3536, -0.3536, -0.9239, 0.1464, -0.9061, 0.1951, 0.3753, -0.1802, -0.9808, 0.0747, -0.9239, 0, 0.3827, -0.1802, 0.9808, 0.0747, -0.9061, -0.1951, 0.3753, -0.3536, 0.9239, 0.1464, -0.8536, -0.3827, 0.3536, -0.5133, 0.8315, 0.2126, -0.7682, -0.5556, 0.3182, -0.6533, 0.7071, 0.2706, -0.6533, -0.7071, 0.2706, -0.7682, 0.5556, 0.3182, -0.3182, 0.9239, 0.2126, -0.7682, -0.3827, 0.5133, -0.4619, 0.8315, 0.3087, -0.6913, -0.5556, 0.4619, -0.5879, 0.7071, 0.3928, -0.5879, -0.7071, 0.3928, -0.6913, 0.5556, 0.4619, -0.4619, -0.8315, 0.3087, -0.7682, 0.3827, 0.5133, -0.3182, -0.9239, 0.2126, -0.8155, 0.1951, 0.5449, -0.1622, -0.9808, 0.1084, -0.8315, 0, 0.5556, -0.1622, 0.9808, 0.1084, -0.8155, -0.1951, 0.5449, -0.6533, 0.3827, 0.6533, -0.2706, -0.9239, 0.2706, -0.6935, 0.1951, 0.6935, -0.1379, -0.9808, 0.1379, -0.7071, 0, 0.7071, -0.1379, 0.9808, 0.1379, -0.6935, -0.1951, 0.6935, -0.2706, 0.9239, 0.2706, -0.6533, -0.3827, 0.6533, -0.3928, 0.8315, 0.3928, -0.5879, -0.5556, 0.5879, -0.5, 0.7071, 0.5, -0.5, -0.7071, 0.5, -0.5879, 0.5556, 0.5879, -0.3928, -0.8315, 0.3928, -0.5133, -0.3827, 0.7682, -0.3087, 0.8315, 0.4619, -0.4619, -0.5556, 0.6913, -0.3928, 0.7071, 0.5879, -0.3928, -0.7071, 0.5879, -0.4619, 0.5556, 0.6913, -0.3087, -0.8315, 0.4619, -0.5133, 0.3827, 0.7682, -0.2126, -0.9239, 0.3182, -0.5449, 0.1951, 0.8155, -0.1084, -0.9808, 0.1622, -0.5556, 0, 0.8315, -0.1084, 0.9808, 0.1622, -0.5449, -0.1951, 0.8155, -0.2126, 0.9239, 0.3182, -0.2126, -0.8315, 0.5133, -0.1464, -0.9239, 0.3536, -0.3536, 0.3827, 0.8536, -0.3753, 0.1951, 0.9061, -0.0747, -0.9808, 0.1802, -0.3827, 0, 0.9239, -0.0747, 0.9808, 0.1802, -0.3753, -0.1951, 0.9061, -0.1464, 0.9239, 0.3536, -0.3536, -0.3827, 0.8536, -0.2126, 0.8315, 0.5133, -0.3182, -0.5556, 0.7682, -0.2706, 0.7071, 0.6533, -0.2706, -0.7071, 0.6533, -0.3182, 0.5556, 0.7682, -0.1802, -0.3827, 0.9061, -0.1622, -0.5556, 0.8155, -0.1084, 0.8315, 0.5449, -0.1379, 0.7071, 0.6935, -0.1379, -0.7071, 0.6935, -0.1622, 0.5556, 0.8155, -0.1084, -0.8315, 0.5449, -0.1802, 0.3827, 0.9061, -0.0747, -0.9239, 0.3753, -0.1913, 0.1951, 0.9619, -0.0381, -0.9808, 0.1913, -0.1951, 0, 0.9808, -0.0381, 0.9808, 0.1913, -0.1913, -0.1951, 0.9619, -0.0747, 0.9239, 0.3753, 0, -0.9239, 0.3827, 0, -0.9808, 0.1951, 0, 0, 1, 0, 0.9808, 0.1951, 0, -0.1951, 0.9808, 0, 0.9239, 0.3827, 0, -0.3827, 0.9239, 0, 0.8315, 0.5556, 0, -0.5556, 0.8315, 0, 0.7071, 0.7071, 0, -0.7071, 0.7071, 0, 0.5556, 0.8315, 0, -0.8315, 0.5556, 0, 0.3827, 0.9239, 0, 0.1951, 0.9808, 0.138, 0.7071, 0.6935, 0.138, -0.7071, 0.6935, 0.1622, 0.5556, 0.8155, 0.1084, -0.8315, 0.5449, 0.1802, 0.3827, 0.9061, 0.0747, -0.9239, 0.3753, 0.1913, 0.1951, 0.9619, 0.0381, -0.9808, 0.1913, 0.1951, 0, 0.9808, 0.0381, 0.9808, 0.1913, 0.1913, -0.1951, 0.9619, 0.0747, 0.9239, 0.3753, 0.1802, -0.3827, 0.9061, 0.1084, 0.8315, 0.5449, 0.1622, -0.5556, 0.8155, 0.3827, 0, 0.9239, 0.0747, 0.9808, 0.1802, 0.0747, -0.9808, 0.1802, 0.3753, -0.1951, 0.9061, 0.1464, 0.9239, 0.3536, 0.3536, -0.3827, 0.8536, 0.2126, 0.8315, 0.5133, 0.3182, -0.5556, 0.7682, 0.2706, 0.7071, 0.6533, 0.2706, -0.7071, 0.6533, 0.3182, 0.5556, 0.7682, 0.2126, -0.8315, 0.5133, 0.3536, 0.3827, 0.8536, 0.1464, -0.9239, 0.3536, 0.3753, 0.1951, 0.9061, 0.3928, -0.7071, 0.5879, 0.3928, 0.7071, 0.5879, 0.4619, 0.5556, 0.6913, 0.3087, -0.8315, 0.4619, 0.5133, 0.3827, 0.7682, 0.2126, -0.9239, 0.3182, 0.5449, 0.1951, 0.8155, 0.1084, -0.9808, 0.1622, 0.5556, 0, 0.8315, 0.1084, 0.9808, 0.1622, 0.5449, -0.1951, 0.8155, 0.2126, 0.9239, 0.3182, 0.5133, -0.3827, 0.7682, 0.3087, 0.8315, 0.4619, 0.4619, -0.5556, 0.6913, 0.138, 0.9808, 0.1379, 0.138, -0.9808, 0.1379, 0.6935, -0.1951, 0.6935, 0.2706, 0.9239, 0.2706, 0.6533, -0.3827, 0.6533, 0.3928, 0.8315, 0.3928, 0.5879, -0.5556, 0.5879, 0.5, 0.7071, 0.5, 0.5, -0.7071, 0.5, 0.5879, 0.5556, 0.5879, 0.3928, -0.8315, 0.3928, 0.6533, 0.3827, 0.6533, 0.2706, -0.9239, 0.2706, 0.6935, 0.1951, 0.6935, 0.7071, 0, 0.7071, 0.5879, 0.7071, 0.3928, 0.6913, 0.5556, 0.4619, 0.5879, -0.7071, 0.3928, 0.4619, -0.8315, 0.3087, 0.7682, 0.3827, 0.5133, 0.3182, -0.9239, 0.2126, 0.8155, 0.1951, 0.5449, 0.1622, -0.9808, 0.1084, 0.8315, 0, 0.5556, 0.1622, 0.9808, 0.1084, 0.8155, -0.1951, 0.5449, 0.3182, 0.9239, 0.2126, 0.7682, -0.3827, 0.5133, 0.4619, 0.8315, 0.3087, 0.6913, -0.5556, 0.4619, 0.9061, -0.1951, 0.3753, 0.3536, 0.9239, 0.1464, 0.8536, -0.3827, 0.3536, 0.5133, 0.8315, 0.2126, 0.7682, -0.5556, 0.3182, 0.6533, 0.7071, 0.2706, 0.6533, -0.7071, 0.2706, 0.7682, 0.5556, 0.3182, 0.5133, -0.8315, 0.2126, 0.8536, 0.3827, 0.3536, 0.3536, -0.9239, 0.1464, 0.9061, 0.1951, 0.3753, 0.1802, -0.9808, 0.0747, 0.9239, 0, 0.3827, 0.1802, 0.9808, 0.0747, 0.5449, -0.8315, 0.1084, 0.9061, 0.3827, 0.1802, 0.3753, -0.9239, 0.0747, 0.9619, 0.1951, 0.1913, 0.1913, -0.9808, 0.0381, 0.9808, 0, 0.1951, 0.1913, 0.9808, 0.0381, 0.9619, -0.1951, 0.1913, 0.3753, 0.9239, 0.0747, 0.9061, -0.3827, 0.1802, 0.5449, 0.8315, 0.1084, 0.8155, -0.5556, 0.1622, 0.6935, 0.7071, 0.1379, 0.6935, -0.7071, 0.1379, 0.8155, 0.5556, 0.1622, 0.9239, -0.3827, 0, 0.3827, 0.9239, 0, 0.5556, 0.8315, 0, 0.8315, -0.5556, 0, 0.7071, 0.7071, 0, 0.7071, -0.7071, 0, 0.8315, 0.5556, 0, 0.5556, -0.8315, 0, 0.9239, 0.3827, 0, 0.3827, -0.9239, 0, 0.9808, 0.1951, 0, 0.1951, -0.9808, 0, 1, 0, 0, 0.1951, 0.9808, 0, 0.9808, -0.1951, 0
+        ];
+        this.indices = [0, 1, 2, 3, 4, 5, 2, 6, 7, 5, 8, 9, 10, 11, 12, 13, 7, 6, 9, 14, 15, 10, 16, 17, 18, 14, 19, 20, 16, 21, 18, 22, 23, 20, 24, 25, 26, 22, 27, 25, 28, 29, 26, 30, 0, 29, 31, 3, 27, 32, 30, 28, 33, 31, 30, 34, 1, 31, 35, 4, 1, 36, 6, 4, 37, 8, 12, 11, 38, 13, 6, 36, 14, 37, 39, 12, 40, 16, 19, 39, 41, 16, 42, 21, 19, 43, 22, 21, 44, 24, 27, 43, 45, 24, 46, 28, 38, 47, 40, 39, 48, 41, 40, 49, 42, 43, 48, 50, 42, 51, 44, 45, 50, 52, 44, 53, 46, 45, 54, 32, 46, 55, 33, 32, 56, 34, 35, 55, 57, 34, 58, 36, 35, 59, 37, 38, 11, 60, 13, 36, 58, 37, 61, 39, 53, 62, 55, 54, 63, 56, 55, 64, 57, 56, 65, 58, 59, 64, 66, 60, 11, 67, 13, 58, 65, 59, 68, 61, 60, 69, 47, 61, 70, 48, 47, 71, 49, 50, 70, 72, 49, 73, 51, 50, 74, 52, 51, 75, 53, 52, 76, 54, 68, 77, 70, 69, 78, 71, 72, 77, 79, 71, 80, 73, 72, 81, 74, 75, 80, 82, 76, 81, 83, 75, 84, 62, 63, 83, 85, 62, 86, 64, 63, 87, 65, 66, 86, 88, 67, 11, 89, 13, 65, 87, 66, 90, 68, 67, 91, 69, 85, 92, 93, 86, 94, 95, 85, 96, 87, 86, 97, 88, 89, 11, 98, 13, 87, 96, 88, 99, 90, 89, 100, 91, 90, 101, 77, 91, 102, 78, 79, 101, 103, 78, 104, 80, 81, 103, 105, 82, 104, 106, 81, 92, 83, 82, 94, 84, 103, 107, 108, 104, 109, 110, 105, 108, 111, 104, 112, 106, 105, 113, 92, 106, 114, 94, 92, 115, 93, 95, 114, 116, 96, 115, 117, 95, 118, 97, 98, 11, 119, 13, 96, 117, 97, 120, 99, 98, 121, 100, 99, 107, 101, 100, 109, 102, 117, 122, 123, 116, 124, 118, 119, 11, 125, 13, 117, 123, 120, 124, 126, 119, 127, 121, 120, 128, 107, 121, 129, 109, 108, 128, 130, 109, 131, 110, 108, 132, 111, 110, 133, 112, 113, 132, 134, 112, 135, 114, 115, 134, 122, 116, 135, 136, 129, 137, 131, 130, 138, 132, 133, 137, 139, 134, 138, 140, 133, 141, 135, 134, 142, 122, 136, 141, 143, 123, 142, 144, 136, 145, 124, 125, 11, 146, 13, 123, 144, 124, 147, 126, 127, 146, 148, 126, 149, 128, 127, 150, 129, 130, 149, 151, 143, 152, 145, 146, 11, 153, 13, 144, 154, 145, 155, 147, 146, 156, 148, 147, 157, 149, 150, 156, 158, 151, 157, 159, 150, 160, 137, 151, 161, 138, 137, 162, 139, 138, 163, 140, 139, 164, 141, 142, 163, 165, 143, 164, 166, 142, 154, 144, 159, 167, 161, 162, 168, 169, 163, 167, 170, 162, 171, 164, 163, 172, 165, 166, 171, 173, 165, 174, 154, 166, 175, 152, 153, 11, 176, 13, 154, 174, 155, 175, 177, 153, 178, 156, 155, 179, 157, 156, 180, 158, 159, 179, 181, 158, 168, 160, 176, 11, 182, 13, 174, 183, 175, 184, 177, 176, 185, 178, 177, 186, 179, 178, 187, 180, 179, 188, 181, 180, 189, 168, 181, 190, 167, 168, 191, 169, 170, 190, 192, 169, 193, 171, 170, 194, 172, 173, 193, 195, 174, 194, 183, 173, 196, 175, 191, 197, 198, 192, 199, 200, 191, 201, 193, 192, 202, 194, 195, 201, 203, 183, 202, 204, 195, 205, 196, 182, 11, 206, 13, 183, 204, 184, 205, 207, 182, 208, 185, 184, 209, 186, 185, 210, 187, 188, 209, 211, 189, 210, 197, 188, 199, 190, 205, 212, 207, 206, 213, 208, 207, 214, 209, 210, 213, 215, 211, 214, 216, 210, 217, 197, 211, 218, 199, 197, 219, 198, 200, 218, 220, 198, 221, 201, 200, 222, 202, 203, 221, 223, 202, 224, 204, 203, 225, 205, 206, 11, 226, 13, 204, 224, 218, 227, 220, 219, 228, 221, 220, 229, 222, 223, 228, 230, 224, 229, 231, 223, 232, 225, 226, 11, 233, 13, 224, 231, 225, 234, 212, 226, 235, 213, 212, 236, 214, 213, 237, 215, 216, 236, 238, 215, 239, 217, 216, 240, 218, 217, 241, 219, 234, 242, 236, 237, 243, 244, 238, 242, 245, 239, 244, 246, 238, 247, 240, 239, 248, 241, 227, 247, 249, 241, 250, 228, 227, 251, 229, 230, 250, 252, 231, 251, 253, 230, 254, 232, 233, 11, 255, 13, 231, 253, 232, 256, 234, 233, 243, 235, 0, 30, 1, 3, 31, 4, 2, 1, 6, 5, 4, 8, 9, 8, 14, 10, 12, 16, 18, 15, 14, 20, 17, 16, 18, 19, 22, 20, 21, 24, 26, 23, 22, 25, 24, 28, 26, 27, 30, 29, 28, 31, 27, 45, 32, 28, 46, 33, 30, 32, 34, 31, 33, 35, 1, 34, 36, 4, 35, 37, 14, 8, 37, 12, 38, 40, 19, 14, 39, 16, 40, 42, 19, 41, 43, 21, 42, 44, 27, 22, 43, 24, 44, 46, 38, 60, 47, 39, 61, 48, 40, 47, 49, 43, 41, 48, 42, 49, 51, 45, 43, 50, 44, 51, 53, 45, 52, 54, 46, 53, 55, 32, 54, 56, 35, 33, 55, 34, 56, 58, 35, 57, 59, 37, 59, 61, 53, 75, 62, 54, 76, 63, 55, 62, 64, 56, 63, 65, 59, 57, 64, 59, 66, 68, 60, 67, 69, 61, 68, 70, 47, 69, 71, 50, 48, 70, 49, 71, 73, 50, 72, 74, 51, 73, 75, 52, 74, 76, 68, 90, 77, 69, 91, 78, 72, 70, 77, 71, 78, 80, 72, 79, 81, 75, 73, 80, 76, 74, 81, 75, 82, 84, 63, 76, 83, 62, 84, 86, 63, 85, 87, 66, 64, 86, 66, 88, 90, 67, 89, 91, 85, 83, 92, 86, 84, 94, 85, 93, 96, 86, 95, 97, 88, 97, 99, 89, 98, 100, 90, 99, 101, 91, 100, 102, 79, 77, 101, 78, 102, 104, 81, 79, 103, 82, 80, 104, 81, 105, 92, 82, 106, 94, 103, 101, 107, 104, 102, 109, 105, 103, 108, 104, 110, 112, 105, 111, 113, 106, 112, 114, 92, 113, 115, 95, 94, 114, 96, 93, 115, 95, 116, 118, 97, 118, 120, 98, 119, 121, 99, 120, 107, 100, 121, 109, 117, 115, 122, 116, 136, 124, 120, 118, 124, 119, 125, 127, 120, 126, 128, 121, 127, 129, 108, 107, 128, 109, 129, 131, 108, 130, 132, 110, 131, 133, 113, 111, 132, 112, 133, 135, 115, 113, 134, 116, 114, 135, 129, 150, 137, 130, 151, 138, 133, 131, 137, 134, 132, 138, 133, 139, 141, 134, 140, 142, 136, 135, 141, 123, 122, 142, 136, 143, 145, 124, 145, 147, 127, 125, 146, 126, 147, 149, 127, 148, 150, 130, 128, 149, 143, 166, 152, 145, 152, 155, 146, 153, 156, 147, 155, 157, 150, 148, 156, 151, 149, 157, 150, 158, 160, 151, 159, 161, 137, 160, 162, 138, 161, 163, 139, 162, 164, 142, 140, 163, 143, 141, 164, 142, 165, 154, 159, 181, 167, 162, 160, 168, 163, 161, 167, 162, 169, 171, 163, 170, 172, 166, 164, 171, 165, 172, 174, 166, 173, 175, 155, 152, 175, 153, 176, 178, 155, 177, 179, 156, 178, 180, 159, 157, 179, 158, 180, 168, 175, 196, 184, 176, 182, 185, 177, 184, 186, 178, 185, 187, 179, 186, 188, 180, 187, 189, 181, 188, 190, 168, 189, 191, 170, 167, 190, 169, 191, 193, 170, 192, 194, 173, 171, 193, 174, 172, 194, 173, 195, 196, 191, 189, 197, 192, 190, 199, 191, 198, 201, 192, 200, 202, 195, 193, 201, 183, 194, 202, 195, 203, 205, 184, 196, 205, 182, 206, 208, 184, 207, 209, 185, 208, 210, 188, 186, 209, 189, 187, 210, 188, 211, 199, 205, 225, 212, 206, 226, 213, 207, 212, 214, 210, 208, 213, 211, 209, 214, 210, 215, 217, 211, 216, 218, 197, 217, 219, 200, 199, 218, 198, 219, 221, 200, 220, 222, 203, 201, 221, 202, 222, 224, 203, 223, 225, 218, 240, 227, 219, 241, 228, 220, 227, 229, 223, 221, 228, 224, 222, 229, 223, 230, 232, 225, 232, 234, 226, 233, 235, 212, 234, 236, 213, 235, 237, 216, 214, 236, 215, 237, 239, 216, 238, 240, 217, 239, 241, 234, 256, 242, 237, 235, 243, 238, 236, 242, 239, 237, 244, 238, 245, 247, 239, 246, 248, 227, 240, 247, 241, 248, 250, 227, 249, 251, 230, 228, 250, 231, 229, 251, 230, 252, 254, 232, 254, 256, 233, 255, 243
+        ];
+        this.normals = [-0.5589, -0.8274, 0.055, -0.3804, -0.9217, 0.0757, -0.3876, -0.921, 0.0381, -0.9209, 0.3789, 0.0907, -0.9622, 0.1939, 0.1914, -0.9764, 0.193, 0.0962, -0.1971, -0.9796, 0.0392, -0.2009, -0.9794, 0.0198, -0.9808, 0, 0.1951, -0.9952, 0, 0.098, -0.2009, 0.9794, 0.0198, 0, 0.998, 0.063, -0.1971, 0.9796, 0.0392, 0, -0.998, 0.063, -0.9622, -0.1939, 0.1914, -0.9764, -0.193, 0.0962, -0.3804, 0.9217, 0.0757, -0.3876, 0.921, 0.0381, -0.9209, -0.3789, 0.0907, -0.907, -0.3805, 0.1804, -0.5589, 0.8274, 0.055, -0.549, 0.8286, 0.1092, -0.8173, -0.5528, 0.1626, -0.8305, -0.5509, 0.0818, -0.6965, 0.704, 0.1385, -0.7084, 0.7023, 0.0698, -0.7084, -0.7023, 0.0698, -0.6965, -0.704, 0.1385, -0.8173, 0.5528, 0.1626, -0.8305, 0.5509, 0.0818, -0.549, -0.8286, 0.1092, -0.907, 0.3805, 0.1804, -0.5171, -0.8286, 0.2142, -0.8544, 0.3805, 0.3539, -0.3583, -0.9217, 0.1484, -0.9063, 0.1939, 0.3754, -0.1856, -0.9796, 0.0769, -0.9239, 0, 0.3827, -0.1856, 0.9796, 0.0769, -0.9063, -0.1939, 0.3754, -0.3583, 0.9217, 0.1484, -0.8544, -0.3805, 0.3539, -0.5171, 0.8286, 0.2142, -0.7699, -0.5528, 0.3189, -0.6561, 0.704, 0.2717, -0.6561, -0.704, 0.2717, -0.7699, 0.5528, 0.3189, -0.3225, 0.9217, 0.2155, -0.7689, -0.3805, 0.5137, -0.4654, 0.8286, 0.311, -0.6929, -0.5528, 0.463, -0.5904, 0.704, 0.3945, -0.5904, -0.704, 0.3945, -0.6929, 0.5528, 0.463, -0.4654, -0.8286, 0.311, -0.7689, 0.3805, 0.5137, -0.3225, -0.9217, 0.2155, -0.8157, 0.1939, 0.545, -0.1671, -0.9796, 0.1116, -0.8314, 0, 0.5556, -0.1671, 0.9796, 0.1116, -0.8157, -0.1939, 0.545, -0.6539, 0.3805, 0.6539, -0.2743, -0.9217, 0.2743, -0.6937, 0.1939, 0.6937, -0.1421, -0.9796, 0.1421, -0.7071, 0, 0.7071, -0.1421, 0.9796, 0.1421, -0.6937, -0.1939, 0.6937, -0.2743, 0.9217, 0.2743, -0.6539, -0.3805, 0.6539, -0.3958, 0.8286, 0.3958, -0.5893, -0.5528, 0.5893, -0.5021, 0.704, 0.5021, -0.5021, -0.704, 0.5021, -0.5893, 0.5528, 0.5893, -0.3958, -0.8286, 0.3958, -0.5137, -0.3805, 0.7689, -0.311, 0.8286, 0.4654, -0.463, -0.5528, 0.6929, -0.3945, 0.704, 0.5904, -0.3945, -0.704, 0.5904, -0.463, 0.5528, 0.6929, -0.311, -0.8286, 0.4654, -0.5137, 0.3805, 0.7689, -0.2155, -0.9217, 0.3225, -0.545, 0.1939, 0.8157, -0.1116, -0.9796, 0.1671, -0.5556, 0, 0.8314, -0.1116, 0.9796, 0.1671, -0.545, -0.1939, 0.8157, -0.2155, 0.9217, 0.3225, -0.2142, -0.8286, 0.5171, -0.1484, -0.9217, 0.3583, -0.3539, 0.3805, 0.8544, -0.3754, 0.1939, 0.9063, -0.0769, -0.9796, 0.1856, -0.3827, 0, 0.9239, -0.0769, 0.9796, 0.1856, -0.3754, -0.1939, 0.9063, -0.1484, 0.9217, 0.3583, -0.3539, -0.3805, 0.8544, -0.2142, 0.8286, 0.5171, -0.3189, -0.5528, 0.7699, -0.2717, 0.704, 0.6561, -0.2717, -0.704, 0.6561, -0.3189, 0.5528, 0.7699, -0.1804, -0.3805, 0.907, -0.1626, -0.5528, 0.8173, -0.1092, 0.8286, 0.549, -0.1385, 0.704, 0.6965, -0.1385, -0.704, 0.6965, -0.1626, 0.5528, 0.8173, -0.1092, -0.8286, 0.549, -0.1804, 0.3805, 0.907, -0.0757, -0.9217, 0.3804, -0.1914, 0.1939, 0.9622, -0.0392, -0.9796, 0.1971, -0.1951, 0, 0.9808, -0.0392, 0.9796, 0.1971, -0.1914, -0.1939, 0.9622, -0.0757, 0.9217, 0.3804, 0, -0.9217, 0.3879, 0, -0.9796, 0.201, 0, 0, 1, 0, 0.9796, 0.201, 0, -0.1939, 0.981, 0, 0.9217, 0.3879, 0, -0.3805, 0.9247, 0, 0.8286, 0.5598, 0, -0.5528, 0.8333, 0, 0.704, 0.7101, 0, -0.704, 0.7101, 0, 0.5528, 0.8333, 0, -0.8286, 0.5598, 0, 0.3805, 0.9247, 0, 0.1939, 0.981, 0.1385, 0.704, 0.6965, 0.1385, -0.704, 0.6965, 0.1626, 0.5528, 0.8173, 0.1092, -0.8286, 0.549, 0.1804, 0.3805, 0.907, 0.0757, -0.9217, 0.3804, 0.1914, 0.1939, 0.9622, 0.0392, -0.9796, 0.1971, 0.1951, 0, 0.9808, 0.0392, 0.9796, 0.1971, 0.1914, -0.1939, 0.9622, 0.0757, 0.9217, 0.3804, 0.1804, -0.3805, 0.907, 0.1092, 0.8286, 0.549, 0.1626, -0.5528, 0.8173, 0.3827, 0, 0.9239, 0.0769, 0.9796, 0.1856, 0.0769, -0.9796, 0.1856, 0.3754, -0.1939, 0.9063, 0.1484, 0.9217, 0.3583, 0.3539, -0.3805, 0.8544, 0.2142, 0.8286, 0.5171, 0.3189, -0.5528, 0.7699, 0.2717, 0.704, 0.6561, 0.2717, -0.704, 0.6561, 0.3189, 0.5528, 0.7699, 0.2142, -0.8286, 0.5171, 0.3539, 0.3805, 0.8544, 0.1484, -0.9217, 0.3583, 0.3754, 0.1939, 0.9063, 0.3945, -0.704, 0.5904, 0.3945, 0.704, 0.5904, 0.463, 0.5528, 0.6929, 0.311, -0.8286, 0.4654, 0.5137, 0.3805, 0.7689, 0.2155, -0.9217, 0.3225, 0.545, 0.1939, 0.8157, 0.1116, -0.9796, 0.1671, 0.5556, 0, 0.8314, 0.1116, 0.9796, 0.1671, 0.545, -0.1939, 0.8157, 0.2155, 0.9217, 0.3225, 0.5137, -0.3805, 0.7689, 0.311, 0.8286, 0.4654, 0.463, -0.5528, 0.6929, 0.1421, 0.9796, 0.1421, 0.1421, -0.9796, 0.1421, 0.6937, -0.1939, 0.6937, 0.2743, 0.9217, 0.2743, 0.6539, -0.3805, 0.6539, 0.3958, 0.8286, 0.3958, 0.5893, -0.5528, 0.5893, 0.5021, 0.704, 0.5021, 0.5021, -0.704, 0.5021, 0.5893, 0.5528, 0.5893, 0.3958, -0.8286, 0.3958, 0.6539, 0.3805, 0.6539, 0.2743, -0.9217, 0.2743, 0.6937, 0.1939, 0.6937, 0.7071, 0, 0.7071, 0.5904, 0.704, 0.3945, 0.6929, 0.5528, 0.463, 0.5904, -0.704, 0.3945, 0.4654, -0.8286, 0.311, 0.7689, 0.3805, 0.5137, 0.3225, -0.9217, 0.2155, 0.8157, 0.1939, 0.545, 0.1671, -0.9796, 0.1116, 0.8314, 0, 0.5556, 0.1671, 0.9796, 0.1116, 0.8157, -0.1939, 0.545, 0.3225, 0.9217, 0.2155, 0.7689, -0.3805, 0.5137, 0.4654, 0.8286, 0.311, 0.6929, -0.5528, 0.463, 0.9063, -0.1939, 0.3754, 0.3583, 0.9217, 0.1484, 0.8544, -0.3805, 0.3539, 0.5171, 0.8286, 0.2142, 0.7699, -0.5528, 0.3189, 0.6561, 0.704, 0.2717, 0.6561, -0.704, 0.2717, 0.7699, 0.5528, 0.3189, 0.5171, -0.8286, 0.2142, 0.8544, 0.3805, 0.3539, 0.3583, -0.9217, 0.1484, 0.9063, 0.1939, 0.3754, 0.1856, -0.9796, 0.0769, 0.9239, 0, 0.3827, 0.1856, 0.9796, 0.0769, 0.549, -0.8286, 0.1092, 0.907, 0.3805, 0.1804, 0.3804, -0.9217, 0.0757, 0.9622, 0.1939, 0.1914, 0.1971, -0.9796, 0.0392, 0.9808, 0, 0.1951, 0.1971, 0.9796, 0.0392, 0.9622, -0.1939, 0.1914, 0.3804, 0.9217, 0.0757, 0.907, -0.3805, 0.1804, 0.549, 0.8286, 0.1092, 0.8173, -0.5528, 0.1626, 0.6965, 0.704, 0.1385, 0.6965, -0.704, 0.1385, 0.8173, 0.5528, 0.1626, 0.9209, -0.3789, 0.0907, 0.3876, 0.921, 0.0381, 0.5589, 0.8274, 0.055, 0.8305, -0.5509, 0.0818, 0.7084, 0.7023, 0.0698, 0.7084, -0.7023, 0.0698, 0.8305, 0.5509, 0.0818, 0.5589, -0.8274, 0.055, 0.9209, 0.3789, 0.0907, 0.3876, -0.921, 0.0381, 0.9764, 0.193, 0.0962, 0.2009, -0.9794, 0.0198, 0.9952, 0, 0.098, 0.2009, 0.9794, 0.0198, 0.9764, -0.193, 0.0962
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 1440)
+        ];
+    }
+}
+
+class Plane extends BasicMesh {
+    constructor(size = new Vec2(1.0, 1.0), segments = new Vec2(1, 1), orientation = 'xz') {
+        super();
+        const w = size.x || 1.0;
+        const h = size.y || 1.0;
+        const gridX = Utils.clamp(Utils.floor(segments.x || 1, 0), 1, Infinity);
+        const gridY = Utils.clamp(Utils.floor(segments.y || 1, 0), 1, Infinity);
+        const orient = orientation || 'xz';
+        const gridX1 = gridX + 1;
+        const gridY1 = gridY + 1;
+        const segmentWidth = w / gridX;
+        const segmentHeight = h / gridY;
+        const vertices = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        const halfW = w * 0.5;
+        const halfH = h * 0.5;
+        for (let iy = 0; iy < gridY1; iy++) {
+            const y = iy * segmentHeight - halfH;
+            for (let ix = 0; ix < gridX1; ix++) {
+                const x = ix * segmentWidth - halfW;
+                if (orient === 'xz') {
+                    vertices.push(x, 0, y);
+                    normals.push(0, 1, 0);
+                }
+                else {
+                    vertices.push(x, -y, 0);
+                    normals.push(0, 0, 1);
+                }
+                uvs.push(ix / gridX, 1.0 - iy / gridY);
+            }
+        }
+        for (let iy = 0; iy < gridY; iy++)
+            for (let ix = 0; ix < gridX; ix++) {
+                const a = ix + gridX1 * iy;
+                const b = ix + gridX1 * (iy + 1);
+                const c = (ix + 1) + gridX1 * (iy + 1);
+                const d = (ix + 1) + gridX1 * iy;
+                indices.push(a, b, d);
+                indices.push(b, c, d);
+            }
+        this.vertices = vertices;
+        this.normals = normals;
+        this.uvs = uvs;
+        this.indices = indices;
+        this.itemSize = 3;
+        this.primitive = 'TRIANGLES';
+        this.subMeshes = [new SubMesh(0, indices.length)];
+    }
+}
+
+class Cylinder extends BasicMesh {
+    constructor(radii = new Vec2(1.0, 1.0), height = 1.0, radialSegments = 16, heightSegments = 1, openEnded = false) {
+        super();
+        const rTop = radii.x;
+        const rBottom = radii.y;
+        const h = height;
+        const radSeg = Utils.clamp(Utils.floor(radialSegments, 0), 3, Infinity);
+        const hSeg = Utils.clamp(Utils.floor(heightSegments, 0), 1, Infinity);
+        const open = openEnded;
+        const vertices = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        let index = 0;
+        const indexGrid = [];
+        const halfH = h * 0.5;
+        const tanTheta = (rBottom - rTop) / h;
+        for (let y = 0; y <= hSeg; y++) {
+            const indexRow = [];
+            const v = y / hSeg;
+            const radius = v * (rBottom - rTop) + rTop;
+            const py = -v * h + halfH;
+            for (let x = 0; x <= radSeg; x++) {
+                const u = x / radSeg;
+                const theta = u * Trigo.twopi;
+                const sinTheta = Trigo.sine(theta);
+                const cosTheta = Trigo.cosine(theta);
+                const px = radius * sinTheta;
+                const pz = radius * cosTheta;
+                vertices.push(px, py, pz);
+                const nx = sinTheta;
+                const ny = tanTheta;
+                const nz = cosTheta;
+                const nLen = Math.hypot(nx, ny, nz) || 1.0;
+                normals.push(nx / nLen, ny / nLen, nz / nLen);
+                uvs.push(u, 1.0 - v);
+                indexRow.push(index++);
+            }
+            indexGrid.push(indexRow);
+        }
+        for (let x = 0; x < radSeg; x++)
+            for (let y = 0; y < hSeg; y++) {
+                const a = indexGrid[y][x];
+                const b = indexGrid[y + 1][x];
+                const c = indexGrid[y + 1][x + 1];
+                const d = indexGrid[y][x + 1];
+                indices.push(a, b, d);
+                indices.push(b, c, d);
+            }
+        if (!open) {
+            if (rTop > 0) {
+                const centerIndexTop = index++;
+                vertices.push(0, halfH, 0);
+                normals.push(0, 1, 0);
+                uvs.push(0.5, 0.5);
+                const topCapStartIndex = index;
+                for (let x = 0; x <= radSeg; x++) {
+                    const u = x / radSeg;
+                    const theta = u * Trigo.twopi;
+                    const px = rTop * Trigo.sine(theta);
+                    const pz = rTop * Trigo.cosine(theta);
+                    vertices.push(px, halfH, pz);
+                    normals.push(0, 1, 0);
+                    uvs.push(Trigo.sine(theta) * 0.5 + 0.5, Trigo.cosine(theta) * 0.5 + 0.5);
+                    index++;
+                }
+                for (let x = 0; x < radSeg; x++)
+                    indices.push(centerIndexTop, topCapStartIndex + x, topCapStartIndex + x + 1);
+            }
+            if (rBottom > 0) {
+                const centerIndexBottom = index++;
+                vertices.push(0, -halfH, 0);
+                normals.push(0, -1, 0);
+                uvs.push(0.5, 0.5);
+                const bottomCapStartIndex = index;
+                for (let x = 0; x <= radSeg; x++) {
+                    const u = x / radSeg;
+                    const theta = u * Trigo.twopi;
+                    const px = rBottom * Trigo.sine(theta);
+                    const pz = rBottom * Trigo.cosine(theta);
+                    vertices.push(px, -halfH, pz);
+                    normals.push(0, -1, 0);
+                    uvs.push(Trigo.sine(theta) * 0.5 + 0.5, Trigo.cosine(theta) * 0.5 + 0.5);
+                    index++;
+                }
+                for (let x = 0; x < radSeg; x++)
+                    indices.push(centerIndexBottom, bottomCapStartIndex + x + 1, bottomCapStartIndex + x);
+            }
+        }
+        this.vertices = vertices;
+        this.normals = normals;
+        this.uvs = uvs;
+        this.indices = indices;
+        this.itemSize = 3;
+        this.primitive = 'TRIANGLES';
+        this.subMeshes = [new SubMesh(0, indices.length)];
+    }
+}
+
+class VWing extends BasicMesh {
+    constructor() {
+        super();
+        this.vertices = [0, 0, -7.3975, 0, -0.2707, 0, 1.4678, 0, 0, 0, 0.5653, 1.8374, 0, 1.4694, 0, 0, 1.553, -1.0874, 0, 0.7405, -5.3869, 2.3189, 0.251, 0, 1.4678, 0, 0, 1.6633, 2.6, 1.6982, 6.65, -0.8596, 3.1485, 2.3189, 0.251, 0, 1.9333, -0.2938, -1.9828, 1.4678, 0, 0, 2.3189, 0.251, 0, 1.4678, 0, 0, 1.4678, 0, 0, 1.6148, -0.4246, -2.7743, 1.9333, -0.2938, -1.9828, 1.4678, 0, 0, 1.6148, -0.4246, -2.7743, 1.6148, -0.4246, -2.7743, 1.9333, -0.2938, -1.9828, -1.4678, 0, 0, -2.3189, 0.251, 0, -1.6633, 2.6, 1.6982, -1.4678, 0, 0, -6.65, -0.8596, 3.1485, -1.9333, -0.2938, -1.9828, -2.3189, 0.251, 0, -1.4678, 0, 0, -2.3189, 0.251, 0, -1.4678, 0, 0, -1.4678, 0, 0, -1.6148, -0.4246, -2.7743, -1.9333, -0.2938, -1.9828, -1.6148, -0.4246, -2.7743, -1.4678, 0, 0, -1.6148, -0.4246, -2.7743, -1.9333, -0.2938, -1.9828, 0, -0.2707, 0, 0, 0.5653, 1.8374, 1.4678, 0, 0, 0, -0.2707, 0, -1.4678, 0, 0
+        ];
+        this.indices = [0, 1, 2, 2, 3, 4, 5, 2, 4, 6, 0, 2, 5, 6, 2, 7, 8, 9, 10, 11, 12, 10, 12, 13, 14, 10, 15, 16, 12, 17, 7, 9, 18, 9, 19, 20, 21, 22, 9, 0, 23, 1, 23, 4, 3, 5, 4, 23, 6, 23, 0, 5, 23, 6, 24, 25, 26, 27, 28, 29, 27, 30, 28, 31, 32, 27, 33, 34, 28, 24, 35, 25, 25, 36, 37, 38, 25, 39, 40, 41, 42, 43, 44, 41
+        ];
+        this.normals = [0, -0.1063, -0.9943, 0, -0.9819, 0.1891, 0.9233, -0.2975, 0.2427, 0, 0.0714, 0.9974, 0, 0.9697, 0.2443, 0, 0.9961, -0.088, 0, 0.9478, -0.3187, 0.553, 0.7911, 0.2613, -0.7402, -0.526, 0.4187, -0.0528, 0.7418, 0.6686, 0.7771, -0.1425, 0.6131, 0.553, 0.7911, 0.2613, 0.8324, -0.4718, -0.2906, -0.7402, -0.526, 0.4187, 0.553, 0.7911, 0.2613, -0.7402, -0.526, 0.4187, -0.7402, -0.526, 0.4187, -0.1135, -0.2998, -0.9472, 0.8324, -0.4718, -0.2906, -0.7402, -0.526, 0.4187, -0.1135, -0.2998, -0.9472, -0.1135, -0.2998, -0.9472, 0.8324, -0.4718, -0.2906, -0.9233, -0.2975, 0.2427, -0.553, 0.7911, 0.2613, 0.0528, 0.7418, 0.6686, 0.7402, -0.526, 0.4187, -0.7771, -0.1425, 0.6131, -0.8324, -0.4718, -0.2906, -0.553, 0.7911, 0.2613, 0.7402, -0.526, 0.4187, -0.553, 0.7911, 0.2613, 0.7402, -0.526, 0.4187, 0.7402, -0.526, 0.4187, 0.1135, -0.2998, -0.9472, -0.8324, -0.4718, -0.2906, 0.1135, -0.2998, -0.9472, 0.7402, -0.526, 0.4187, 0.1135, -0.2998, -0.9472, -0.8324, -0.4718, -0.2906, 0, -0.9819, 0.1891, 0, 0.0714, 0.9974, 0.9233, -0.2975, 0.2427, 0, -0.9819, 0.1891, -0.9233, -0.2975, 0.2427
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 78),
+            new SubMesh(78, 6)
+        ];
+    }
+}
+
+class Cannon extends BasicMesh {
+    constructor() {
+        super();
+        this.vertices = [0, -0.4, 0.1885, 0.7, 0, -0.9849, 0, -0.4, -0.9849, 0, 0.4, -0.9849, 0.7, 0, 0.4525, 0, 0.4, 0.9293, 0, 0, -0.8408, 0, 0.4, -0.9849, 0, 0, 1.9525, 0, 0.4, 0.9293, 0.7, 0, 0.4525, 0, 0, -0.8408, 0, 0.3, -1.1203, 0.6, 0, -1.1203, 0, 0.11, -2.8486, 0.2351, 0, -3.0108, 0, -0.11, -3.0108, 0, -0.3, -1.1203, 0, 0, -0.8408, 0.7, 0, 0.4525, 0, -0.4, 0.1885, -0.7, 0, -0.9849, -0.7, 0, 0.4525, 0, 0.4, -0.9849, -0.7, 0, 0.4525, 0, 0.4, 0.9293, 0, 0, -0.8408, -0.6, 0, -1.1203, -0.2351, 0, -3.0108, 0, 0, -0.8408, -0.7, 0, 0.4525, 0, -0.4, 0.1885, 0.7, 0, 0.4525, -0.7, 0, 0.4525
+        ];
+        this.indices = [0, 1, 2, 3, 4, 5, 1, 6, 2, 1, 7, 6, 8, 9, 10, 11, 12, 13, 14, 13, 12, 15, 14, 16, 13, 17, 18, 19, 20, 8, 17, 13, 15, 15, 16, 17, 21, 0, 2, 22, 3, 5, 21, 2, 6, 21, 6, 23, 8, 24, 25, 26, 27, 12, 27, 14, 12, 28, 16, 14, 27, 29, 17, 30, 8, 31, 17, 28, 27, 28, 17, 16, 0, 32, 1, 3, 1, 4, 14, 15, 13, 21, 33, 0, 22, 21, 3, 27, 28, 14
+        ];
+        this.normals = [0, -0.9962, 0.0863, 0.7964, 0, -0.6047, 0, -0.7073, -0.7069, 0, 0.7073, -0.7069, 0.9834, -0.0314, 0.1787, 0, 0.973, 0.231, 0, 0, -1, 0, 0.7073, -0.7069, 0, -0.0518, 0.9987, 0, 0.973, 0.231, 0.9834, -0.0314, 0.1787, 0, 0, -1, 0, 0.9499, 0.3124, 0.9369, 0.0022, 0.3496, 0, 0.9436, -0.3311, 0.6731, 0.0686, -0.7363, 0, -0.5683, -0.8228, 0, -0.948, 0.3182, 0, 0, -1, 0.9834, -0.0314, 0.1787, 0, -0.9962, 0.0863, -0.7964, 0, -0.6047, -0.9834, -0.0314, 0.1787, 0, 0.7073, -0.7069, -0.9834, -0.0314, 0.1787, 0, 0.973, 0.231, 0, 0, -1, -0.9369, 0.0022, 0.3496, -0.6731, 0.0686, -0.7363, 0, 0, -1, -0.9834, -0.0314, 0.1787, 0, -0.9962, 0.0863, 0.9834, -0.0314, 0.1787, -0.9834, -0.0314, 0.1787
+        ];
+        this.subMeshes = [
+            new SubMesh(0, 90)
+        ];
+    }
+}
+
+class CustomMesh {
+    vertices;
+    indices;
+    normals;
+    uvs;
+    subMeshes;
+    itemSize;
+    primitive;
+    primitives;
+    constructor() {
+        this.vertices = null;
+        this.indices = null;
+        this.normals = null;
+        this.uvs = null;
+        this.subMeshes = [];
+        this.itemSize = 3;
+        this.primitive = 'TRIANGLES';
+        this.primitives = ['POINTS',
+            'LINE_STRIP',
+            'LINE_LOOP',
+            'LINES',
+            'TRIANGLE_STRIP',
+            'TRIANGLE_FAN',
+            'TRIANGLES'
+        ];
+    }
+    static toFloat32(array) {
+        const flat = new Float32Array(array.length * 3);
+        for (let i = 0; i < array.length; i++)
+            array[i].toArray(flat, i * 3);
+        return flat;
+    }
+    setVertices(array) {
+        this.vertices = CustomMesh.toFloat32(array);
+    }
+    setIndices(array) {
+        this.indices = array instanceof Int32Array ? array.slice(0) : new Int32Array(array);
+    }
+    setNormals(array) {
+        this.normals = CustomMesh.toFloat32(array);
+    }
+    setUvs(array) {
+        this.uvs = array instanceof Float32Array ? array.slice(0) : new Float32Array(array);
+    }
+    addSubMeshes(array) {
+        for (let i = 0; i < array.length; i += 2)
+            this.addSubMesh(array[i], array[i + 1]);
+    }
+    addSubMesh(start, count) {
+        this.subMeshes.push(new SubMesh(start, count));
+    }
+    setItemSize(itemSize) {
+        this.itemSize = itemSize;
+    }
+    setPrimitive(primitive) {
+        for (let i = 0; i < this.primitives.length; i++)
+            if (this.primitives[i] === primitive) {
+                this.primitive = primitive;
+                return true;
+            }
+        return false;
+    }
+    static _vA = new Vec3();
+    static _vB = new Vec3();
+    static _vC = new Vec3();
+    static _e1 = new Vec3();
+    static _e2 = new Vec3();
+    static _n = new Vec3();
+    static _sum = new Vec3();
+    static UP = new Vec3(0, 1, 0);
+    static accumulate(normals, offset, n) {
+        CustomMesh._sum.setArray(normals, offset).add(n).toArray(normals, offset);
+    }
+    computeVertexNormals() {
+        if (!this.vertices || this.vertices.length === 0)
+            return null;
+        const vertices = this.vertices;
+        const normals = new Float32Array(vertices.length);
+        const vA = CustomMesh._vA, vB = CustomMesh._vB, vC = CustomMesh._vC;
+        const e1 = CustomMesh._e1, e2 = CustomMesh._e2, n = CustomMesh._n;
+        const faceNormal = (iA, iB, iC) => {
+            vA.setArray(vertices, iA);
+            vB.setArray(vertices, iB);
+            vC.setArray(vertices, iC);
+            return n.crossVectors(e1.subVectors(vB, vA), e2.subVectors(vC, vA));
+        };
+        if (this.indices && this.indices.length > 0)
+            for (let i = 0; i + 2 < this.indices.length; i += 3) {
+                const iA = this.indices[i] * 3;
+                const iB = this.indices[i + 1] * 3;
+                const iC = this.indices[i + 2] * 3;
+                faceNormal(iA, iB, iC);
+                CustomMesh.accumulate(normals, iA, n);
+                CustomMesh.accumulate(normals, iB, n);
+                CustomMesh.accumulate(normals, iC, n);
+            }
+        else
+            for (let i = 0; i + 8 < vertices.length; i += 9) {
+                faceNormal(i, i + 3, i + 6);
+                n.toArray(normals, i);
+                n.toArray(normals, i + 3);
+                n.toArray(normals, i + 6);
+            }
+        for (let i = 0; i < normals.length; i += 3)
+            n.setArray(normals, i).normalize(CustomMesh.UP).toArray(normals, i);
+        this.normals = normals;
+        return this.normals;
+    }
+}
+
+const SpriteShader = {
+    vertex: `
+attribute vec3 aVertexPosition;
+attribute vec2 aTextureCoord;
+
+uniform mat4 uModelMatrix;
+uniform mat4 uViewMatrix;
+uniform mat4 uProjectionMatrix;
+uniform float uFrame;
+uniform float uFrames;
+uniform float uBillboard;
+uniform float uDepthBias;
+
+varying vec2 vTextureCoord;
+varying float vDepth;
+
+void main(void) {
+  vTextureCoord = vec2((uFrame + aTextureCoord.x) / uFrames, aTextureCoord.y);
+  vec3 view;
+  if (uBillboard < 0.5) {
+    view = (uViewMatrix * uModelMatrix * vec4(aVertexPosition, 1.0)).xyz;
+  } else {
+    vec3 origin = (uViewMatrix * uModelMatrix * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
+    vec3 up = vec3(0.0, 1.0, 0.0);
+    vec3 right = vec3(1.0, 0.0, 0.0);
+    if (uBillboard > 1.5) {
+      up = normalize((uViewMatrix * vec4(0.0, 1.0, 0.0, 0.0)).xyz);
+      vec3 across = cross(origin, up);
+      if (length(across) > 0.0001)
+        right = normalize(across);
+    }
+    float scaleX = length(uModelMatrix[0].xyz);
+    float scaleY = length(uModelMatrix[1].xyz);
+    view = origin + right * aVertexPosition.x * scaleX + up * aVertexPosition.y * scaleY;
+  }
+  vDepth = -view.z;
+  vec4 clip = uProjectionMatrix * vec4(view, 1.0);
+  // only the depth moves: the picture stays where it is and as big as it is
+  float bias = min(uDepthBias, max(0.0, vDepth - 1.0));
+  if (bias > 0.0) {
+    vec4 nearer = uProjectionMatrix * vec4(view.xy, view.z + bias, 1.0);
+    clip.z = nearer.z / nearer.w * clip.w;
+  }
+  gl_Position = clip;
+}
+`,
+    fragment: `
+precision mediump float;
+
+uniform sampler2D uSampler;
+uniform vec3 uMaterialDiffuse;
+uniform float uAlphaCutoff;
+uniform int uHasFog;
+uniform vec3 uFogColor;
+uniform float uFogNear;
+uniform float uFogFar;
+
+varying vec2 vTextureCoord;
+varying float vDepth;
+
+void main(void) {
+  vec4 texel = texture2D(uSampler, vTextureCoord);
+  if (texel.a < uAlphaCutoff)
+    discard;
+  vec3 color = texel.rgb * uMaterialDiffuse;
+  if (uHasFog == 1) {
+    float fade = clamp((vDepth - uFogNear) / (uFogFar - uFogNear), 0.0, 1.0);
+    color = mix(color, uFogColor, fade);
+  }
+  gl_FragColor = vec4(color, texel.a);
+}
+`,
+    create(context) {
+        return Program.create(context, SpriteShader.vertex, SpriteShader.fragment);
+    }
+};
+
+const scratchSpritePos = new Vec3();
+const scratchSpriteScale = new Vec3();
+const scratchSpriteNormal = new Vec3();
+const scratchSpriteUp = new Vec3();
+const scratchSpriteRight = new Vec3();
+const scratchSpriteHit = new Vec3();
+const scratchSpriteC0 = new Vec3();
+const scratchSpriteC1 = new Vec3();
+const scratchSpriteC2 = new Vec3();
+const scratchSpriteC3 = new Vec3();
+function raycastSprite(sprite, ray) {
+    const worldPos = sprite.getWorldPosition(scratchSpritePos);
+    const scale = sprite.worldMatrix.getScale(scratchSpriteScale);
+    const normal = scratchSpriteNormal;
+    const up = scratchSpriteUp;
+    const right = scratchSpriteRight;
+    if (sprite.billboard === 'spherical') {
+        normal.copy(ray.direction).opposite().normalize();
+        up.setScalar(0, 1, 0);
+        const dotUp = up.dotProduct(normal);
+        up.subtractScaledVector(normal, dotUp);
+        if (up.getMagnitude(true) < 0.0001) {
+            up.setScalar(0, 0, 1);
+            const dotZ = up.dotProduct(normal);
+            up.subtractScaledVector(normal, dotZ);
+        }
+        up.normalize();
+        right.crossVectors(up, normal).normalize();
+    }
+    else {
+        up.setScalar(0, 1, 0);
+        normal.setScalar(-ray.direction.x, 0, -ray.direction.z);
+        if (normal.getMagnitude(true) < 0.0001)
+            normal.setScalar(ray.origin.x - worldPos.x, 0, ray.origin.z - worldPos.z);
+        if (normal.getMagnitude(true) < 0.0001)
+            normal.setScalar(0, 0, 1);
+        else
+            normal.normalize();
+        right.crossVectors(up, normal).normalize();
+    }
+    const hw = (sprite.width / 2) * scale.x;
+    const y0 = (sprite.anchor === 'bottom' ? 0 : -sprite.height / 2) * scale.y;
+    const y1 = (sprite.anchor === 'bottom' ? sprite.height : sprite.height / 2) * scale.y;
+    const c0 = scratchSpriteC0.setScalar(worldPos.x - right.x * hw + up.x * y0, worldPos.y - right.y * hw + up.y * y0, worldPos.z - right.z * hw + up.z * y0);
+    const c1 = scratchSpriteC1.setScalar(worldPos.x + right.x * hw + up.x * y0, worldPos.y + right.y * hw + up.y * y0, worldPos.z + right.z * hw + up.z * y0);
+    const c2 = scratchSpriteC2.setScalar(worldPos.x + right.x * hw + up.x * y1, worldPos.y + right.y * hw + up.y * y1, worldPos.z + right.z * hw + up.z * y1);
+    const c3 = scratchSpriteC3.setScalar(worldPos.x - right.x * hw + up.x * y1, worldPos.y - right.y * hw + up.y * y1, worldPos.z - right.z * hw + up.z * y1);
+    let hit = ray.intersectTriangle(c0, c1, c2, false, scratchSpriteHit);
+    if (!hit)
+        hit = ray.intersectTriangle(c0, c2, c3, false, scratchSpriteHit);
+    if (!hit)
+        return null;
+    return { distance: ray.origin.getDistance(hit), point: new Vec3().copy(hit) };
+}
+
+const BILLBOARD_VALUES = { none: 0, spherical: 1, cylindrical: 2 };
+class Sprite extends Mesh {
+    width;
+    height;
+    frames;
+    anchor;
+    billboard;
+    currentFrame = 0;
+    alphaCutoff = 0.5;
+    depthBias = 0;
+    static scratchSpriteMin = new Vec3();
+    static scratchSpriteMax = new Vec3();
+    static scratchSpriteBox = new Box();
+    static scratchSpriteHit = new Vec3();
+    constructor(context, options) {
+        const size = options.size ?? new Vec2(1, 1);
+        const width = size.x;
+        const height = size.y;
+        const anchor = options.anchor ?? 'center';
+        const billboard = options.billboard ?? 'spherical';
+        const frames = Math.max(1, Math.floor(options.frames ?? 1));
+        const x = width / 2;
+        const y0 = anchor === 'bottom' ? 0 : -height / 2;
+        const y1 = anchor === 'bottom' ? height : height / 2;
+        const geometry = {
+            vertices: [-x, y0, 0, x, y0, 0, x, y1, 0, -x, y0, 0, x, y1, 0, -x, y1, 0],
+            uvs: [0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1],
+            indices: null,
+            normals: null,
+            subMeshes: [],
+            itemSize: 3,
+            primitive: 'TRIANGLES'
+        };
+        super(geometry, context);
+        this.width = width;
+        this.height = height;
+        this.frames = frames;
+        this.anchor = anchor;
+        this.billboard = billboard;
+        this.alphaCutoff = options.alphaCutoff ?? 0.5;
+        this.depthBias = options.depthBias ?? 0;
+        const material = options.material ?? new Material({ diffuse: new Vec3(1, 1, 1) });
+        this.addProgram(SpriteShader.vertex, options.fragment ?? SpriteShader.fragment, material);
+        this.addCustomUniform('frame', 'uniform1f', 0);
+        this.addCustomUniform('frames', 'uniform1f', frames);
+        this.addCustomUniform('billboard', 'uniform1f', BILLBOARD_VALUES[billboard]);
+        this.addCustomUniform('alphaCutoff', 'uniform1f', this.alphaCutoff);
+        this.addCustomUniform('depthBias', 'uniform1f', this.depthBias);
+        this.updateLocalBounds();
+        if (options.texture)
+            this.setTexture(options.texture, options.textureOptions);
+    }
+    updateLocalBounds() {
+        const x = this.width / 2;
+        const y0 = this.anchor === 'bottom' ? 0 : -this.height / 2;
+        const y1 = this.anchor === 'bottom' ? this.height : this.height / 2;
+        if (this.billboard !== 'none') {
+            const reach = Math.hypot(x, Math.max(Math.abs(y0), Math.abs(y1)));
+            if (this.billboard === 'spherical') {
+                Sprite.scratchSpriteMin.setScalar(-reach, -reach, -reach);
+                Sprite.scratchSpriteMax.setScalar(reach, reach, reach);
+            }
+            else {
+                Sprite.scratchSpriteMin.setScalar(-x, y0, -x);
+                Sprite.scratchSpriteMax.setScalar(x, y1, x);
+            }
+        }
+        else {
+            Sprite.scratchSpriteMin.setScalar(-x, y0, 0);
+            Sprite.scratchSpriteMax.setScalar(x, y1, 0);
+        }
+        Sprite.scratchSpriteBox.set(Sprite.scratchSpriteMin, Sprite.scratchSpriteMax);
+        this.setLocalBounds(Sprite.scratchSpriteBox);
+    }
+    setFrame(frame) {
+        this.currentFrame = ((Math.floor(frame) % this.frames) + this.frames) % this.frames;
+        this.setCustomUniform('frame', this.currentFrame);
+        return this;
+    }
+    getFrame() {
+        return this.currentFrame;
+    }
+    setFrames(frames) {
+        this.frames = Math.max(1, Math.floor(frames));
+        this.setCustomUniform('frames', this.frames);
+        return this.setFrame(this.currentFrame);
+    }
+    getFrames() {
+        return this.frames;
+    }
+    setBillboard(billboard) {
+        if (this.billboard === billboard)
+            return this;
+        this.billboard = billboard;
+        this.setCustomUniform('billboard', BILLBOARD_VALUES[billboard]);
+        this.updateLocalBounds();
+        return this;
+    }
+    getBillboard() {
+        return this.billboard;
+    }
+    setAlphaCutoff(cutoff) {
+        this.alphaCutoff = cutoff;
+        this.setCustomUniform('alphaCutoff', cutoff);
+        return this;
+    }
+    getAlphaCutoff() {
+        return this.alphaCutoff;
+    }
+    setDepthBias(depthBias) {
+        this.depthBias = depthBias;
+        this.setCustomUniform('depthBias', depthBias);
+        return this;
+    }
+    getDepthBias() {
+        return this.depthBias;
+    }
+    getWidth() {
+        return this.width;
+    }
+    getHeight() {
+        return this.height;
+    }
+    getSize(target = new Vec2()) {
+        target.x = this.width;
+        target.y = this.height;
+        return target;
+    }
+    getAnchor() {
+        return this.anchor;
+    }
+    raycast(ray, precise = false) {
+        if (!this.isActive())
+            return null;
+        if (this.billboard === 'none')
+            return super.raycast(ray, precise);
+        const sphere = this.computeBoundingSphere();
+        const hitSphere = ray.intersectSphere(sphere, Sprite.scratchSpriteHit);
+        if (!hitSphere)
+            return null;
+        if (!precise)
+            return { distance: ray.origin.getDistance(hitSphere), point: new Vec3().copy(hitSphere) };
+        return raycastSprite(this, ray);
+    }
+}
+
+class DirectionalLight {
+    position;
+    diffuse;
+    specular;
+    direction;
+    type;
+    constructor(directionOrOptions) {
+        this.position = new Vec3();
+        this.direction = new Vec3(0, -1, 0);
+        this.diffuse = new Vec3(0.6, 0.6, 0.6);
+        this.specular = new Vec3(0.8, 0.8, 0.8);
+        this.type = 'directional';
+        if (directionOrOptions)
+            if (directionOrOptions instanceof Vec3)
+                this.setDirection(directionOrOptions);
+            else {
+                if (directionOrOptions.direction)
+                    this.setDirection(directionOrOptions.direction);
+                if (directionOrOptions.diffuse)
+                    this.setDiffuse(directionOrOptions.diffuse);
+                if (directionOrOptions.specular)
+                    this.setSpecular(directionOrOptions.specular);
+                if (directionOrOptions.position)
+                    this.setPosition(directionOrOptions.position);
+            }
+    }
+    setPosition(position) {
+        this.position.copy(position);
+    }
+    setDirection(direction) {
+        this.direction.copy(direction).normalize();
+    }
+    setDiffuse(diffuse) {
+        this.diffuse.copy(diffuse);
+    }
+    setSpecular(specular) {
+        this.specular.copy(specular);
+    }
+}
+
+class PointLight extends DirectionalLight {
+    constantAttenuation;
+    linearAttenuation;
+    quadraticAttenuation;
+    constructor(positionOrOptions) {
+        super();
+        this.constantAttenuation = 0;
+        this.linearAttenuation = 1.0;
+        this.quadraticAttenuation = 0;
+        this.type = 'point';
+        if (positionOrOptions)
+            if (positionOrOptions instanceof Vec3)
+                this.setPosition(positionOrOptions);
+            else {
+                if (positionOrOptions.position)
+                    this.setPosition(positionOrOptions.position);
+                if (positionOrOptions.diffuse)
+                    this.setDiffuse(positionOrOptions.diffuse);
+                if (positionOrOptions.specular)
+                    this.setSpecular(positionOrOptions.specular);
+                if (positionOrOptions.constantAttenuation !== undefined)
+                    this.setConstantAttenuation(positionOrOptions.constantAttenuation);
+                if (positionOrOptions.linearAttenuation !== undefined)
+                    this.setLinearAttenuation(positionOrOptions.linearAttenuation);
+                if (positionOrOptions.quadraticAttenuation !== undefined)
+                    this.setQuadraticAttenuation(positionOrOptions.quadraticAttenuation);
+            }
+    }
+    setConstantAttenuation(value) {
+        this.constantAttenuation = value;
+    }
+    setLinearAttenuation(value) {
+        this.linearAttenuation = value;
+    }
+    setQuadraticAttenuation(value) {
+        this.quadraticAttenuation = value;
+    }
+}
+
+class SpotLight extends PointLight {
+    cutoff;
+    exponent;
+    direction;
+    constructor(positionOrOptions) {
+        super(positionOrOptions);
+        this.cutoff = 180;
+        this.exponent = 0;
+        this.direction = new Vec3(1.0, 0.0, 0.0);
+        this.type = 'spot';
+        if (positionOrOptions && !(positionOrOptions instanceof Vec3)) {
+            if (positionOrOptions.direction)
+                this.setDirection(positionOrOptions.direction);
+            if (positionOrOptions.cutoff !== undefined)
+                this.setCutoff(positionOrOptions.cutoff);
+            if (positionOrOptions.exponent !== undefined)
+                this.setExponent(positionOrOptions.exponent);
+        }
+    }
+    setCutoff(value) {
+        this.cutoff = value;
+    }
+    setExponent(value) {
+        this.exponent = value;
+    }
+    setDirection(direction) {
+        this.direction.copy(direction);
+    }
+}
+
+class AmbientLight {
+    diffuse;
+    intensity;
+    type;
+    constructor(diffuse = new Vec3(1.0, 1.0, 1.0), intensity = 1.0) {
+        this.diffuse = new Vec3().copy(diffuse);
+        this.intensity = intensity;
+        this.type = 'ambient';
+    }
+    setColor(diffuse) {
+        this.diffuse.copy(diffuse);
+        return this;
+    }
+    setIntensity(intensity) {
+        this.intensity = intensity;
+        return this;
+    }
+    getColor(target = new Vec3()) {
+        return target.copy(this.diffuse);
+    }
+    get color() {
+        return this.diffuse;
+    }
+    set color(c) {
+        this.diffuse.copy(c);
+    }
+}
+
+function assignVec3(target, xOrVec, y, z) {
+    if (xOrVec instanceof Vec3)
+        return target.copy(xOrVec);
+    if (typeof xOrVec === 'number')
+        return target.setScalar(xOrVec, y, z);
+    return target.setArray(xOrVec);
+}
+function assignVec2(target, xOrVec, y) {
+    if (xOrVec instanceof Vec2)
+        return target.copy(xOrVec);
+    if (typeof xOrVec === 'number')
+        return target.setScalar(xOrVec, y);
+    return target.setArray(xOrVec);
+}
+
+export { AmbientLight, BasicMesh, BasicShader, Camera, Cannon, Cube, CustomMesh, Cylinder, DirectionalLight, FullscreenQuad, Hemisphere, Lights, Line, MAX_LIGHTS, Material, Mesh, MultiQuad, Node, NormalShader, OrbitControls, OrthographicCamera, PerspectiveCamera, PhongShader, Plane, PointLight, Program, Quad, RenderTarget, Renderer, Scene, Shader, Sphere, SpotLight, Sprite, SpriteShader, SubMesh, Texture, Uniform, VWing, assignVec2, assignVec3, eDrawMethod };