@1pizzateam/roostr 0.7.0 → 0.8.0

package/dist/roostr.js

@@ -24,8 +24,8 @@ SOFTWARE.
 https://github.com/1pizzateam/RoostR.js
 */
 
-import { Mat4x3, Vec3, Frustum, Vec2, Time, Utils, Mat4, Ray3, Rect, Trigo, Quat, Mat3, Box, Sphere as Sphere$1 } from '@1pizzateam/spock';
-export { Accumulator, Bezier, Box as BoundingBox, Sphere as BoundingSphere, Circ, Frustum, Grid, Mat3, Mat4, Mat4x3, NumArray, Quat, Rand, Ray3 as Ray, Rect, RollingAverage, Plane as SpatialPlane, Time, Trigo, Utils, Vec2, Vec3 } from '@1pizzateam/spock';
+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;
@@ -42,6 +42,13 @@ class GLState {
         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) {
@@ -68,6 +75,13 @@ class SceneRenderer {
         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();
@@ -103,7 +117,7 @@ class SceneRenderer {
         this.context.depthMask(false);
     }
     enableBlendMode(equation, source, destination) {
-        const key = equation + '|' + source + '|' + destination;
+        const key = `${equation}|${source}|${destination}`;
         if (key !== this.blendKey) {
             this.setBlendEquation(equation);
             this.setBlendFunction(source, destination);
@@ -154,9 +168,105 @@ class SceneGraph {
     }
 }
 
+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 {
-    static _ambient = new Vec3();
     warnedOverflow = false;
     directionals;
     points;
@@ -249,106 +359,13 @@ class Lights {
                 return false;
         }
     }
-    ClearFlatArrays() {
-        this.flatArrays.position.length = 0;
-        this.flatArrays.diffuse.length = 0;
-        this.flatArrays.specular.length = 0;
-        this.flatArrays.constantAttenuation.length = 0;
-        this.flatArrays.linearAttenuation.length = 0;
-        this.flatArrays.quadraticAttenuation.length = 0;
-        this.flatArrays.cutoff.length = 0;
-        this.flatArrays.exponent.length = 0;
-        this.flatArrays.direction.length = 0;
-        this.flatArrays.type.length = 0;
-    }
-    ensureBuffers(count) {
-        const f = this.flatArrays;
-        if (f.floatPosition && f.floatPosition.length === count * 3)
-            return;
-        f.floatPosition = new Float32Array(count * 3);
-        f.floatDiffuse = new Float32Array(count * 3);
-        f.floatSpecular = new Float32Array(count * 3);
-        f.floatDirection = new Float32Array(count * 3);
-        f.floatAttenuation = new Float32Array(count * 3);
-        f.floatCutoff = new Float32Array(count);
-        f.floatExponent = new Float32Array(count);
-        f.floatType = new Float32Array(count);
-        f.packedPosition = new Float32Array(count * 4);
-        f.packedDiffuse = new Float32Array(count * 4);
-        f.packedSpecular = new Float32Array(count * 4);
-    }
-    push(index, kind, light) {
-        const f = this.flatArrays;
-        const o = index * 3;
-        const isSpot = kind === 'spot';
-        const isDirectional = kind === 'directional';
-        const att = isDirectional ? null : light;
-        light.position.toArray(f.floatPosition, o);
-        light.diffuse.toArray(f.floatDiffuse, o);
-        light.specular.toArray(f.floatSpecular, o);
-        if (isDirectional)
-            light.direction.toArray(f.floatDirection, o);
-        else if (isSpot)
-            light.direction.toArray(f.floatDirection, o);
-        else
-            f.floatDirection.fill(0, o, o + 3);
-        const constant = att ? att.constantAttenuation : 1;
-        const linear = att ? att.linearAttenuation : 0;
-        const quadratic = att ? att.quadraticAttenuation : 0;
-        f.floatAttenuation[o] = constant;
-        f.floatAttenuation[o + 1] = linear;
-        f.floatAttenuation[o + 2] = quadratic;
-        f.floatCutoff[index] = isSpot ? light.cutoff : 0;
-        f.floatExponent[index] = isSpot ? light.exponent : 0;
-        f.floatType[index] = isDirectional ? 0 : isSpot ? 2 : 1;
-        const q = index * 4;
-        light.position.toArray(f.packedPosition, q);
-        f.packedPosition[q + 3] = f.floatType[index];
-        light.diffuse.toArray(f.packedDiffuse, q);
-        f.packedDiffuse[q + 3] = f.floatCutoff[index];
-        light.specular.toArray(f.packedSpecular, q);
-        f.packedSpecular[q + 3] = f.floatExponent[index];
-        const dir = isDirectional || isSpot ? light.direction : null;
-        f.position.push(light.position.x, light.position.y, light.position.z);
-        f.diffuse.push(light.diffuse.x, light.diffuse.y, light.diffuse.z);
-        f.specular.push(light.specular.x, light.specular.y, light.specular.z);
-        if (dir)
-            f.direction.push(dir.x, dir.y, dir.z);
-        else
-            f.direction.push(0, 0, 0);
-        f.constantAttenuation.push(constant);
-        f.linearAttenuation.push(linear);
-        f.quadraticAttenuation.push(quadratic);
-        f.cutoff.push(isSpot ? light.cutoff : 0);
-        f.exponent.push(isSpot ? light.exponent : 0);
-        f.type.push(kind);
-    }
     flatten(extraAmbient) {
-        this.ClearFlatArrays();
         const total = this.nbSpots + this.nbPoints + this.nbDirectionals;
-        const count = Math.min(total, MAX_LIGHTS);
         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.`);
         }
-        this.ensureBuffers(count);
-        let index = 0;
-        for (let i = 0; i < this.nbSpots && index < count; i++)
-            this.push(index++, 'spot', this.spots[i]);
-        for (let i = 0; i < this.nbPoints && index < count; i++)
-            this.push(index++, 'point', this.points[i]);
-        for (let i = 0; i < this.nbDirectionals && index < count; i++)
-            this.push(index++, 'directional', this.directionals[i]);
-        const ambient = Lights._ambient.setScalar(0, 0, 0);
-        if (extraAmbient)
-            ambient.add(extraAmbient);
-        for (let i = 0; i < this.nbAmbients; i++)
-            ambient.addScaledVector(this.ambients[i].diffuse, this.ambients[i].intensity);
-        if (!this.flatArrays.floatAmbient)
-            this.flatArrays.floatAmbient = new Float32Array(3);
-        ambient.toArray(this.flatArrays.floatAmbient);
-        this.flatArrays.ambient = [ambient.x, ambient.y, ambient.z];
-        return this.flatArrays;
+        return packLights(this.directionals, this.points, this.spots, this.ambients, this.flatArrays, MAX_LIGHTS, extraAmbient);
     }
     clear() {
         this.directionals = [];
@@ -359,7 +376,7 @@ class Lights {
         this.nbPoints = 0;
         this.nbSpots = 0;
         this.nbAmbients = 0;
-        this.ClearFlatArrays();
+        clearFlatArrays(this.flatArrays);
     }
     getFlatArray(property) {
         if (this.flatArrays.hasOwnProperty(property))
@@ -368,12 +385,70 @@ class Lights {
     }
 }
 
-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 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 {
@@ -386,14 +461,11 @@ class Scene {
     context;
     renderer;
     graph;
+    collector;
     resolution;
-    scratchFrustum = new Frustum();
-    scratchVec = new Vec3();
     frame = { id: 0 };
     frameCounter = 0;
     traversalStamp = 0;
-    opaqueList = [];
-    blendedList = [];
     constructor(contextOrOptions) {
         this.meshes = [];
         this.nbMeshes = 0;
@@ -401,6 +473,7 @@ class Scene {
         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')
@@ -427,15 +500,14 @@ class Scene {
         this.renderer = new SceneRenderer(this.context);
         this.graph = new SceneGraph();
         if (opts && this.context) {
-            if (opts.viewport)
-                this.setViewport(opts.viewport.x || 0, opts.viewport.y || 0, opts.viewport.width, opts.viewport.height);
-            if (opts.clearColor) {
-                const c = opts.clearColor;
-                if (Array.isArray(c))
-                    this.context.clearColor(c[0] ?? 0, c[1] ?? 0, c[2] ?? 0, c[3] ?? 1);
-                else if ('x' in c && 'y' in c && 'z' in c)
-                    this.context.clearColor(c.x, c.y, c.z, 1.0);
+            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)
@@ -460,20 +532,32 @@ class Scene {
             return null;
         return (canvas.getContext('webgl') || canvas.getContext('experimental-webgl'));
     }
-    setViewport(x, y, width, height) {
-        this.resolution.setScalar(width, height);
+    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, width, height);
+            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(sizeOrWidth, height) {
-        const w = sizeOrWidth instanceof Vec2 ? sizeOrWidth.x : sizeOrWidth;
-        const h = sizeOrWidth instanceof Vec2 ? sizeOrWidth.y : (height ?? 0);
+    setSize(size) {
         if (this.context && this.context.canvas) {
             const canvas = this.context.canvas;
-            canvas.width = w;
-            canvas.height = h;
+            canvas.width = size.x;
+            canvas.height = size.y;
         }
-        this.setViewport(0, 0, w, h);
+        this.setViewport(size);
     }
     clear(color = true, depth = true) {
         if (!this.context)
@@ -507,26 +591,16 @@ class Scene {
     removeLight(light) {
         return this.lights.removeLight(light);
     }
-    setAmbientColor(rOrVec, g, b) {
-        if (typeof rOrVec === 'number')
-            this.ambientColor.setScalar(rOrVec, g ?? 0, b ?? 0);
-        else
-            assignVec3(this.ambientColor, rOrVec);
+    setAmbientColor(color) {
+        this.ambientColor.copy(color);
         return this;
     }
-    setFog(color, nearOrG, farOrB, near, far) {
-        if (typeof color === 'number')
-            this.fog = {
-                color: new Vec3(color, nearOrG, farOrB ?? 0),
-                near: near ?? 1,
-                far: far ?? 1000
-            };
-        else
-            this.fog = {
-                color: assignVec3(new Vec3(), color),
-                near: nearOrG,
-                far: farOrB ?? 1000
-            };
+    setFog(color, near, far = 1000) {
+        this.fog = {
+            color: new Vec3(color.x, color.y, color.z),
+            near,
+            far
+        };
         return this;
     }
     clearFog() {
@@ -540,6 +614,11 @@ class Scene {
     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)
@@ -562,41 +641,27 @@ class Scene {
     }
     raycast(ray, precise = false) {
         this.computeWorldMatrices();
-        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 this.meshes)
-            if (mesh.traversalStamp !== this.traversalStamp)
-                visit(mesh);
-        hits.sort((a, b) => a.distance - b.distance);
-        return hits;
+        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.scratchFrustum.setFromProjectionViewMatrix(camera.getProjectionViewMatrix())
+            ? this.collector.scratchFrustum.setFromProjectionViewMatrix(camera.getProjectionViewMatrix())
             : null;
-        this.collect(camera, frustum, true, true, this.traversalStamp);
+        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.opaqueList) {
+        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.drawBlended(camera, time, flatLights, frame);
+        renderedCount += this.collector.drawBlended(this, camera, time, flatLights, frame);
         this.renderer.setDepthWrite(true);
         return renderedCount;
     }
@@ -624,52 +689,105 @@ class Scene {
         this.frame.resolution = this.resolution;
         return this.frame;
     }
-    collect(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 this.meshes)
-            if (mesh.traversalStamp !== stamp)
-                visit(mesh);
+    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());
     }
-    drawBlended(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;
-            this.enableBlendMode(blend.equation, blend.source, blend.destination);
-            this.renderer.setDepthWrite(mesh.depthWrite);
-            mesh.renderSelf(projMatrix, viewMatrix, flatLights, time, true, camPos, this.fog, frame);
+}
+
+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;
         }
-        this.disableBlendMode();
-        this.renderer.setDepthWrite(true);
-        return list.length;
+        return shader;
     }
-    renderBlended(camera, time = Time.now(), flatLights = this.lights.flatten(this.ambientColor), frustum = null) {
-        this.collect(camera, frustum, false, true, this.markDescendants());
-        return this.drawBlended(camera, time, flatLights, this.beginFrame());
+};
+
+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;
@@ -687,14 +805,19 @@ class Renderer {
         };
         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) {
-            this.canvas.width = options.width ?? 1280;
-            this.canvas.height = options.height ?? 720;
+            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;
@@ -720,8 +843,8 @@ class Renderer {
         this.setFrontFace('CW');
         this.enable('CULL_FACE');
         this.setCullFace('BACK');
-        this.setViewport(this.context.drawingBufferWidth, this.context.drawingBufferHeight);
-        this.setClearColor(0.0, 0.0, 0.0, 1.0);
+        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)
@@ -739,22 +862,14 @@ class Renderer {
         if (this.context)
             this.context.cullFace(this.context[mode]);
     }
-    setViewport(width, height) {
+    setViewport(size) {
         if (this.context)
-            this.context.viewport(0, 0, width, height);
+            this.context.viewport(0, 0, size.x, size.y);
     }
-    setClearColor(rOrVec, g, b, a) {
-        if (this.context)
-            if (rOrVec instanceof Vec3) {
-                const alpha = g !== undefined ? Utils.clamp(g, 0, 1) : 1.0;
-                this.context.clearColor(Utils.clamp(rOrVec.x, 0, 1), Utils.clamp(rOrVec.y, 0, 1), Utils.clamp(rOrVec.z, 0, 1), alpha);
-            }
-            else {
-                const green = g !== undefined ? Utils.clamp(g, 0, 1) : 0;
-                const blue = b !== undefined ? Utils.clamp(b, 0, 1) : 0;
-                const alpha = a !== undefined ? Utils.clamp(a, 0, 1) : 1.0;
-                this.context.clearColor(Utils.clamp(rOrVec, 0, 1), green, blue, alpha);
-            }
+    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)
@@ -766,14 +881,19 @@ class Renderer {
     getCanvas() {
         return this.canvas;
     }
-    setSize(sizeOrWidth, height) {
-        const w = sizeOrWidth instanceof Vec2 ? sizeOrWidth.x : sizeOrWidth;
-        const h = sizeOrWidth instanceof Vec2 ? sizeOrWidth.y : (height ?? 0);
+    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) {
-            this.canvas.width = w;
-            this.canvas.height = h;
+            target.x = this.canvas.width;
+            target.y = this.canvas.height;
         }
-        this.setViewport(w, h);
+        return target;
     }
     findById(id) {
         return document.getElementById(id);
@@ -787,22 +907,18 @@ class RenderTarget {
     framebuffer;
     texture;
     depthBuffer;
-    constructor(sizeOrWidth, heightOrContext, context) {
-        if (sizeOrWidth instanceof Vec2) {
-            this.width = sizeOrWidth.x;
-            this.height = sizeOrWidth.y;
-            this.context = heightOrContext;
-        }
-        else {
-            this.width = sizeOrWidth;
-            this.height = heightOrContext;
-            this.context = context;
-        }
+    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();
@@ -828,20 +944,20 @@ class RenderTarget {
         gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
         gl.viewport(0, 0, this.width, this.height);
     }
-    unbind(viewportWidthOrSize, viewportHeight) {
+    unbind(viewportSize) {
         const gl = this.context;
         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
-        if (viewportWidthOrSize instanceof Vec2)
-            gl.viewport(0, 0, viewportWidthOrSize.x, viewportWidthOrSize.y);
-        else if (viewportWidthOrSize !== undefined && viewportHeight !== undefined)
-            gl.viewport(0, 0, viewportWidthOrSize, viewportHeight);
+        if (viewportSize)
+            gl.viewport(0, 0, viewportSize.x, viewportSize.y);
     }
     getSize(target = new Vec2()) {
-        return target.setScalar(this.width, this.height);
+        target.x = this.width;
+        target.y = this.height;
+        return target;
     }
-    setSize(sizeOrWidth, height) {
-        const w = sizeOrWidth instanceof Vec2 ? sizeOrWidth.x : sizeOrWidth;
-        const h = sizeOrWidth instanceof Vec2 ? sizeOrWidth.y : (height ?? 0);
+    setSize(size) {
+        const w = size.x;
+        const h = size.y;
         if (this.width === w && this.height === h)
             return;
         this.width = w;
@@ -932,25 +1048,16 @@ class Camera {
         }
         return this.inverseProjectionViewMatrix;
     }
-    setPosition(xOrVec, y, z) {
-        if (xOrVec instanceof Vec3)
-            this.position.copy(xOrVec);
-        else
-            this.position.setScalar(xOrVec, y, z);
+    setPosition(position) {
+        this.position.copy(position);
         this.setViewMatrix();
     }
-    setTarget(xOrVec, y, z) {
-        if (xOrVec instanceof Vec3)
-            this.target.copy(xOrVec);
-        else
-            this.target.setScalar(xOrVec, y, z);
+    setTarget(target) {
+        this.target.copy(target);
         this.setViewMatrix();
     }
-    setUp(xOrVec, y, z) {
-        if (xOrVec instanceof Vec3)
-            this.up.copy(xOrVec);
-        else
-            this.up.setScalar(xOrVec, y, z);
+    setUp(up) {
+        this.up.copy(up);
         this.setViewMatrix();
     }
     lookAt(target) {
@@ -978,26 +1085,13 @@ class Camera {
     getProjectionMatrixObject() {
         return this.projectionMatrix;
     }
-    getRay(ndcOrX, ndcYOrTarget, targetRay = new Ray3()) {
-        let ndcX;
-        let ndcY;
-        let outRay = targetRay;
-        if (ndcOrX instanceof Vec2) {
-            ndcX = ndcOrX.x;
-            ndcY = ndcOrX.y;
-            if (ndcYOrTarget instanceof Ray3)
-                outRay = ndcYOrTarget;
-        }
-        else {
-            ndcX = ndcOrX;
-            ndcY = typeof ndcYOrTarget === 'number' ? ndcYOrTarget : 0;
-        }
+    getRay(ndc, targetRay = new Ray3()) {
         const inverse = this.getInverseProjectionViewMatrix();
-        const near = inverse.transformPoint(Camera._scratchNdc.setScalar(ndcX, ndcY, -1), Camera._scratchNear);
-        const far = inverse.transformPoint(Camera._scratchNdc.setScalar(ndcX, ndcY, 1.0), Camera._scratchFar);
+        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();
-        outRay.set(near, dir);
-        return outRay;
+        targetRay.set(near, dir);
+        return targetRay;
     }
 }
 
@@ -1006,35 +1100,24 @@ class PerspectiveCamera extends Camera {
     ratio;
     zNear;
     zFar;
-    constructor(fov, zNearOrContext, zFarOrNear, contextOrFar) {
+    constructor(fov, nearFar = new Vec2(0.1, 1000), context) {
         super(new Vec3(), new Vec3(), new Vec3(0.0, 1.0, 0.0));
-        let zNear = 0.1;
-        let zFar = 1000;
-        let context = null;
-        if (zNearOrContext && typeof zNearOrContext !== 'number') {
-            context = zNearOrContext;
-            zNear = typeof zFarOrNear === 'number' ? zFarOrNear : 0.1;
-            zFar = typeof contextOrFar === 'number' ? contextOrFar : 1000;
-        }
-        else {
-            zNear = typeof zNearOrContext === 'number' ? zNearOrContext : 0.1;
-            zFar = typeof zFarOrNear === 'number' ? zFarOrNear : 1000;
-            if (contextOrFar && typeof contextOrFar !== 'number')
-                context = contextOrFar;
-        }
         this.fov = fov;
         this.ratio = 0;
-        this.zNear = zNear;
-        this.zFar = zFar;
-        const viewport = context && typeof context.getParameter === 'function' ? context.getParameter(context.VIEWPORT) : null;
+        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 instanceof Vec2)
+        if (viewport)
             this.ratio = viewport.x / Math.max(1, viewport.y);
-        else if (viewport && viewport.length >= 4)
-            this.ratio = viewport[2] / Math.max(1, viewport[3]);
         else
             this.ratio = this.ratio || 1;
         this.projectionMatrix.perspective(this.fov, this.ratio, this.zNear, this.zFar);
@@ -1044,11 +1127,16 @@ class PerspectiveCamera extends Camera {
         this.fov = fov;
         this.setProjectionMatrix();
     }
-    setNearFar(zNear, zFar) {
-        this.zNear = zNear;
-        this.zFar = zFar;
+    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 {
@@ -1058,24 +1146,14 @@ class OrthographicCamera extends Camera {
     bottom;
     near;
     far;
-    constructor(boundsOrLeft, rightOrNear, topOrFar, bottom, near, far) {
+    constructor(bounds, nearFar = new Vec2(-1e3, 1000)) {
         super(new Vec3(), new Vec3(), new Vec3(0.0, 1.0, 0.0));
-        if (boundsOrLeft instanceof Rect) {
-            this.left = boundsOrLeft.topLeftCorner.x;
-            this.right = boundsOrLeft.bottomRightCorner.x;
-            this.bottom = boundsOrLeft.topLeftCorner.y;
-            this.top = boundsOrLeft.bottomRightCorner.y;
-            this.near = rightOrNear !== undefined ? rightOrNear : -1e3;
-            this.far = topOrFar !== undefined ? topOrFar : 1000;
-        }
-        else {
-            this.left = boundsOrLeft;
-            this.right = rightOrNear;
-            this.top = topOrFar;
-            this.bottom = bottom;
-            this.near = near !== undefined ? near : -1e3;
-            this.far = far !== undefined ? far : 1000;
-        }
+        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();
     }
@@ -1083,29 +1161,22 @@ class OrthographicCamera extends Camera {
         this.projectionMatrix.orthographic(this.left, this.right, this.top, this.bottom, this.near, this.far);
         super.setProjectionMatrix();
     }
-    setBounds(boundsOrLeft, rightOrNear, topOrFar, bottom, near, far) {
-        if (boundsOrLeft instanceof Rect) {
-            this.left = boundsOrLeft.topLeftCorner.x;
-            this.right = boundsOrLeft.bottomRightCorner.x;
-            this.bottom = boundsOrLeft.topLeftCorner.y;
-            this.top = boundsOrLeft.bottomRightCorner.y;
-            if (rightOrNear !== undefined)
-                this.near = rightOrNear;
-            if (topOrFar !== undefined)
-                this.far = topOrFar;
-        }
-        else {
-            this.left = boundsOrLeft;
-            this.right = rightOrNear;
-            this.top = topOrFar;
-            this.bottom = bottom;
-            if (near !== undefined)
-                this.near = near;
-            if (far !== undefined)
-                this.far = far;
+    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 {
@@ -1326,88 +1397,273 @@ class OrbitControls {
     }
 }
 
-const Shader = {
-    create(context, str, type) {
-        let 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();
-class Program {
-    static create(context, vertexShader, fragmentShader) {
-        let program = context.createProgram();
-        if (program) {
-            let vshader = Shader.create(context, vertexShader, 'VERTEX_SHADER');
-            let 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);
+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;
         }
-        return program;
     }
-    static acquire(context, vertexShader, fragmentShader) {
-        let cache = caches.get(context);
-        if (!cache) {
-            cache = new Map();
-            caches.set(context, cache);
+    removeChild(node) {
+        const index = this.children.indexOf(node);
+        if (index !== -1) {
+            this.children.splice(index, 1);
+            node.parent = null;
+            node.isWorldDirty = true;
+            return true;
         }
-        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);
+        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;
         }
-        entry.refs++;
-        return entry.program;
+        return this._rotation;
     }
-    static release(context, program) {
-        const entry = owners.get(program);
-        if (!entry) {
-            context.deleteProgram(program);
+    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);
         }
-        if (--entry.refs > 0)
-            return;
-        caches.get(context)?.delete(entry.key);
-        owners.delete(program);
-        context.deleteProgram(program);
+        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)
@@ -1416,7 +1672,7 @@ function canGenerateMipmaps(context, width, height) {
 }
 const Texture = {
     create(source, context, options) {
-        let webGLTexture = context.createTexture();
+        const webGLTexture = context.createTexture();
         if (!webGLTexture)
             return null;
         const flipY = options?.flipY !== undefined ? options.flipY : true;
@@ -1430,13 +1686,16 @@ const Texture = {
         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)
-            context.texImage2D(context.TEXTURE_2D, 0, context.RGBA, options?.width || 1, options?.height || 1, 0, context.RGBA, context.UNSIGNED_BYTE, source);
+        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.width || 1 : source.width;
-            const height = source instanceof Uint8Array ? options.height || 1 : source.height;
+            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
@@ -1454,11 +1713,15 @@ const Texture = {
             img.src = url;
         });
     },
-    update(texture, source, context, xOffset = 0, yOffset = 0, width, height, flipY = true) {
+    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 || 1, height || 1, context.RGBA, context.UNSIGNED_BYTE, source);
+            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);
@@ -1494,6 +1757,95 @@ function uploadUniform(context, location, uniform) {
         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;
@@ -1505,7 +1857,7 @@ class MeshRenderer {
     defaultSettings() {
     }
     createBuffer(target, size, drawMethod) {
-        let buffer = this.context.createBuffer();
+        const buffer = this.context.createBuffer();
         this.bindBuffer(target, buffer);
         this.context.bufferData(this.context[target], size, this.context[drawMethod]);
         return buffer;
@@ -1564,6 +1916,70 @@ class MeshRenderer {
         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 {
@@ -1604,16 +2020,16 @@ class Material {
                 this.setShininess(options.shininess);
         }
     }
-    setAmbient(xOrVec, y, z) {
-        assignVec3(this.ambient, xOrVec, y, z).toArray(this.uniforms.materialAmbient.value);
+    setAmbient(ambient) {
+        this.ambient.copy(ambient).toArray(this.uniforms.materialAmbient.value);
         this.version++;
     }
-    setDiffuse(xOrVec, y, z) {
-        assignVec3(this.diffuse, xOrVec, y, z).toArray(this.uniforms.materialDiffuse.value);
+    setDiffuse(diffuse) {
+        this.diffuse.copy(diffuse).toArray(this.uniforms.materialDiffuse.value);
         this.version++;
     }
-    setSpecular(xOrVec, y, z) {
-        assignVec3(this.specular, xOrVec, y, z).toArray(this.uniforms.materialSpecular.value);
+    setSpecular(specular) {
+        this.specular.copy(specular).toArray(this.uniforms.materialSpecular.value);
         this.version++;
     }
     setShininess(shininess) {
@@ -1661,54 +2077,25 @@ void main(void) {
     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 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;
+varying vec2 vTextureCoord;
+
+uniform sampler2D uSampler;
+uniform vec3 uMaterialDiffuse;
+uniform int uHasTexture;
 
 void main(void) {
-  gl_FragColor = vec4(vNormal * 0.5 + 0.5, 1.0);
+  vec4 color = vec4(uMaterialDiffuse, 1.0);
+  if (uHasTexture == 1) {
+    color *= texture2D(uSampler, vTextureCoord);
+  }
+  gl_FragColor = color;
 }
 `,
     create(context) {
-        return Program.create(context, NormalShader.vertex, NormalShader.fragment);
+        return Program.create(context, BasicShader.vertex, BasicShader.fragment);
     }
 };
+
 const PhongShader = {
     vertex: `
 attribute vec3 aVertexPosition;
@@ -1846,14 +2233,124 @@ void main(void) {
     }
 };
 
+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 {
-    boundingBox;
-    boundingSphere;
+class Mesh extends Node {
     vertices;
     indices;
     normals;
@@ -1870,49 +2367,23 @@ class Mesh {
     indexBuffer;
     normalBuffer;
     texCoordBuffer;
-    position;
-    scale;
-    quaternion;
-    modelMatrix;
-    worldMatrix;
-    normalMatrix;
-    parent = null;
-    traversalStamp = 0;
     sortKey = 0;
-    _rotation;
-    isRotationStale;
-    isTransformDirty;
-    isWorldDirty = true;
     ownsTexture = false;
+    textureSource = null;
+    textureOptions;
     indexType;
-    static UP = new Vec3(0, 1, 0);
-    static scratchQuat = new Quat();
-    static scratchView = new Mat4x3();
-    static scratchVec = new Vec3();
-    static scratchCamera = new Vec3();
-    static scratchDir = new Vec3();
-    static scratchA = new Vec3();
-    static scratchB = new Vec3();
-    static scratchC = new Vec3();
     static scratchHit = new Vec3();
-    static scratchWorldHit = new Vec3();
-    static scratchInverse = new Mat4x3();
-    static scratchRay = new Ray3();
-    isBoundsDirty = true;
-    isNormalMatrixDirty = true;
-    localBoundingBox;
-    localBoundingSphere;
     active;
     drawMethod;
     programs;
     nbPrograms;
     materials;
-    children;
     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')) {
@@ -1937,37 +2408,12 @@ class Mesh {
         this.context = context;
         this.renderer = new MeshRenderer(this.context);
         this.WebGLTexture = null;
-        this.vertexBuffer = this.vertices
-            ? this.renderer.createBuffer('ARRAY_BUFFER', this.vertices instanceof Float32Array ? this.vertices : new Float32Array(this.vertices), 'STATIC_DRAW')
-            : null;
+        this.vertexBuffer = null;
+        this.indexBuffer = null;
+        this.normalBuffer = null;
+        this.texCoordBuffer = 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;
-        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.isRotationStale = false;
-        this.isTransformDirty = false;
-        this.modelMatrix.identity();
-        this.worldMatrix.identity();
-        this.normalMatrix.identity();
-        this.isBoundsDirty = true;
-        this.isNormalMatrixDirty = true;
-        this.localBoundingBox = new Box();
-        this.localBoundingSphere = new Sphere$1();
-        this.boundingBox = new Box();
-        this.boundingSphere = new Sphere$1();
+        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);
@@ -1977,7 +2423,6 @@ class Mesh {
         this.programs = [];
         this.nbPrograms = 0;
         this.materials = [];
-        this.children = [];
         this.blendMode = false;
         this.zOrder = 0;
     }
@@ -1994,256 +2439,52 @@ class Mesh {
     isActive() {
         return this.active;
     }
-    addChild(mesh) {
-        if (this.children.indexOf(mesh) === -1) {
-            if (mesh.parent && mesh.parent !== this)
-                mesh.parent.removeChild(mesh);
-            this.children.push(mesh);
-            mesh.parent = this;
-            mesh.isWorldDirty = true;
-        }
-    }
-    removeChild(mesh) {
-        const index = this.children.indexOf(mesh);
-        if (index !== -1) {
-            this.children.splice(index, 1);
-            mesh.parent = null;
-            mesh.isWorldDirty = true;
-            return true;
-        }
-        return false;
-    }
     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 (let 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);
-            let materialUniforms = material.uniforms;
-            for (let property in materialUniforms)
-                if (materialUniforms.hasOwnProperty(property))
-                    for (let program of this.programs)
-                        if (program[property] === undefined)
-                            program[property] = this.context.getUniformLocation(program, 'u' + this.ucfirst(property));
-            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(xOrVec, y, z) {
-        assignVec3(this.position, xOrVec, y, z);
-        this.markDirty();
-        return this;
-    }
-    setRotation(xOrVec, y, z) {
-        assignVec3(this._rotation, xOrVec, y, z);
-        this.quaternion.setFromEuler(this._rotation);
-        this.isRotationStale = false;
-        this.markDirty();
-        return this;
-    }
-    setScale(xOrVec, y, z) {
-        if (typeof xOrVec === 'number' && y === undefined && z === undefined)
-            this.scale.setScalar(xOrVec, xOrVec, xOrVec);
-        else
-            assignVec3(this.scale, xOrVec, y, z);
-        this.markDirty();
-        return this;
-    }
-    scaleBy(factorOrVec) {
-        if (factorOrVec instanceof Vec3)
-            this.scale.multiply(factorOrVec);
-        else
-            this.scale.scale(factorOrVec);
-        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(Mesh.scratchQuat.setAxisAngle(axis, angle));
-        this.rotationChanged();
-        return this;
-    }
-    translate(xOrVec, y, z) {
-        if (typeof xOrVec === 'number')
-            this.position.add(Mesh.scratchVec.setScalar(xOrVec, y ?? 0, z ?? 0));
-        else
-            this.position.add(xOrVec instanceof Vec3 ? xOrVec : Mesh.scratchVec.setArray(xOrVec));
-        this.markDirty();
-        return this;
-    }
-    lookAt(target, up = Mesh.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(Mesh.scratchVec).getDistance(targetPos);
-    }
-    isInsideBounds(min, max) {
-        return this.getWorldPosition(Mesh.scratchVec).isInBounds(min, max);
-    }
-    computeBounds() {
-        if (!this.isBoundsDirty)
-            return;
-        if (this.vertices && this.vertices.length > 0) {
-            this.boundingBox.copy(this.localBoundingBox).applyMatrix4(this.worldMatrix);
-            this.boundingSphere.copy(this.localBoundingSphere).applyMatrix4(this.worldMatrix);
-        }
-        else {
-            const pos = this.getWorldPosition(Mesh.scratchVec);
-            this.boundingBox.set(pos, pos);
-            this.boundingSphere.set(pos, 0);
+        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;
         }
-        this.isBoundsDirty = false;
+        return false;
     }
-    computeBoundingBox() {
-        this.computeBounds();
-        return this.boundingBox;
+    clearPrograms() {
+        for (const program of this.programs)
+            Program.release(this.context, program);
+        this.programs = [];
+        this.nbPrograms = 0;
+        this.materials = [];
     }
-    computeBoundingSphere() {
-        this.computeBounds();
-        return this.boundingSphere;
+    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);
+        const hitPoint = ray.intersectSphere(sphere, Mesh.scratchHit);
         if (!hitPoint)
             return null;
         if (precise && this.vertices && (this.primitive === 'TRIANGLES' || this.primitive === 'TRIANGLE_STRIP'))
-            return this.raycastTriangles(ray);
-        return { distance: ray.origin.getDistance(hitPoint), point: hitPoint };
-    }
-    raycastTriangles(ray) {
-        const inverse = Mesh.scratchInverse.copy(this.worldMatrix).invertAffine();
-        const localRay = Mesh.scratchRay.set(inverse.transformPoint(ray.origin, Mesh.scratchVec), inverse.transformDirection(ray.direction, Mesh.scratchDir));
-        const strip = this.primitive === 'TRIANGLE_STRIP';
-        let best = null;
-        let bestDistance = Infinity;
-        for (const subMesh of this.subMeshes) {
-            const end = subMesh.start + subMesh.count;
-            for (let i = subMesh.start; i + 2 < end; i += strip ? 1 : 3) {
-                this.getVertex(i, Mesh.scratchA);
-                if (strip && (i - subMesh.start) % 2 === 1) {
-                    this.getVertex(i + 2, Mesh.scratchB);
-                    this.getVertex(i + 1, Mesh.scratchC);
-                }
-                else {
-                    this.getVertex(i + 1, Mesh.scratchB);
-                    this.getVertex(i + 2, Mesh.scratchC);
-                }
-                const local = localRay.intersectTriangle(Mesh.scratchA, Mesh.scratchB, Mesh.scratchC, false, Mesh.scratchHit);
-                if (!local)
-                    continue;
-                const world = this.worldMatrix.transformPoint(local, Mesh.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;
-    }
-    getVertex(index, target) {
-        const vertices = this.vertices;
-        const size = this.itemSize || 3;
-        const offset = (this.indices ? this.indices[index] : index) * size;
-        return target.setScalar(vertices[offset], vertices[offset + 1], size > 2 ? vertices[offset + 2] : 0);
+            return raycastTriangles(this, ray);
+        return { distance: ray.origin.getDistance(hitPoint), point: new Vec3().copy(hitPoint) };
     }
     useBasicMaterial(options) {
         const mat = new Material();
@@ -2287,12 +2528,8 @@ class Mesh {
             this.context.deleteTexture(this.WebGLTexture);
         this.WebGLTexture = null;
         this.ownsTexture = false;
-    }
-    setWorldMatrix(worldMatrix) {
-        this.worldMatrix.copy(worldMatrix).multiply(this.modelMatrix);
-        this.isBoundsDirty = true;
-        this.isNormalMatrixDirty = true;
-        this.isWorldDirty = false;
+        this.textureSource = null;
+        this.textureOptions = undefined;
     }
     setTexture(img, options) {
         const texture = Texture.create(img, this.context, options);
@@ -2301,16 +2538,14 @@ class Mesh {
         this.releaseTexture();
         this.WebGLTexture = texture;
         this.ownsTexture = true;
-        for (let program of this.programs)
-            if (program.sampler === undefined)
-                program.sampler = this.context.getUniformLocation(program, 'uSampler');
+        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);
-            for (let program of this.programs)
-                if (program[name] === undefined)
-                    program[name] = this.context.getUniformLocation(program, 'u' + this.ucfirst(name));
+            syncCustomUniform(this.context, this.programs, name);
         }
     }
     setCustomUniform(name, value) {
@@ -2331,66 +2566,48 @@ class Mesh {
         }
         return indices instanceof Uint16Array ? indices : new Uint16Array(indices);
     }
-    static initializedPrograms = new WeakSet();
-    createProgram() {
-        let program = this.programs[this.nbPrograms];
-        if (!Mesh.initializedPrograms.has(program)) {
-            Mesh.initializedPrograms.add(program);
-            this.addProgramAttribute('vertexPosition');
-            this.addProgramAttribute('vertexNormal');
-            this.addProgramAttribute('textureCoord');
-            this.addProgramUniform('modelMatrix');
-            this.addProgramUniform('normalMatrix');
-            this.addProgramUniform('viewMatrix');
-            this.addProgramUniform('projectionMatrix');
-            this.addProgramUniform('time');
-            this.addProgramUniform('screenResolution');
-            this.addProgramUniform('sampler');
-            this.addProgramUniform('hasTexture');
-            this.addProgramUniform('nbLights');
-            this.addProgramUniform('lightPosition');
-            this.addProgramUniform('lightDiffuse');
-            this.addProgramUniform('lightSpecular');
-            this.addProgramUniform('lightDirection');
-            this.addProgramUniform('lightAttenuation');
-            this.addProgramUniform('lightCutoff');
-            this.addProgramUniform('lightExponent');
-            this.addProgramUniform('lightType');
-            this.addProgramUniform('lightPositionType');
-            this.addProgramUniform('lightDiffuseCutoff');
-            this.addProgramUniform('lightSpecularExponent');
-            this.addProgramUniform('ambientLight');
-            this.addProgramUniform('ambientColor');
-            this.addProgramUniform('cameraPosition');
-            this.addProgramUniform('hasFog');
-            this.addProgramUniform('fogColor');
-            this.addProgramUniform('fogNear');
-            this.addProgramUniform('fogFar');
-            if (program.screenResolution) {
-                this.renderer.useProgram(program);
-                let viewport = this.context.getParameter(this.context.VIEWPORT);
-                if (viewport && viewport.length >= 4)
-                    this.context.uniform2f(program.screenResolution, viewport[2], viewport[3]);
-            }
-        }
-        for (let property in this.customUniforms)
-            if (this.customUniforms.hasOwnProperty(property) && program[property] === undefined)
-                this.addProgramUniform(property);
-        for (let mat of this.materials)
-            for (let property in mat.uniforms)
-                if (mat.uniforms.hasOwnProperty(property) && program[property] === undefined)
-                    this.addProgramUniform(property);
-        this.nbPrograms++;
+    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;
     }
-    addProgramAttribute(name) {
-        this.programs[this.nbPrograms][name] = this.context.getAttribLocation(this.programs[this.nbPrograms], 'a' + this.ucfirst(name));
+    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();
     }
-    addProgramUniform(name) {
-        const ucName = 'u' + this.ucfirst(name);
-        let loc = this.context.getUniformLocation(this.programs[this.nbPrograms], ucName);
-        if (loc === null)
-            loc = this.context.getUniformLocation(this.programs[this.nbPrograms], ucName + '[0]');
-        this.programs[this.nbPrograms][name] = loc;
+    createProgram() {
+        initProgramLocations(this.context, this.programs[this.nbPrograms], this.customUniforms, this.materials);
+        this.nbPrograms++;
     }
     activateBlendMode() {
         this.blendMode = true;
@@ -2409,178 +2626,17 @@ class Mesh {
         this.depthWrite = enabled;
         return this;
     }
-    computeWorldMatrix(graph) {
-        const modelChanged = this.updateModelMatrix();
-        const changed = this.isWorldDirty || modelChanged;
-        if (changed)
-            this.setWorldMatrix(graph.getWorldMatrix());
-        graph.pushModelMatrix(this.worldMatrix);
-        for (let child of this.children) {
-            if (changed)
-                child.isWorldDirty = true;
-            child.computeWorldMatrix(graph);
-        }
-        graph.popModelMatrix();
-    }
     render(projectionMatrix, viewMatrix, lights, time, blendMode, cameraPosition, fog, frame) {
         if (!this.isActive())
             return;
         this.renderSelf(projectionMatrix, viewMatrix, lights, time, blendMode, cameraPosition, fog, frame);
-        for (let child of this.children)
+        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;
-        const context = this.context;
-        const renderer = this.renderer;
-        const state = renderer.state;
-        for (let i = 0; i < this.nbSubMeshes; i++) {
-            const program = this.programs[i] || this.programs[this.nbPrograms - 1];
-            renderer.useProgram(program);
-            if (!frame || state.frameOfProgram.get(program) !== frame.id) {
-                if (frame)
-                    state.frameOfProgram.set(program, frame.id);
-                this.uploadFrameUniforms(program, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame);
-            }
-            const material = this.materials[i] || this.materials[this.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 (let property in materialUniforms)
-                        if (materialUniforms.hasOwnProperty(property) && program[property])
-                            uploadUniform(context, program[property], materialUniforms[property]);
-                }
-            }
-            let attributeMask = 0;
-            if (this.indices)
-                renderer.bindBuffer('ELEMENT_ARRAY_BUFFER', this.indexBuffer);
-            if (program.vertexPosition !== -1 && program.vertexPosition !== undefined && this.vertexBuffer) {
-                renderer.bindBuffer('ARRAY_BUFFER', this.vertexBuffer);
-                renderer.vertexAttribPointer(program.vertexPosition, this.itemSize, 'FLOAT', false, 0, 0);
-                attributeMask |= 1 << program.vertexPosition;
-            }
-            if (this.normals && program.vertexNormal !== -1 && program.vertexNormal !== undefined) {
-                renderer.bindBuffer('ARRAY_BUFFER', this.normalBuffer);
-                renderer.vertexAttribPointer(program.vertexNormal, 3, 'FLOAT', false, 0, 0);
-                attributeMask |= 1 << program.vertexNormal;
-            }
-            if (this.uvs && program.textureCoord !== -1 && program.textureCoord !== undefined) {
-                renderer.bindBuffer('ARRAY_BUFFER', this.texCoordBuffer);
-                renderer.vertexAttribPointer(program.textureCoord, 2, 'FLOAT', false, 0, 0);
-                attributeMask |= 1 << program.textureCoord;
-            }
-            renderer.setAttributeMask(attributeMask);
-            if (this.WebGLTexture) {
-                context.activeTexture(context.TEXTURE0);
-                context.bindTexture(context.TEXTURE_2D, this.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, this.worldMatrix.toArray());
-            if (program.normalMatrix) {
-                this.computeNormalMatrix();
-                context.uniformMatrix3fv(program.normalMatrix, false, this.normalMatrix.toArray());
-            }
-            for (let property in this.customUniforms)
-                if (this.customUniforms.hasOwnProperty(property) && program[property])
-                    uploadUniform(context, program[property], this.customUniforms[property]);
-            renderer[this.drawMethod](this.primitive, this.subMeshes[i], this.indexType);
-        }
-    }
-    static lightTypeValue(type) {
-        return type === 'directional' ? 0 : type === 'point' ? 1 : 2;
-    }
-    static 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;
-    }
-    uploadFrameUniforms(program, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame) {
-        const context = this.context;
-        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 || Mesh.packVec4(lights.position, (lights.type || []).map(Mesh.lightTypeValue)));
-            if (program.lightDiffuseCutoff && lights.diffuse && lights.diffuse.length > 0)
-                context.uniform4fv(program.lightDiffuseCutoff, lights.packedDiffuse || Mesh.packVec4(lights.diffuse, lights.cutoff || []));
-            if (program.lightSpecularExponent && lights.specular && lights.specular.length > 0)
-                context.uniform4fv(program.lightSpecularExponent, lights.packedSpecular || Mesh.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) {
-                Mesh.scratchView.toArray().set(viewMatrix);
-                camera = Mesh.scratchView.invertAffine().getTranslation(Mesh.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);
+        this.renderer.drawMesh(this, projectionMatrix, viewMatrix, lights, time, cameraPosition, fog, frame);
     }
     destroy() {
         this.clearPrograms();
@@ -2593,15 +2649,12 @@ class Mesh {
         if (this.texCoordBuffer)
             this.renderer.deleteBuffer(this.texCoordBuffer), this.texCoordBuffer = null;
         this.releaseTexture();
-        for (let child of this.children) {
+        for (const child of this.children) {
             child.parent = null;
             child.destroy();
         }
         this.children = [];
     }
-    ucfirst(string) {
-        return string.charAt(0).toUpperCase() + string.slice(1);
-    }
 }
 
 class BasicMesh {
@@ -2625,22 +2678,23 @@ class BasicMesh {
 
 class Line extends BasicMesh {
     thickness;
-    constructor(vertices, thickness) {
+    constructor(vertices = [], thickness = 2.0) {
         super();
-        this.thickness = thickness ? thickness * 0.5 : 1.0;
-        if (vertices && vertices.length > 0 && vertices[0] instanceof Vec3) {
-            const flat = [];
+        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;
-        }
-        else
-            this.vertices = vertices || [];
-        this.itemSize = 3;
+        this.vertices = flat;
         this.subMeshes = [
             new SubMesh(0, this.vertices.length / this.itemSize)
         ];
-        this.primitive = 'LINE_STRIP';
+        return this;
     }
 }
 
@@ -2666,21 +2720,17 @@ class FullscreenQuad extends BasicMesh {
 }
 
 class Quad extends BasicMesh {
-    constructor(sizeOrWidth, height) {
+    constructor(size = new Vec2(2.0, 2.0)) {
         super();
         let width;
         let h;
-        if (sizeOrWidth instanceof Vec2) {
-            width = sizeOrWidth.x * 0.5;
-            h = sizeOrWidth.y * 0.5;
-        }
-        else if (sizeOrWidth instanceof Rect) {
-            width = sizeOrWidth.size.x * 0.5;
-            h = sizeOrWidth.size.y * 0.5;
+        if (size instanceof Rect) {
+            width = size.size.x * 0.5;
+            h = size.size.y * 0.5;
         }
         else {
-            width = sizeOrWidth ? sizeOrWidth * 0.5 : 1.0;
-            h = height ? height * 0.5 : 1.0;
+            width = size.x * 0.5;
+            h = size.y * 0.5;
         }
         this.vertices = [width, -h, 0.0,
             -width, -h, 0.0,
@@ -2702,21 +2752,17 @@ class Quad extends BasicMesh {
 
 class MultiQuad extends BasicMesh {
     quad;
-    constructor(sizeOrWidth, height) {
+    constructor(size = new Vec2(2.0, 2.0)) {
         super();
         let width;
         let h;
-        if (sizeOrWidth instanceof Vec2) {
-            width = sizeOrWidth.x * 0.5;
-            h = sizeOrWidth.y * 0.5;
-        }
-        else if (sizeOrWidth instanceof Rect) {
-            width = sizeOrWidth.size.x * 0.5;
-            h = sizeOrWidth.size.y * 0.5;
+        if (size instanceof Rect) {
+            width = size.size.x * 0.5;
+            h = size.size.y * 0.5;
         }
         else {
-            width = sizeOrWidth ? sizeOrWidth * 0.5 : 1.0;
-            h = height ? height * 0.5 : 1.0;
+            width = size.x * 0.5;
+            h = size.y * 0.5;
         }
         this.quad = {
             vertices: new Float32Array([width, -h, 0.0,
@@ -2758,21 +2804,14 @@ class MultiQuad extends BasicMesh {
 }
 
 class Cube extends BasicMesh {
-    constructor(sizeOrDimensions = 1.0, flat = false) {
+    constructor(size = new Vec3(2.0, 2.0, 2.0), flat = false) {
         super();
-        let sx, sy, sz;
-        if (sizeOrDimensions instanceof Vec3) {
-            const half = sizeOrDimensions.clone().halve();
-            sx = half.x || 0.5;
-            sy = half.y || 0.5;
-            sz = half.z || 0.5;
-        }
-        else {
-            const s = sizeOrDimensions ? sizeOrDimensions * 0.5 : 1.0;
-            sx = s;
-            sy = s;
-            sz = s;
-        }
+        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,
@@ -2835,7 +2874,7 @@ class Cube extends BasicMesh {
 }
 
 class Sphere extends BasicMesh {
-    constructor() {
+    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
         ];
@@ -2846,6 +2885,28 @@ class Sphere extends BasicMesh {
         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;
+                    }
+            }
+        }
     }
 }
 
@@ -2865,27 +2926,13 @@ class Hemisphere extends BasicMesh {
 }
 
 class Plane extends BasicMesh {
-    constructor(sizeOrWidth = 1.0, heightOrWidthSegments = 1.0, widthOrHeightSegments = 1, heightSegmentsOrOrientation, orientation = 'xz') {
+    constructor(size = new Vec2(1.0, 1.0), segments = new Vec2(1, 1), orientation = 'xz') {
         super();
-        let w;
-        let h;
-        let gridX;
-        let gridY;
-        let orient;
-        if (sizeOrWidth instanceof Vec2) {
-            w = sizeOrWidth.x || 1.0;
-            h = sizeOrWidth.y || 1.0;
-            gridX = Utils.clamp(Utils.floor(heightOrWidthSegments || 1, 0), 1, Infinity);
-            gridY = Utils.clamp(Utils.floor(widthOrHeightSegments || 1, 0), 1, Infinity);
-            orient = (typeof heightSegmentsOrOrientation === 'string' ? heightSegmentsOrOrientation : orientation) || 'xz';
-        }
-        else {
-            w = sizeOrWidth || 1.0;
-            h = heightOrWidthSegments || 1.0;
-            gridX = Utils.clamp(Utils.floor(widthOrHeightSegments || 1, 0), 1, Infinity);
-            gridY = Utils.clamp(Utils.floor((typeof heightSegmentsOrOrientation === 'number' ? heightSegmentsOrOrientation : 1) || 1, 0), 1, Infinity);
-            orient = orientation || 'xz';
-        }
+        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;
@@ -2931,13 +2978,14 @@ class Plane extends BasicMesh {
 }
 
 class Cylinder extends BasicMesh {
-    constructor(radiusTop = 1.0, radiusBottom = 1.0, height = 1.0, radialSegments = 16, heightSegments = 1, openEnded = false) {
+    constructor(radii = new Vec2(1.0, 1.0), height = 1.0, radialSegments = 16, heightSegments = 1, openEnded = false) {
         super();
-        const rTop = radiusTop !== undefined ? radiusTop : 1.0;
-        const rBottom = radiusBottom !== undefined ? radiusBottom : 1.0;
-        const h = height || 1.0;
-        const radSeg = Utils.clamp(Utils.floor(radialSegments || 16, 0), 3, Infinity);
-        const hSeg = Utils.clamp(Utils.floor(heightSegments || 1, 0), 1, Infinity);
+        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 = [];
@@ -2978,7 +3026,7 @@ class Cylinder extends BasicMesh {
                 indices.push(a, b, d);
                 indices.push(b, c, d);
             }
-        if (!openEnded) {
+        if (!open) {
             if (rTop > 0) {
                 const centerIndexTop = index++;
                 vertices.push(0, halfH, 0);
@@ -3086,13 +3134,10 @@ class CustomMesh {
         ];
     }
     static toFloat32(array) {
-        if (array.length > 0 && array[0] instanceof Vec3) {
-            const flat = new Float32Array(array.length * 3);
-            for (let i = 0; i < array.length; i++)
-                array[i].toArray(flat, i * 3);
-            return flat;
-        }
-        return array instanceof Float32Array ? array.slice(0) : new Float32Array(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);
@@ -3172,6 +3217,284 @@ class CustomMesh {
     }
 }
 
+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;
@@ -3185,9 +3508,9 @@ class DirectionalLight {
         this.specular = new Vec3(0.8, 0.8, 0.8);
         this.type = 'directional';
         if (directionOrOptions)
-            if (directionOrOptions instanceof Vec3 || Array.isArray(directionOrOptions))
+            if (directionOrOptions instanceof Vec3)
                 this.setDirection(directionOrOptions);
-            else if (typeof directionOrOptions === 'object') {
+            else {
                 if (directionOrOptions.direction)
                     this.setDirection(directionOrOptions.direction);
                 if (directionOrOptions.diffuse)
@@ -3198,17 +3521,17 @@ class DirectionalLight {
                     this.setPosition(directionOrOptions.position);
             }
     }
-    setPosition(xOrVec, y, z) {
-        assignVec3(this.position, xOrVec, y, z);
+    setPosition(position) {
+        this.position.copy(position);
     }
-    setDirection(xOrVec, y, z) {
-        assignVec3(this.direction, xOrVec, y, z).normalize();
+    setDirection(direction) {
+        this.direction.copy(direction).normalize();
     }
-    setDiffuse(xOrVec, y, z) {
-        assignVec3(this.diffuse, xOrVec, y, z);
+    setDiffuse(diffuse) {
+        this.diffuse.copy(diffuse);
     }
-    setSpecular(xOrVec, y, z) {
-        assignVec3(this.specular, xOrVec, y, z);
+    setSpecular(specular) {
+        this.specular.copy(specular);
     }
 }
 
@@ -3223,9 +3546,9 @@ class PointLight extends DirectionalLight {
         this.quadraticAttenuation = 0;
         this.type = 'point';
         if (positionOrOptions)
-            if (positionOrOptions instanceof Vec3 || Array.isArray(positionOrOptions))
+            if (positionOrOptions instanceof Vec3)
                 this.setPosition(positionOrOptions);
-            else if (typeof positionOrOptions === 'object') {
+            else {
                 if (positionOrOptions.position)
                     this.setPosition(positionOrOptions.position);
                 if (positionOrOptions.diffuse)
@@ -3261,7 +3584,7 @@ class SpotLight extends PointLight {
         this.exponent = 0;
         this.direction = new Vec3(1.0, 0.0, 0.0);
         this.type = 'spot';
-        if (positionOrOptions && typeof positionOrOptions === 'object' && !(positionOrOptions instanceof Vec3) && !Array.isArray(positionOrOptions)) {
+        if (positionOrOptions && !(positionOrOptions instanceof Vec3)) {
             if (positionOrOptions.direction)
                 this.setDirection(positionOrOptions.direction);
             if (positionOrOptions.cutoff !== undefined)
@@ -3276,8 +3599,8 @@ class SpotLight extends PointLight {
     setExponent(value) {
         this.exponent = value;
     }
-    setDirection(xOrVec, y, z) {
-        assignVec3(this.direction, xOrVec, y, z);
+    setDirection(direction) {
+        this.direction.copy(direction);
     }
 }
 
@@ -3285,31 +3608,21 @@ class AmbientLight {
     diffuse;
     intensity;
     type;
-    constructor(rOrVec = 1.0, g = 1.0, b = 1.0, intensity = 1.0) {
-        this.diffuse = new Vec3();
-        if (rOrVec instanceof Vec3) {
-            this.diffuse.copy(rOrVec);
-            this.intensity = g !== undefined ? g : 1.0;
-        }
-        else {
-            this.diffuse.setScalar(rOrVec, g, b);
-            this.intensity = intensity;
-        }
+    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(xOrVec, y, z) {
-        if (typeof xOrVec === 'number')
-            this.diffuse.setScalar(xOrVec, y ?? 0, z ?? 0);
-        else
-            assignVec3(this.diffuse, xOrVec);
+    setColor(diffuse) {
+        this.diffuse.copy(diffuse);
         return this;
     }
     setIntensity(intensity) {
         this.intensity = intensity;
         return this;
     }
-    getColor() {
-        return this.diffuse;
+    getColor(target = new Vec3()) {
+        return target.copy(this.diffuse);
     }
     get color() {
         return this.diffuse;
@@ -3319,4 +3632,19 @@ class AmbientLight {
     }
 }
 
-export { AmbientLight, BasicMesh, BasicShader, Camera, Cannon, Cube, CustomMesh, Cylinder, DirectionalLight, FullscreenQuad, Hemisphere, Lights, Line, MAX_LIGHTS, Material, Mesh, MultiQuad, NormalShader, OrbitControls, OrthographicCamera, PerspectiveCamera, PhongShader, Plane, PointLight, Program, Quad, RenderTarget, Renderer, Scene, Shader, Sphere, SpotLight, SubMesh, Texture, Uniform, VWing, eDrawMethod };
+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 };