@woosh/meep-engine 2.33.26 → 2.33.30

package/engine/graphics/render/forward_plus/prototypeLightManager.js

@@ -317,7 +317,7 @@ function prepare_scene_0() {
 
     const bounds_size = 15;
 
-    const light_radius = 2;
+    const light_radius = 5;
 
     for (let i = 0; i < 5000; i++) {
         const radius = randomFloatBetween(random, light_radius, light_radius);
@@ -624,7 +624,7 @@ fp_materials.forEach(m => {
 
     renderer.getSize(v2);
 
-    m.uniforms.resolution.value.set(
+    m.uniforms.fp_resolution.value.set(
         v2.x * window.devicePixelRatio, v2.y * window.devicePixelRatio
     );
 
@@ -693,7 +693,7 @@ function animate() {
         m.uniforms.fp_f_camera_far.value = camera.far;
 
 
-        m.uniforms.resolution.value.set(scratch_v2.x, scratch_v2.y);
+        m.uniforms.fp_resolution.value.set(scratch_v2.x, scratch_v2.y);
     });
 
     lightClusterWidget.update();
@@ -760,7 +760,7 @@ function draw_camera_view_planes() {
     });
 }
 
-prepare_scene_4();
+prepare_scene_0();
 animate();
 
 // draw_camera_view_planes();

package/engine/graphics/render/forward_plus/query/point_light_inside_volume.js

@@ -42,21 +42,22 @@ export function point_light_inside_volume(
         if (distance < 0) {
             // center of the sphere is below the plane
 
-            if (distance < -radius) {
-                // sphere is entirely below the plane
+            if (distance >= -radius) {
 
-                // query_bvh_frustum_from_objects.rejection_sphere_count++;
+                // sphere intersects the plane
 
-                return false;
-            }
+                outside_plane_count++;
 
-            // sphere intersects the plane
+                const plane_bit_mask = 1 << j;
 
-            outside_plane_count++;
+                outside_plane_bitfield |= plane_bit_mask;
+            } else {
+                // sphere is entirely below the plane
 
-            const plane_bit_mask = 1 << j;
+                // query_bvh_frustum_from_objects.rejection_sphere_count++;
 
-            outside_plane_bitfield |= plane_bit_mask;
+                return false;
+            }
         }
 
     }

package/engine/graphics/texture/atlas/ManagedTextureAtlas.js

@@ -6,6 +6,7 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { HashMap } from "../../../../core/collection/HashMap.js";
 import { strictEquals } from "../../../../core/function/Functions.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { copy_Sampler2D_channel_data } from "../sampler/copy_Sampler2D_channel_data.js";
 
 const CACHE_SIZE = 4194304;
 
@@ -139,10 +140,20 @@ export class ManagedAtlas {
 
                     const image = asset.create();
 
+                    const source = new Sampler2D(image.data, image.itemSize, image.width, image.height);
                     //assert.equal(atlas.patches.filter(p => p.sampler.data === image.data).length, 0, "Atlas already contains this asset data");
 
                     //build sampler
-                    const sampler = new Sampler2D(image.data, 4, image.width, image.height);
+                    let sampler;
+
+                    if (source.itemSize !== 4) {
+                        // source image is not in RGBA layout, resample
+                        sampler = Sampler2D.uint8(4, image.width, image.height);
+                        copy_Sampler2D_channel_data(source, sampler)
+                    } else {
+                        sampler = source;
+                    }
+
                     const patch = atlas.add(sampler);
 
                     //record active patch

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -164,11 +164,13 @@ export function Sampler2D(data = [], itemSize = 1, width = 0, height = 0) {
      * @type {Number}
      */
     this.height = height;
+
     /**
-     *
+     * Number of channels
      * @type {Number}
      */
     this.itemSize = itemSize;
+
     /**
      *
      * @type {Array<number>|Uint8Array|Uint16Array|Int8Array|Float32Array|Float64Array}

package/engine/graphics/texture/sampler/convertTexture2Sampler2D.js

@@ -17,7 +17,7 @@ const DEFAULT_TEXTURE_HEIGHT = 512;
  * @return {Sampler2D}
  */
 export function convertTexture2Sampler2D(texture, width, height, flipY = true) {
-
+    // TODO take channel count into account
 
     if (width === undefined || height === undefined) {
 

package/engine/graphics/texture/sampler/copy_Sampler2D_channel_data.js

@@ -0,0 +1,66 @@
+/**
+ * Allows copying data from one sampler to another with unequal number of channels (a.itemSize !== b.itemSize)
+ * @example convert RGBA to RGB or R to RGB
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ */
+export function copy_Sampler2D_channel_data(source, destination) {
+    if (source.width !== destination.width || source.height !== destination.height) {
+        throw new Error('Source and destination dimensions do not match');
+    }
+
+    const source_item_size = source.itemSize;
+    const destination_item_size = destination.itemSize;
+
+    const pixel_count = source.width * source.height;
+
+    const destination_data = destination.data;
+    const source_data = source.data;
+
+    let i, j;
+
+    if (source_item_size === destination_item_size) {
+        // just copy data chunk
+        destination_data.set(source_data);
+
+    } else if (source_item_size > destination_item_size) {
+
+        for (i = 0; i < pixel_count; i++) {
+            const source_sample_offset = i * source_item_size;
+            const destination_sample_offset = i * destination_item_size;
+
+            for (j = 0; j < destination_item_size; j++) {
+                destination_data[destination_sample_offset + j] = source_data[source_sample_offset + j];
+            }
+        }
+
+    } else if (source_item_size === 3 && destination_item_size === 4) {
+        // RGB -> RGBA
+        for (i = 0; i < pixel_count; i++) {
+            const i3 = i * 3;
+            const i4 = i * 4;
+
+            destination_data[i4] = source_data[i3];
+            destination_data[i4 + 1] = source_data[i3 + 1];
+            destination_data[i4 + 2] = source_data[i3 + 2];
+
+            destination_data[i4] = 255; // fill alpha
+        }
+    } else if (source_item_size === 2 && destination_item_size === 4) {
+        //RA -> RGBA
+        for (i = 0; i < pixel_count; i++) {
+            const i2 = i * 2;
+            const i4 = i * 4;
+
+            const r = source_data[i2];
+
+            destination_data[i4] = r;
+            destination_data[i4 + 1] = r;
+            destination_data[i4 + 2] = r;
+
+            destination_data[i4 + 3] = source_data[i2 + 1]; // fill alpha
+        }
+    } else {
+        throw new Error('Unsupported channel layout combination');
+    }
+}

package/engine/input/devices/KeyCodes.d.ts

@@ -0,0 +1 @@
+export const KeyCodes: { [name: string]: number };

package/package.json

@@ -4,7 +4,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.33.26",
+  "version": "2.33.30",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",

package/view/minimap/gl/MinimapWorldGL.js

@@ -171,13 +171,20 @@ export class MinimapWorldGL {
     }
 
     update() {
-        this.layers.forEach(o => {
-            o.update(this.camera);
-            if (o.needsRender) {
+        const layers = this.layers;
+        const layer_count = layers.length;
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = layers[i];
+
+            layer.update(this.camera);
+
+            if (layer.needsRender) {
                 this.renderNeedsUpdate = true;
-                o.needsRender = false;
+                layer.needsRender = false;
             }
-        });
+
+        }
 
         if (this.renderNeedsUpdate) {
             this.render();