SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
#!/usr/bin/env python3
"""Native SELENE trailing-arm suspension and closed-loop coilovers.
The original six Drive modules become limited revolute assemblies. Each wheel
is reparented to its module, and each coilover is split into a barrel and rod.
The model is an ideal kinematic mechanism, not an elastic spring or force model.
Rigid spring and motor-lead geometry is retained for the neutral render pose;
motion profiles must hide it. All command angles are degrees and lengths mm.
Original piston and suspension-ring body labels are retained: late renames force
expensive source-history rebuilds. Their physical roles are stated in manifest().
``stages()`` bounds geometry batches to two wheel modules each, followed by
finishes and assembly. Twelve component anchors are collected in one from_bodies
command, avoiding a full-document rebuild per component. Recreate motion studies
after the assembly stage: deleting the old wheel joints retires their study keys.
"""
from __future__ import annotations
import argparse
import json
import math
from pathlib import Path
POSITIONS = [(side, x) for side in (-1, 1) for x in (-90, 0, 90)]
SOURCE_DRIVE_OCCURRENCES = [2109, 2192, 2275, 2358, 2441, 2524]
HINGE_LIMITS = (-4.0, 1.5)
STROKE_LIMITS = (-3.0, 1.0)
def c(command_id: str, **params) -> dict:
return {"command": command_id, "params": params}
def names(side: int, x: int) -> dict[str, str]:
suffix = f"{side}:{x}"
return {
"suffix": suffix, "drive": f"Drive module {suffix}", "wheel": f"Wheel {suffix}",
"barrel": f"SELENE suspension barrel {suffix}", "rod": f"Damper piston {suffix}",
"hinge": f"SELENE suspension hinge {suffix}", "root": f"SELENE suspension root pin {suffix}",
"stroke": f"SELENE suspension stroke {suffix}", "tip": f"SELENE suspension tip pin {suffix}",
"bushing": f"Suspension bearing {suffix}:{x - 20}",
"spacer": f"Suspension bearing {suffix}:{x}",
}
def stroke(angle_deg: float) -> float:
"""Independent pin-distance relation: L(theta) - neutral length 22 mm."""
t = math.radians(angle_deg)
return math.hypot(35 * math.cos(t) - 20 * math.sin(t) - 35,
-35 * math.sin(t) - 20 * math.cos(t) - 2) - 22
def ring(name, point, axis, outer, inner, length):
if axis == [0, 0, 1]:
xd, yd = [1, 0, 0], [0, 1, 0]
elif axis == [0, 1, 0]:
xd, yd = [1, 0, 0], [0, 0, -1]
else:
raise ValueError("The suspension only needs +Z and +Y annular profiles.")
return [
c("sketch.create", name=name + " profile", plane={"origin": point, "x_dir": xd, "y_dir": yd}),
c("sketch.circle.center", center=[0, 0], radius=outer),
c("sketch.circle.center", center=[0, 0], radius=inner),
c("sketch.constraint.fix", entities=["c1", "c2"], fixed=True),
c("sketch.finish"),
c("solid.extrude", sketch=name + " profile", profiles=[{"point": [(outer + inner) / 2, 0]}],
distance=length, operation="new", body_name=name, name=name + " extrusion"),
]
def barrel_commands(side, x):
n = names(side, x)
result = ring(n["barrel"], [x + 15, side * 60, 85], [0, 0, 1], 3.4, 1.8, 10)
# The source neck ended at the upper pin centre and intersected the pin.
# A short closed end below the eye bore gives a real barrel-to-eye bridge.
result.append(c("solid.cylinder", base=[x + 15, side * 60, 94], radius=2.1, height=2,
operation="join", targets=[n["barrel"]], name=n["barrel"] + " upper neck"))
return result
def gusset_commands(side, x):
result = []
y = side * 54 + (1 if side == 1 else -4)
# Both ribs sit outboard of the carrier's M3 heads, bridge the arm to its
# fixed carrier and clear the retained carrier axle. Their interfaces are
# welded visual overlaps, not claimed press-fit or fastener tolerance data.
for hand in (-1, 1):
name = f"SELENE suspension carrier gusset {side}:{x}:{hand}"
points = [[hand * 10, -67.9], [hand * 3.2, -67.9], [hand * 7, -74.0]]
result.extend([
c("sketch.create", name=name + " profile",
plane={"origin": [x, y, 0], "x_dir": [1, 0, 0], "y_dir": [0, 0, -1]}),
c("sketch.line", points=points, closed=True, infer=False),
c("sketch.constraint.fix", entities=["l1", "l2", "l3"], fixed=True),
c("sketch.finish"),
c("solid.extrude", sketch=name + " profile", distance=3, operation="new",
body_name=name, name=name + " extrusion"),
])
return result
def geometry_commands_for_positions(positions) -> list[dict]:
result = []
for side, x in positions:
n = names(side, x)
suffix = n["suffix"]
result.append(c("component.activate", component="Structure"))
result.append(c("solid.cylinder", base=[x - 20, side * 54 - 3, 96], axis=[0, 1, 0],
radius=9.2, height=6, operation="cut", targets=[f"Suspension chassis shoe {suffix}"],
name=f"SELENE trailing arm shoe clearance {suffix}"))
result.append(c("solid.cylinder", base=[x + 15, side * 60 - 3.1, 98], axis=[0, 1, 0],
radius=3.15, height=6.2, operation="cut", targets=[f"Coilover upper foot {suffix}"],
name=f"SELENE coilover eye foot clearance {suffix}"))
result.append(c("component.activate", component=n["drive"]))
result.append(c("solid.remove", bodies=[f"Gold suspension damper {suffix}",
f"Damper upper neck {suffix}"],
name=f"SELENE retire solid damper {suffix}"))
# Give the piston a genuine overlap with its eye, below the eye's bore.
result.append(c("solid.cylinder", base=[x + 15, side * 60, 77.8], radius=1.7, height=1.4,
operation="join", targets=[f"Damper piston {suffix}"],
name=f"SELENE piston eye bridge {suffix}"))
# The barrel neck is now Ø4.2 rather than the source's Ø3.4. Open the
# spring-seat clearance to Ø4.3 without changing its outer envelope.
result.append(c("solid.cylinder", base=[x + 15, side * 60, 94.8], radius=2.15, height=2,
operation="cut", targets=[f"Spring upper seat {suffix}"],
name=f"SELENE barrel neck seat clearance {suffix}"))
result.append(c("material.assign", bodies=[n["bushing"]], material="Brass"))
result.append(c("appearance.assign", bodies=[n["bushing"]], color=[189, 148, 73],
pbr={"metallic": 1, "roughness": .3, "dielectric_ior": 1.5}))
result.append(c("material.assign", bodies=[n["spacer"]], material="Aluminum"))
result.append(c("component.activate", component="root"))
result.extend(barrel_commands(side, x))
result.extend(gusset_commands(side, x))
return result
def finishing_commands() -> list[dict]:
barrels = [names(side, x)["barrel"] for side, x in POSITIONS]
rods = [names(side, x)["rod"] for side, x in POSITIONS]
gussets = [f"SELENE suspension carrier gusset {side}:{x}:{hand}"
for side, x in POSITIONS for hand in (-1, 1)]
return [
c("material.assign", bodies=barrels + gussets, material="Aluminum"),
c("appearance.assign", bodies=barrels, color=[175, 128, 46],
pbr={"metallic": 1, "roughness": .28, "dielectric_ior": 1.5}),
c("appearance.assign", bodies=gussets, color=[89, 102, 116],
pbr={"metallic": 1, "roughness": .32, "dielectric_ior": 1.5}),
c("material.assign", bodies=rods, material="Steel"),
c("appearance.assign", bodies=rods, color=[180, 190, 201],
pbr={"metallic": 1, "roughness": .18, "dielectric_ior": 1.5}),
c("component.activate", component="root"),
]
def geometry_commands() -> list[dict]:
return ([c("component.activate", component="root")]
+ geometry_commands_for_positions(POSITIONS) + finishing_commands())
def loop_commands(side, x) -> list[dict]:
n = names(side, x)
a, root, tip = [x - 20, side * 54, 96], [x + 15, side * 60, 98], [x + 15, side * 60, 76]
result = [c("joint.as_built", type="revolute", a="Structure", b=n["drive"],
at={"occurrence": "Structure", "point": a, "z": [0, 1, 0]},
name=n["hinge"], limits=[list(HINGE_LIMITS)], quiet=True)]
for kind, name, left, right, point, axis, limits in (
("revolute", n["root"], "Structure", n["barrel"], root, [0, 1, 0], None),
("slider", n["stroke"], n["barrel"], n["rod"], root, [0, 0, -1], [list(STROKE_LIMITS)]),
("revolute", n["tip"], n["rod"], n["drive"], tip, [0, 1, 0], None),
):
params = {"type": kind, "name": name, "flip": True, "quiet": True,
"a": {"occurrence": left, "point": point, "z": axis},
"b": {"occurrence": right, "point": point, "z": axis}}
if limits is not None:
params["limits"] = limits
result.append(c("joint.create", **params))
return result
def assembly_commands() -> list[dict]:
result = [c("component.activate", component="root")]
anchors = [names(side, x)[part] for side, x in POSITIONS for part in ("barrel", "rod")]
result.append(c("component.from_bodies", bodies=anchors))
for side, x in POSITIONS:
n, suffix = names(side, x), f"{side}:{x}"
result.append(c("component.move_bodies", component=n["barrel"], bodies=[
f"Coilover upper eye {suffix}", f"Spring upper seat {suffix}",
]))
result.append(c("component.move_bodies", component=n["rod"], bodies=[
f"Coilover lower eye {suffix}", f"Spring lower seat {suffix}",
]))
upper_fixed = [f"Suspension shaft {suffix}:{x - 20}",
f"Suspension retaining washer {suffix}:{x - 20}",
f"Coilover upper pin {suffix}"]
upper_fixed += [f"Coilover upper pin cap {suffix}:{y:g}" for y in (side * 60 - 7.8, side * 60 + 6)]
upper_fixed += [f"Motor lead ({side}, {x}, {offset}) floor gland" for offset in (-3, 3)]
result.append(c("component.move_bodies", component="Structure", bodies=upper_fixed))
result.append(c("component.move_bodies", component=n["drive"], bodies=[
f"SELENE suspension carrier gusset {suffix}:{hand}" for hand in (-1, 1)
]))
# These exact original joint names belong to the admitted native source.
# Deletion removes their old dependent links and study keys. Recreate the
# inspection studies after this module using joint names, not saved ids.
for occurrence in SOURCE_DRIVE_OCCURRENCES:
result.append(c("joint.delete", joint=f"Rigid Group 1930:{occurrence}"))
for side, x in POSITIONS:
result.append(c("joint.delete", joint=f"Wheel axis {side}:{x}"))
for side, x in POSITIONS:
n = names(side, x)
result.extend(loop_commands(side, x))
result.append(c("joint.as_built", type="revolute", a=n["drive"], b=n["wheel"],
at={"occurrence": n["drive"], "point": [x, side * 86, 40], "z": [0, 1, 0]},
name=f"Wheel axis {side}:{x}", quiet=True))
wheels = [f"Wheel axis {side}:{x}" for side, x in POSITIONS]
for first, second in zip(wheels, wheels[1:]):
result.append(c("joint.motion_link", a=first, b=second, ratio=1, offset=0, quiet=True))
result.append(c("joint.rack_pinion", a=wheels[0], b="Track slide", radius=40, reverse=True, quiet=True))
result.append(c("component.activate", component="root"))
return result
def stages() -> list[tuple[str, list[dict]]]:
result = []
for index, start in enumerate(range(0, len(POSITIONS), 2), 1):
batch = geometry_commands_for_positions(POSITIONS[start:start + 2])
if index == 1:
batch.insert(0, c("component.activate", component="root"))
result.append((f"suspension-geometry-{index}", batch))
result.append(("suspension-finishes", finishing_commands()))
result.append(("suspension-assembly", assembly_commands()))
return result
def commands() -> list[dict]:
return geometry_commands() + assembly_commands()
def fixture_commands(side: int = -1, x: int = -90) -> list[dict]:
"""Four-component analytic fixture with genuine barrel, eyes and pins."""
n, sy = names(side, x), side * 60
result = [c("component.activate", component="root"),
c("solid.box", corner=[x - 29, side * 50 - 11, 101], length=47, width=22, height=4,
operation="new", body_name="Structure", name="Fixture chassis shoe"),
c("solid.cylinder", base=[x - 20, side * 54 - 3, 96], axis=[0, 1, 0],
radius=9.2, height=6, operation="cut", targets=["Structure"], name="Fixture arm clearance"),
c("solid.box", corner=[x + 10, sy - 6, 99], length=10, width=12, height=3,
operation="new", body_name="Fixture upper mounting foot", name="Fixture upper mounting foot"),
c("solid.cylinder", base=[x + 15, sy - 3.1, 98], axis=[0, 1, 0],
radius=3.15, height=6.2, operation="cut", targets=["Fixture upper mounting foot"],
name="Fixture eye clearance"),
c("sketch.create", name="Fixture trailing arm profile",
plane={"origin": [0, side * 54 - 2, 0], "x_dir": [1, 0, 0], "y_dir": [0, 0, -1]}),
c("sketch.slot.center_to_center", p0=[x - 20, -96], p1=[x, -78], width=17),
c("sketch.circle.center", center=[x - 20, -96], radius=6.1),
c("sketch.circle.center", center=[x, -78], radius=6.1),
c("sketch.constraint.fix", entities=["l1", "a1", "l2", "a2", "c1", "c2"], fixed=True),
c("sketch.finish"),
c("solid.extrude", sketch="Fixture trailing arm profile", profiles=[{"point": [x - 10, -87]}],
distance=4, operation="new", body_name=n["drive"], name="Fixture trailing arm extrusion")]
result += barrel_commands(side, x)
result.append(c("solid.cylinder", base=[x + 15, sy, 79], radius=1.7, height=8,
operation="new", body_name=n["rod"], name="Fixture piston"))
result.append(c("solid.cylinder", base=[x + 15, sy, 77.8], radius=1.7, height=1.4,
operation="join", targets=[n["rod"]], name="Fixture piston eye bridge"))
result += ring("Fixture upper eye", [x + 15, sy - 3, 98], [0, 1, 0], 3, 1.75, 6)
result += ring("Fixture lower eye", [x + 15, sy - 3, 76], [0, 1, 0], 3, 1.75, 6)
result += ring("Fixture plain bushing", [x - 20, side * 54 - 2, 96], [0, 1, 0], 6, 3.05, 4)
result += ring("Fixture upper spring seat", [x + 15, sy, 95], [0, 0, 1], 6.2, 1.75, 1.5)
result.append(c("solid.cylinder", base=[x + 15, sy, 94.8], radius=2.15, height=2,
operation="cut", targets=["Fixture upper spring seat"], name="Fixture neck seat clearance"))
result.append(c("solid.box", corner=[x - 17, side * 54 - 12, 65], length=34, width=24, height=3,
operation="new", body_name="Fixture motor carrier", name="Fixture motor carrier"))
result += gusset_commands(side, x)
for name, point, radius, length in (
("Fixture upper pin", [x + 15, sy - 7, 98], 1.7, 14),
("Fixture lower pin", [x + 15, sy - 7, 76], 1.7, 14),
("Fixture pivot axle", [x - 20, side * 54 - 7.5, 96], 3, 15),
):
result.append(c("solid.cylinder", base=point, axis=[0, 1, 0], radius=radius,
height=length, operation="new", body_name=name, name=name))
result.extend([
c("component.from_bodies", bodies=["Structure", n["drive"], n["barrel"], n["rod"]]),
c("component.move_bodies", component="Structure", bodies=["Fixture upper pin", "Fixture pivot axle", "Fixture upper mounting foot"]),
c("component.move_bodies", component=n["drive"], bodies=["Fixture lower pin", "Fixture plain bushing", "Fixture motor carrier"]
+ [f"SELENE suspension carrier gusset {side}:{x}:{hand}" for hand in (-1, 1)]),
c("component.move_bodies", component=n["barrel"], bodies=["Fixture upper eye", "Fixture upper spring seat"]),
c("component.move_bodies", component=n["rod"], bodies=["Fixture lower eye"]),
c("occurrence.ground", occurrence="Structure:1", grounded=True),
])
result += loop_commands(side, x)
result.append(c("component.activate", component="root"))
return result
def manifest() -> dict:
return {
"scope": "Ideal kinematics; no spring force, elastic coils, contact dynamics or cable deformation",
"source_body_labels_retained": True,
"label_policy": "Original Damper piston and Suspension bearing body labels are retained to avoid expensive late source-history rebuilds. The rod uses its original piston label; the pivot ring is a brass plain bushing and the carrier ring is a fixed spacer.",
"new_components": 12, "net_new_joints": 18,
"bodies_added": 18, "bodies_removed": 12, "net_bodies_added": 6,
"neutral_damper_pin_spacing_mm": 22, "barrel_outer_diameter_mm": 6.8,
"barrel_inner_diameter_mm": 3.6, "piston_diameter_mm": 3.4,
"barrel_with_neck_volume_mm3": math.pi * ((3.4 ** 2 - 1.8 ** 2) * 10 + 2.1 ** 2 * 2 - (2.1 ** 2 - 1.8 ** 2)),
"piston_volume_mm3": math.pi * 1.7 ** 2 * 9.2,
"gusset_volume_mm3": .5 * 6.8 * 6.1 * 3,
"support_clearances_mm": {"arm_shoe_radius": 9.2, "arm_outer_radius": 8.5,
"upper_eye_foot_radius": 3.15, "upper_eye_outer_radius": 3.0},
"hinge_limits_deg": list(HINGE_LIMITS), "slider_limits_mm": list(STROKE_LIMITS),
"endpoint_strokes_mm": {str(angle): stroke(angle) for angle in HINGE_LIMITS},
"modules": [{**names(side, x), "hinge_point_mm": [x - 20, side * 54, 96],
"root_point_mm": [x + 15, side * 60, 98], "tip_point_mm": [x + 15, side * 60, 76]}
for side, x in POSITIONS],
"hide_for_motion": [f"Suspension spring {side}:{x}" for side, x in POSITIONS]
+ [f"Motor lead ({side}, {x}, {offset})" for side, x in POSITIONS for offset in (-3, 3)],
"rebuild_studies_after_stage": True,
}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--out", type=Path, required=True)
parser.add_argument("--fixture", action="store_true")
parser.add_argument("--manifest", type=Path)
args = parser.parse_args()
steps = fixture_commands() if args.fixture else commands()
args.out.parent.mkdir(parents=True, exist_ok=True)
args.out.write_text(json.dumps({"commands": steps}, indent=2) + "\n")
if args.manifest:
args.manifest.parent.mkdir(parents=True, exist_ok=True)
args.manifest.write_text(json.dumps(manifest(), indent=2) + "\n")
print(f"{len(steps)} native commands")
if __name__ == "__main__":
main()