@woosh/meep-engine 2.97.0 → 2.98.1

package/build/meep.module.js

@@ -53175,7 +53175,7 @@ const SCRATCH_UINT32_TRAVERSAL_STACK = new Uint32Array(781250);
  */
 SCRATCH_UINT32_TRAVERSAL_STACK.pointer = 0;
 
-const fabsf$1 = Math.abs;
+const abs = Math.abs;
 
 /**
  * NOTES:
@@ -53212,7 +53212,7 @@ function aabb3_intersects_ray(
     const diff_x = origin_x - center_x;
 
 
-    if (diff_x * direction_x >= 0.0 && fabsf$1(diff_x) > extents_x) {
+    if (diff_x * direction_x >= 0.0 && abs(diff_x) > extents_x) {
         return false;
     }
 
@@ -53224,7 +53224,7 @@ function aabb3_intersects_ray(
     const diff_y = origin_y - center_y;
 
 
-    if (diff_y * direction_y >= 0.0 && fabsf$1(diff_y) > extents_y) {
+    if (diff_y * direction_y >= 0.0 && abs(diff_y) > extents_y) {
         return false;
     }
 
@@ -53236,28 +53236,28 @@ function aabb3_intersects_ray(
     const diff_z = origin_z - center_z;
 
 
-    if (diff_z * direction_z >= 0.0 && fabsf$1(diff_z) > extents_z) {
+    if (diff_z * direction_z >= 0.0 && abs(diff_z) > extents_z) {
         return false;
     }
 
-    const abs_direction_y = fabsf$1(direction_y);
-    const abs_direction_z = fabsf$1(direction_z);
+    const abs_direction_y = abs(direction_y);
+    const abs_direction_z = abs(direction_z);
 
-    const f0 = fabsf$1(direction_y * diff_z - direction_z * diff_y);
+    const f0 = abs(direction_y * diff_z - direction_z * diff_y);
 
     if (f0 > extents_y * abs_direction_z + extents_z * abs_direction_y) {
         return false;
     }
 
-    const abs_direction_x = fabsf$1(direction_x);
+    const abs_direction_x = abs(direction_x);
 
-    const f1 = fabsf$1(direction_z * diff_x - direction_x * diff_z);
+    const f1 = abs(direction_z * diff_x - direction_x * diff_z);
 
     if (f1 > extents_x * abs_direction_z + extents_z * abs_direction_x) {
         return false;
     }
 
-    const f2 = fabsf$1(direction_x * diff_y - direction_y * diff_x);
+    const f2 = abs(direction_x * diff_y - direction_y * diff_x);
 
     return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
 }
@@ -53336,8 +53336,8 @@ function bvh_query_leaves_ray(
         if (child_1 !== NULL_NODE) {
 
             // this is not a leaf node, push children onto traversal stack
-            stack$9[stack$9.pointer++] = child_1;
             stack$9[stack$9.pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack$9[stack$9.pointer++] = child_1;
 
         } else {
             // leaf node
@@ -53631,7 +53631,11 @@ function rgb2uint24(r, g, b) {
 }
 
 function convert(c) {
-    return (c < 0.0031308) ? c * 12.92 : 1.055 * (Math.pow(c, 0.41666)) - 0.055;
+    if (c < 0.0031308) {
+        return c * 12.92;
+    } else {
+        return 1.055 * (Math.pow(c, 0.4166666666666667)) - 0.055;
+    }
 }
 
 /**
@@ -53641,10 +53645,17 @@ function convert(c) {
  * @param {number[]|ArrayLike<number>} input
  * @param {number} input_offset
  */
