fwcd / mini-cad

Parametric 3D modeller with a Swift-inspired DSL for macOS and iOS (WWDC 2023 submission)

MiniCAD

A parameteric 3D modeller for macOS and iOS featuring a Swift-inspired Domain Specific Language (DSL) for modeling.

Description

MiniCAD is a parametric 3D modeling program that lets users construct models with a Swift-like domain-specific language (DSL), drawing inspiration from apps like OpenSCAD, Blender and Swift Playgrounds. The core idea is simple: Use geometric primitives and combine them with unions, differences and intersections to create complex shapes. The programming-centered approach provides the ability to work abstractly in terms of variables and functions, all while using a familiar syntax in a highly interactive environment.

On a more technical level, the app is implemented using SwiftUI and SceneKit. Text rendering uses Core Text. The UI is structured using the Model-View-ViewModel paradigm and is heavily based around value types and protocols. The DSL uses a combination of recursive-descent and operator precedence parsing to convert the user's program into a syntax tree. From there, it is interpreted asynchronously in the background, leveraging Swift's powerful concurrency model. MiniCAD also includes an implementation of Computational Solid Geometry (CSG) based on Binary Space Partitioning (BSP) and ear-clipping polygon triangulation for the mesh operations. The app supports exporting the user's models to the Standard Tesselated Geometry (STL) file format, which makes it easy to open models in other applications such as Preview or even to slice and 3D-print them.

Open Source

The app includes the Suzanne.stl model, a demo model from the open-source 3D modeling application Blender, to showcase the import of external STL models.

Also the implementation of CSG is based on a port of the wonderfully simple and elegant JavaScript implementation by Evan Wallace: https://github.com/evanw/csg.js/ This code is MIT-licensed with Copyright (c) 2011 Evan Wallace (http://madebyevan.com/).

See also

• MiniBlocks, an open-world sandbox game built with SceneKit (my 2022 project)
• MiniCut, a tiny video editor built with SpriteKit (my 2021 project)
• MiniJam, a tiny digital audio workstation built with SwiftUI (my 2020 project)

mini-cad's Issues

Add code completion

It would be cool to have code completion in the editor.

Add CI

We could e.g. automatically run the test suite in CI.

Add prefix, postfix and ternary operators

Another thing for the wishlist. Ternaries might be tricky to parse, we'll have to see how well that plays with our precedence climbing parser.

• Prefix operators
• Postfix operators (only calls and trailing blocks currently)
• Ternary operator

Add `if` statements

Should be self-explanatory.

Use SwiftUI document APIs to implement support for reading/writing recipes

Recipes should use the .swift extension (or a custom one, like .recipe if we want to deviate from Swift syntax).

Add built-in operator for defining custom meshes dynamically

This should be pretty easy to do.

Add argument labels

It would be cool to have support for Swift-style argument labels.

Store save state

Our current 'save' always saves as a new file. It would be nice to differentiate between 'save' and 'save as' by memorizing the file path to the opened file.

Investigate whether we can make the preview scene interactive

This could get pretty tricky after we have #3 and #5, since we'd need to track the 'origin' of each triangle throughout the CSG transformations (#22 would probably come in handy too).

But it would still be very cool if the user could e.g. drag/scale/rotate the objects in real-time in the preview as the code updates automatically (and perhaps snap it to the grid (optionally?)).

Note that this might also require inverting the entire tranformation stack. E.g. if the cube dragged by the user is inside a

Translate(...) {
  Rotate(...) {
    ...
  }
}

we'd have to compute how the original position/scales would have to be modified.

Add proper icon

Zoom the stage view when scrolling

We should fix the camera control to zoom the view towards/away from the orbited point. See also this todo comment:

https://github.com/fwcd/mini-slice/blob/f2fb2482a4dc2d3f5f15d845a33a8aa435f46d2e/MiniSlice.swiftpm/Sources/View/StageView.swift#L9

Implement slicer

Depends on

• #3

Implement a slicer that generates gcode from meshes (and ideally even visualizes it).

Track source ranges of AST nodes

Wrap nodes in @Ranged (or Ranged<...> in lists).

• Statements
• Expressions

Show tips/instructions

We should provide some instructional tips in the UI, e.g.

• briefly explain the UI
• provide useful tips, like using Option+Scroll for zooming

Fix text to mesh conversion (by fixing polygon triangulation)

Use proper precedences in expression pretty-printing

Something we could address after #16.

Investigate how to make built-ins more type-safe

Currently, our built-ins are defined in a rather weakly typed way. It would be cool if we could somehow abstract over this (e.g. structures with Codable arguments and use a custom decoder to deserialize [Value] or similar).

Add support for automatic indentation in editor

It would be convenient to have automatic indentation in the editor.

Implement CSG algorithms (union, intersection, ...)

We could either do this ourselves or use a library such as https://github.com/nicklockwood/Euclid.

Interpret program asynchronously

We probably want to interpret the program asynchronously and add a debouncer to wait until the user has finished typing.

Remove debug views etc.

Before submitting the project, all debug views and outputs should be removed.

Add support for comments and string literals

These should be tokenized with higher precedence than the operators.

Add proper `Mesh` type

Instead of generating Cuboids, we should generate actual meshes and then use CSG algorithms to e.g. compute unions, intersections etc.

Add `while` statements

Should be self-explanatory.

Draw axes in 2D with constant thickness

Currently, their apparent thickness depends on how closely the camera is zoomed in.

Improve interactive visualization of AST/tokenization

It would be cool if the user could interactively explore the AST/the tokenization in a more visual way.

Display errors inline

Now that we have the line it would be cool if we could display parse errors inline, similar e.g. to Xcode.

Add support for mutable variables

Similar to Swift, we could use the var keyword.

Add support for parsing infix expressions

We should have the ability to parse and interpret infix mathematical expressions.

Add Xcode project with "proper" macOS and iOS targets

Similar to last year.

Make `BinaryExpression` a structure

https://github.com/fwcd/mini-slice/blob/9b8b862b21b976583f1e25909d392b23d046e421/MiniSlice.swiftpm/Sources/Model/Recipe/BinaryExpression.swift#L3

This would probably entail

• using the @Box property wrapper for lhs and rhs
• integrating BinaryOperator into the Pretty hierarchy
  • Perhaps even remove its CustomStringConvertible conformance? This would require updating the tokenizer accordingly.
• updating the tests, the interpreter and other places

Add a result builder DSL for `Recipe`

Just to make it slightly more convenient to construct syntax trees programmatically, similar to e.g. SwiftSyntaxBuilder.

Implement STL export

We should have the ability to export triangulated meshes in the STL format.

Add built-in operators for scaling and rotation

Similar to our Translate operator.