@woosh/meep-engine 2.33.63 → 2.33.64

package/engine/ecs/attachment/AttachmentSystem.js

@@ -7,38 +7,6 @@ import Mesh from "../../graphics/ecs/mesh/Mesh.js";
 import { BoneAttachmentBinding } from "./BoneAttachmentBinding.js";
 import { TransformAttachmentBinding } from "./TransformAttachmentBinding.js";
 
-/**
- * @readonly
- * @enum {number}
- */
-const WaitingType = {
-    Entity: 0,
-    Socket: 1,
-    Mesh: 2,
-    Transform: 3
-};
-
-class WaitingEntry {
-    /**
-     *
-     * @param {number} entity
-     * @param {WaitingType} type
-     */
-    constructor(entity, type) {
-        /**
-         *
-         * @type {number}
-         */
-        this.entity = entity;
-        /**
-         *
-         * @type {WaitingType}
-         */
-        this.type = type;
-    }
-}
-
-
 export class AttachmentSystem extends System {
     constructor() {
         super();
@@ -315,17 +283,10 @@ export class AttachmentSystem extends System {
         }
     }
 
-    /**
-     *
-     * @param {number} entity
-     * @private
-     */
-    __update_entity(entity) {
-        const bindings = this.parentBindingIndex.get(entity);
+    __updateAll() {
+        for (const [entity, bindings] of this.parentBindingIndex) {
 
-        if (bindings !== undefined) {
             const n = bindings.length;
-
             for (let i = 0; i < n; i++) {
                 const binding = bindings[i];
 
@@ -334,15 +295,6 @@ export class AttachmentSystem extends System {
         }
     }
 
-    /**
-     *
-     * @param {Mesh} mesh
-     * @param {number} entity
-     */
-    visitComponent(mesh, entity) {
-        this.__update_entity(entity);
-    }
-
     update(timeDelta) {
         //process wait queue
         this.processWaiting();
@@ -355,6 +307,6 @@ export class AttachmentSystem extends System {
             return;
         }
 
-        ecd.traverseComponents(Attachment, this.visitComponent, this);
+        this.__updateAll();
     }
 }

package/engine/graphics/geometry/AttributeSpec.d.ts

@@ -0,0 +1,8 @@
+import {DataType} from "../../../core/parser/simple/DataType";
+
+export class AttributeSpec {
+    readonly name: string
+    readonly type: DataType
+    readonly itemSize: number
+    readonly normalized: boolean
+}

package/engine/graphics/geometry/VertexDataSpec.d.ts

@@ -0,0 +1,15 @@
+import {AttributeSpec} from "./AttributeSpec";
+
+export class VertexDataSpec {
+    readonly attributes: AttributeSpec[]
+
+    getAttributeByName(name: string): AttributeSpec | undefined
+
+    add(attribute: AttributeSpec): this
+
+    setAttributes(attributes: AttributeSpec[]): void
+
+    equals(other: VertexDataSpec): boolean
+
+    hash(): number
+}

package/engine/graphics/geometry/buffered/deinterleaveBufferAttribute.js

@@ -0,0 +1,39 @@
+import { BufferAttribute } from "three";
+
+
+/**
+ *
+ * @param {THREE.InterleavedBufferAttribute|THREE.BufferAttribute} source_attribute
+ * @returns {THREE.BufferAttribute}
+ */
+export function deinterleaveBufferAttribute(source_attribute) {
+    if (source_attribute.isInterleavedBufferAttribute !== true && source_attribute.isBufferAttribute) {
+        return source_attribute;
+    }
+
+    const source_data = source_attribute.data;
+    const source_data_array = source_data.array;
+    const stride = source_data.stride;
+
+    const item_count = source_attribute.count;
+    const itemSize = source_attribute.itemSize;
+    const array_size = item_count * itemSize;
+
+    const offset = source_attribute.offset;
+
+    const destination_array = new source_data_array.constructor(array_size);
+
+    const attribute = new BufferAttribute(destination_array, itemSize);
+
+    attribute.normalized = source_attribute.normalized;
+    attribute.name = source_attribute.name;
+
+    // copy data
+    for (let i = 0; i < item_count; i++) {
+        for (let j = 0; j < itemSize; j++) {
+            destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
+        }
+    }
+
+    return attribute;
+}

package/engine/graphics/geometry/buffered/deinterleaveBufferGeometry.js

@@ -0,0 +1,50 @@
+import { BufferGeometry } from "three";
+import { deinterleaveBufferAttribute } from "./deinterleaveBufferAttribute.js";
+
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @returns {THREE.BufferGeometry}
+ */
+export function deinterleaveBufferGeometry(geometry) {
+    const result = new BufferGeometry();
+
+    if (geometry.getIndex() !== null) {
+        result.setIndex(deinterleaveBufferAttribute(geometry.getIndex()));
+    }
+
+    for (const attribute_key in geometry.attributes) {
+        const source_attribute = geometry.attributes[attribute_key];
+
+        result.setAttribute(attribute_key, deinterleaveBufferAttribute(source_attribute));
+    }
+
+    // copy other bits
+    result.name = geometry.name;
+
+    result.morphTargetsRelative = geometry.morphTargetsRelative;
+
+    for (const attribute_key in geometry.morphAttributes) {
+        const source_attributes = geometry.morphAttributes[attribute_key];
+
+        const result_attributes = [];
+
+        result.morphAttributes[attribute_key] = result_attributes;
+
+        for (let i = 0; i < source_attributes.length; i++) {
+            const source_attribute = source_attributes[i];
+            result_attributes[i] = deinterleaveBufferAttribute(source_attribute);
+        }
+    }
+
+    result.groups = geometry.groups.slice();
+
+
+    result.boundingBox = geometry.boundingBox !== null ? geometry.boundingBox.clone() : null;
+    result.boundingSphere = geometry.boundingSphere !== null ? geometry.boundingSphere.clone() : null;
+    result.drawRange.start = geometry.drawRange.start;
+    result.drawRange.count = geometry.drawRange.count;
+    result.userData = JSON.parse(JSON.stringify(geometry.userData));
+
+    return result;
+}

package/engine/graphics/micron/build/buildMicronGeometryFromBufferGeometry.js

@@ -12,6 +12,7 @@ import { expandConnectivityByLocality } from "../../../../core/geom/3d/topology/
 import { build_geometry_info } from "./build_geometry_info.js";
 import { build_leaf_patches_metis } from "./clustering/build_leaf_patches_metis.js";
 import { compute_buffer_geometry_byte_size } from "../../geometry/buffered/compute_buffer_geometry_byte_size.js";
+import { deinterleaveBufferGeometry } from "../../geometry/buffered/deinterleaveBufferGeometry.js";
 
 /**
  * Returns current time in milliseconds
@@ -105,11 +106,13 @@ const PRINT_VERBOSE_STATS = false;
  * @returns {MicronGeometry}
  */
 export async function buildMicronGeometryFromBufferGeometry(input) {
+    const source_geometry = deinterleaveBufferGeometry(input);
+
     // build topology representation
     const topoMesh = new TopoMesh();
 
-    const position_attribute = input.getAttribute("position");
-    const index_attribute = input.index;
+    const position_attribute = source_geometry.getAttribute("position");
+    const index_attribute = source_geometry.index;
 
     const face_index_array = index_attribute.array;
     const vertex_position_array = position_attribute.array;
@@ -183,18 +186,18 @@ export async function buildMicronGeometryFromBufferGeometry(input) {
 
     const r = new MicronGeometry();
 
-    r.proxy = input; // TODO use r.buildProxy(1) instead
+    r.proxy = source_geometry; // TODO use r.buildProxy(1) instead
 
     r.source_triangle_count = index_attribute.count / 3;
-    r.source_vertex_count = input.getAttribute('position').count;
-    r.source_byte_size = compute_buffer_geometry_byte_size(input);
+    r.source_vertex_count = source_geometry.getAttribute('position').count;
+    r.source_byte_size = compute_buffer_geometry_byte_size(source_geometry);
 
     // console.time('build geometry');
 
-    const vertex_attributes = attributes_from_buffer_geometry(input);
+    const vertex_attributes = attributes_from_buffer_geometry(source_geometry);
 
     r.vertex_spec.setAttributes(vertex_attributes);
-    r.root = compilePatchGraph(root, input, r.vertex_spec);
+    r.root = compilePatchGraph(root, source_geometry, r.vertex_spec);
 
     r.initialize();
 

package/engine/graphics/micron/format/MicronGeometry.d.ts

@@ -1,5 +1,9 @@
 import {BufferGeometry} from "three";
+import {VertexDataSpec} from "../../geometry/VertexDataSpec";
 
 export class MicronGeometry {
+    vertex_spec: VertexDataSpec
     public proxy: BufferGeometry
+
+    initialize(): void
 }

package/engine/graphics/render/webgpu/sample/MeshInstance.js

@@ -83,6 +83,14 @@ export class MeshInstance {
 
     }
 
+    /**
+     *
+     * @param {GPURenderPassEncoder} pass
+     */
+    preparePass(pass) {
+
+    }
+
     /**
      *
      * @param {GPURenderPassEncoder} pass
@@ -94,6 +102,7 @@ export class MeshInstance {
 
         pass.setVertexBuffer(0, this.vertex_buffer);
         pass.setIndexBuffer(this.index_buffer, 'uint32');
+
         pass.drawIndexed(this.geometry.getIndex().array.length);
     }
 }

package/engine/graphics/render/webgpu/sample/main.js

@@ -323,7 +323,7 @@ const init = async ({ canvasRef, gui }) => {
     };
     const settings = {
         mode: 'rendering',
-        numLights: 128,
+        numLights:1,
     };
     const configUniformBuffer = (() => {
         const buffer = device.createBuffer({
@@ -541,7 +541,7 @@ const init = async ({ canvasRef, gui }) => {
             gBufferPass.setPipeline(writeGBuffersPipeline);
             gBufferPass.setBindGroup(0, sceneUniformBindGroup);
 
-            m_instance.draw(gBufferPass);
+                m_instance.draw(gBufferPass);
 
             gBufferPass.endPass();
         }

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.33.63",
+  "version": "2.33.64",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/util/ScreenGridPicker.js

@@ -1,3 +0,0 @@
-/**
- * Created by Alex on 13/06/2016.
- */