-function linear_to_sRGB(output, output_offset, input, input_offset) {
-    output[output_offset] = convert(input[input_offset]);
-    output[output_offset + 1] = convert(input[input_offset + 1]);
-    output[output_offset + 2] = convert(input[input_offset + 2]);
+function linear_to_sRGB(
+    output, output_offset,
+    input, input_offset
+) {
+    const r = input[input_offset];
+    const g = input[input_offset + 1];
+    const b = input[input_offset + 2];
+
+    output[output_offset] = convert(r);
+    output[output_offset + 1] = convert(g);
+    output[output_offset + 2] = convert(b);
 }
 
 /**
@@ -53653,7 +53664,11 @@ function linear_to_sRGB(output, output_offset, input, input_offset) {
  * @return {number|number}
  */
 function convert_channel_sRGB_to_linear(c) {
-    return (c < 0.04045) ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+    if (c < 0.04045) {
+        return c * 0.0773993808;
+    } else {
+        return Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+    }
 }
 
 /**
@@ -53663,10 +53678,18 @@ function convert_channel_sRGB_to_linear(c) {
  * @param {number[]} input
  * @param {number} input_offset
  */
-function sRGB_to_linear(output, output_offset, input, input_offset) {
-    output[output_offset] = convert_channel_sRGB_to_linear(input[input_offset]);
-    output[output_offset + 1] = convert_channel_sRGB_to_linear(input[input_offset + 1]);
-    output[output_offset + 2] = convert_channel_sRGB_to_linear(input[input_offset + 2]);
+function sRGB_to_linear(
+    output, output_offset,
+    input, input_offset
+) {
+
+    const sR = input[input_offset];
+    const sG = input[input_offset + 1];
+    const sB = input[input_offset + 2];
+
+    output[output_offset] = convert_channel_sRGB_to_linear(sR);
+    output[output_offset + 1] = convert_channel_sRGB_to_linear(sG);
+    output[output_offset + 2] = convert_channel_sRGB_to_linear(sB);
 }
 
 /**
@@ -54951,19 +54974,22 @@ function ceilPowerOfTwo(v) {
  * @param {number} b_offset
  * @param {number} length How many elements should be moved
  */
-function array_swap(a, a_offset, b, b_offset, length) {
-
-    let i, j, k;
+function array_swap(
+    a, a_offset,
+    b, b_offset,
+    length
+) {
 
-    for (k = 0; k < length; k++) {
-        i = a_offset + k;
-        j = b_offset + k;
+    for (let k = 0; k < length; k++) {
+        const i = a_offset + k;
+        const j = b_offset + k;
 
-        const t = b[j];
+        const swap = b[j];
 
         b[j] = a[i];
-        a[i] = t;
+        a[i] = swap;
     }
+
 }
 
 //
@@ -58823,25 +58849,138 @@ class TerrainTileManager {
     }
 }
 
+class WebGLRendererPool {
+
+    used = new Set();
+
+    get() {
+        const canvas = document.createElement('canvas');
+        const context = canvas.getContext('webgl2', { antialias: true });
+
+        const renderer = new WebGLRenderer({
+            alpha: true,
+            context,
+            canvas
+        });
+
+        this.used.add(renderer);
+        return renderer;
+    }
+
+    /**
+     *
+     * @param {THREE.WebGLRenderer} renderer
+     * @returns {boolean}
+     */
+    release(renderer) {
+        if (!this.used.has(renderer)) {
+            //not from this pool
+            return false;
+        }
+        this.used.delete(renderer);
+
+        renderer.forceContextLoss();
+        renderer.dispose();
+        renderer.domElement = null;
+
+        return true;
+    }
+
+    /**
+     * After callback returns, renderer is released back into the pool
+     * @template T
+     * @param {function(renderer:WebGLRenderer):T} callback
+     * @param {*} [thisArg]
+     */
+    use(callback, thisArg) {
+
+        const renderer = this.get();
+
+        try {
+            const result = callback.call(thisArg, renderer);
+
+            if (result instanceof Promise) {
+            }
+
+            return result;
+
+        } finally {
+
+            this.release(renderer);
+        }
+
+    }
+
+    /**
+     * @template T
+     * @param {function(renderer:WebGLRenderer):Promise<T>} callback
+     * @param {*} [thisArg]
+     */
+    async useAsync(callback, thisArg) {
+
+        const renderer = this.get();
+
+        try {
+            await callback.call(thisArg, renderer);
+        } finally {
+            this.release(renderer);
+        }
+    }
+
+    static global = new WebGLRendererPool();
+}
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {THREE.DataTexture} texture
+ */
+function writeSample2DDataToDataTexture(sampler, texture) {
+    if (sampler.itemSize === 1) {
+        if (texture.format !== RedFormat && texture.format !== LuminanceFormat) {
+            throw new Error('itemSize is 1 and texture.format is not RedFormat');
+        }
+    } else if (sampler.itemSize === 2) {
+        if (texture.format !== RGFormat) {
+            throw new Error('itemSize is 2 and texture.format is not RGFormat');
+        }
+    } else if (sampler.itemSize === 3) {
+        if (texture.format !== RGBFormat) {
+            throw new Error('itemSize is 2 and texture.format is not RGBFormat');
+        }
+    } else if (sampler.itemSize === 4) {
+        if (texture.format !== RGBAFormat) {
+            throw new Error('itemSize is 2 and texture.format is not RGBAFormat');
+        }
+    } else {
+        throw new Error('Unsupported itemSize');
+    }
+
+    if (texture.image.data !== sampler.data) {
+        // dispose of previous texture data
+        texture.dispose();
+    }
+
+    texture.image.data = sampler.data;
+    texture.image.width = sampler.width;
+    texture.image.height = sampler.height;
+
+    texture.needsUpdate = true;
+}
+
 /**
  * Created by Alex on 10/11/2014.
  */
 
-const AmbientOcclusionShader = function () {
+
+const NormalMapShader = function () {
     return {
 
         uniforms: {
 
-            "normalMap": { type: "t", value: null },
             "heightMap": { type: "t", value: null },
-            "world_size": { type: "v2", value: new Vector2$1(512, 512) },
-            "rayLength": { type: 'f', value: 17 }
-
-        },
+            "resolution": { type: "v2", value: new Vector2$1(512, 512) }
 
-        defines: {
-            'NUM_SAMPLES': 64,
-            'NUM_RINGS': 7,
         },
 
         vertexShader: [
@@ -58857,102 +58996,53 @@ const AmbientOcclusionShader = function () {
 
         ].join("\n"),
 
+        /**
+         * Reference: https://stackoverflow.com/questions/49640250/calculate-normals-from-heightmap
+         */
         fragmentShader: [
-            `
-            uniform sampler2D normalMap;
-            uniform sampler2D heightMap;
-            uniform float rayLength;
-            uniform vec2 world_size;
+            "uniform vec2 resolution;",
+            "uniform sampler2D heightMap;",
 
-            varying vec2 vUv;
+            "#define sqrt2 1.41421356237;",
+
+            "varying vec2 vUv;",
+
+            "void main() {",
+            "   float uStep = 1.0/resolution.x;",
+            "   float vStep = 1.0/resolution.y;",
+            //
+            //
+            "   float top = texture2D( heightMap, vUv + vec2(0, -vStep)).x;",
+            "   float bottom = texture2D( heightMap, vUv + vec2(0, +vStep)).x;",
+            "   float left = texture2D( heightMap, vUv + vec2(-uStep, 0)).x;",
+            "   float right = texture2D( heightMap, vUv + vec2(+uStep, 0)).x;",
+            //
+
+            "   float dX = (right ) - ( left);",
+            "   float dY = (  bottom ) - (  top);",
+            "   float dZ = 2.0;",
+            "   vec3 n = normalize(vec3(dX, dY, dZ));",
+
+            "   gl_FragColor = vec4( n*0.5+0.5, 1.0 );",
+
+            "}"
 
-            vec3 get(float x, float y){
-               vec2 _uv = vUv.xy + vec2(x,y) / world_size;
-               float h = texture2D(heightMap, _uv).x;
-               return vec3( _uv.x * world_size.x, h, _uv.y * world_size.y );
-            }
-            
-            float hash1( float n )
-            {
-                return fract( n*17.0*fract( n*0.3183099 ) );
-            }
-            
-            float hash1( vec2 p )
-            {
-                p  = 50.0*fract( p*0.3183099 );
-                return fract( p.x*p.y*(p.x+p.y) );
-            }
-            
-            // Non-sin based hash function, fast and has good randomness
-            float hash12(vec2 p){
-                vec3 p3  = fract(vec3(p.xyx) * .1031);
-                p3 += dot(p3, p3.yzx + 33.33);
-                return fract((p3.x + p3.y) * p3.z);
-            }
-            
-            const float bias = 0.001;
-            
-            float pow2(float x){
-                return x*x;
-            }
-    
-            float getOcclusion(vec3 origin, vec3 normal, vec3 hit_position){
-                vec3 viewDelta = hit_position - origin;
-                
-                float viewDistance = length( viewDelta );
-                
-                float vn = dot( normal, viewDelta );
-                float a2 = (vn) / viewDistance - bias;
-                float a1 = (1.0 + pow2( viewDistance ) );
-                
-                return max(0.0, a2) / a1;
-            }
-                
-            const float PI2 = 6.28318530717958;
-            const float kernelRadius = 100.0;
-    
-            const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
-            const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
-            
-            float getAmbientOcclusion(vec3 world_position, vec3 world_normal){
-                // jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
-                float angle = hash12( vUv  ) * PI2;
-                vec2 radius = vec2( rayLength * INV_NUM_SAMPLES );
-                
-                float occlusionSum = 0.0;
-                float weightSum = 0.0;
-                
-                for( int i = 0; i < NUM_SAMPLES; i ++ ) {
-                    vec2 sampleUv = vec2( cos( angle ), sin( angle ) ) * radius * float(i+1);
-                    
-                    angle += ANGLE_STEP;
-                        
-                    vec3 sample_pos = get(sampleUv.x, sampleUv.y);
-                
-                    occlusionSum += getOcclusion(world_position, world_normal, sample_pos);
-                    weightSum += 1.0;
-                }
-                
-                return occlusionSum/weightSum;
-            }
-            
-            void main() {
-               vec3 pos = get(0.0, 0.0);
-               
-               vec3 normal = texture2D( normalMap, vUv ).xzy;
-               
-               float occlusion = getAmbientOcclusion(pos, normal);
-               
-               float incident = 1.0 - occlusion;
-               
-               gl_FragColor = vec4(pow(incident,10.0), 0.0, 0.0, 1.0);
-            }
-            `
         ].join('\n')
 
     }
 };
 
+const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
+        varying vec2 vUv;
+
+        void main() {
+
+            vUv = uv;
+                
+            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
+            
+        }`;
+
 const FULL_SCREEN_TRIANGLE_GEOMETRY = new BufferGeometry();
 FULL_SCREEN_TRIANGLE_GEOMETRY.setAttribute(
     'position',
@@ -58970,17 +59060,6 @@ FULL_SCREEN_TRIANGLE_GEOMETRY.setAttribute(
     )
 );
 
-const FULL_SCREEN_QUAD_VERTEX_SHADER = `        
-        varying vec2 vUv;
-
-        void main() {
-
-            vUv = uv;
-                
-            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-            
-        }`;
-
 /**
  * Created by Alex on 09/11/2014.
  */
@@ -58992,7 +59071,7 @@ const FULL_SCREEN_QUAD_VERTEX_SHADER = `
  * @param {number} width
  * @param {number} height
  * @param {{vertexShader?:string,fragmentShader:string, uniforms?:Object, defines?:Object}} processShader
- * @param {Uint8Array} [destination]
+ * @param {Uint8Array|Uint8ClampedArray} [destination]
  * @return {{array: Uint8Array, renderer: WebGLRenderer}}
  */
 function processTexture(
@@ -59003,7 +59082,7 @@ function processTexture(
     destination
 ) {
     if (destination === undefined) {
-        destination = new Uint8Array(width * height * 4);
+        destination = new Uint8ClampedArray(width * height * 4);
     }
 
     //make a webgl renderer with orthographic camera
@@ -59173,6 +59252,207 @@ function sampler2DtoFloat32Texture(sampler) {
     return texture;
 }
 
+/**
+ * Created by Alex on 15/11/2014.
+ */
+
+
+
+function convertChannel(v) {
+    return (v) / 255 - 0.5;
+}
+
+/**
+ *
+ * @param {number[]|Uint8Array} source
+ * @returns {Float32Array}
+ */
+function rgbaArray2RGB(source) {
+    const length = source.length;
+    const numPixels = Math.floor(length / 4);
+    const target = new Float32Array(numPixels * 3);
+    //
+    let h;
+    for (let i = 0; i < numPixels; i++) {
+        const j = i * 4;
+        const k = i * 3;
+        //normalize source to normal vectors
+        let x = convertChannel(source[j]);
+        let y = convertChannel(source[j + 1]);
+        let z = convertChannel(source[j + 2]);
+        //
+        h = Math.sqrt(x * x + y * y + z * z);
+
+        x /= h;
+        y /= h;
+        z /= h;
+        //
+        target[k] = x;
+        target[k + 1] = y;
+        target[k + 2] = z;
+    }
+    return target;
+}
+
+/**
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Sampler2D} sampler
+ * @returns {Sampler2D}
+ */
+function heightMap2NormalMap(renderer, sampler) {
+
+    const width = sampler.width;
+    const height = sampler.height;
+
+    const texture = sampler2DtoFloat32Texture(sampler);
+
+    //construct shader
+    const shader = new NormalMapShader();
+    shader.uniforms.heightMap.value = texture;
+    shader.uniforms.resolution.value.set(width, height);
+
+    //perform filtering
+    const result = processTexture(renderer, width, height, shader);
+
+    //create the sampler
+    const array = result.array;
+    const rgb = rgbaArray2RGB(array);
+
+    //reduce array's alpha component
+    return new Sampler2D(rgb, 3, width, height);
+}
+
+/**
+ * Created by Alex on 10/11/2014.
+ */
+
+const AmbientOcclusionShader = function () {
+    return {
+
+        uniforms: {
+
+            "normalMap": { type: "t", value: null },
+            "heightMap": { type: "t", value: null },
+            "world_size": { type: "v2", value: new Vector2$1(512, 512) },
+            "rayLength": { type: 'f', value: 17 }
+
+        },
+
+        defines: {
+            'NUM_SAMPLES': 64,
+            'NUM_RINGS': 7,
+        },
+
+        vertexShader: [
+
+            "varying vec2 vUv;",
+
+            "void main() {",
+
+            "vUv = uv;",
+            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+
+            "}"
+
+        ].join("\n"),
+
+        fragmentShader: [
+            `
+            uniform sampler2D normalMap;
+            uniform sampler2D heightMap;
+            uniform float rayLength;
+            uniform vec2 world_size;
+
+            varying vec2 vUv;
+
+            vec3 get(float x, float y){
+               vec2 _uv = vUv.xy + vec2(x,y) / world_size;
+               float h = texture2D(heightMap, _uv).x;
+               return vec3( _uv.x * world_size.x, h, _uv.y * world_size.y );
+            }
+            
+            float hash1( float n )
+            {
+                return fract( n*17.0*fract( n*0.3183099 ) );
+            }
+            
+            float hash1( vec2 p )
+            {
+                p  = 50.0*fract( p*0.3183099 );
+                return fract( p.x*p.y*(p.x+p.y) );
+            }
+            
+            // Non-sin based hash function, fast and has good randomness
+            float hash12(vec2 p){
+                vec3 p3  = fract(vec3(p.xyx) * .1031);
+                p3 += dot(p3, p3.yzx + 33.33);
+                return fract((p3.x + p3.y) * p3.z);
+            }
+            
+            const float bias = 0.001;
+            
+            float pow2(float x){
+                return x*x;
+            }
+    
+            float getOcclusion(vec3 origin, vec3 normal, vec3 hit_position){
+                vec3 viewDelta = hit_position - origin;
+                
+                float viewDistance = length( viewDelta );
+                
+                float vn = dot( normal, viewDelta );
+                float a2 = (vn) / viewDistance - bias;
+                float a1 = (1.0 + pow2( viewDistance ) );
+                
+                return max(0.0, a2) / a1;
+            }
+                
+            const float PI2 = 6.28318530717958;
+            const float kernelRadius = 100.0;
+    
+            const float ANGLE_STEP = PI2 * float( NUM_RINGS ) / float( NUM_SAMPLES );
+            const float INV_NUM_SAMPLES = 1.0 / float( NUM_SAMPLES );
+            
+            float getAmbientOcclusion(vec3 world_position, vec3 world_normal){
+                // jsfiddle that shows sample pattern: https://jsfiddle.net/a16ff1p7/
+                float angle = hash12( vUv  ) * PI2;
+                vec2 radius = vec2( rayLength * INV_NUM_SAMPLES );
+                
+                float occlusionSum = 0.0;
+                float weightSum = 0.0;
+                
+                for( int i = 0; i < NUM_SAMPLES; i ++ ) {
+                    vec2 sampleUv = vec2( cos( angle ), sin( angle ) ) * radius * float(i+1);
+                    
+                    angle += ANGLE_STEP;
+                        
+                    vec3 sample_pos = get(sampleUv.x, sampleUv.y);
+                
+                    occlusionSum += getOcclusion(world_position, world_normal, sample_pos);
+                    weightSum += 1.0;
+                }
+                
+                return occlusionSum/weightSum;
+            }
+            
+            void main() {
+               vec3 pos = get(0.0, 0.0);
+               
+               vec3 normal = texture2D( normalMap, vUv ).xzy;
+               
+               float occlusion = getAmbientOcclusion(pos, normal);
+               
+               float incident = 1.0 - occlusion;
+               
+               gl_FragColor = vec4(pow(incident,10.0), 0.0, 0.0, 1.0);
+            }
+            `
+        ].join('\n')
+
+    }
+};
+
 const KERNEL_SIZE = 15;
 
 const fragment$1 = `
@@ -59370,219 +59650,6 @@ function normalMap2OcclusionMap(
     return result;
 }
 
-/**
- * Created by Alex on 10/11/2014.
- */
-
-
-const NormalMapShader = function () {
-    return {
-
-        uniforms: {
-
-            "heightMap": { type: "t", value: null },
-            "resolution": { type: "v2", value: new Vector2$1(512, 512) }
-
-        },
-
-        vertexShader: [
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-
-            "vUv = uv;",
-            "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-
-            "}"
-
-        ].join("\n"),
-
-        /**
-         * Reference: https://stackoverflow.com/questions/49640250/calculate-normals-from-heightmap
-         */
-        fragmentShader: [
-            "uniform vec2 resolution;",
-            "uniform sampler2D heightMap;",
-
-            "#define sqrt2 1.41421356237;",
-
-            "varying vec2 vUv;",
-
-            "void main() {",
-            "   float uStep = 1.0/resolution.x;",
-            "   float vStep = 1.0/resolution.y;",
-            //
-            //
-            "   float top = texture2D( heightMap, vUv + vec2(0, -vStep)).x;",
-            "   float bottom = texture2D( heightMap, vUv + vec2(0, +vStep)).x;",
-            "   float left = texture2D( heightMap, vUv + vec2(-uStep, 0)).x;",
-            "   float right = texture2D( heightMap, vUv + vec2(+uStep, 0)).x;",
-            //
-
-            "   float dX = (right ) - ( left);",
-            "   float dY = (  bottom ) - (  top);",
-            "   float dZ = 2.0;",
-            "   vec3 n = normalize(vec3(dX, dY, dZ));",
-
-            "   gl_FragColor = vec4( n*0.5+0.5, 1.0 );",
-
-            "}"
-
-        ].join('\n')
-
-    }
-};
-
-/**
- * Created by Alex on 15/11/2014.
- */
-
-
-
-function convertChannel(v) {
-    return (v) / 255 - 0.5;
-}
-
-/**
- *
- * @param {number[]|Uint8Array} source
- * @returns {Float32Array}
- */
-function rgbaArray2RGB(source) {
-    const length = source.length;
-    const numPixels = Math.floor(length / 4);
-    const target = new Float32Array(numPixels * 3);
-    //
-    let h;
-    for (let i = 0; i < numPixels; i++) {
-        const j = i * 4;
-        const k = i * 3;
-        //normalize source to normal vectors
-        let x = convertChannel(source[j]);
-        let y = convertChannel(source[j + 1]);
-        let z = convertChannel(source[j + 2]);
-        //
-        h = Math.sqrt(x * x + y * y + z * z);
-
-        x /= h;
-        y /= h;
-        z /= h;
-        //
-        target[k] = x;
-        target[k + 1] = y;
-        target[k + 2] = z;
-    }
-    return target;
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Sampler2D}
- */
-function heightMap2NormalMap(renderer, sampler) {
-
-    const width = sampler.width;
-    const height = sampler.height;
-
-    const texture = sampler2DtoFloat32Texture(sampler);
-
-    //construct shader
-    const shader = new NormalMapShader();
-    shader.uniforms.heightMap.value = texture;
-    shader.uniforms.resolution.value.set(width, height);
-
-    //perform filtering
-    const result = processTexture(renderer, width, height, shader);
-
-    //create the sampler
-    const array = result.array;
-    const rgb = rgbaArray2RGB(array);
-
-    //reduce array's alpha component
-    return new Sampler2D(rgb, 3, width, height);
-}
-
-class WebGLRendererPool {
-
-    used = new Set();
-
-    get(options) {
-        const canvas = document.createElement('canvas');
-        const context = canvas.getContext('webgl2', { antialias: true });
-
-        const renderer = new WebGLRenderer({
-            alpha: true,
-            context,
-            canvas
-        });
-
-        this.used.add(renderer);
-        return renderer;
-    }
-
-    /**
-     *
-     * @param {THREE.WebGLRenderer} renderer
-     * @returns {boolean}
-     */
-    release(renderer) {
-        if (!this.used.has(renderer)) {
-            //not from this pool
-            return false;
-        }
-        this.used.delete(renderer);
-
-        renderer.forceContextLoss();
-        renderer.dispose();
-        renderer.domElement = null;
-
-        return true;
-    }
-
-    static global = new WebGLRendererPool();
-}
-
-/**
- *
- * @param {Sampler2D} sampler
- * @param {THREE.DataTexture} texture
- */
-function writeSample2DDataToDataTexture(sampler, texture) {
-    if (sampler.itemSize === 1) {
-        if (texture.format !== RedFormat && texture.format !== LuminanceFormat) {
-            throw new Error('itemSize is 1 and texture.format is not RedFormat');
-        }
-    } else if (sampler.itemSize === 2) {
-        if (texture.format !== RGFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGFormat');
-        }
-    } else if (sampler.itemSize === 3) {
-        if (texture.format !== RGBFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBFormat');
-        }
-    } else if (sampler.itemSize === 4) {
-        if (texture.format !== RGBAFormat) {
-            throw new Error('itemSize is 2 and texture.format is not RGBAFormat');
-        }
-    } else {
-        throw new Error('Unsupported itemSize');
-    }
-
-    if (texture.image.data !== sampler.data) {
-        // dispose of previous texture data
-        texture.dispose();
-    }
-
-    texture.image.data = sampler.data;
-    texture.image.width = sampler.width;
-    texture.image.height = sampler.height;
-
-    texture.needsUpdate = true;
-}
-
 /**
  *
  * @param {WebGLRenderer} renderer
@@ -59651,32 +59718,25 @@ function promiseSamplerAO(
 function buildLightTexture({
                                       texture,
                                       heightSampler,
-                                      resolution= new Vector2(texture.image.width, texture.image.height),
+                                      resolution = new Vector2(texture.image.width, texture.image.height),
                                       rayLength = 11,
                                       worldSize = resolution
                                   }) {
 
-    const renderer = WebGLRendererPool.global.get();
+    return WebGLRendererPool.global.useAsync(async renderer => {
+        const normal = promiseSamplerNormal(renderer, heightSampler);
 
-    const normal = promiseSamplerNormal(renderer, heightSampler);
-    const ao = promiseSamplerAO({
-        renderer: renderer,
-        pSamplerNormal: normal,
-        samplerHeight: heightSampler,
-        resolution: resolution,
-        rayLength: rayLength,
-        worldSize
-    });
-
-    const promise = ao.then(sampler => {
-        writeSample2DDataToDataTexture(sampler, texture);
-    });
+        const ao = await promiseSamplerAO({
+            renderer: renderer,
+            pSamplerNormal: normal,
+            samplerHeight: heightSampler,
+            resolution: resolution,
+            rayLength: rayLength,
+            worldSize
+        });
 
-    Promise.all([normal, ao]).finally(() => {
-        WebGLRendererPool.global.release(renderer);
+        writeSample2DDataToDataTexture(ao, texture);
     });
-
-    return promise;
 }
 
 const GridTransformKind = {
@@ -59765,7 +59825,7 @@ function invokeObjectHash(object) {
  * @param {number} index0
  * @param {number} index1
  */
-function arraySwapElements(array, index0, index1) {
+function array_swap_one(array, index0, index1) {
     const t = array[index0];
 
     array[index0] = array[index1];
@@ -59819,7 +59879,7 @@ function generate_next_linear_congruential_index(index, mask) {
 /**
  * @template K,V
  */
-class MapEntry {
+class HashMapEntry {
     /**
      *
      * @param {K} key
@@ -59907,7 +59967,7 @@ const UNDEFINED_BIN_INDEX = ~0;
 
 /**
  * @template K,V
- * @param {MapEntry<K,V>} record
+ * @param {HashMapEntry<K,V>} record
  * @param {number} hash
  * @param {K} key
  * @param {function(a:K,b:K):boolean} equality_op
@@ -59947,7 +60007,7 @@ class HashMap {
 
     /**
      * Note that dead entries are marked as such with a special reserved hash values, so records can be reused for new entries
-     * @type {Array<MapEntry<K,V>>}
+     * @type {Array<HashMapEntry<K,V>>}
      */
     #entries = new Array(0);
 
@@ -60125,7 +60185,7 @@ class HashMap {
             entry.key = k;
             entry.value = v;
         } else {
-            this.#entries[i] = new MapEntry(k, v, hash);
+            this.#entries[i] = new HashMapEntry(k, v, hash);
         }
 
         return i;
@@ -60133,7 +60193,7 @@ class HashMap {
 
     /**
      *
-     * @param {MapEntry<K,V>} entry
+     * @param {HashMapEntry<K,V>} entry
      */
     #deallocate(entry) {
 
@@ -60390,7 +60450,7 @@ class HashMap {
             }
 
             /**
-             * @type {MapEntry<K,V>}
+             * @type {HashMapEntry<K,V>}
              */
             const entry = this.#entries[bin - ENTRY_BASE];
 
@@ -60441,7 +60501,7 @@ class HashMap {
 
             if (new_index !== existing_entry_index) {
                 // move entries to the new position, compacting holes
-                arraySwapElements(entries, new_index, existing_entry_index);
+                array_swap_one(entries, new_index, existing_entry_index);
             }
 
             let bin_index = this.#compute_bin_index(hash);
@@ -60495,7 +60555,7 @@ class HashMap {
             }
 
             /**
-             * @type {MapEntry<K,V>}
+             * @type {HashMapEntry<K,V>}
              */
             const entry = entries[bin - ENTRY_BASE];
 
@@ -60566,7 +60626,7 @@ class HashMap {
             }
 
             /**
-             * @type {MapEntry<K,V>}
+             * @type {HashMapEntry<K,V>}
              */
             const entry = entries[bin - ENTRY_BASE];
 
@@ -67264,6 +67324,37 @@ function computeFileExtension(path) {
     }
 }
 
+/**
+ * @param {Uint8Array} input
+ * @param {number} width
+ * @param {number} height
+ * @param {number} channel_count
+ */
+function flipArrayInPlace(input, width, height, channel_count = 4) {
+    const row_size = width * channel_count;
+    let t, x0, x1;
+    let i = 0;
+    const column_count = height >> 1;
+
+    for (; i < column_count; i++) {
+
+        //swap lines
+        const k = (height - i - 1) * row_size;
+        const m = i * row_size;
+
+        for (let j = 0; j < row_size; j++) {
+            x0 = m + j;
+            x1 = k + j;
+
+            t = input[x0];
+
+            input[x0] = input[x1];
+            input[x1] = t;
+        }
+
+    }
+}
+
 /**
  * @author alteredq / http://alteredqualia.com/
  *
@@ -67310,37 +67401,6 @@ const CopyShader = {
 
 };
 
-/**
- * @param {Uint8Array} input
- * @param {number} width
- * @param {number} height
- * @param {number} channel_count
- */
-function flipArrayInPlace(input, width, height, channel_count = 4) {
-    const row_size = width * channel_count;
-    let t, x0, x1;
-    let i = 0;
-    const column_count = height >> 1;
-
-    for (; i < column_count; i++) {
-
-        //swap lines
-        const k = (height - i - 1) * row_size;
-        const m = i * row_size;
-
-        for (let j = 0; j < row_size; j++) {
-            x0 = m + j;
-            x1 = k + j;
-
-            t = input[x0];
-
-            input[x0] = input[x1];
-            input[x1] = t;
-        }
-
-    }
-}
-
 const DEFAULT_TEXTURE_WIDTH = 512;
 const DEFAULT_TEXTURE_HEIGHT = 512;
 
@@ -67349,39 +67409,47 @@ const DEFAULT_TEXTURE_HEIGHT = 512;
  * @param {Texture} texture
  * @param {number} [width]
  * @param {number} [height]
- * @param {boolean} flipY
+ * @param {boolean} [flipY]
  * @return {Sampler2D}
  */
-function convertTexture2Sampler2D(texture, width, height, flipY = true) {
+function convertTexture2Sampler2D(
+    texture,
+    width,
+    height,
+    flipY = true
+) {
+    let _height = height;
+    let _width = width;
+
     // TODO take channel count into account
 
-    if (width === undefined || height === undefined) {
+    if (_width === undefined || _height === undefined) {
 
         //figure out texture size
         const image = texture.image;
 
         if (image !== undefined && image !== null) {
-            if (width === undefined) {
+            if (_width === undefined) {
                 if (typeof image.width === "number") {
-                    width = image.width;
+                    _width = image.width;
                 } else {
-                    width = DEFAULT_TEXTURE_WIDTH;
+                    _width = DEFAULT_TEXTURE_WIDTH;
                 }
             }
-            if (height === undefined) {
+            if (_height === undefined) {
                 if (typeof image.height === "number") {
-                    height = image.height;
+                    _height = image.height;
                 } else {
-                    height = DEFAULT_TEXTURE_HEIGHT;
+                    _height = DEFAULT_TEXTURE_HEIGHT;
                 }
             }
         } else {
-            if (width === undefined) {
-                width = DEFAULT_TEXTURE_WIDTH;
+            if (_width === undefined) {
+                _width = DEFAULT_TEXTURE_WIDTH;
             }
 
-            if (height === undefined) {
-                height = DEFAULT_TEXTURE_HEIGHT;
+            if (_height === undefined) {
+                _height = DEFAULT_TEXTURE_HEIGHT;
             }
         }
 
@@ -67389,34 +67457,32 @@ function convertTexture2Sampler2D(texture, width, height, flipY = true) {
 
     // TODO add special case for DataTexture
 
-    const renderer = WebGLRendererPool.global.get({});
+    const built = WebGLRendererPool.global.use(renderer => {
 
-    const ctx = renderer.getContext();
+        const ctx = renderer.getContext();
 
-    //support for compressed textures
-    ctx.getExtension("WEBGL_compressed_texture_s3tc");
+        //support for compressed textures
+        ctx.getExtension("WEBGL_compressed_texture_s3tc");
 
-    const built = processTexture(renderer, width, height, {
-        vertexShader: CopyShader.vertexShader,
-        fragmentShader: CopyShader.fragmentShader,
-        uniforms: {
-            tDiffuse: {
-                value: texture,
-                type: 't'
-            },
-            opacity: { value: 1.0 }
-        }
-    });
+        return processTexture(renderer, _width, _height, {
+            vertexShader: CopyShader.vertexShader,
+            fragmentShader: CopyShader.fragmentShader,
+            uniforms: {
+                tDiffuse: {
+                    value: texture,
+                    type: 't'
+                },
+                opacity: { value: 1.0 }
+            }
+        });
 
-    WebGLRendererPool.global.release(renderer);
+    });
 
     if (flipY) {
-        flipArrayInPlace(built.array, width, height);
+        flipArrayInPlace(built.array, _width, _height);
     }
 
-    const sampler = new Sampler2D(built.array, 4, width, height);
-
-    return sampler;
+    return new Sampler2D(built.array, 4, _width, _height);
 }
 
 /**
@@ -69047,10 +69113,14 @@ class Camera {
      * @param {Camera|THREE.PerspectiveCamera|THREE.OrthographicCamera} camera
      * @param {number} x
      * @param {number} y
-     * @param {Vector3} source
-     * @param {Vector3} direction
+     * @param {Vector3} out_source
+     * @param {Vector3} out_direction
      */
-    static projectRay(camera, x, y, source, direction) {
+    static projectRay(
+        camera,
+        x, y,
+        out_source, out_direction
+    ) {
 
         // assert.ok(x >= -1, `X(=${x}) must be greater than or equal to -1.0, not a clip-space coordinate`);
         // assert.ok(x <= 1, `X(=${x}) must be less than or equal to 1.0, not a clip-space coordinate`);
@@ -69059,7 +69129,10 @@ class Camera {
         // assert.ok(y <= 1, `Y(=${y}) must be less than or equal to 1.0, not a clip-space coordinate`);
 
         if (camera.isPerspectiveCamera || camera.isOrthographicCamera) {
-            scratch_v3_1.setFromMatrixPosition(camera.matrixWorld.elements);
+            const m4_world = camera.matrixWorld.elements;
+            const m4_projection_inverse = camera.projectionMatrixInverse.elements;
+
+            scratch_v3_1.setFromMatrixPosition(m4_world);
 
             scratch_v3_0.set(x, y, 0.5);
 
@@ -69068,16 +69141,16 @@ class Camera {
             unprojectPoint(
                 scratch_v3_0,
                 scratch_v3_0,
-                camera.projectionMatrixInverse.elements,
-                camera.matrixWorld.elements
+                m4_projection_inverse,
+                m4_world
             );
 
             //get direction
             scratch_v3_0.sub(scratch_v3_1);
             scratch_v3_0.normalize();
 
-            source.copy(scratch_v3_1);
-            direction.copy(scratch_v3_0);
+            out_source.copy(scratch_v3_1);
+            out_direction.copy(scratch_v3_0);
 
         } else {
             throw new Error('Unsupported camera type');
@@ -74588,7 +74661,7 @@ function arrayQuickSort(
     data,
     score_function, score_function_context,
     start, end,
-    swap_operator = arraySwapElements, swap_context = undefined
+    swap_operator = array_swap_one, swap_context = undefined
 ) {
     if (start >= end) {
         // section of 0 size, nothing to sort
@@ -81313,6 +81386,7 @@ class Token {
      * @param {T} type
      */
     constructor(value, start, end, name, type) {
+
         /**
          * @readonly
          * @type {V}
@@ -81362,8 +81436,7 @@ class Token {
      * @return {number}
      */
     hash() {
-        // TODO make an actual hash
-        return 0;
+        return this.start ^ (this.end << 16);
     }
 }
 
@@ -81379,10 +81452,71 @@ const TooltipTokenType = {
     ReferenceValue: 4,
 };
 
-function ParserError(position, message, input) {
-    this.position = position;
-    this.message = message;
-    this.input = input;
+/**
+ * Repeat a given piece of text a {@link count} times
+ * @example "ABC_" repeated 2 times results in "ABC_ABC_"
+ * @param {string} what
+ * @param {number} count
+ * @return {string}
+ */
+function string_repeat(what, count) {
+
+    if (count <= 0) {
+        // special case
+        return "";
+    }
+
+    let out = what;
+
+    for (let i = 1; i < count; i++) {
+        out += what;
+    }
+
+    return out;
+}
+
+class ParserError extends Error {
+    /**
+     *
+     * @param {number} position
+     * @param {string} message
+     * @param {string} input
+     */
+    constructor(
+        position,
+        message,
+        input
+    ) {
+
+        super();
+
+        this.position = position;
+        this.message = message;
+        this.input = input;
+    }
+
+    getDetails() {
+        const input = this.input;
+        const position = this.position;
+
+        // get snippet around where the problem has occurred
+        const input_start = max2(0, position - 10);
+
+        const input_end = min2(input.length, position + 10);
+
+        const snippet = input.slice(input_start, input_end);
+
+        const offset_into_snippet = position - input_start;
+
+        // a piece of text with marker to show where the error occurs
+        const arrow_text = string_repeat(" ", offset_into_snippet) + "^";
+
+        return snippet + "\n" + arrow_text;
+    }
+
+    toString() {
+        return `[ParseError] ${this.message}. Error at position ${this.position} near:\n${this.getDetails()}`
+    }
 }
 
 /**
@@ -81478,28 +81612,6 @@ class KeyValuePair {
     }
 }
 
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {number}
- */
-function skipWhitespace(text, cursor, length) {
-    let i = cursor;
-    let char;
-    while (i < length) {
-        char = text.charAt(i);
-
-        if (char === ' ' || char === '\n' || char === '\t') {
-            i++;
-        } else {
-            break;
-        }
-    }
-    return i;
-}
-
 /**
  *
  * @enum {string}
@@ -81514,7 +81626,7 @@ const DataType = {
 };
 
 /**
- * @enum {{LiteralString: string, LiteralNumber: string, LiteralBoolean: string}}
+ * @enum {string}
  */
 const TokenType = {
     LiteralString: "literal-string",
@@ -81532,6 +81644,7 @@ const TokenType = {
  * @returns {Token}
  */
 function readBooleanToken(text, cursor, length) {
+
     const firstChar = text.charAt(cursor);
 
     let value;
@@ -81558,96 +81671,6 @@ function readBooleanToken(text, cursor, length) {
     return new Token(value, cursor, end, TokenType.LiteralBoolean, DataType.Boolean);
 }
 
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @returns {string}
- */
-function readQuote(text, cursor) {
-    const char = text.charAt(cursor);
-
-    if (char !== '"' && char !== '\'') {
-        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
-    }
-
-    return char;
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readStringToken(text, cursor, length) {
-    let i = cursor;
-
-    const openingQuote = readQuote(text, i);
-
-    i++;
-
-    let char;
-
-    let value = '';
-    const lastPossibleChar = length - 1;
-
-    for (; i < lastPossibleChar; i++) {
-        char = text.charAt(i);
-
-        if (char === '\\') {
-            i++;
-            //read escape sequence
-            char = text.charAt(i);
-
-            switch (char) {
-                case 'n':
-                    value += '\n';
-                    break;
-                case 't':
-                    value += '\t';
-                    break;
-                case 'r':
-                    value += '\r';
-                    break;
-                case 'b':
-                    value += '\b';
-                    break;
-                case 'f':
-                    value += '\f';
-                    break;
-                case 'v':
-                    value += '\v';
-                    break;
-                case '0':
-                    value += '\0';
-                    break;
-                case '\\':
-                case "'":
-                case '"':
-                default:
-                    value += char;
-                    break;
-            }
-        } else if (char !== openingQuote) {
-            value += char;
-        } else {
-            break;
-        }
-    }
-
-    char = text.charAt(i);
-
-    if (char !== openingQuote) {
-        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
-    }
-
-    i++;
-
-    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
-}
-
 /**
  *
  * @param {string} text
@@ -81656,6 +81679,7 @@ function readStringToken(text, cursor, length) {
  * @returns {Token}
  */
 function readHexToken(text, cursor, length) {
+
     const c0 = text.charAt(cursor);
     const c1 = text.charAt(cursor + 1);
 
@@ -81737,7 +81761,7 @@ function readHexToken(text, cursor, length) {
     }
 
 
-    return new Token(value, cursor, i, null, DataType.Number);
+    return new Token(value, cursor, i, "uint", DataType.Number);
 }
 
 /**
@@ -81748,6 +81772,7 @@ function readHexToken(text, cursor, length) {
  * @returns {Token}
  */
 function readUnsignedIntegerToken(text, cursor, length) {
+
     let i = cursor;
 
     let value = 0;
@@ -81799,7 +81824,32 @@ function readUnsignedIntegerToken(text, cursor, length) {
     }
 
 
-    return new Token(value, cursor, i, null, DataType.Number);
+    return new Token(value, cursor, i, "uint", DataType.Number);
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {number}
+ */
+function skipWhitespace(text, cursor, length) {
+
+    let i = cursor;
+    let char;
+
+    while (i < length) {
+        char = text.charAt(i);
+
+        if (char === ' ' || char === '\n' || char === '\t') {
+            i++;
+        } else {
+            break;
+        }
+    }
+
+    return i;
 }
 
 /**
@@ -81810,6 +81860,7 @@ function readUnsignedIntegerToken(text, cursor, length) {
  * @returns {Token}
  */
 function readNumberToken(text, cursor, length) {
+
     let i = cursor;
 
     //read optional sign
@@ -81869,6 +81920,97 @@ function readNumberToken(text, cursor, length) {
     return new Token(value, cursor, i, TokenType.LiteralNumber, DataType.Number);
 }
 
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @returns {string}
+ */
+function readQuote(text, cursor) {
+    const char = text.charAt(cursor);
+
+    if (char !== '"' && char !== '\'') {
+        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
+    }
+
+    return char;
+}
+
+/**
+ *
+ * @param {string} text
+ * @param {number} cursor
+ * @param {number} length
+ * @returns {Token}
+ */
+function readStringToken(text, cursor, length) {
+
+    let i = cursor;
+
+    const openingQuote = readQuote(text, i);
+
+    i++;
+
+    let char;
+
+    let value = '';
+    const lastPossibleChar = length - 1;
+
+    for (; i < lastPossibleChar; i++) {
+        char = text.charAt(i);
+
+        if (char === '\\') {
+            i++;
+            //read escape sequence
+            char = text.charAt(i);
+
+            switch (char) {
+                case 'n':
+                    value += '\n';
+                    break;
+                case 't':
+                    value += '\t';
+                    break;
+                case 'r':
+                    value += '\r';
+                    break;
+                case 'b':
+                    value += '\b';
+                    break;
+                case 'f':
+                    value += '\f';
+                    break;
+                case 'v':
+                    value += '\v';
+                    break;
+                case '0':
+                    value += '\0';
+                    break;
+                case '\\':
+                case "'":
+                case '"':
+                default:
+                    value += char;
+                    break;
+            }
+        } else if (char !== openingQuote) {
+            value += char;
+        } else {
+            break;
+        }
+    }
+
+    char = text.charAt(i);
+
+    if (char !== openingQuote) {
+        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
+    }
+
+    i++;
+
+    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
+}
+
 /**
  *
  * @param {string} text
@@ -81927,6 +82069,7 @@ function readArrayLiteral(text, cursor, length) {
  * @returns {Token}
  */
 function readLiteralToken(text, cursor, length) {
+
     const firstChar = text.charAt(cursor);
 
     switch (firstChar) {
@@ -83906,11 +84049,14 @@ class BinaryHeap {
     }
 }
 
+/**
+ * Decorator that wraps another map and lets you observe mutations
+ * @template K,V
+ */
 class ObservedMap {
     /**
      * @template K,V
      * @constructor
-     * @property {number} size
      */
     constructor(source = new Map()) {
         this.on = {
@@ -83993,10 +84139,11 @@ const STATUS_NORMAL = 2;
 class Deque {
     /**
      * @template T
+     * @param {number} [min_size]
      */
-    constructor(minSize = DEFAULT_SIZE) {
+    constructor(min_size = DEFAULT_SIZE) {
 
-        const size = ceilPowerOfTwo(max2(1, minSize));
+        const size = ceilPowerOfTwo(max2(1, min_size));
 
         /**
          * Using static array allocator to preserve data locality.
@@ -84007,15 +84154,31 @@ class Deque {
          */
         this.__data = new Array(size);
 
+        /**
+         *
+         * @type {number}
+         * @private
+         */
         this.__head = 0;
+        /**
+         *
+         * @type {number}
+         * @private
+         */
         this.__tail = 0;
 
+        /**
+         *
+         * @type {number}
+         * @private
+         */
         this.__status = STATUS_EMPTY;
     }
 
     /**
      *
      * @param {boolean} adding
+     * @private
      */
     resetStatus(adding) {
         const head = this.__head;
@@ -84034,11 +84197,12 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __circularBiggerPos(current) {
-        // TODO this can be done faster using mod operator (%)
+    __circular_next_position(current) {
         const next = current + 1;
 
-        return (next >= this.__data.length) ? 0 : next;
+        const length = this.__data.length;
+
+        return (next >= length) ? 0 : next;
     }
 
     /**
@@ -84047,43 +84211,57 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __circularSmallerPos(current) {
+    __circular_previous_position(current) {
         const prev = current - 1;
         return (prev < 0) ? (this.__data.length - 1) : prev;
     }
 
-    __checkAndExpand() {
+    __check_and_expand() {
         const status = this.__status;
+
         if (status !== STATUS_FULL) {
+            // queue still has space, we're done
             return;
         }
+
         const length = this.__data.length;
 
-        if (Number.MAX_SAFE_INTEGER === length) {
+        if (UINT32_MAX === length) {
             throw new Error('Maximum array size exceeded');
         }
 
-        let newLength = length * 2;
+        let new_length = length * 2;
+
         // bigger than Integer.MAX_VALUE
-        if (newLength < 0) {
-            newLength = Number.MAX_SAFE_INTEGER;
+        if (new_length > UINT32_MAX) {
+            new_length = UINT32_MAX;
         }
 
-        const newElements = new Array(newLength);
+        /**
+         *
+         * @type {T[]}
+         */
+        const new_data = new Array(new_length);
 
-        // copy front portion of data
         const head = this.__head;
 
-        array_copy(this.__data, head, newElements, 0, length - head);
-        array_copy(this.__data, 0, newElements, length - head, head);
+        // copy the front portion
+        array_copy(this.__data, head, new_data, 0, length - head);
+        // copy the remainder
+        array_copy(this.__data, 0, new_data, length - head, head);
 
         this.__head = 0;
         this.__tail = length;
+
         this.__status = STATUS_NORMAL;
 
-        this.__data = newElements;
+        this.__data = new_data;
     }
 
+    /**
+     *
+     * @return {boolean}
+     */
     isEmpty() {
         return this.size() === 0;
     }
@@ -84095,7 +84273,7 @@ class Deque {
 
             do {
                 this.__data[cursor] = undefined;
-                cursor = this.__circularBiggerPos(cursor);
+                cursor = this.__circular_next_position(cursor);
             } while (cursor !== tail);
 
             this.__status = STATUS_EMPTY;
@@ -84124,32 +84302,45 @@ class Deque {
     /**
      *
      * @param {number} current
-     * @param {boolean} frontShift
+     * @param {boolean} shift_front should we shift elements before the removed element or after?
      * @private
      */
-    __removeInternal(current, frontShift) {
+    __remove_internal(current, shift_front) {
         let cursor = current;
-        if (frontShift) {
+
+        if (shift_front) {
+
+            // shift towards tail
+
             const head = this.__head;
+
             while (cursor !== head) {
-                const next = this.__circularSmallerPos(cursor);
+                const next = this.__circular_previous_position(cursor);
                 this.__data[cursor] = this.__data[next];
                 cursor = next;
             }
-            this.__head = this.__circularBiggerPos(head);
+
+            this.__head = this.__circular_next_position(head);
+
         } else {
+
+            // shift towards head
+
             const tail = this.__tail;
 
             while (cursor !== tail) {
-                const next = this.__circularBiggerPos(cursor);
+                const next = this.__circular_next_position(cursor);
                 this.__data[cursor] = this.__data[next];
                 cursor = next;
             }
 
-            this.__tail = this.__circularSmallerPos(tail);
+            this.__tail = this.__circular_previous_position(tail);
+
         }
 
+        // fill in slot of last moved element
         this.__data[cursor] = undefined;
+
         this.resetStatus(false);
     }
 
@@ -84165,7 +84356,7 @@ class Deque {
             return false;
         }
 
-        this.__removeInternal(i, true);
+        this.__remove_internal(i, true);
 
         return true;
     }
@@ -84209,20 +84400,20 @@ class Deque {
      * @param {T} e
      */
     addFirst(e) {
-        this.__checkAndExpand();
-        this.__head = this.__circularSmallerPos(this.__head);
+        this.__check_and_expand();
+        this.__head = this.__circular_previous_position(this.__head);
         this.__data[this.__head] = e;
         this.resetStatus(true);
     }
 
     /**
      * Remove element from the front of the queue
-     * @returns {T}
+     * @returns {T|undefined}
      */
     removeFirst() {
         const element = this.__data[this.__head];
         this.__data[this.__head] = undefined;
-        this.__head = this.__circularBiggerPos(this.__head);
+        this.__head = this.__circular_next_position(this.__head);
         this.resetStatus(false);
         return element;
     }
@@ -84240,9 +84431,9 @@ class Deque {
      * @param {T} e
      */
     addLast(e) {
-        this.__checkAndExpand();
+        this.__check_and_expand();
         this.__data[this.__tail] = e;
-        this.__tail = this.__circularBiggerPos(this.__tail);
+        this.__tail = this.__circular_next_position(this.__tail);
         this.resetStatus(true);
     }
 
@@ -84251,7 +84442,7 @@ class Deque {
      * @returns {T}
      */
     removeLast() {
-        const last = this.__circularSmallerPos(this.__tail);
+        const last = this.__circular_previous_position(this.__tail);
         const element = this.__data[last];
         this.__data[last] = undefined;
         this.__tail = last;
@@ -84262,10 +84453,10 @@ class Deque {
 
     /**
      * Peek element from the end of the queue without removing it
-     * @returns {T}
+     * @returns {T|undefined}
      */
     getLast() {
-        const last = this.__circularSmallerPos(this.__tail);
+        const last = this.__circular_previous_position(this.__tail);
         return this.__data[last];
     }
 }
@@ -85973,35 +86164,44 @@ Preloader.prototype.load = function (assetManager) {
     return this;
 };
 
-class AbstractMetric {
-    /**
-     *
-     * @param {number} value
-     * @returns {void}
-     */
-    record(value) {
-        throw new Error('Not implemented');
-    }
+/**
+ * @template V
+ * @param {V[]} data
+ * @param {number} [start]
+ * @param {number} [end]
+ * @return {number}
+ */
+function array_compute_max(data, start = 0, end = data.length) {
+    let result = Number.NEGATIVE_INFINITY;
 
-    /**
-     * @returns {number|undefined}
-     */
-    getLastRecord() {
-        throw new Error('Not implemented');
+    for (let i = start; i < end; i++) {
+        const value = data[i];
+        if (value > result) {
+            result = value;
+        }
     }
 
-    /**
-     *
-     * @param {MetricStatistics} result
-     * @returns {boolean} whether metric was successfully computed or not
-     */
-    computeStats(result) {
-        throw new Error('Not implemented');
-    }
+    return result;
+}
+
+/**
+ * @template V
+ * @param {V[]} data
+ * @param {number} [start]
+ * @param {number} [end]
+ * @return {number}
+ */
+function array_compute_min(data, start = 0, end = data.length) {
+    let result = Number.POSITIVE_INFINITY;
 
-    clear() {
-        throw new Error('Not implemented');
+    for (let i = start; i < end; i++) {
+        const value = data[i];
+        if (value < result) {
+            result = value;
+        }
     }
+
+    return result;
 }
 
 class RingBuffer {
@@ -86271,44 +86471,35 @@ function computeStatisticalPartialMedian(values, start, end) {
     return copy[position];
 }
 
-/**
- * @template V
- * @param {V[]} data
- * @param {number} [start]
- * @param {number} [end]
- * @return {number}
- */
-function computeArrayMax(data, start = 0, end = data.length) {
-    let result = Number.NEGATIVE_INFINITY;
-
-    for (let i = start; i < end; i++) {
-        const value = data[i];
-        if (value > result) {
-            result = value;
-        }
+class AbstractMetric {
+    /**
+     *
+     * @param {number} value
+     * @returns {void}
+     */
+    record(value) {
+        throw new Error('Not implemented');
     }
 
-    return result;
-}
-
-/**
- * @template V
- * @param {V[]} data
- * @param {number} [start]
- * @param {number} [end]
- * @return {number}
- */
-function computeArrayMin(data, start = 0, end = data.length) {
-    let result = Number.POSITIVE_INFINITY;
+    /**
+     * @returns {number|undefined}
+     */
+    getLastRecord() {
+        throw new Error('Not implemented');
+    }
 
-    for (let i = start; i < end; i++) {
-        const value = data[i];
-        if (value < result) {
-            result = value;
-        }
+    /**
+     *
+     * @param {MetricStatistics} result
+     * @returns {boolean} whether metric was successfully computed or not
+     */
+    computeStats(result) {
+        throw new Error('Not implemented');
     }
 
-    return result;
+    clear() {
+        throw new Error('Not implemented');
+    }
 }
 
 class RingBufferMetric extends AbstractMetric {
@@ -86365,8 +86556,8 @@ class RingBufferMetric extends AbstractMetric {
 
             result.mean = computeStatisticalMean(array, 0, data_count);
             result.median = computeStatisticalPartialMedian(array, 0, data_count - 1);
-            result.max = computeArrayMax(array, 0, data_count);
-            result.min = computeArrayMin(array, 0, data_count);
+            result.max = array_compute_max(array, 0, data_count);
+            result.min = array_compute_min(array, 0, data_count);
 
             return true;
 
@@ -110070,7 +110261,7 @@ class LightManager {
     __build_view_frustum(camera) {
         frustum_from_camera(camera, this.__view_frustum, false);
 
-        arraySwapElements(this.__view_frustum.planes, 4, 5);
+        array_swap_one(this.__view_frustum.planes, 4, 5);
 
         this.__build_view_frustum_points();
     }