Parts, and the code that made them

package main

import (
	"log"
	"math"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	plate := must(blacksmith.XY().Extrude(must(blacksmith.Rect(120, 80)), 14).Solid())
	defer plate.Close()
	boss := must(blacksmith.FromSolid(plate).
		Faces(blacksmith.Max(blacksmith.AxisZ)).OnFace().
		Extrude(must(blacksmith.Circle(22)), 26).Solid())
	defer boss.Close()
	joined := must(plate.Join(boss, blacksmith.DefaultTolerance))
	defer joined.Close()

	bore := must(must(blacksmith.XY().Extrude(must(blacksmith.Circle(11)), 60).Solid()).Translate(0, 0, -10))
	defer bore.Close()
	bored := must(joined.Cut(bore, blacksmith.DefaultTolerance))
	defer bored.Close()

	// The plate's four vertical corners: the lines along Z between two planes
	// (the boss has vertical seams too, but those lie on its cylinder).
	var corners []int
	for _, e := range must(bored.Edges()) {
		d, ok := e.Direction()
		if !ok || math.Abs(d[2]) <= 0.99 {
			continue
		}
		planes := true
		for _, f := range e.Faces {
			planes = planes && must(bored.FaceKind(f)) == "plane"
		}
		if planes {
			corners = append(corners, e.Index)
		}
	}
	part := must(bored.Fillet(corners, 12, blacksmith.FilletTolerance))
	defer part.Close()
	if err := part.Step("plate.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	box := must(blacksmith.Cuboid(20, 20, 20))
	defer box.Close()
	edges := blacksmith.EdgeIndices(must(box.Edges()))
	part := must(box.Fillet(edges, 2, blacksmith.FilletTolerance))
	defer part.Close()
	if err := part.Step("box-fillet-all.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	box := must(blacksmith.Cuboid(20, 20, 20))
	defer box.Close()
	edges := blacksmith.EdgeIndices(must(box.Edges()))
	part := must(box.Chamfer(edges, 2, blacksmith.FilletTolerance))
	defer part.Close()
	if err := part.Step("box-chamfer-all.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	plate := must(must(blacksmith.Cuboid(60, 40, 4)).Translate(30, 20, 2))

	// Six by four holes of radius 2.5, each a short cylinder cut through the plate.
	for i := 0; i < 6; i++ {
		for j := 0; j < 4; j++ {
			hole := must(blacksmith.XY().Extrude(must(blacksmith.Circle(2.5)), 6).Solid())
			moved := must(hole.Translate(7+9.2*float64(i), 7+8.7*float64(j), -1))
			plate = must(plate.Cut(moved, blacksmith.DefaultTolerance))
			hole.Close()
			moved.Close()
		}
	}

	if err := plate.Step("plate-holes.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	box := must(blacksmith.Cuboid(30, 30, 30))
	defer box.Close()
	hollow := must(box.Shell(3, nil, blacksmith.FilletTolerance))
	defer hollow.Close()

	// A window through the front wall, to see the void the shell left.
	window := must(must(blacksmith.Cuboid(10, 8, 10)).Translate(0, -15, 0))
	defer window.Close()
	part := must(hollow.Cut(window, blacksmith.DefaultTolerance))
	defer part.Close()
	if err := part.Step("hollow-box-window.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"
	"math"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	// The bottle's side, a degree-3 spline in the x/z half-plane (x the radius),
	// closed along the axis so the ends are capped flat.
	side := [][2]float64{{7.238, 1.498}, {9.221, 3.368}, {10.868, 15.965}, {7.306, 22.771},
		{1.909, 24.951}, {3.059, 33.424}, {3.591, 33.377}, {4.0, 34.0}}
	knots := []float64{0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 6, 6, 6}
	profile := must(blacksmith.NewPath(6, 0).NurbsTo(side, knots, 3, nil).
		LineTo(0, 34).LineTo(0, 0).LineTo(6, 0).End())
	defer profile.Close()

	bottle := must(blacksmith.Revolve(profile, [6]float64{0, 0, 0, 0, 0, 1}, 2*math.Pi))
	defer bottle.Close()
	if err := bottle.Step("revolve-bottle.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	// A closed degree-3 spline: the control points after the start, the start last.
	points := [][2]float64{{3.427, -2.292}, {12.491, -5.040}, {23.139, 3.080}, {14.951, 16.721},
		{1.057, 14.037}, {-0.434, 4.100}, {0, 0}}
	knots := []float64{0, 0, 0, 0, 1, 2, 3, 4, 5, 5, 5, 5}
	profile := must(blacksmith.NewPath(0, 0).NurbsTo(points, knots, 3, nil).End())
	defer profile.Close()

	prism := must(blacksmith.XY().Extrude(profile, 15).Solid())
	defer prism.Close()
	if err := prism.Step("spline-prism.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"
	"math"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	// A full turn about Z, starting on the x axis at radius 10.
	path := blacksmith.NewSweepPath(10, 0, 0).Arc([3]float64{0, 0, 0}, [3]float64{0, 0, 1}, 2*math.Pi)
	defer path.Close()

	// The profile sits at the path's start, its plane normal to the path (along +Y).
	start := blacksmith.Frame{10, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0}
	ring := must(blacksmith.Sweep(must(blacksmith.Circle(2)), start, path))
	defer ring.Close()
	if err := ring.Step("sweep-ring.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"log"
	"math"

	"github.com/rdeioris/cadaclysm-sdk/go/blacksmith"
)

func must[T any](v T, err error) T {
	if err != nil {
		log.Fatal(err)
	}
	return v
}

func main() {
	base := must(blacksmith.Cuboid(30, 30, 5))
	defer base.Close()
	pillar := must(blacksmith.FromSolid(base).
		Faces(blacksmith.Max(blacksmith.AxisZ)).OnFace().
		Extrude(must(blacksmith.Circle(6)), 12).Solid())
	defer pillar.Close()
	joined := must(base.Join(pillar, blacksmith.DefaultTolerance))
	defer joined.Close()

	// The joint: the one round edge at the top of the base.
	top := must(base.Bounds()).Max[2]
	var joint []int
	for _, e := range must(joined.Edges()) {
		if !e.IsLine() && math.Abs(e.Segments[0][0][2]-top) < 1e-6 {
			joint = append(joint, e.Index)
		}
	}
	part := must(joined.Fillet(joint, 2, blacksmith.FilletTolerance))
	defer part.Close()
	if err := part.Step("pillar-fillet.stp", "", "mm"); err != nil {
		log.Fatal(err)
	}
}