fwcd / mini-cad Goto Github PK

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

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

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

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).

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

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.

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

Similar to Swift, we could use the var keyword.

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

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

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

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

Similar to last year.

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

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

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

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

• Statements
• Expressions

Should be self-explanatory.

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

Something we could address after #16.

Similar to our Translate operator.

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

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

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.

These should be tokenized with higher precedence than the operators.

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

Should be self-explanatory.

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

Depends on

• #3

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

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

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

This should be pretty easy to do.

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