The site isn't totally up to date – the Python bindings + API are brand new, and need some examples, but they work great if you know how to use them!
This sounds like a bug, please open a Github issue and I'll investigate.
Either way I should probably close https://github.com/libfive/libfive/issues/206 ?
Surprised to be hearing about this here instead of via that issue closing :p
Yes, these are now part of libfive's core – Python is an important-enough language that having canonical, first-party bindings seems important.
There was a bunch of infrastructure work to get to this point: the standard library was ported from Scheme to C++, so the shape bindings are now autogenerated for both target languages and use FFI to call into a dynamic library (with a C API).
libfive installs custom readers for #0, #1, #2, and so on, which all do the same thing: store the syntax position (row/column/span), then create a free variable with a particular id that's associated with that syntax position.
When pushing and pulling on the surface, it's solving for free variables values that put the surface at your mouse cursor's position. Then, it can splice those values back into the original script using the row/column/span data from before.
Python does the same thing with a magic `var(...)` function, which is used as the target for an AST transform here:
https://github.com/libfive/libfive/blob/master/libfive/bind/...
[1] http://www.gnu.org/software/guile/manual/guile.html#Reader-E...
OpenSCAD is simple and relatively intuitive once you get your head around 3D space and how every object sits in it. The concept - code on the left, visualisation on the right is great. However, it's barely had any improvements in the 8 or so years I've been using it. The tooling is very basic and the performance can be very poor. There's often no way to know if a tiny change will crash (or slow down computation for so long it locks up) the environment (because it doesn't seem to have separation between the render thread and the GUI). Things like fillets, which other CAD environments can do seamlessly, are only possible with a hack which increases rendering time by many orders of magnitude (if it even finishes).
CadQuery seems promising, but in the time I spent with it I found the workplane model quite frustrating. I wanted to write small functional geometries which I could reuse again and again - but I didn't find an easy way to do that. It seems to use global coordinates for all the transformations, so you need to know ahead of time what plane something's on. Maybe I just didn't understand the documentation though - it's incomplete and so you have to piece things together based on examples.
These are of course open source tools, so it's great that they exist at all. In the age of 3D printing, laser cutting and CNC machining fully parametric code based model generation is really exciting.
I'm extremely impressed by what it tries to be, although I found it to be rather hit-and-miss stability-wise. Seems to be the work of a single gifted developer. I would love to see this tool mature because it's pretty much exactly what I want.
For programmatic mesh-based modeling - which is popular in the 3d-printing world but basically a non-starter for "real" CAD - Blender is starting to look quite promising. Blender's Python API is actually very nice for dealing with different coordinate systems (albeit a bit baroque when it comes to interacting with blender's knobs and buttons - although it's very discoverable thanks to the helpful API reference in the tooltips).
There also seems to be an emphasis on correctness in the code, which sounds great to anyone who ever tried doing real work in FreeCad, though of course the gap in functionality is vast.
Coding shapes with signed distance fields is, unfortunately, highly impractical for CAD; operations tend to compose poorly (most operations a) assume euclidian space and b) distort space away from euclidian). But it's a pretty nice medium for generative art, and Scheme is a beautiful language to do it in.
This means that you can go wild with geometric and coordinate transformations – even weird things like twisting or attract/repel will work fine.
(the only requirement is C0 continuity, which is the bare minimum; otherwise, a point could be both inside and outside the shape depending on which direction you approach it from)
Outside of art and black holes and stuff, of course.
You can't mingle MPL/LGPL code with non-copyleft code unless it compiles to a separate binary.
And on iOS/Android - you're forced to have a single signed binary for distribution on the official stores.
Have I misunderstood? I would like to use it in conjunction with Apache licenced code. It feels like I'd be complying with the spirit but not the letter of the licence.
I don't believe the MPL requires the ability to re-link; this is one of the reasons I chose it over the LGPL.
(My intentions are to promote development of the libfive by require changes to the library itself to be shared, while not limiting commercial use / distribution / embedding into a larger application; there is at least one commercial CAD company using libfive as a component in their application)
If anyone wants to help that would be appreciated heaps.
> This library provides a safe mechanism for calling C++ code from Rust and Rust code from C++. It carves out a regime of commonality where Rust and C++ are semantically very similar and guides the programmer to express their language boundary effectively within this regime. CXX fills in the low level stuff so that you get a safe binding, preventing the pitfalls of doing a foreign function interface over unsafe C-style signatures.
If you're interested in chatting with a random inexperienced student about a month into writing his first Rust bindings I'd enjoy sharing approaches. I'm dzfranklin on the Rust language discord. (If you're not already aware of it the channel #black-magic is great for getting help with unsafe code)
