libfive VS rust-bindgen

No; Bauble doesn't know how to "rasterize" SDFs into meshes; it only knows how to raymarch them. It's theoretically possible, but it's a pretty complex problem that would take me much too long to figure out and implement. So Bauble is relegated to just making pretty pictures for now. If you want to produce meshes using SDFs, check out https://libfive.com/

This is a mid-point in Matt Keeter's research.

Start at:

http://mattkeeter.com/research/thesis.pdf

then see:

http://www.mattkeeter.com/projects/kokopelli/

then Antimony (see the article at: http://hackaday.com/2015/05/29/otherworldy-cad-software-hail... ), then the current effort:

https://github.com/libfive/libfive

(and also see: https://www.gitlab.com/kavalogic-inc/tovero "a binding of Libfive to Common Lisp, including a standalone REPL-based viewer"[https://github.com/Irev-Dev/curated-code-cad] can be integrated with https://www.gitlab.com/kavalogic-inc/clive

Currently I'm using OpenSCAD (w/ BlockSCAD as a front-end: https://www.blockscad3d.com because I prefer a sort of visual representation), but have been stymied by the lack of file I/O (I want to write out G-code).

Still looking for a 3D modeling tool which is:

- a node or block editor

From another random git commit I found it it seems the project moved to being hosted on gitlab.com under the account name "kavalogic-inc" but all the repos got deleted: - https://gitlab.com/kavalogic-inc

A recent question on AutoCAD lisp pointed to the libfive C++ library with C bindings. It's GitHub page points to the Tovero 3D Modeling system (link on Gitlab). That project is not found on Gitlab.

Or https://libfive.com/, which is less clunky (but no longer OpenSCAD-based).

I thought that early on, and looked (several times!) for something else besides OpenSCAD that would fill the bill (i.e. language-based CAD). There were some dozen projects, and most of them had been abandoned. The closest I got was in using libfive, an f-rep system with a binding to Scheme. But it was too easy for me to cause it to put out no shape at all, and to take a long time doing it.

It looks like the guy you're replying too was kind of an ass, but I do want to point out for anyone else reading that that's not actually that much of a technical limitation: rust code can natively call C code. The main thing you need is a translation of the C library's header file so rustc knows what C functions and structs exist, and that can be automatically generated with bindgen.

It's quite the different approach, but you could consider using bindgen instead.

While I'd also not really like that it's made easier by binding-generators (rust-bindgen for example generates bindings to C (and to some extent C++)). You'll most likely still wanna wrap the generated code into an idiomatic rust API but at least the super painful work can be automated.

Using C libraries from Rust is straightforward with bindgen. Using C++-libraries is less so, but should be doable using cxx. Fortunately, I haven't had a need for that myself, so I can't say how much of a hassle it is.

Then use bindgen in your build.rs file of your crate to generate Rust bindings to the C types.

This is where bingen is coming to help. Bingen takes C//C++ header files as an input and generates rust definitions of the functions and types provided by them. Let's add it to our Cargo.toml as well:

We are planning to use rust-bindgen project to automatically generate rust bindings based on the C++ library header. We will use bindgen as rust library during the build time, however it require libclang to operate, so we have to install it:

There's bindgen, cxx and autocxx. Obviously not as convenient as C++ calling C++; the more you need to interoperate with C++ code the more it makes sense to just stay with C++.

That's literally automated, although I can't imagine what special C libraries you're going to call from a package manager.