Passing geometry from worker to program

[BarbourSmith]

I'm working on a flow type interface for Replicad (think like how Grasshopper works for Rhino)

The basic app example was super helpful to get started (Thank You!), but now I've run into a more complex issue. I'm running into Uncaught (in promise) TypeError: Unserializable return value when I try to return geometry from the worker.

It makes sense that geometry can't be serialized directly, but is there any way to pass geometry to and from the worker? The idea would be that each node on the graph could generate it's geometry and display values in the worker, but then hold onto that value locally to be passed around between nodes if that makes sense.

Basically my question is, Is there a way to serialize geometry? JSON.stringify(sketchCircle(10)) or something?

[BarbourSmith]

I'm still interested in learning more about this, but I came up with a solution which is to store the geometry in a library in the worker and pass back and forth IDs to access the library. It seems like it should work great.

The only downside is that it means that I can't use multiple workers in parallel to speed up processing which would be nice :)

[BarbourSmith]

Hmm actually perhaps not. It seems like my stored geometry is getting deleted. I'm getting the error message:

comlink.ts:259 Uncaught (in promise) Error: This object has been deleted
    at get wrapped [as wrapped] (replicad.js?v=c3426b02:44:13)
    at makeVec (replicad.js?v=c3426b02:143:35)
    at new Vector (replicad.js?v=c3426b02:150:11)
    at Sketch.extrude (replicad.js?v=c3426b02:4016:7)
    at worker.js?type=module&worker_file:84:39

When I try to extrude a stored circle later.

Any thoughts on how I could store geometry (ie sketchCircle(20)) persistently either in the worker or in the app for later use (ie .extrude(5))?

[sgenoud]

I don't thing the issue is with storing - but there are some methods that still delete the original shape when done (this was here for memory management - but I found a better way so I should stop deleting original shapes).

A quick fix would be to .clone() a shape that is stored to ensure it is not destroy or modified by an operation.

[BarbourSmith]

That sounds exactly like what I should do. What would that look like? I've got the same structure as the example app (just modifying it a little bit) with:

export function createCircle(diameter){
  const circle = sketchCircle(diameter/2);
  return circle;
}

in cad.js

and

function circle(id, diameter) {
  return started.then(() => {
    library[id] = createCircle(diameter);
    return true
  });
}

exposed in worker.js .

If I display the stored circle right away it works perfectly, but if I come back to display it later I get the error message that it has been deleted, although if I print out what is in the library at that point the circle object is still there:

How does .clone() work? Where would be the right place to use it?

[sgenoud]

I think that your solution of storing geometries in the worker is the way to go unless you to learn a lot about both how webassembly memory works and workers.

Note that you would need to learn the same things if you try to work in different workers. If this is the way you want to go anyway, I would start here and follow the links to emscripten stuff - and tell me about all the replicad bugs related to multithreading (because there will be some for sure).

[BarbourSmith]

I've narrowed down the issue with geometry being automatically deleted to a very specific case and I modified the replicad app example file to make a very minimal test case where it happens.

replicad-app-example-minimal.zip

Basically what it comes down to is that 3D geometry saves just fine, but 2D geometry is automatically deleted. The way the test case works is that cad.js just creates a 2d rounded rectangle.

import { drawRoundedRectangle } from "replicad";

// The replicad code! Not much there!
export function drawBox(thickness) {
  return drawRoundedRectangle(30, 50)
    .sketchOnPlane();
}

And then in worker.js we can write that 2d rectangle to a variable and then read it back:

var savedRectangle = null; //This will be used to store the box

function writeBox(thickness) {
  return started.then(() => {
    savedRectangle = drawBox(thickness);
  });
}


function readBox() {
  return started.then(() => {
    return {
      faces: savedRectangle.extrude(5).mesh(),
      edges: savedRectangle.extrude(5).meshEdges(),
    };
  });
}

And it won't be there when we read it back: comlink.ts:259 Uncaught (in promise) Error: This object has been deleted

Now if we move the .extrude into the cad.js file so that we are saving 3D geometry to the variable everything works beautifully.

What do you think? Is this the correct behavior, or a bug, or am I doing something silly? 🤔

[sgenoud]

I would implement it that way:

async function readBox() {
  await started;
  const shape = savedRectangle.clone().extrude(5);
  return {
    faces: shape.mesh(),
    edges: shape.meshEdges(),
  };
}

(I find the async function nicer to read).

Then I would clone the rectangle - so any deletion is not an issue.

Why is the sketch deleted?

The 2D geometry is actually a 2D shape in 3D space - what I call a Sketch. Originally I did not have a good method to do garbage collection of the kernel I use - so I made sure to delete everything when it was used.

I am slowly changing the method to not automatically clean the underlying object.

A random note

While playing with your code I found something weird going on (that I don't have the time now to investigate further), if I do

async function readBox() {
  await started;
  const shape = savedRectangle.clone().extrude(5);
  const shape2 = savedRectangle.clone().extrude(5);

  return {
    faces: shape.mesh(),
    edges: shape2.meshEdges(),
  };
}

but this would be weird (I want both the faces and edges from the same shape).

[BarbourSmith]

Thanks! That is exactly what I needed :)