@woosh/meep-engine 2.34.49 → 2.35.0

package/engine/graphics/micron/render/v1/VGThreeRenderer.js

@@ -16,6 +16,7 @@ const scratch_mvc = new MaterialVertexSpec();
 export class VGThreeRenderer {
     constructor() {
         this.geometry = new VirtualGeometry();
+
         this.builder = new VirtualGeometryBuilder();
 
         /**
@@ -158,6 +159,10 @@ export class VGThreeRenderer {
         const contexts = this.__contexts_array;
         const context_count = contexts.length;
 
+        /**
+         *
+         * @type {Map<number, MaterialContext>}
+         */
         const instance_to_ctx = new Map();
 
         for (let i = 0; i < context_count; i++) {
@@ -175,18 +180,28 @@ export class VGThreeRenderer {
         const patches = geometry.patches;
 
         for (let i = 0; i < patch_count; i++) {
-            const patch = patches[i];
+            const i3 = i * 3;
+
+            const instance_id = patches[i3];
+            const geometry_id = patches[i3 + 1];
+            const patch_id = patches[i3 + 2];
+
+            const ctx = instance_to_ctx.get(instance_id);
+
+            const target_address = ctx.__patch_count * 3;
 
-            const ctx = instance_to_ctx.get(patch.instance_id);
+            ctx.__patches[target_address] = instance_id;
+            ctx.__patches[target_address + 1] = geometry_id;
+            ctx.__patches[target_address + 2] = patch_id;
 
-            ctx.__patches[ctx.__patch_count++] = patch;
+            ctx.__patch_count++;
         }
 
         // build each context
         for (let i = 0; i < context_count; i++) {
             const ctx = contexts[i];
 
-            ctx.build();
+            ctx.build(this.geometry);
         }
     }
 

package/engine/graphics/render/utils/ThreeBypassRenderer.js

@@ -72,8 +72,9 @@ export class ThreeBypassRenderer {
 
         let stack_top = 0;
         let j = 0;
+        let i = 0;
 
-        for (let i = 0; i < input_size; i++) {
+        for (; i < input_size; i++) {
             const object3D = input[i];
 
             if (input_filter(object3D)) {
@@ -119,7 +120,7 @@ export class ThreeBypassRenderer {
             const children = object3D.children;
             const child_count = children.length;
 
-            for (let i = 0; i < child_count; i++) {
+            for (i = 0; i < child_count; i++) {
                 const child = children[i];
 
                 stack[stack_top++] = child;

package/engine/graphics/texture/normalized_internal_format.js

@@ -0,0 +1,48 @@
+import { DataType } from "../../../core/collection/table/DataType.js";
+import { assert } from "../../../core/assert.js";
+
+/**
+ *
+ * @returns {string}
+ * @param {DataType} dt
+ * @param {number} channel_count
+ */
+export function normalized_internal_format(dt, channel_count) {
+    assert.isNonNegativeInteger(channel_count, 'channel_count');
+
+    let suffix = '';
+    switch (dt) {
+        case DataType.Uint8:
+            suffix = '8';
+            break;
+        case DataType.Int8:
+            suffix = '8_SNORM';
+            break;
+        case DataType.Uint16:
+            suffix = '16UI';
+            break;
+        default:
+            throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+    let prefix = '';
+
+    switch (channel_count) {
+        case 1:
+            prefix = 'R';
+            break;
+        case 2:
+            prefix = 'RG';
+            break;
+        case 3:
+            prefix = 'RGB';
+            break;
+        case 4:
+            prefix = 'RGBA';
+            break;
+        default:
+            throw new Error(`Unsupported channel count '${channel_count}'`);
+    }
+
+    return prefix + suffix;
+}

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

@@ -1555,3 +1555,9 @@ Sampler2D.prototype.traverseOrthogonalNeighbours = function (x, y, visitor, this
     }
 };
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Sampler2D.prototype.isSampler2D = true;
+

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

@@ -0,0 +1,25 @@
+//
+
+/**
+ * Copy single channel from one sampler to another
+ * @param {Sampler2D} source
+ * @param {number} source_channel
+ * @param {Sampler2D} destination
+ * @param {number} destination_channel
+ */
+export function sampler2d_copy_channel_data(source, source_channel, destination, destination_channel) {
+    const pixel_count = source.height * source.width;
+
+    const source_item_size = source.itemSize;
+    const destination_item_size = destination.itemSize;
+
+    const source_data = source.data;
+    const destination_data = destination.data;
+
+    for (let i = 0; i < pixel_count; i++) {
+        const address_source = i * source_item_size + source_channel;
+        const address_destination = i * destination_item_size + destination_channel;
+
+        destination_data[address_destination] = source_data[address_source];
+    }
+}

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

@@ -10,6 +10,9 @@ import { genericResampleSampler2D } from "./genericResampleSampler2D.js";
  * @param {Sampler2D} output
  */
 export function scaleSampler2D(input, output) {
+    assert.equal(input.isSampler2D, true, 'input.isSampler2D !== true');
+    assert.equal(output.isSampler2D, true, 'output.isSampler2D !== true');
+
     const targetItemSize = output.itemSize;
 
     assert.equal(input.itemSize, targetItemSize, 'both source and target must have the same number of channels');

package/engine/graphics/texture/sampler/util/drawSamplerHTML.js

@@ -16,7 +16,20 @@ import { typedArrayConstructorByInstance } from "../typedArrayConstructorByInsta
 export function drawSamplerHTML(parentNode, sampler, x, y, scale, offset, size) {
 
 
-    const target = new Sampler2D(typedArrayConstructorByInstance(sampler.data), sampler.itemSize, size, size);
+    const TA = typedArrayConstructorByInstance(sampler.data);
+
+
+    let target_width = size;
+    let target_height = size;
+
+    // apply aspect ratio
+    if (sampler.width > sampler.height) {
+        target_height = Math.ceil(size * (sampler.height / sampler.width));
+    } else if (sampler.width < sampler.height) {
+        target_width = Math.ceil(size * (sampler.width / sampler.height));
+    }
+
+    const target = new Sampler2D(new TA(target_width * target_height * sampler.itemSize), sampler.itemSize, target_width, target_height);
 
     scaleSampler2D(sampler, target);
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.49",
+  "version": "2.35.0",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",