cf303ebe97
* Declare pattern transform using KCL Signed-off-by: Nick Cameron <nrc@ncameron.org> * Boolean function param defaults Signed-off-by: Nick Cameron <nrc@ncameron.org> * Parse empty record types in fn types Signed-off-by: Nick Cameron <nrc@ncameron.org> --------- Signed-off-by: Nick Cameron <nrc@ncameron.org>
567 lines
17 KiB
Plaintext
567 lines
17 KiB
Plaintext
/// This module contains functions for modifying solids, e.g., by adding a fillet or chamfer, or
|
|
/// removing part of a solid.
|
|
|
|
@no_std
|
|
@settings(defaultLengthUnit = mm, kclVersion = 1.0)
|
|
|
|
import Face from "std::types"
|
|
|
|
/// Blend a transitional edge along a tagged path, smoothing the sharp edge.
|
|
///
|
|
/// Fillet is similar in function and use to a chamfer, except
|
|
/// a chamfer will cut a sharp transition along an edge while fillet
|
|
/// will smoothly blend the transition.
|
|
///
|
|
/// ```
|
|
/// width = 20
|
|
/// length = 10
|
|
/// thickness = 1
|
|
/// filletRadius = 2
|
|
///
|
|
/// mountingPlateSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-width/2, -length/2])
|
|
/// |> line(endAbsolute = [width/2, -length/2], tag = $edge1)
|
|
/// |> line(endAbsolute = [width/2, length/2], tag = $edge2)
|
|
/// |> line(endAbsolute = [-width/2, length/2], tag = $edge3)
|
|
/// |> close(tag = $edge4)
|
|
///
|
|
/// mountingPlate = extrude(mountingPlateSketch, length = thickness)
|
|
/// |> fillet(
|
|
/// radius = filletRadius,
|
|
/// tags = [
|
|
/// getNextAdjacentEdge(edge1),
|
|
/// getNextAdjacentEdge(edge2),
|
|
/// getNextAdjacentEdge(edge3),
|
|
/// getNextAdjacentEdge(edge4)
|
|
/// ],
|
|
/// )
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// width = 20
|
|
/// length = 10
|
|
/// thickness = 1
|
|
/// filletRadius = 1
|
|
///
|
|
/// mountingPlateSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-width/2, -length/2])
|
|
/// |> line(endAbsolute = [width/2, -length/2], tag = $edge1)
|
|
/// |> line(endAbsolute = [width/2, length/2], tag = $edge2)
|
|
/// |> line(endAbsolute = [-width/2, length/2], tag = $edge3)
|
|
/// |> close(tag = $edge4)
|
|
///
|
|
/// mountingPlate = extrude(mountingPlateSketch, length = thickness)
|
|
/// |> fillet(
|
|
/// radius = filletRadius,
|
|
/// tolerance = 0.000001,
|
|
/// tags = [
|
|
/// getNextAdjacentEdge(edge1),
|
|
/// getNextAdjacentEdge(edge2),
|
|
/// getNextAdjacentEdge(edge3),
|
|
/// getNextAdjacentEdge(edge4)
|
|
/// ],
|
|
/// )
|
|
/// ```
|
|
@(impl = std_rust)
|
|
export fn fillet(
|
|
/// The solid whose edges should be filletted
|
|
@solid: Solid,
|
|
/// The radius of the fillet
|
|
radius: number(Length),
|
|
/// The paths you want to fillet
|
|
tags: [Edge; 1+],
|
|
/// The tolerance for this fillet
|
|
tolerance?: number(Length),
|
|
/// Create a new tag which refers to this fillet
|
|
tag?: tag,
|
|
): Solid {}
|
|
|
|
/// Cut a straight transitional edge along a tagged path.
|
|
///
|
|
/// Chamfer is similar in function and use to a fillet, except
|
|
/// a fillet will blend the transition along an edge, rather than cut
|
|
/// a sharp, straight transitional edge.
|
|
///
|
|
/// ```
|
|
/// // Chamfer a mounting plate.
|
|
/// width = 20
|
|
/// length = 10
|
|
/// thickness = 1
|
|
/// chamferLength = 2
|
|
///
|
|
/// mountingPlateSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-width/2, -length/2])
|
|
/// |> line(endAbsolute = [width/2, -length/2], tag = $edge1)
|
|
/// |> line(endAbsolute = [width/2, length/2], tag = $edge2)
|
|
/// |> line(endAbsolute = [-width/2, length/2], tag = $edge3)
|
|
/// |> close(tag = $edge4)
|
|
///
|
|
/// mountingPlate = extrude(mountingPlateSketch, length = thickness)
|
|
/// |> chamfer(
|
|
/// length = chamferLength,
|
|
/// tags = [
|
|
/// getNextAdjacentEdge(edge1),
|
|
/// getNextAdjacentEdge(edge2),
|
|
/// getNextAdjacentEdge(edge3),
|
|
/// getNextAdjacentEdge(edge4)
|
|
/// ],
|
|
/// )
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Sketch on the face of a chamfer.
|
|
/// fn cube(pos, scale) {
|
|
/// sg = startSketchOn(XY)
|
|
/// |> startProfile(at = pos)
|
|
/// |> line(end = [0, scale])
|
|
/// |> line(end = [scale, 0])
|
|
/// |> line(end = [0, -scale])
|
|
///
|
|
/// return sg
|
|
/// }
|
|
///
|
|
/// part001 = cube(pos = [0,0], scale = 20)
|
|
/// |> close(tag = $line1)
|
|
/// |> extrude(length = 20)
|
|
/// // We tag the chamfer to reference it later.
|
|
/// |> chamfer(
|
|
/// length = 10,
|
|
/// tags = [getOppositeEdge(line1)],
|
|
/// tag = $chamfer1,
|
|
/// )
|
|
///
|
|
/// sketch001 = startSketchOn(part001, face = chamfer1)
|
|
/// |> startProfile(at = [10, 10])
|
|
/// |> line(end = [2, 0])
|
|
/// |> line(end = [0, 2])
|
|
/// |> line(end = [-2, 0])
|
|
/// |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
|
|
/// |> close()
|
|
/// |> extrude(length = 10)
|
|
/// ```
|
|
@(impl = std_rust)
|
|
export fn chamfer(
|
|
/// The solid whose edges should be chamfered
|
|
@solid: Solid,
|
|
/// The length of the chamfer
|
|
length: number(Length),
|
|
/// The paths you want to chamfer
|
|
tags: [Edge; 1+],
|
|
/// Create a new tag which refers to this chamfer
|
|
tag?: tag,
|
|
): Solid {}
|
|
|
|
/// Remove volume from a 3-dimensional shape such that a wall of the
|
|
/// provided thickness remains, taking volume starting at the provided
|
|
/// face, leaving it open in that direction.
|
|
///
|
|
/// ```
|
|
/// // Remove the end face for the extrusion.
|
|
/// firstSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-12, 12])
|
|
/// |> line(end = [24, 0])
|
|
/// |> line(end = [0, -24])
|
|
/// |> line(end = [-24, 0])
|
|
/// |> close()
|
|
/// |> extrude(length = 6)
|
|
///
|
|
/// // Remove the end face for the extrusion.
|
|
/// shell(
|
|
/// firstSketch,
|
|
/// faces = [END],
|
|
/// thickness = 0.25,
|
|
/// )
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Remove the start face for the extrusion.
|
|
/// firstSketch = startSketchOn(-XZ)
|
|
/// |> startProfile(at = [-12, 12])
|
|
/// |> line(end = [24, 0])
|
|
/// |> line(end = [0, -24])
|
|
/// |> line(end = [-24, 0])
|
|
/// |> close()
|
|
/// |> extrude(length = 6)
|
|
///
|
|
/// // Remove the start face for the extrusion.
|
|
/// shell(
|
|
/// firstSketch,
|
|
/// faces = [START],
|
|
/// thickness = 0.25,
|
|
/// )
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Remove a tagged face and the end face for the extrusion.
|
|
/// firstSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-12, 12])
|
|
/// |> line(end = [24, 0])
|
|
/// |> line(end = [0, -24])
|
|
/// |> line(end = [-24, 0], tag = $myTag)
|
|
/// |> close()
|
|
/// |> extrude(length = 6)
|
|
///
|
|
/// // Remove a tagged face for the extrusion.
|
|
/// shell(
|
|
/// firstSketch,
|
|
/// faces = [myTag],
|
|
/// thickness = 0.25,
|
|
/// )
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Remove multiple faces at once.
|
|
/// firstSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-12, 12])
|
|
/// |> line(end = [24, 0])
|
|
/// |> line(end = [0, -24])
|
|
/// |> line(end = [-24, 0], tag = $myTag)
|
|
/// |> close()
|
|
/// |> extrude(length = 6)
|
|
///
|
|
/// // Remove a tagged face and the end face for the extrusion.
|
|
/// shell(
|
|
/// firstSketch,
|
|
/// faces = [myTag, END],
|
|
/// thickness = 0.25,
|
|
/// )
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Shell a sketch on face.
|
|
/// size = 100
|
|
/// case = startSketchOn(-XZ)
|
|
/// |> startProfile(at = [-size, -size])
|
|
/// |> line(end = [2 * size, 0])
|
|
/// |> line(end = [0, 2 * size])
|
|
/// |> tangentialArc(endAbsolute = [-size, size])
|
|
/// |> close()
|
|
/// |> extrude(length = 65)
|
|
///
|
|
/// thing1 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [-size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// thing2 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// // We put "case" in the shell function to shell the entire object.
|
|
/// shell(case, faces = [START], thickness = 5)
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Shell a sketch on face object on the end face.
|
|
/// size = 100
|
|
/// case = startSketchOn(XY)
|
|
/// |> startProfile(at = [-size, -size])
|
|
/// |> line(end = [2 * size, 0])
|
|
/// |> line(end = [0, 2 * size])
|
|
/// |> tangentialArc(endAbsolute = [-size, size])
|
|
/// |> close()
|
|
/// |> extrude(length = 65)
|
|
///
|
|
/// thing1 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [-size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// thing2 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// // We put "thing1" in the shell function to shell the end face of the object.
|
|
/// shell(thing1, faces = [END], thickness = 5)
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Shell sketched on face objects on the end face, include all sketches to shell
|
|
/// // the entire object.
|
|
///
|
|
/// size = 100
|
|
/// case = startSketchOn(XY)
|
|
/// |> startProfile(at = [-size, -size])
|
|
/// |> line(end = [2 * size, 0])
|
|
/// |> line(end = [0, 2 * size])
|
|
/// |> tangentialArc(endAbsolute = [-size, size])
|
|
/// |> close()
|
|
/// |> extrude(length = 65)
|
|
///
|
|
/// thing1 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [-size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// thing2 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [size / 2, -size / 2], radius = 25)
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// // We put "thing1" and "thing2" in the shell function to shell the end face of the object.
|
|
/// shell([thing1, thing2], faces = [END], thickness = 5)
|
|
/// ```
|
|
@(impl = std_rust)
|
|
export fn shell(
|
|
/// Which solid (or solids) to shell out
|
|
@solids: [Solid; 1+],
|
|
/// The thickness of the shell
|
|
thickness: number(Length),
|
|
/// The faces you want removed
|
|
faces: [tag; 1+],
|
|
): [Solid] {}
|
|
|
|
|
|
/// Make the inside of a 3D object hollow.
|
|
///
|
|
/// Remove volume from a 3-dimensional shape such that a wall of the
|
|
/// provided thickness remains around the exterior of the shape.
|
|
///
|
|
/// ```
|
|
/// // Hollow a basic sketch.
|
|
/// firstSketch = startSketchOn(XY)
|
|
/// |> startProfile(at = [-12, 12])
|
|
/// |> line(end = [24, 0])
|
|
/// |> line(end = [0, -24])
|
|
/// |> line(end = [-24, 0])
|
|
/// |> close()
|
|
/// |> extrude(length = 6)
|
|
/// |> hollow (thickness = 0.25)
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Hollow a basic sketch.
|
|
/// firstSketch = startSketchOn(-XZ)
|
|
/// |> startProfile(at = [-12, 12])
|
|
/// |> line(end = [24, 0])
|
|
/// |> line(end = [0, -24])
|
|
/// |> line(end = [-24, 0])
|
|
/// |> close()
|
|
/// |> extrude(length = 6)
|
|
/// |> hollow (thickness = 0.5)
|
|
/// ```
|
|
///
|
|
/// ```
|
|
/// // Hollow a sketch on face object.
|
|
/// size = 100
|
|
/// case = startSketchOn(-XZ)
|
|
/// |> startProfile(at = [-size, -size])
|
|
/// |> line(end = [2 * size, 0])
|
|
/// |> line(end = [0, 2 * size])
|
|
/// |> tangentialArc(endAbsolute = [-size, size])
|
|
/// |> close()
|
|
/// |> extrude(length = 65)
|
|
///
|
|
/// thing1 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [-size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// thing2 = startSketchOn(case, face = END)
|
|
/// |> circle( center = [size / 2, -size / 2], radius = 25 )
|
|
/// |> extrude(length = 50)
|
|
///
|
|
/// hollow(case, thickness = 0.5)
|
|
/// ```
|
|
@(impl = std_rust)
|
|
export fn hollow(
|
|
/// Which solid to hollow out
|
|
@solid: Solid,
|
|
/// The thickness of the remaining shell
|
|
thickness: number(Length),
|
|
): Solid {}
|
|
|
|
/// Repeat a 3-dimensional solid, changing it each time.
|
|
///
|
|
/// Replicates the 3D solid, applying a transformation function to each replica.
|
|
/// Transformation function could alter rotation, scale, visibility, position, etc.
|
|
///
|
|
/// The `patternTransform` call itself takes a number for how many total instances of
|
|
/// the shape should be. For example, if you use a circle with `patternTransform(instances = 4, transform = f)`
|
|
/// then there will be 4 circles: the original, and 3 created by replicating the original and
|
|
/// calling the transform function on each.
|
|
///
|
|
/// The transform function takes a single parameter: an integer representing which
|
|
/// number replication the transform is for. E.g. the first replica to be transformed
|
|
/// will be passed the argument `1`. This simplifies your math: the transform function can
|
|
/// rely on id `0` being the original instance passed into the `patternTransform`. See the examples.
|
|
///
|
|
/// The transform function returns a transform object. All properties of the object are optional,
|
|
/// they each default to "no change". So the overall transform object defaults to "no change" too.
|
|
/// Its properties are:
|
|
///
|
|
/// - `translate` (3D point)
|
|
///
|
|
/// Translates the replica, moving its position in space.
|
|
///
|
|
/// - `replicate` (bool)
|
|
///
|
|
/// If false, this ID will not actually copy the object. It'll be skipped.
|
|
///
|
|
/// - `scale` (3D point)
|
|
///
|
|
/// Stretches the object, multiplying its width in the given dimension by the point's component in
|
|
/// that direction.
|
|
///
|
|
/// - `rotation` (object, with the following properties)
|
|
///
|
|
/// - `rotation.axis` (a 3D point, defaults to the Z axis)
|
|
///
|
|
/// - `rotation.angle` (number of degrees)
|
|
///
|
|
/// - `rotation.origin` (either "local" i.e. rotate around its own center, "global" i.e. rotate around the scene's center, or a 3D point, defaults to "local")
|
|
///
|
|
/// ```kcl
|
|
/// // Each instance will be shifted along the X axis.
|
|
/// fn transform(@id) {
|
|
/// return { translate = [4 * id, 0, 0] }
|
|
/// }
|
|
///
|
|
/// // Sketch 4 cylinders.
|
|
/// sketch001 = startSketchOn(XZ)
|
|
/// |> circle(center = [0, 0], radius = 2)
|
|
/// |> extrude(length = 5)
|
|
/// |> patternTransform(instances = 4, transform = transform)
|
|
/// ```
|
|
///
|
|
/// ```kcl
|
|
/// // Each instance will be shifted along the X axis,
|
|
/// // with a gap between the original (at x = 0) and the first replica
|
|
/// // (at x = 8). This is because `id` starts at 1.
|
|
/// fn transform(@id) {
|
|
/// return { translate = [4 * (1+id), 0, 0] }
|
|
/// }
|
|
///
|
|
/// sketch001 = startSketchOn(XZ)
|
|
/// |> circle(center = [0, 0], radius = 2)
|
|
/// |> extrude(length = 5)
|
|
/// |> patternTransform(instances = 4, transform = transform)
|
|
/// ```
|
|
///
|
|
/// ```kcl
|
|
/// fn cube(length, center) {
|
|
/// l = length/2
|
|
/// x = center[0]
|
|
/// y = center[1]
|
|
/// p0 = [-l + x, -l + y]
|
|
/// p1 = [-l + x, l + y]
|
|
/// p2 = [ l + x, l + y]
|
|
/// p3 = [ l + x, -l + y]
|
|
///
|
|
/// return startSketchOn(XY)
|
|
/// |> startProfile(at = p0)
|
|
/// |> line(endAbsolute = p1)
|
|
/// |> line(endAbsolute = p2)
|
|
/// |> line(endAbsolute = p3)
|
|
/// |> line(endAbsolute = p0)
|
|
/// |> close()
|
|
/// |> extrude(length = length)
|
|
/// }
|
|
///
|
|
/// width = 20
|
|
/// fn transform(@i) {
|
|
/// return {
|
|
/// // Move down each time.
|
|
/// translate = [0, 0, -i * width],
|
|
/// // Make the cube longer, wider and flatter each time.
|
|
/// scale = [pow(1.1, exp = i), pow(1.1, exp = i), pow(0.9, exp = i)],
|
|
/// // Turn by 15 degrees each time.
|
|
/// rotation = {
|
|
/// angle = 15 * i,
|
|
/// origin = "local",
|
|
/// }
|
|
/// }
|
|
/// }
|
|
///
|
|
/// myCubes =
|
|
/// cube(length = width, center = [100,0])
|
|
/// |> patternTransform(instances = 25, transform = transform)
|
|
/// ```
|
|
///
|
|
/// ```kcl
|
|
/// fn cube(length, center) {
|
|
/// l = length/2
|
|
/// x = center[0]
|
|
/// y = center[1]
|
|
/// p0 = [-l + x, -l + y]
|
|
/// p1 = [-l + x, l + y]
|
|
/// p2 = [ l + x, l + y]
|
|
/// p3 = [ l + x, -l + y]
|
|
///
|
|
/// return startSketchOn(XY)
|
|
/// |> startProfile(at = p0)
|
|
/// |> line(endAbsolute = p1)
|
|
/// |> line(endAbsolute = p2)
|
|
/// |> line(endAbsolute = p3)
|
|
/// |> line(endAbsolute = p0)
|
|
/// |> close()
|
|
/// |> extrude(length = length)
|
|
/// }
|
|
///
|
|
/// width = 20
|
|
/// fn transform(@i) {
|
|
/// return {
|
|
/// translate = [0, 0, -i * width],
|
|
/// rotation = {
|
|
/// angle = 90 * i,
|
|
/// // Rotate around the overall scene's origin.
|
|
/// origin = "global",
|
|
/// }
|
|
/// }
|
|
/// }
|
|
/// myCubes =
|
|
/// cube(length = width, center = [100,100])
|
|
/// |> patternTransform(instances = 4, transform = transform)
|
|
/// ```
|
|
///
|
|
/// ```kcl
|
|
/// // Parameters
|
|
/// r = 50 // base radius
|
|
/// h = 10 // layer height
|
|
/// t = 0.005 // taper factor [0-1)
|
|
/// // Defines how to modify each layer of the vase.
|
|
/// // Each replica is shifted up the Z axis, and has a smoothly-varying radius
|
|
/// fn transform(@replicaId) {
|
|
/// scale = r * abs(1 - (t * replicaId)) * (5 + cos((replicaId / 8): number(rad)))
|
|
/// return {
|
|
/// translate = [0, 0, replicaId * 10],
|
|
/// scale = [scale, scale, 0],
|
|
/// }
|
|
/// }
|
|
/// // Each layer is just a pretty thin cylinder.
|
|
/// fn layer() {
|
|
/// return startSketchOn(XY) // or some other plane idk
|
|
/// |> circle(center = [0, 0], radius = 1, tag = $tag1)
|
|
/// |> extrude(length = h)
|
|
/// }
|
|
/// // The vase is 100 layers tall.
|
|
/// // The 100 layers are replica of each other, with a slight transformation applied to each.
|
|
/// vase = layer() |> patternTransform(instances = 100, transform = transform)
|
|
/// ```
|
|
///
|
|
/// ```kcl
|
|
/// fn transform(@i) {
|
|
/// // Transform functions can return multiple transforms. They'll be applied in order.
|
|
/// return [
|
|
/// { translate = [30 * i, 0, 0] },
|
|
/// { rotation = { angle = 45 * i } },
|
|
/// ]
|
|
/// }
|
|
/// startSketchOn(XY)
|
|
/// |> startProfile(at = [0, 0])
|
|
/// |> polygon(
|
|
/// radius = 10,
|
|
/// numSides = 4,
|
|
/// center = [0, 0],
|
|
/// inscribed = false,
|
|
/// )
|
|
/// |> extrude(length = 4)
|
|
/// |> patternTransform(instances = 3, transform = transform)
|
|
/// ```
|
|
@(impl = std_rust)
|
|
export fn patternTransform(
|
|
/// The solid(s) to duplicate.
|
|
@solids: [Solid; 1+],
|
|
/// The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect.
|
|
instances: number(Count),
|
|
/// How each replica should be transformed. The transform function takes a single parameter: an integer representing which number replication the transform is for. E.g. the first replica to be transformed will be passed the argument `1`. This simplifies your math: the transform function can rely on id `0` being the original instance passed into the `patternTransform`. See the examples.
|
|
transform: fn(number(Count)): {},
|
|
/// If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid.
|
|
useOriginal?: boolean = false,
|
|
): [Solid; 1+] {}
|