worker model load, remove, sync using cache

src/main/mesh.js

@@ -55,6 +55,7 @@ broker.subscribe('space_init', data => {
     let { space, platform } = data;
     let platcolor = 0x00ff00;
     let api = mesh.api;
+    let { selection } = api;
 
     // add file drop handler
     space.event.addHandlers(self, [
@@ -84,16 +85,21 @@ broker.subscribe('space_init', data => {
         'keypress', evt => {
             switch (evt.code) {
                 case 'KeyC':
-                    api.selection.centerXY().focus();
+                    selection.centerXY().focus();
                     break;
                 case 'KeyV':
-                    api.selection.focus();
+                    selection.focus();
                     break;
                 case 'KeyW':
-                    api.selection.wireframe({toggle:true});
+                    selection.wireframe({toggle:true});
                     break;
                 case 'KeyB':
-                    api.selection.boundsBox({toggle:true});
+                    selection.boundsBox({toggle:true});
+                    break;
+                case 'KeyS':
+                    for (let m of selection.models()) {
+                        m.sync();
+                    }
                     break;
                 case 'KeyH':
                     space.view.home();
@@ -115,7 +121,7 @@ broker.subscribe('space_init', data => {
             switch (code) {
                 case 'KeyA':
                     if (metaKey || ctrlKey) {
-                        api.selection.set(api.group.list());
+                        selection.set(api.group.list());
                         estop(evt);
                     }
                     break;
@@ -123,35 +129,35 @@ broker.subscribe('space_init', data => {
                     broker.send.space_debug();
                     break;
                 case 'Escape':
-                    api.selection.clear();
+                    selection.clear();
                     estop(evt);
                     break;
                 case 'Backspace':
                 case 'Delete':
-                    for (let s of api.selection.list()) {
+                    for (let s of selection.list()) {
                         s.showBounds(false);
                         s.remove();
                     }
                     estop(evt);
                     break;
                 case 'ArrowUp':
-                    api.selection.rotate(-rv,0,0).floor();
+                    selection.rotate(-rv,0,0).floor();
                     break;
                 case 'ArrowDown':
-                    api.selection.rotate(rv,0,0).floor();
+                    selection.rotate(rv,0,0).floor();
                     break;
                 case 'ArrowLeft':
                     if (shiftKey) {
-                        api.selection.rotate(0,-rv,0).floor();
+                        selection.rotate(0,-rv,0).floor();
                     } else {
-                        api.selection.rotate(0,0,rv).floor();
+                        selection.rotate(0,0,rv).floor();
                     }
                     break;
                 case 'ArrowRight':
                     if (shiftKey) {
-                        api.selection.rotate(0,rv,0).floor();
+                        selection.rotate(0,rv,0).floor();
                     } else {
-                        api.selection.rotate(0,0,-rv).floor();
+                        selection.rotate(0,0,-rv).floor();
                     }
                     break;
             }
@@ -176,7 +182,7 @@ broker.subscribe('space_init', data => {
                     group.qrotation(q);
                     group.floor();
                 } else {
-                    api.selection.toggle(model.group);
+                    selection.toggle(model.group);
                 }
             }
         } else {
@@ -186,7 +192,7 @@ broker.subscribe('space_init', data => {
 
     space.mouse.onDrag((delta, offset, up = false) => {
         if (delta) {
-            api.selection.move(delta.x, delta.y, 0);
+            selection.move(delta.x, delta.y, 0);
         } else {
             return api.objects().length > 0;
         }

src/mesh/api.js

@@ -189,11 +189,6 @@ let model = {
     // @returns {MeshModel[]}
     list() {
         return groups.map(g => g.models).flat();
-    },
-
-    // @param group {MeshModel}
-    remove(model) {
-        model.group.remove(model);
     }
 };
 

src/mesh/group.js

@@ -53,6 +53,8 @@ mesh.group = class MeshGroup extends mesh.object {
         model.group = undefined;
         this.models.remove(model);
         this.group.remove(model.mesh);
+        // trigger sync with worker
+        model.remove(true);
         // auto-remove group when empty
         if (this.group.children.length === 0) {
             mesh.api.group.remove(this);

src/mesh/model.js

@@ -55,14 +55,13 @@ mesh.model = class MeshModel extends mesh.object {
 
     sync() {
         moto.client.fn.model_sync({
-            vertices: this.mesh.geometry.attributes.position.array,
             matrix: this.mesh.matrixWorld.elements,
             id: this.id
         }).then(data => {
             if (data && data.length)
             // for debugging matrix ops
             return mesh.api.group.new([new mesh.model({
-                file: "synth",
+                file: `synth-${this.name}`,
                 mesh: data[0]
             })]);
         });
@@ -80,6 +79,8 @@ mesh.model = class MeshModel extends mesh.object {
         meh.renderOrder = 1;
         // this ref allows clicks to be traced to models and groups
         meh.model = this;
+        // sync data to worker
+        moto.client.fn.model_load({id: this.id, name: this.name, vertices, indices});
         return meh;
     }
 
@@ -158,7 +159,12 @@ mesh.model = class MeshModel extends mesh.object {
     }
 
     remove() {
-        mesh.api.model.remove(this);
+        if (arguments.length === 0) {
+            // direct call requires pass through group
+        } else {
+            // called from group
+            moto.client.fn.model_remove({id: this.id});
+        }
     }
 };
 

src/mesh/work.js

@@ -20,13 +20,32 @@ gapp.finalize("mesh.work", [
 // compensation for space/world/platform rotation
 let space_rotation = new THREE.Matrix4().makeRotationX(Math.PI / 2);
 
+let { client, worker } = moto;
 let cache = {};
 
-moto.worker.bind("model_sync", (data, send) => {
+worker.bind("debug", (data, send) => {
-    let { vertices, matrix, id } = data;
+    console.log({cache});
-    // return send.done(vertices);
+    send.done();
+});
+
+worker.bind("model_load", (data, send) => {
+    let { vertices, name, id } = data;
     let geo = new THREE.BufferGeometry();
     geo.setAttribute('position', new THREE.BufferAttribute(vertices, 3));
+    geo.computeVertexNormals();
+    cache[id] = { id, name, geo };
+    send.done();
+});
+
+worker.bind("model_remove", (data, send) => {
+    delete cache[data.id];
+    send.done();
+});
+
+worker.bind("model_sync", (data, send) => {
+    let { matrix, id } = data;
+    let rec = cache[id];
+    let geo = rec.geo.clone();
     let m4 = space_rotation.clone().multiply( new THREE.Matrix4().fromArray(matrix) );
     geo.applyMatrix4(m4);
     // for debugging matrix ops