Bevy Plugin

[onkoe]

Hi there! Thanks for maintaining this project!

I was wondering if you had any plans to develop some form of Bevy Engine plugin for Manifold. As mentioned in this issue, Bevy notably lacks support for boolean operations on its mesh types. Manifold would be a nice stopgap solution for Rust's largest game engine.

This functionality is essential for my project, so I'd love to assist in any way I can. If you're not planning this kind of support, I'll probably try my hand at something, but my experience here is very limited!

Again, thank you for the great crate! :D

---

I'll go ahead and list a few considerations for this functionality:

• Would using Manifold significantly impact performance over a Rust-native solution?
• What types would need repr(C)? Does Bevy already use repr(C) on its mesh types?
• What data should be sent over FFI, and how often?
• How 'stateful' are Manifold objects? Should they be constructed frequently from Bevy types, or mutated to match them?
• Is there any way to make the two binary-compatible without much hassle?

[WilstonOreo]

Hi, thanks for the feedback!

I am 100% sure that integration into bevy is possible. However, only with a few tweaks and I guess binary compatibility is not possible.
Also, I wrote this wrapper not too much with maximum performance in mind, but rather with a focus on an easy-to-use API.
But the data upload is done using slices with primitive types only, so that should take only a memcpy.

I am also not familiar with bevy (yet), but I took a brief look here:

• https://bevyengine.org/examples-webgpu/3d-rendering/generate-custom-mesh/
• https://docs.rs/bevy/latest/bevy/prelude/struct.Mesh.html

In bevy, you can create custom meshes using the Mesh struct. In manifold-rs, I use an indexed-based topology, so one slice for the vertices and one for the indices is used: https://github.com/WilstonOreo/manifold-rs/blob/410a30d2cda7e85bf5d24485dcb158ed62754779/src/lib.rs#L100C1-L100C85
I don't have support for normals (yet) in manifold-rs, but we could add it.
Bevy (please correct me if I'm wrong), uses triangle lists as mesh data, so you need to convert the indexed-based vertex list into a triangle list. I do this already in the write_stl.rs example.

All in all, the data flow in one-direction could look roughly like this:

• Create a Manifold struct in manifold-rs. The impl of the manifold struct supports almost all operations of C++ manifold API.
• Convert the manifold to a manifold-rs Mesh (Using to_mesh())
• Extract the vertices and indices from the Mesh. (takes two memcpys)
• Convert the list of indexed vertices into a triangle list (another memcpy)
• Compute the normals
• Create a bevy::Mesh using this triangle list and add an attribute array with the normals

The data flow in the opposite direction is basically the reversed order of steps (without the normal computation step).

I hope that helps!

[WilstonOreo]

PS: There is a BatchBoolean method in manifold C++ API. This can be used to avoid the costly data conversions between bevy and manifold types. However, I haven't wrapped it into Rust yet.

[WilstonOreo]

I added a bevy example: https://github.com/WilstonOreo/manifold-rs/blob/755079c6dcffd07f9912ba4c48bde416683f4994/examples/bevy.rs

[onkoe]

This is great - thanks for your effort! :)