Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add reusable assembly components and mounting sites

Yuechen Lib36af05d3c3b
diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblySiteAuthoringTests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblySiteAuthoringTests.cs
new file mode 100644
index 00000000..050c12bf
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblySiteAuthoringTests.cs
@@ -0,0 +1,88 @@
+using Aetheris.Kernel.Firmament.Assembly;
+
+namespace Aetheris.Kernel.Firmament.Tests.Assembly;
+
+public sealed class AssemblySiteAuthoringTests
+{
+ private static string Fixture => FirmamentCorpusHarness.ResolveFixtureFullPath(
+ "fixtures/Canonical/AssemblyInterfaces/AuthoringFoundation/mounting-rows.firmament");
+
+ [Fact]
+ public void RowsReuseOneComponentAndSeatInTiltedFrameWithProperClocking()
+ {
+ var result = new AssemblyM1Pipeline().CompileFile(Fixture);
+ Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics));
+ Assert.Single(result.Ir!.AssemblyDefinitions!);
+ Assert.Equal(2, result.Geometry!.DefinitionBodies.Count);
+ Assert.Equal(12, result.Geometry.InstanceBodies.Count);
+ var exported = AssemblyIrAp242Exporter.Export(result);
+ Assert.True(exported.IsSuccess, string.Join("\n", exported.Diagnostics));
+ var imported = Aetheris.Kernel.Core.Step242.Step242AssemblyImporter.Import(exported.Value);
+ Assert.True(imported.IsSuccess, string.Join("\n", imported.Diagnostics));
+ var geometryIds = imported.Value.Definitions.Where(d => d.Geometry is not null).Select(d => d.StableId).ToHashSet();
+ Assert.Equal(12, imported.Value.Occurrences.Count(o => geometryIds.Contains(o.DefinitionStableId!)));
+ var patterns = result.Ir.Patterns!;
+ Assert.Equal(2, patterns.Count);
+ Assert.Single(patterns.Single(p => p.Name == "BassRow").SiteRecipe!);
+ Assert.Equal(2, patterns.Single(p => p.Name == "TrebleRow").SiteRecipe!.Count);
+ Assert.All(patterns, p => Assert.Equal(new[] { "Low", "Middle", "High" }, p.Associations!.Select(a => a.SourceEntry)));
+ var angle = -13 * Math.PI / 180;
+ foreach (var (key, y) in new[] { ("Low", 20), ("Middle", 50), ("High", 80) })
+ {
+ var bass = result.Ir.Instances.Single(i => i.Path.ToString() == $"MountingRows.BassRow.{key}.Unit.Post").ResolvedTransform!.Matrix;
+ var treble = result.Ir.Instances.Single(i => i.Path.ToString() == $"MountingRows.TrebleRow.{key}.Unit.Post").ResolvedTransform!.Matrix;
+ Assert.Equal(-10, bass[12], 8); Assert.Equal(10, treble[12], 8);
+ Assert.Equal(y * Math.Cos(angle), bass[13], 8);
+ Assert.Equal(7 + y * Math.Sin(angle), bass[14], 8);
+ Assert.Equal(bass[13], treble[13], 8); Assert.Equal(bass[14], treble[14], 8);
+ Assert.Equal(1, bass[0], 8); Assert.Equal(-1, treble[0], 8);
+ Assert.Equal(bass[9], treble[9], 8); Assert.Equal(bass[10], treble[10], 8);
+ var leftButton = result.Ir.Instances.Single(i => i.Path.ToString() == $"MountingRows.BassRow.{key}.Unit.Button");
+ var rightButton = result.Ir.Instances.Single(i => i.Path.ToString() == $"MountingRows.TrebleRow.{key}.Unit.Button");
+ Assert.Equal(-15, leftButton.ResolvedTransform!.Matrix[12], 8);
+ Assert.Equal(15, rightButton.ResolvedTransform!.Matrix[12], 8);
+ }
+ }
+
+ [Fact]
+ public void PitchChangesKeepOccurrenceIdentitiesAndMoveOnlyLaterKeys()
+ {
+ var source = File.ReadAllText(Fixture);
+ AssemblyCompilationResult Compile(string text)
+ {
+ var parsed = new AssemblyM0Parser().Parse(text);
+ Assert.True(parsed.IsSuccess, string.Join("\n", parsed.Diagnostics));
+ var compiled = new AssemblyM0Compiler().Compile(parsed.Source!);
+ Assert.True(compiled.IsSuccess, string.Join("\n", compiled.Diagnostics));
+ return compiled;
+ }
+ var before = Compile(source); var after = Compile(source.Replace("30mm", "36mm"));
+ foreach (var occurrence in before.Ir!.Instances)
+ {
+ var changed = after.Ir!.Instances.Single(i => i.Path.ToString() == occurrence.Path.ToString());
+ Assert.Equal(occurrence.StableId, changed.StableId);
+ if (occurrence.Path.ToString().Contains(".Low.", StringComparison.Ordinal))
+ Assert.Equal(occurrence.ResolvedTransform!.Matrix, changed.ResolvedTransform!.Matrix);
+ }
+ Assert.NotEqual(before.Ir.Instances.Single(i => i.Path.ToString() == "MountingRows.BassRow.High.Unit").ResolvedTransform!.Matrix[13],
+ after.Ir!.Instances.Single(i => i.Path.ToString() == "MountingRows.BassRow.High.Unit").ResolvedTransform!.Matrix[13]);
+ }
+
+ [Theory]
+ [InlineData("[Low, Middle, High]", "[Low, Low, High]")]
+ [InlineData("[Low, Middle, High]", "[]")]
+ [InlineData("[0mm,30mm,0mm]", "[0mm,0mm,0mm]")]
+ [InlineData("[0mm,30mm,0mm]", "[0mm,30deg,0mm]")]
+ [InlineData("[0mm,30mm,0mm]", "[0mm,NaNmm,0mm]")]
+ [InlineData("[0mm,30mm,0mm]", "[0mm,1e308mm,0mm]")]
+ [InlineData("Across: YZ", "Across: UnknownPlane")]
+ [InlineData("From BassSites", "From MissingSites")]
+ [InlineData("Across: YZ;", "Across: YZ; Extra: 1;")]
+ [InlineData("Across: YZ;", "Across: YZ; Across: XZ;")]
+ public void InvalidSiteRecipesFailAtAuthoringBoundary(string oldValue, string newValue)
+ {
+ var parsed = new AssemblyM0Parser().Parse(File.ReadAllText(Fixture).Replace(oldValue, newValue));
+ Assert.False(parsed.IsSuccess);
+ Assert.Contains(parsed.Diagnostics, d => d.Code == "assembly-pattern-invalid" && d.Message.Contains("assembly-sites-invalid"));
+ }
+}
diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs
index f574a769..79a8753f 100644
--- a/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs
@@ -15,7 +15,7 @@ public sealed class GuitarSurfacingWitnessTests
Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics));
Assert.Equal(53, result.Geometry!.DefinitionBodies.Count);
Assert.Equal(91, result.Geometry.InstanceBodies.Count);
- Assert.Equal(7, result.Ir!.AssemblyDefinitions!.Count);
+ Assert.Equal(10, result.Ir!.AssemblyDefinitions!.Count);
var neck = result.Ir.Instances.Single(i => i.Path.ToString() == "GuitarX0.Neck");
Assert.True(neck.IsEncapsulatedDefinition);
Assert.True(neck.SemanticRoot.ExposedMembers.ContainsKey("NutMount"));
@@ -24,7 +24,7 @@ public sealed class GuitarSurfacingWitnessTests
Assert.Equal(660, nut.OriginY, 6);
Assert.Equal(55, nut.OriginZ, 6);
Assert.DoesNotContain("Headstock", neck.SemanticRoot.ExposedMembers.Keys);
- Assert.Equal(16, result.Ir.SourceDependencies!.Count);
+ Assert.Equal(19, result.Ir.SourceDependencies!.Count);
Assert.Contains(result.Ir.SourceDependencies, d => d.Path == "tuners-assembly.firmament");
}
[Fact]
@@ -38,12 +38,17 @@ public sealed class GuitarSurfacingWitnessTests
Assert.Equal(91, mesh.Occurrences.Count(o => o.DefinitionId is not null));
Assert.Equal(4, compiled.Ir!.Patterns!.Count);
Assert.Empty(compiled.Ir.Joints!);
- Assert.Equal(7, compiled.Ir.AssemblyDefinitions!.Count);
+ Assert.Equal(10, compiled.Ir.AssemblyDefinitions!.Count);
Assert.Single(compiled.Ir.AssemblyDefinitions.Single(d => d.DefinitionIdentity == "GuitarNeck").LocalMates,
mate => mate.Name == "VeneerSeat");
Assert.DoesNotContain(File.ReadAllText(path), "LegacyExplicit");
- Assert.Contains(compiled.Ir.Instances, i => i.Path.ToString() == "GuitarX0.Neck.Tuners.TunerPosts.TunerPost00.TunerPost"
+ Assert.Contains(compiled.Ir.Instances, i => i.Path.ToString() == "GuitarX0.Neck.Tuners.BassRow.Low.Tuner.TunerPost"
&& i.Provenance.Any(p => p.Stage == "assembly-pattern"));
+ var tunerUnits = compiled.Ir.Instances.Where(i => i.DefinitionIdentity == "GuitarTuner").ToArray();
+ Assert.Equal(6, tunerUnits.Length);
+ Assert.All(tunerUnits, t => Assert.True(t.SemanticRoot.ExposedMembers.ContainsKey("Mount")));
+ Assert.Equal(4, compiled.Ir.Instances.Count(i => i.DefinitionIdentity == "ControlKnob"));
+ Assert.Single(compiled.Ir.Instances, i => i.DefinitionIdentity == "PickupSelector");
var pickups = compiled.Ir.Instances.Where(i => i.DefinitionIdentity.StartsWith("Humbucker<", StringComparison.Ordinal)).ToArray();
Assert.Equal(2, pickups.Length);
Assert.All(pickups, p => Assert.Equal(53, p.ResolvedTransform!.Matrix[14], 6));
@@ -52,6 +57,16 @@ public sealed class GuitarSurfacingWitnessTests
var head = compiled.Ir.Instances.Single(i => i.Path.ToString() == "GuitarX0.Neck.Headstock");
Assert.Equal(660, head.ResolvedTransform!.Matrix[13], 6);
Assert.Equal(48, head.ResolvedTransform.Matrix[14], 6);
+ foreach (var tuner in tunerUnits)
+ {
+ var m = tuner.ResolvedTransform!.Matrix;
+ // Washer underside lies on the actual veneer top: head-local z = 15mm.
+ var dy = m[13] - head.ResolvedTransform.Matrix[13];
+ var dz = m[14] - head.ResolvedTransform.Matrix[14];
+ Assert.Equal(15, dy * head.ResolvedTransform.Matrix[9] + dz * head.ResolvedTransform.Matrix[10], 7);
+ Assert.Equal(head.ResolvedTransform.Matrix[9], m[9], 8);
+ Assert.Equal(head.ResolvedTransform.Matrix[10], m[10], 8);
+ }
Assert.Equal(6, mesh.Definitions.Count(d => d.Identity.StartsWith("GuitarString<", StringComparison.Ordinal)));
var surfaced = mesh.Definitions.Where(d => d.Identity.StartsWith("SectionChainFile", StringComparison.Ordinal)).ToArray();
Assert.Equal(4, surfaced.Length);
@@ -111,5 +126,12 @@ public sealed class GuitarSurfacingWitnessTests
"Centerline samples must lie on the straight back or flat seat.");
}
Assert.Contains("subdivisionScheme = \"none\"", AssemblyUsdExporter.Serialize(compiled.Ir!, mesh));
+ var exported = AssemblyIrAp242Exporter.Export(compiled);
+ Assert.True(exported.IsSuccess, string.Join("\n", exported.Diagnostics));
+ var imported = Aetheris.Kernel.Core.Step242.Step242AssemblyImporter.Import(exported.Value);
+ Assert.True(imported.IsSuccess, string.Join("\n", imported.Diagnostics));
+ var geometryIds = imported.Value.Definitions.Where(d => d.Geometry is not null).Select(d => d.StableId).ToHashSet();
+ Assert.Equal(53, geometryIds.Count);
+ Assert.Equal(91, imported.Value.Occurrences.Count(o => geometryIds.Contains(o.DefinitionStableId!)));
}
}
diff --git a/Aetheris.Kernel.Firmament.Tests/ConceptDerivationTests.cs b/Aetheris.Kernel.Firmament.Tests/ConceptDerivationTests.cs
index 002c7ded..06307d52 100644
--- a/Aetheris.Kernel.Firmament.Tests/ConceptDerivationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/ConceptDerivationTests.cs
@@ -126,7 +126,7 @@ public sealed class ConceptDerivationTests
var documents = Directory.GetFiles(Path.GetDirectoryName(path)!,"*.firmament").Append(path).ToDictionary(p => Path.GetFileName(p),File.ReadAllText);
using var session = new FirmamentCompilationSession();
var first = session.CompileProject(new("guitar.firmasm",documents));
- Assert.True(first.IsSuccess, string.Join("\n",first.Diagnostics)); Assert.Equal(16, first.Ir!.SourceDependencies!.Count);
+ Assert.True(first.IsSuccess, string.Join("\n",first.Diagnostics)); Assert.Equal(19, first.Ir!.SourceDependencies!.Count);
Assert.Single(first.Ir.SourceDependencies, d => d.IsRoot);
Assert.Equal(9, first.Geometry!.Artifact.Definitions.Sum(d => d.Provenance.Count(p => p.Stage == "concept-boundary-placement")));
documents["body-outline.firmament"] = documents["body-outline.firmament"].Replace("115mm,-195mm", "115.1mm,-195mm");
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM2Interop.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM2Interop.cs
index e4fea5b2..75d44bcd 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM2Interop.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM2Interop.cs
@@ -111,11 +111,33 @@ public static class AssemblyIrAp242Exporter
.OrderBy(definition => definition.StableId, StringComparer.Ordinal).ToArray();
var byId = ir.Instances.ToDictionary(item => item.StableId, StringComparer.Ordinal);
var assemblyDefinitionByIdentity = (ir.AssemblyDefinitions ?? []).ToDictionary(item => item.DefinitionIdentity, item => item.StableId, StringComparer.Ordinal);
+ // A reusable product owns its child usages. Recovering these from each
+ // posed world occurrence introduces roundoff-dependent duplicate STEP
+ // usages. Read the already-solved local definition once instead.
+ var definitionChildTransforms = new Dictionary<(string Definition, string Child), IReadOnlyList<double>>();
+ foreach (var definition in ir.AssemblyDefinitions ?? [])
+ {
+ var root = definition.LocalInstances.Single(item => item.ParentStableId is null);
+ if (root.ResolvedTransform is null) return Failure($"Assembly definition '{definition.DefinitionIdentity}' has no solved local root.");
+ var rootInverse = Transform3D.FromRowMajor(root.ResolvedTransform.Matrix).Inverse();
+ foreach (var child in definition.LocalInstances.Where(item => item.ParentStableId == root.StableId))
+ {
+ if (child.ResolvedTransform is null) return Failure($"Assembly definition '{definition.DefinitionIdentity}' has an unsolved child '{child.Path}'.");
+ definitionChildTransforms.Add((definition.DefinitionIdentity, child.Path.Segments.Last()),
+ (Transform3D.FromRowMajor(child.ResolvedTransform.Matrix) * rootInverse).ToRowMajor());
+ }
+ }
+ foreach (var instance in ir.Instances.Where(item => item.ParentStableId is not null))
+ if (byId[instance.ParentStableId!].IsEncapsulatedDefinition &&
+ !definitionChildTransforms.ContainsKey((byId[instance.ParentStableId!].DefinitionIdentity, instance.Path.Segments.Last())))
+ return Failure($"Occurrence '{instance.Path}' has no definition-owned local child transform.");
var occurrences = ir.Instances.OrderBy(item => item.Path.Segments.Count).ThenBy(item => item.StableId, StringComparer.Ordinal).Select(instance =>
{
var world = instance.ResolvedTransform ?? AssemblyTransform.Identity;
IReadOnlyList<double> local = world.Matrix;
- if (instance.ParentStableId is not null && byId[instance.ParentStableId].ResolvedTransform is { } parentWorld)
+ if (instance.ParentStableId is not null && byId[instance.ParentStableId].IsEncapsulatedDefinition)
+ local = definitionChildTransforms[(byId[instance.ParentStableId].DefinitionIdentity, instance.Path.Segments.Last())];
+ else if (instance.ParentStableId is not null && byId[instance.ParentStableId].ResolvedTransform is { } parentWorld)
{
var parent = Transform3D.FromRowMajor(parentWorld.Matrix);
local = (Transform3D.FromRowMajor(world.Matrix) * parent.Inverse()).ToRowMajor();
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/AssemblySiteAuthoring.cs b/Aetheris.Kernel.Firmament/FirmamentV2/AssemblySiteAuthoring.cs
new file mode 100644
index 00000000..50ab9335
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/AssemblySiteAuthoring.cs
@@ -0,0 +1,87 @@
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace Aetheris.Kernel.Firmament.FirmamentV2;
+
+/// <summary>Finite, named mounting-site recipes. Coordinates belong to the consumer's
+/// target frame; this produces checked Set data, never reflected occurrence matrices.</summary>
+internal static class AssemblySiteAuthoring
+{
+ private sealed record Site(string Key, double[] Point);
+ internal sealed record Result(string Source, IReadOnlyDictionary<string, IReadOnlyList<string>> Recipes);
+ internal static Result? Expand(string source, List<string> diagnostics)
+ {
+ var declarations = Regex.Matches(source,
+ @"\b(?<kind>Linear|Mirrored)\s+Sites\s+(?<name>[A-Za-z_]\w*)(?:\s+From\s+(?<from>[A-Za-z_]\w*))?\s*\{").Cast<Match>().ToArray();
+ if (declarations.Length == 0) return new(source, new Dictionary<string, IReadOnlyList<string>>());
+ var values = new Dictionary<string, Site[]>(StringComparer.Ordinal);
+ var recipes = new Dictionary<string, IReadOnlyList<string>>(StringComparer.Ordinal);
+ var changes = new List<(int Start, int Length, string Text)>();
+ foreach (var declaration in declarations)
+ {
+ var name = declaration.Groups["name"].Value;
+ var open = declaration.Index + declaration.Length - 1;
+ var close = source.IndexOf('}', open);
+ void Error(string detail) => diagnostics.Add(CanonicalStaticAuthoring.Prefix + "assembly-sites-invalid:" + name + ":" + detail);
+ if (close < 0) { Error("unclosed"); return null; }
+ var body = source[(open + 1)..close];
+ var fields = new Dictionary<string, string>(StringComparer.Ordinal);
+ foreach (var field in body.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+ {
+ var split = field.Split(':', 2, StringSplitOptions.TrimEntries);
+ if (split.Length != 2 || !fields.TryAdd(split[0], split[1])) Error("malformed-or-duplicate-field");
+ }
+ if (values.ContainsKey(name)) { Error("duplicate-name"); continue; }
+ Site[]? sites = null;
+ if (declaration.Groups["kind"].Value == "Linear")
+ {
+ if (declaration.Groups["from"].Success || fields.Count != 3 ||
+ !fields.TryGetValue("Keys", out var keysText) || !fields.TryGetValue("Start", out var startText) ||
+ !fields.TryGetValue("Step", out var stepText)) { Error("expected-Keys-Start-Step"); continue; }
+ var keysMatch = Regex.Match(keysText, @"^\[(?<keys>[^\[\]]*)\]$");
+ var keys = keysMatch.Groups["keys"].Value.Split(',', StringSplitOptions.TrimEntries);
+ if (!keysMatch.Success || keys.Length > 1024 || keys.Any(k => !Regex.IsMatch(k, @"^[A-Za-z_]\w*$")) ||
+ keys.Distinct(StringComparer.Ordinal).Count() != keys.Length) { Error("invalid-keys"); continue; }
+ var start = Vector(startText); var step = Vector(stepText);
+ if (start is null || step is null || step.All(v => v == 0)) { Error("finite-mm-vectors-and-nonzero-step-required"); continue; }
+ sites = keys.Select((key, i) => new Site(key, start.Zip(step, (s, d) => s + i * d).ToArray())).ToArray();
+ if (sites.Any(s => s.Point.Any(p => !double.IsFinite(p)))) { Error("coordinate-overflow"); continue; }
+ }
+ else
+ {
+ if (!declaration.Groups["from"].Success || !values.TryGetValue(declaration.Groups["from"].Value, out var parent))
+ { Error("source-must-be-an-earlier-site-recipe"); continue; }
+ if (fields.Count != 1 || !fields.TryGetValue("Across", out var plane) || plane is not ("YZ" or "XZ" or "XY"))
+ { Error("Across-must-be-local-YZ-XZ-or-XY"); continue; }
+ var axis = plane == "YZ" ? 0 : plane == "XZ" ? 1 : 2;
+ sites = parent.Select(s => new Site(s.Key, s.Point.Select((p, i) => i == axis ? -p : p).ToArray())).ToArray();
+ }
+ values.Add(name, sites);
+ var recipe = source[declaration.Index..(close + 1)];
+ recipes.Add(name, declaration.Groups["from"].Success
+ ? [.. recipes[declaration.Groups["from"].Value], recipe] : [recipe]);
+ var type = "__AssemblySite_" + name;
+ string Mm(double number) => number.ToString("R", CultureInfo.InvariantCulture) + "mm";
+ var rows = sites.Select(s => $"{s.Key} => {type} {{ X: {Mm(s.Point[0])}; Y: {Mm(s.Point[1])}; Z: {Mm(s.Point[2])} }}");
+ changes.Add((declaration.Index, close - declaration.Index + 1,
+ $"Record {type} {{ X: Length; Y: Length; Z: Length }}\nStatic {name}: Set<{type}> {{\n{string.Join("\n", rows)}\n}}"));
+ }
+ if (diagnostics.Count > 0) return null;
+ foreach (var change in changes.OrderByDescending(c => c.Start))
+ source = source.Remove(change.Start, change.Length).Insert(change.Start, change.Text);
+ return new(source, recipes);
+ }
+
+ private static double[]? Vector(string text)
+ {
+ var match = Regex.Match(text, @"^\[(?<v>[^\[\]]*)\]$");
+ if (!match.Success) return null;
+ var terms = match.Groups["v"].Value.Split(',', StringSplitOptions.TrimEntries);
+ if (terms.Length != 3) return null;
+ var result = new double[3];
+ for (var i = 0; i < 3; i++)
+ if (!terms[i].EndsWith("mm", StringComparison.Ordinal) ||
+ !double.TryParse(terms[i][..^2], NumberStyles.Float, CultureInfo.InvariantCulture, out result[i]) || !double.IsFinite(result[i])) return null;
+ return result;
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs b/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs
index 02aaf030..37d924c1 100644
--- a/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs
@@ -15,6 +15,9 @@ internal static class CanonicalStaticAuthoring
/// <summary>Assembly consumes the same checked Record/Set values, but yields product-tree declarations.</summary>
internal static Result? ExpandAssemblyPatterns(string source, List<string> diagnostics)
{
+ var sites = AssemblySiteAuthoring.Expand(source, diagnostics);
+ if (sites is null) return null;
+ source = sites.Source;
var headers = Regex.Matches(source,@"\bPattern\s+(?<name>[A-Za-z_]\w*)\s+Over\s+(?<set>[A-Za-z_]\w*)\s*\{").Cast<Match>()
.Where(h => Regex.IsMatch(source[(h.Index+h.Length)..],@"^\s*[A-Za-z_]\w*\s*=>\s*<(?:Part|Assembly)\b")).ToArray();
if (headers.Length == 0) return new(source,null);
@@ -52,7 +55,8 @@ internal static class CanonicalStaticAuthoring
associations.Add(new(name+"."+entry.Name,set.Name,entry.Name,entry.Value,entry.SourceOrder,entry.Provenance));
}
changes.Add((header.Index,close-header.Index+1,$"<Assembly {name}> {identity}\n{string.Join(Environment.NewLine,output)}\n</Assembly>"));
- patterns.Add(new(name,set.Name,"Assembly",set.Entries.Count,associations.Select(a=>a.GeneratedId).ToArray(),new(header.Index,close-header.Index+1),associations));
+ patterns.Add(new(name,set.Name,"Assembly",set.Entries.Count,associations.Select(a=>a.GeneratedId).ToArray(),new(header.Index,close-header.Index+1),associations,
+ sites.Recipes.GetValueOrDefault(set.Name)));
}
foreach (var change in changes.OrderByDescending(c=>c.Start)) source=source.Remove(change.Start,change.Length).Insert(change.Start,change.Text);
return new(source,data.Document with { Patterns=patterns });
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs
index ae3a45e8..461b05c1 100644
--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs
@@ -286,7 +286,7 @@ public sealed record FirmamentV2StaticRecordDecl(string Name, string RecordType,
/// <summary>Columnar compile-time table evidence. Rows are created only on static lookup and never enter AIR.</summary>
public sealed record FirmamentV2StaticTableDecl(string Name, string RowType, string? KeyField, IReadOnlyDictionary<string, IReadOnlyList<string>> Columns, int RowCount, FirmamentV2SourceSpan SourceSpan);
public sealed record FirmamentV2CanonicalTemplateDecl(string Name, string ParameterType, string ParameterName, string Body, FirmamentV2SourceSpan SourceSpan);
-public sealed record FirmamentV2CanonicalPatternDecl(string Name, string Source, string Template, int GeneratedCount, IReadOnlyList<string> GeneratedIds, FirmamentV2SourceSpan SourceSpan, IReadOnlyList<FirmamentV2PatternAssociation>? Associations = null);
+public sealed record FirmamentV2CanonicalPatternDecl(string Name, string Source, string Template, int GeneratedCount, IReadOnlyList<string> GeneratedIds, FirmamentV2SourceSpan SourceSpan, IReadOnlyList<FirmamentV2PatternAssociation>? Associations = null, IReadOnlyList<string>? SiteRecipe = null);
public sealed record FirmamentV2PatternAssociation(string GeneratedId, string SourceSet, string SourceEntry, string SourceValue, int ExpansionOrdinal, FirmamentV2SourceSpan Provenance);
public sealed record FirmamentV2MirrorDerivation(string Destination, string Kind, string Source, string AcrossPlane, string HandednessCorrection, IReadOnlyList<FirmamentV2MirrorMemberProvenance> Members, FirmamentV2SourceSpan SourceSpan, IReadOnlyList<string> Provenance);
public sealed record FirmamentV2MirrorMemberProvenance(string DerivedIdentity, string SourceIdentity, string Transform, string SourceSpan);
diff --git a/docs/public/README.md b/docs/public/README.md
index 0e3b70a9..7a534192 100644
--- a/docs/public/README.md
+++ b/docs/public/README.md
@@ -21,3 +21,6 @@ For source-traceable PDF markup and LLM handoff before CAD reconstruction, see [
For closed-shape authoring with named tabs and smooth replacements, see
[Immutable Profile boundary edits](firmament/profile-boundary-edits.md).
+
+For reusable knobs, selectors, tuners and keyed mounting rows, see
+[Assembly components and mounting sites](firmament/assembly-components-and-sites.md).
diff --git a/docs/public/demos/guitar-subassemblies.md b/docs/public/demos/guitar-subassemblies.md
index 16523e02..397ef183 100644
--- a/docs/public/demos/guitar-subassemblies.md
+++ b/docs/public/demos/guitar-subassemblies.md
@@ -17,8 +17,11 @@ guitar.firmasm
│ └─ body-outline.firmament Shared boundary for nine Concept placements
├─ neck-assembly.firmament neck, board, frets, inlays, nut and headstock
│ ├─ Neck.firmament exact six-section neck and published ports
-│ └─ tuners-assembly.firmament keyed tuner posts, washers and buttons
+│ └─ tuners-assembly.firmament local bass row and mirrored treble row
+│ └─ tuner.firmament complete washer/post/button component
├─ electronics-assembly.firmament knobs, selector and decorative covers
+│ ├─ knob.firmament reusable complete control knob
+│ ├─ selector.firmament reusable complete pickup selector
│ └─ pickups-assembly.firmament two complete pickup occurrences
│ └─ pickup.firmament housing, coil functions and pole feature pattern
├─ bridge-assembly.firmament bridge, stop tailpiece and keyed saddles
@@ -29,8 +32,11 @@ These are real reusable `Subassembly` definitions, not text fragments or importe
STEP packages. Tuners are a nested occurrence under Neck; Pickups nest under
Electronics. The root retains five readable placements. Each module owns its
local layout; moving a root occurrence moves its already-solved children.
-Existing absolute coordinates now describe module-local layout. Replacing all
-of those with new mounting ports is a separate refinement.
+Knobs, selector and tuners now publish component Mount frames. Tuners use
+headstock-local linear/reflected site recipes and one shared component definition;
+the group seats on the headstock front plus veneer thickness. See
+[Components and mounting sites](../firmament/assembly-components-and-sites.md).
+Remaining explicit control seat coordinates describe module-local layout.
Neck exposes only NutMount, HeelMount and HeadFront. Its NutWorld/HeadTilt frames
and Fixed VeneerSeat remain private to that definition. The parent cannot reach
@@ -47,7 +53,7 @@ all included modules, rather than stopping at the first subassembly declaration.
The immutable project-snapshot path resolves included modules and the four
SectionChain resources from supplied documents. Its dependency report includes
-13 used source documents, each with a hash. Existing include checks and private
+19 used source documents, each with a hash. Existing include checks and private
semantic boundaries remain in force. Source-row offsets still refer to the
expanded source; this change does not add per-file editor source maps.
@@ -59,12 +65,53 @@ dotnet Aetheris.CLI/bin/Release/net10.0/aetheris.dll asm inspect fixtures/Canoni
./scripts/qualify-guitar-x0.ps1 -OutDir artifacts/local/guitar-subassemblies -Viewport
```
-The existing generator writes the modules reproducibly. Profile interpolation,
+The existing generator preserves the directly authored component and electronics/
+tuner modules and writes the remaining generated modules reproducibly. Profile interpolation,
fret formulas and string-route calculations remain its current responsibilities;
Authoring D is not part of this reorganization. Downstream sunburst shading also
remains unchanged. Generated exports and evidence belong under artifacts/local.
-## Qualification
+## Component ownership refinement
+
+The current model has 10 reusable assembly definitions, four named knobs, one
+selector, and six occurrences of one tuner definition. The tuners form a 36mm
+bass-side row and a reflected treble-side row, both seated on the headstock
+veneer through its published frame. The treble row clocks the same tuner 180deg
+to turn its button outward. See the [implemented site syntax](../firmament/assembly-components-and-sites.md).
+
+The controls preserve their previous placements within numerical roundoff; all
+52 other parts with unchanged identities, excluding updated strings, preserve
+their world-transform matrices exactly. Surface, pickup and WireForm display
+checks have no unmatched edges or inward normal triangles. The fresh Cycles hero
+uses the exported 91 product meshes without changing their topology.
+
+This dogfood case also exposed an AP242 shared-child bug: reconstructing local
+transforms independently from posed world occurrences produced tiny numerical
+differences, and STEP reimport expanded 197 bodies instead of 91. The exporter
+now consumes the existing solved definition-local transforms. The corrected
+reimport has 53 geometry definitions, 91 bodies, 38 subassembly occurrences,
+129 total occurrences and hierarchy depth 6. Both the mounting-row fixture and
+the guitar have regression assertions for exact part occurrence counts.
+
+Current artifacts are under ignored `artifacts/local/component-authoring/`:
+`guitar.step`, `guitar.usda`, `beauty/hero.png`, `beauty/guitar-studio.blend`,
+`after.json`, `placement-check.json`, `mesh-check.json`, `generator-check.json`
+and `step-reimport-final.log`. Earlier failing STEP evidence is retained under
+explicit before-fix names/logs. Camera interaction was not remeasured in this
+refinement; the original viewer evidence below remains historical.
+
+Release solution build passed. The core fast lane passed 1,004 tests; 36 focused
+foundation/site/guitar tests and 20 focused site/guitar/AP242 tests passed. The
+final full solution gate, with projects and xUnit collections serialized, passed
+4,108 tests with seven existing skips across 20 projects. The first default full
+run had one unchanged core tessellation deadline failure and one old dependency
+count assertion (16 versus the new 19 files). The count assertion was corrected;
+the core test passed in isolation and both controlled full runs passed. No
+tessellation budget or assertion was relaxed. See `full.log`,
+`core-timeout-isolated.log`, `full-final-serial.log` and `test-summary.json` in
+the artifact directory for the distinct results.
+
+## Original modularization qualification (historical)
The modular witness was qualified through the real CLI, immutable project
snapshot, AP242 exporter/importer and OpenUSD viewer:
diff --git a/docs/public/firmament/assembly-authoring-foundation.md b/docs/public/firmament/assembly-authoring-foundation.md
index e06d5b5d..8a4aafa5 100644
--- a/docs/public/firmament/assembly-authoring-foundation.md
+++ b/docs/public/firmament/assembly-authoring-foundation.md
@@ -5,6 +5,9 @@ keyed finite occurrence patterns, and Fixed seating. These extend the existing
semantic binder, finite Record/Set frontend, exact materializer, and frame solver.
No user-defined Lower language or second placement solver is introduced.
+For complete-component ownership and finite linear/reflected mounting rows, see
+[Components and mounting sites](assembly-components-and-sites.md).
+
## Readable placement
```firmament
diff --git a/docs/public/firmament/assembly-components-and-sites.md b/docs/public/firmament/assembly-components-and-sites.md
new file mode 100644
index 00000000..e2e159e1
--- /dev/null
+++ b/docs/public/firmament/assembly-components-and-sites.md
@@ -0,0 +1,130 @@
+# Components and mounting sites
+
+Organize an assembly around complete components: a knob, selector or tuner owns
+its children, local dimensions and published mounting frame. Pattern component
+occurrences rather than separate categories of their constituent parts.
+
+The guitar demonstrates this in directly authored
+[`knob.firmament`](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/knob.firmament),
+[`selector.firmament`](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/selector.firmament)
+and [`tuner.firmament`](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuner.firmament)
+modules. Its composition root remains
+[`guitar.firmasm`](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm).
+A component is an ordinary reusable subassembly:
+
+```firmament
+Subassembly GuitarTuner {
+ <Assembly GuitarTuner>
+ <Part TunerWasher = Drum<R:7mm,H:1.5mm>>
+ Placement { From: BottomSeat.Frame; To: World; }
+ </Part>
+ <Part TunerPost = Drum<R:4mm,H:8mm>>
+ Placement { From: BottomSeat.Frame; To: World; }
+ </Part>
+ <Part TunerButton = Panel<L:15mm,W:19mm,H:6mm,R:5mm>>
+ Placement { From: BottomSeat.Frame; To: World; TranslateLocal: [-22mm,0mm,-7mm]; }
+ </Part>
+ </Assembly>
+ Anchor: GuitarTuner;
+ Expose { DatumFrame Mount = TunerWasher.BottomSeat.Frame; }
+}
+```
+
+Here `Drum` and `Panel` publish `BottomSeat.Frame`. `Mount` is the component's
+public frame. External placement uses `From: Mount`, while child placements are
+solved once in the component's own local world. One occurrence placement moves
+the whole component. AP242 export uses these solved definition-local child
+transforms when emitting shared product usages. It does not recompute them from
+each posed world occurrence: numerical roundoff in that recomputation could
+otherwise produce duplicate component children after STEP reimport.
+The washer and post are overlapping decorative placeholders;
+this does not claim detailed tuner mechanics or washer bore manufacture.
+
+## Rows and reflected mounting sites
+
+Assembly sources now admit two finite site recipes:
+
+```firmament
+Linear Sites BassTunerSites {
+ Keys: [Low, Middle, High];
+ Start: [-27mm,58mm,0mm];
+ Step: [0mm,36mm,0mm];
+}
+Mirrored Sites TrebleTunerSites From BassTunerSites { Across: YZ; }
+```
+
+`Keys` gives ordered semantic identities. For key ordinal `i`, the point is
+`Start + i * Step`. `Start` and `Step` are finite three-component mm vectors;
+`Step` must be nonzero. Each recipe admits 1–1024 unique identifier keys.
+Changing pitch preserves occurrence identities. Reordering keys changes which
+ordinal each key occupies, so it changes their positions deliberately.
+
+`Mirrored Sites` preserves keys and reflects points across the local origin
+plane `YZ`, `XZ` or `XY`. Its source must be an earlier site recipe; chains are
+allowed. These are coordinate planes **in the consuming placement's target
+frame**. This bounded spelling does not yet accept arbitrary named Concept
+planes, transform geometry, infer orientation or manufacture reflected rigid
+matrices. Unknown fields, duplicate fields, bad units, invalid keys, forward
+references and nonfinite/overflowing coordinates fail at the authoring boundary.
+
+Both recipes produce ordinary checked `Set` records with `X`, `Y`, `Z` Length
+fields. Consume them through the existing keyed assembly pattern:
+
+```firmament
+Pattern BassRow Over BassTunerSites {
+ site => <Assembly Tuner = GuitarTuner>
+ Placement { From: Mount; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }
+ </Assembly>
+}
+Pattern TrebleRow Over TrebleTunerSites {
+ site => <Assembly Tuner = GuitarTuner>
+ Placement { From: Mount; To: World; TranslateLocal: [site.X,site.Y,site.Z];
+ RotateLocal: { Axis: Z; Angle: 180deg } }
+ </Assembly>
+}
+```
+
+The explicit 180deg clocking turns the same tuner's button outward. Both rows
+keep their mounting normal and proper right-handed frames. Actual handed hardware
+can use separate component definitions. No negative scale reaches occurrence
+placement. Existing pattern limits and the prohibition on nested pattern bodies
+remain in force; patterns may instantiate reusable subassemblies.
+
+Inspection retains ordinary expanded keyed paths, shared geometry definitions,
+row values and associations. Patterns derived from site recipes also carry
+`siteRecipe`, the ordered authored derivation chain. Existing source offsets
+refer to expanded source; per-file source-map reconstruction remains separate.
+
+## Seating the guitar's entire tuner group
+
+Inside the neck assembly:
+
+```firmament
+<Assembly Tuners = GuitarTuners>
+ Placement { From: Origin; To: GuitarNeck.Headstock.Front.Frame;
+ TranslateLocal: [0mm,0mm,1mm]; }
+</Assembly>
+```
+
+`Headstock.Front.Frame` is a definition-owned mathematical datum published at
+the 14mm headstock front. The 1mm offset seats the washers on the veneer top.
+Row spacing and component orientation are headstock-local, so the compiler
+composes the tilt once. No general non-planar surface projection is implied.
+
+The four knobs use an explicit keyed `KnobSeats` Set named `NeckVolume`,
+`BridgeVolume`, `NeckTone`, `BridgeTone`. Their distinct seat heights on the
+carved body remain visible engineering data. They share `ControlKnob`; the
+selector is one `PickupSelector` occurrence. Internal component offsets occur
+only in their defining modules.
+
+The guitar generator preserves these directly authored modules. It still computes
+fret spacing and WireForm routes; string endpoints follow the corrected tuner
+post seats. The nut bend radius is 4mm, with matching tangent setbacks, so the
+revised leads pass the existing WireForm clearance checks at every string gauge.
+Those route calculations are not an assembly placement authority.
+
+Ground truth:
+
+```powershell
+dotnet Aetheris.CLI/bin/Release/net10.0/aetheris.dll asm inspect fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm --json --profile
+```
diff --git a/fixtures/Canonical/AssemblyInterfaces/AuthoringFoundation/mounting-rows.firmament b/fixtures/Canonical/AssemblyInterfaces/AuthoringFoundation/mounting-rows.firmament
new file mode 100644
index 00000000..ba7a83d5
--- /dev/null
+++ b/fixtures/Canonical/AssemblyInterfaces/AuthoringFoundation/mounting-rows.firmament
@@ -0,0 +1,36 @@
+Template<H: Length> Struct Post {
+ Circle2 Outline { Center: [0mm,0mm]; Radius: 2mm }
+ Profile P { Loop Outer { Outline |> TraceLoop } }
+ Extrude Body { Profile: P; From: 0mm; To: H }
+ Expose { Semantic Bottom { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }
+}
+Subassembly Tuner {
+ <Assembly Tuner>
+ <Part Post = Post<H:8mm>> Placement { From: Bottom.Frame; To: World; } </Part>
+ <Part Button = Post<H:3mm>> Placement { From: Bottom.Frame; To: World; TranslateLocal: [-5mm,0mm,0mm]; } </Part>
+ </Assembly>
+ Anchor: Tuner;
+ Expose { DatumFrame Mount = Post.Bottom.Frame; }
+}
+Linear Sites BassSites {
+ Keys: [Low, Middle, High];
+ Start: [-10mm,20mm,0mm];
+ Step: [0mm,30mm,0mm];
+}
+Mirrored Sites TrebleSites From BassSites { Across: YZ; }
+Assembly MountingRows {
+ <Assembly MountingRows>
+ Pattern BassRow Over BassSites {
+ site => <Assembly Unit = Tuner>
+ Placement { From: Mount; To: Tilt.Frame; TranslateLocal: [site.X,site.Y,site.Z]; }
+ </Assembly>
+ }
+ Pattern TrebleRow Over TrebleSites {
+ site => <Assembly Unit = Tuner>
+ Placement { From: Mount; To: Tilt.Frame; TranslateLocal: [site.X,site.Y,site.Z]; RotateLocal: { Axis: Z; Angle: 180deg } }
+ </Assembly>
+ }
+ </Assembly>
+ FrameTransform Tilt { From: World; TranslateLocal: [0mm,0mm,7mm]; RotateLocal: { Axis: X; Angle: -13deg } }
+ Anchor: MountingRows;
+}
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/electronics-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/electronics-assembly.firmament
index e12fa324..f768380a 100644
--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/electronics-assembly.firmament
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/electronics-assembly.firmament
@@ -1,52 +1,24 @@
Include "pickups-assembly.firmament";
+Include "knob.firmament";
+Include "selector.firmament";
+// Named controls retain explicit seat heights on the carved body.
+Static KnobSeats: Set<HardwareSite> {
+ NeckVolume => HardwareSite { X: 79mm; Y: -95mm; Z: 50mm }
+ BridgeVolume => HardwareSite { X: 123mm; Y: -70mm; Z: 45mm }
+ NeckTone => HardwareSite { X: 75mm; Y: -156mm; Z: 47mm }
+ BridgeTone => HardwareSite { X: 121mm; Y: -131mm; Z: 43mm }
+}
Subassembly GuitarElectronics {
<Assembly GuitarElectronics>
- <Part KnobSkirt0 = Drum<R:12mm,H:3mm>>
- Placement { From: Origin; To: World; TranslateLocal: [79mm,-95mm,50mm]; }
- </Part>
- <Part AmberKnob0 = Drum<R:9mm,H:9mm>>
- Placement { From: Origin; To: World; TranslateLocal: [79mm,-95mm,53mm]; }
- </Part>
- <Part KnobCap0 = Drum<R:5mm,H:1mm>>
- Placement { From: Origin; To: World; TranslateLocal: [79mm,-95mm,62mm]; }
- </Part>
- <Part KnobSkirt1 = Drum<R:12mm,H:3mm>>
- Placement { From: Origin; To: World; TranslateLocal: [123mm,-70mm,45mm]; }
- </Part>
- <Part AmberKnob1 = Drum<R:9mm,H:9mm>>
- Placement { From: Origin; To: World; TranslateLocal: [123mm,-70mm,48mm]; }
- </Part>
- <Part KnobCap1 = Drum<R:5mm,H:1mm>>
- Placement { From: Origin; To: World; TranslateLocal: [123mm,-70mm,57mm]; }
- </Part>
- <Part KnobSkirt2 = Drum<R:12mm,H:3mm>>
- Placement { From: Origin; To: World; TranslateLocal: [75mm,-156mm,47mm]; }
- </Part>
- <Part AmberKnob2 = Drum<R:9mm,H:9mm>>
- Placement { From: Origin; To: World; TranslateLocal: [75mm,-156mm,50mm]; }
- </Part>
- <Part KnobCap2 = Drum<R:5mm,H:1mm>>
- Placement { From: Origin; To: World; TranslateLocal: [75mm,-156mm,59mm]; }
- </Part>
- <Part KnobSkirt3 = Drum<R:12mm,H:3mm>>
- Placement { From: Origin; To: World; TranslateLocal: [121mm,-131mm,43mm]; }
- </Part>
- <Part AmberKnob3 = Drum<R:9mm,H:9mm>>
- Placement { From: Origin; To: World; TranslateLocal: [121mm,-131mm,46mm]; }
- </Part>
- <Part KnobCap3 = Drum<R:5mm,H:1mm>>
- Placement { From: Origin; To: World; TranslateLocal: [121mm,-131mm,55mm]; }
- </Part>
- <Part SelectorRing = Drum<R:16mm,H:1.5mm>>
- Placement { From: Origin; To: World; TranslateLocal: [-73mm,137mm,43mm]; }
- </Part>
- <Part SelectorStem = Drum<R:2.5mm,H:12mm>>
- Placement { From: Origin; To: World; TranslateLocal: [-73mm,137mm,44.5mm]; }
- </Part>
- <Part SelectorTip = Drum<R:4mm,H:7mm>>
- Placement { From: Origin; To: World; TranslateLocal: [-73mm,137mm,54mm]; }
- </Part>
+ Pattern Controls Over KnobSeats {
+ seat => <Assembly Knob = ControlKnob>
+ Placement { From: Mount; To: World; TranslateLocal: [seat.X,seat.Y,seat.Z]; }
+ </Assembly>
+ }
+ <Assembly Selector = PickupSelector>
+ Placement { From: Mount; To: World; TranslateLocal: [-73mm,137mm,43mm]; }
+ </Assembly>
<Part ControlCover = Panel<L:63mm,W:93mm,H:1mm,R:15mm>>
Placement { From: Origin; To: World; TranslateLocal: [85mm,-115mm,-1mm]; }
</Part>
@@ -57,6 +29,5 @@ Subassembly GuitarElectronics {
Placement { From: Origin; To: World; }
</Assembly>
</Assembly>
-
Anchor: GuitarElectronics;
}
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament
index 60f3acb4..5d7c94ec 100644
--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament
@@ -5,6 +5,7 @@ Template<L: Length, W: Length, H: Length, R: Length> Struct Panel {
Extrude Body { Profile: P From: 0mm To: H }
}
Template<R: Length,H: Length> Struct Drum {
+ Expose { Semantic BottomSeat { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }
Circle2 Outline { Center: [0mm,0mm] Radius: R }
Profile P { Loop Outer { Outline |> TraceLoop } }
Extrude Body { Profile: P From: 0mm To: H }
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/knob.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/knob.firmament
new file mode 100644
index 00000000..558c7470
--- /dev/null
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/knob.firmament
@@ -0,0 +1,16 @@
+// A complete decorative control knob. All dimensions are local to its mounting seat.
+Subassembly ControlKnob {
+ <Assembly ControlKnob>
+ <Part KnobSkirt = Drum<R:12mm,H:3mm>>
+ Placement { From: BottomSeat.Frame; To: World; }
+ </Part>
+ <Part AmberKnob = Drum<R:9mm,H:9mm>>
+ Placement { From: BottomSeat.Frame; To: World; TranslateLocal: [0mm,0mm,3mm]; }
+ </Part>
+ <Part KnobCap = Drum<R:5mm,H:1mm>>
+ Placement { From: BottomSeat.Frame; To: World; TranslateLocal: [0mm,0mm,12mm]; }
+ </Part>
+ </Assembly>
+ Anchor: ControlKnob;
+ Expose { DatumFrame Mount = KnobSkirt.BottomSeat.Frame; }
+}
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/neck-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/neck-assembly.firmament
index 52ecf2d2..171dbb32 100644
--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/neck-assembly.firmament
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/neck-assembly.firmament
@@ -113,7 +113,8 @@ Subassembly GuitarNeck {
Placement { From: Origin; To: World; TranslateLocal: [0mm,206.226542mm,62mm]; }
</Part>
<Assembly Tuners = GuitarTuners>
- Placement { From: Origin; To: World; }
+ // Front includes the 14mm headstock; 1mm seats on its veneer.
+ Placement { From: Origin; To: GuitarNeck.Headstock.Front.Frame; TranslateLocal: [0mm,0mm,1mm]; }
</Assembly>
</Assembly>
FrameTransform NutWorld { From: GuitarNeck.Neck.NutMount.Frame; Normal: [0,1,0]; Up: [0,0,1]; TranslateLocal: [0mm,-7mm,0mm]; }
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/selector.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/selector.firmament
new file mode 100644
index 00000000..4eb90dd0
--- /dev/null
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/selector.firmament
@@ -0,0 +1,16 @@
+// A complete decorative pickup selector, seated at the underside of its ring.
+Subassembly PickupSelector {
+ <Assembly PickupSelector>
+ <Part SelectorRing = Drum<R:16mm,H:1.5mm>>
+ Placement { From: BottomSeat.Frame; To: World; }
+ </Part>
+ <Part SelectorStem = Drum<R:2.5mm,H:12mm>>
+ Placement { From: BottomSeat.Frame; To: World; TranslateLocal: [0mm,0mm,1.5mm]; }
+ </Part>
+ <Part SelectorTip = Drum<R:4mm,H:7mm>>
+ Placement { From: BottomSeat.Frame; To: World; TranslateLocal: [0mm,0mm,11mm]; }
+ </Part>
+ </Assembly>
+ Anchor: PickupSelector;
+ Expose { DatumFrame Mount = SelectorRing.BottomSeat.Frame; }
+}
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/string-low-e.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/string-low-e.firmament
index 703e19e6..f62fa35e 100644
--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/string-low-e.firmament
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/string-low-e.firmament
@@ -4,9 +4,9 @@ Model GuitarLowE {
WireForm String {
Diameter: 0.68mm
Material: Standard.Materials.StainlessSteel.304_Annealed
- StartFrame { Origin: [25.5mm,-75mm,65mm]; Tangent: [-0.0102313880420824,0.999947657979523,0]; Up: [-0.735853071477427,-0.00752919240938704,-0.677099378569276] }
- Straight SpeakingLength { Length: 732.679593mm }
- Bend NutBreak { Radius: 3mm; Angle: 13.639458deg; Plane: Up }
- Straight TunerLead { Length: 59.754816mm }
+ StartFrame { Origin: [25.5mm,-75mm,65mm]; Tangent: [-0.0102313880420824,0.999947657979523,0]; Up: [-0.738352332641793,-0.00755476465868138,-0.674372863046382] }
+ Straight SpeakingLength { Length: 732.589494mm }
+ Bend NutBreak { Radius: 4mm; Angle: 12.805738deg; Plane: Up }
+ Straight TunerLead { Length: 64.073073mm }
}
}
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/strings-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/strings-assembly.firmament
index 2a480e29..5fe280a7 100644
--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/strings-assembly.firmament
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/strings-assembly.firmament
@@ -6,30 +6,30 @@ Template<D: Length, Lead: Length, Tail: Length, Deflection: Angle> Struct Guitar
Material: Standard.Materials.StainlessSteel.304_Annealed
StartFrame { Origin: [0mm,0mm,0mm]; Tangent: [0,0,1]; Up: [1,0,0] }
Straight SpeakingLength { Length: Lead }
- Bend NutBreak { Radius: 3mm; Angle: Deflection; Plane: Up }
+ Bend NutBreak { Radius: 4mm; Angle: Deflection; Plane: Up }
Straight TunerLead { Length: Tail }
}
}
Subassembly GuitarStrings {
<Assembly GuitarStrings>
- <Part String0 = GuitarString<D:0.28mm,Lead:732.679593mm,Tail:59.754816mm,Deflection:13.639458deg>>
- Placement { From: Origin; To: World; TranslateLocal: [-25.5mm,-75mm,65mm]; Normal: [0.0102313880420824,0.999947657979523,0]; Up: [0.677063937819737,-0.00692766648519513,0.735891589530075]; }
+ <Part String0 = GuitarString<D:0.28mm,Lead:732.589494mm,Tail:64.073073mm,Deflection:12.805738deg>>
+ Placement { From: Origin; To: World; TranslateLocal: [-25.5mm,-75mm,65mm]; Normal: [0.0102313880420824,0.999947657979523,0]; Up: [0.674337565008175,-0.00689977044687765,0.738390981517668]; }
</Part>
- <Part String1 = GuitarString<D:0.36mm,Lead:732.619706mm,Tail:96.378981mm,Deflection:14.968066deg>>
- Placement { From: Origin; To: World; TranslateLocal: [-15.3mm,-75mm,65mm]; Normal: [0.00613903847430546,0.999981155925756,0]; Up: [0.67110198271469,-0.00411999852962634,0.741353596071758]; }
+ <Part String1 = GuitarString<D:0.36mm,Lead:732.509486mm,Tail:100.649868mm,Deflection:14.372058deg>>
+ Placement { From: Origin; To: World; TranslateLocal: [-15.3mm,-75mm,65mm]; Normal: [0.00613903847430546,0.999981155925756,0]; Up: [0.669164958053743,-0.00410810683661916,0.743102538261814]; }
</Part>
- <Part String2 = GuitarString<D:0.44mm,Lead:732.593764mm,Tail:133.054198mm,Deflection:15.480813deg>>
- Placement { From: Origin; To: World; TranslateLocal: [-5.1mm,-75mm,65mm]; Normal: [0.00204638043552803,0.999997906161364,0]; Up: [0.664265923957594,-0.001359343637021,0.747495106641937]; }
+ <Part String2 = GuitarString<D:0.44mm,Lead:732.474127mm,Tail:137.301981mm,Deflection:15.022472deg>>
+ Placement { From: Origin; To: World; TranslateLocal: [-5.1mm,-75mm,65mm]; Normal: [0.00204638043552803,0.999997906161364,0]; Up: [0.662627199851135,-0.00135599017704871,0.748948165968837]; }
</Part>
- <Part String5 = GuitarString<D:0.68mm,Lead:732.679593mm,Tail:59.754816mm,Deflection:13.639458deg>>
- Placement { From: Origin; To: World; TranslateLocal: [25.5mm,-75mm,65mm]; Normal: [-0.0102313880420824,0.999947657979523,0]; Up: [-0.677063937819737,-0.00692766648519513,0.735891589530075]; }
+ <Part String5 = GuitarString<D:0.68mm,Lead:732.589494mm,Tail:64.073073mm,Deflection:12.805738deg>>
+ Placement { From: Origin; To: World; TranslateLocal: [25.5mm,-75mm,65mm]; Normal: [-0.0102313880420824,0.999947657979523,0]; Up: [-0.674337565008175,-0.00689977044687765,0.738390981517668]; }
</Part>
- <Part String4 = GuitarString<D:0.6mm,Lead:732.619706mm,Tail:96.378981mm,Deflection:14.968066deg>>
- Placement { From: Origin; To: World; TranslateLocal: [15.3mm,-75mm,65mm]; Normal: [-0.00613903847430546,0.999981155925756,0]; Up: [-0.67110198271469,-0.00411999852962634,0.741353596071758]; }
+ <Part String4 = GuitarString<D:0.6mm,Lead:732.509486mm,Tail:100.649868mm,Deflection:14.372058deg>>
+ Placement { From: Origin; To: World; TranslateLocal: [15.3mm,-75mm,65mm]; Normal: [-0.00613903847430546,0.999981155925756,0]; Up: [-0.669164958053743,-0.00410810683661916,0.743102538261814]; }
</Part>
- <Part String3 = GuitarString<D:0.52mm,Lead:732.593764mm,Tail:133.054198mm,Deflection:15.480813deg>>
- Placement { From: Origin; To: World; TranslateLocal: [5.1mm,-75mm,65mm]; Normal: [-0.00204638043552803,0.999997906161364,0]; Up: [-0.664265923957594,-0.001359343637021,0.747495106641937]; }
+ <Part String3 = GuitarString<D:0.52mm,Lead:732.474127mm,Tail:137.301981mm,Deflection:15.022472deg>>
+ Placement { From: Origin; To: World; TranslateLocal: [5.1mm,-75mm,65mm]; Normal: [-0.00204638043552803,0.999997906161364,0]; Up: [-0.662627199851135,-0.00135599017704871,0.748948165968837]; }
</Part>
</Assembly>
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuner.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuner.firmament
new file mode 100644
index 00000000..1cef44cd
--- /dev/null
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuner.firmament
@@ -0,0 +1,17 @@
+// One complete tuner placeholder. The button projects along local -X.
+// The opposite row clocks this same component 180deg about its mounting normal.
+Subassembly GuitarTuner {
+ <Assembly GuitarTuner>
+ <Part TunerWasher = Drum<R:7mm,H:1.5mm>>
+ Placement { From: BottomSeat.Frame; To: World; }
+ </Part>
+ <Part TunerPost = Drum<R:4mm,H:8mm>>
+ Placement { From: BottomSeat.Frame; To: World; }
+ </Part>
+ <Part TunerButton = Panel<L:15mm,W:19mm,H:6mm,R:5mm>>
+ Placement { From: BottomSeat.Frame; To: World; TranslateLocal: [-22mm,0mm,-7mm]; }
+ </Part>
+ </Assembly>
+ Anchor: GuitarTuner;
+ Expose { DatumFrame Mount = TunerWasher.BottomSeat.Frame; }
+}
diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuners-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuners-assembly.firmament
index 190e6884..f7b19a13 100644
--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuners-assembly.firmament
+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/tuners-assembly.firmament
@@ -1,45 +1,26 @@
-Static TunerPostsSites: Set<HardwareSite> {
- TunerPost00 => HardwareSite { X: -27mm; Y: 716.513464mm; Z: 49.56839mm }
- TunerPost01 => HardwareSite { X: -27mm; Y: 751.590786mm; Z: 41.470152mm }
- TunerPost02 => HardwareSite { X: -27mm; Y: 786.668108mm; Z: 33.371914mm }
- TunerPost20 => HardwareSite { X: 27mm; Y: 716.513464mm; Z: 49.56839mm }
- TunerPost21 => HardwareSite { X: 27mm; Y: 751.590786mm; Z: 41.470152mm }
- TunerPost22 => HardwareSite { X: 27mm; Y: 786.668108mm; Z: 33.371914mm }
-}
-Static TunerWashersSites: Set<HardwareSite> {
- TunerWasher00 => HardwareSite { X: -27mm; Y: 716.513464mm; Z: 49.56839mm }
- TunerWasher01 => HardwareSite { X: -27mm; Y: 751.590786mm; Z: 41.470152mm }
- TunerWasher02 => HardwareSite { X: -27mm; Y: 786.668108mm; Z: 33.371914mm }
- TunerWasher20 => HardwareSite { X: 27mm; Y: 716.513464mm; Z: 49.56839mm }
- TunerWasher21 => HardwareSite { X: 27mm; Y: 751.590786mm; Z: 41.470152mm }
- TunerWasher22 => HardwareSite { X: 27mm; Y: 786.668108mm; Z: 33.371914mm }
-}
-Static TunerButtonsSites: Set<HardwareSite> {
- TunerButton00 => HardwareSite { X: -49mm; Y: 716.513464mm; Z: 42.56839mm }
- TunerButton01 => HardwareSite { X: -49mm; Y: 751.590786mm; Z: 34.470152mm }
- TunerButton02 => HardwareSite { X: -49mm; Y: 786.668108mm; Z: 26.371914mm }
- TunerButton20 => HardwareSite { X: 49mm; Y: 716.513464mm; Z: 42.56839mm }
- TunerButton21 => HardwareSite { X: 49mm; Y: 751.590786mm; Z: 34.470152mm }
- TunerButton22 => HardwareSite { X: 49mm; Y: 786.668108mm; Z: 26.371914mm }
+Include "tuner.firmament";
+
+// Mounting sites are expressed in the headstock-front coordinate system.
+Linear Sites BassTunerSites {
+ Keys: [Low, Middle, High];
+ Start: [-27mm,58mm,0mm];
+ Step: [0mm,36mm,0mm];
}
+Mirrored Sites TrebleTunerSites From BassTunerSites { Across: YZ; }
+
Subassembly GuitarTuners {
<Assembly GuitarTuners>
- Pattern TunerPosts Over TunerPostsSites {
- site => <Part TunerPost = Drum<R:4mm,H:8mm>>
- Placement { From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }
- </Part>
- }
- Pattern TunerWashers Over TunerWashersSites {
- site => <Part TunerWasher = Drum<R:7mm,H:1.5mm>>
- Placement { From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }
- </Part>
+ Pattern BassRow Over BassTunerSites {
+ site => <Assembly Tuner = GuitarTuner>
+ Placement { From: Mount; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }
+ </Assembly>
}
- Pattern TunerButtons Over TunerButtonsSites {
- site => <Part TunerButton = Panel<L:15mm,W:19mm,H:6mm,R:5mm>>
- Placement { From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }
- </Part>
+ Pattern TrebleRow Over TrebleTunerSites {
+ site => <Assembly Tuner = GuitarTuner>
+ Placement { From: Mount; To: World; TranslateLocal: [site.X,site.Y,site.Z];
+ RotateLocal: { Axis: Z; Angle: 180deg } }
+ </Assembly>
}
</Assembly>
-
Anchor: GuitarTuners;
}
diff --git a/scripts/create-guitar-x0.py b/scripts/create-guitar-x0.py
index 9ed7e539..23918d7b 100644
--- a/scripts/create-guitar-x0.py
+++ b/scripts/create-guitar-x0.py
@@ -141,7 +141,7 @@ Template<D: Length, Lead: Length, Tail: Length, Deflection: Angle> Struct Guitar
Material: Standard.Materials.StainlessSteel.304_Annealed
StartFrame { Origin: [0mm,0mm,0mm]; Tangent: [0,0,1]; Up: [1,0,0] }
Straight SpeakingLength { Length: Lead }
- Bend NutBreak { Radius: 3mm; Angle: Deflection; Plane: Up }
+ Bend NutBreak { Radius: 4mm; Angle: Deflection; Plane: Up }
Straight TunerLead { Length: Tail }
}
}
@@ -152,6 +152,7 @@ Template<L: Length, W: Length, H: Length, R: Length> Struct Panel {
Extrude Body { Profile: P From: 0mm To: H }
}
Template<R: Length,H: Length> Struct Drum {
+ Expose { Semantic BottomSeat { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }
Circle2 Outline { Center: [0mm,0mm] Radius: R }
Profile P { Loop Outer { Outline |> TraceLoop } }
Extrude Body { Profile: P From: 0mm To: H }
@@ -213,7 +214,8 @@ def formed_string(name, start, nut, end, diameter):
xaxis=[v/length(normal) for v in normal]
yaxis=[zaxis[1]*xaxis[2]-zaxis[2]*xaxis[1],zaxis[2]*xaxis[0]-zaxis[0]*xaxis[2],zaxis[0]*xaxis[1]-zaxis[1]*xaxis[0]]
angle=math.acos(sum(a*b for a,b in zip(zaxis,target)))
- setback=3*math.tan(angle/2)
+ # A 4mm nut bend keeps the revised post leads clear at every string gauge.
+ setback=4*math.tan(angle/2)
definition=f'GuitarString<D:{number(diameter)}mm,Lead:{number(lead_length-setback)}mm,Tail:{number(tail_length-setback)}mm,Deflection:{number(math.degrees(angle))}deg>'
vector=lambda vs:','.join(f'{v:.15g}' for v in vs)
parts.append(f' <Part {name} = {definition}>\n Placement {{ From: Origin; To: World; TranslateLocal: [{",".join(number(v)+"mm" for v in start)}]; Normal: [{vector(zaxis)}]; Up: [{vector(yaxis)}]; }}\n </Part>')
@@ -228,7 +230,7 @@ Model GuitarLowE {{
Material: Standard.Materials.StainlessSteel.304_Annealed
StartFrame {{ Origin: [{','.join(number(v)+'mm' for v in start)}]; Tangent: [{vector(zaxis)}]; Up: [{vector(xaxis)}] }}
Straight SpeakingLength {{ Length: {number(lead_length-setback)}mm }}
- Bend NutBreak {{ Radius: 3mm; Angle: {number(math.degrees(angle))}deg; Plane: Up }}
+ Bend NutBreak {{ Radius: 4mm; Angle: {number(math.degrees(angle))}deg; Plane: Up }}
Straight TunerLead {{ Length: {number(tail_length-setback)}mm }}
}}
}}
@@ -249,15 +251,6 @@ part('Tailpiece','Panel<L:88mm,W:15mm,H:7mm,R:6mm>',y=-75,z=53)
for i in range(6):
x=(i-2.5)*10.2
part(f'Saddle{i}','Panel<L:7mm,W:9mm,H:2mm,R:1mm>',x=x,y=-35,z=63)
-for i,(x,y,z) in enumerate([(79,-95,50),(123,-70,45),(75,-156,47),(121,-131,43)]):
- part(f'KnobSkirt{i}','Drum<R:12mm,H:3mm>',x,y,z)
- part(f'AmberKnob{i}','Drum<R:9mm,H:9mm>',x,y,z+3)
- part(f'KnobCap{i}','Drum<R:5mm,H:1mm>',x,y,z+12)
-part('SelectorRing','Drum<R:16mm,H:1.5mm>',x=-73,y=137,z=43)
-part('SelectorStem','Drum<R:2.5mm,H:12mm>',x=-73,y=137,z=44.5)
-part('SelectorTip','Drum<R:4mm,H:7mm>',x=-73,y=137,z=54)
-part('ControlCover','Panel<L:63mm,W:93mm,H:1mm,R:15mm>',x=85,y=-115,z=-1)
-part('SelectorCover','Drum<R:24mm,H:1mm>',x=-73,y=137,z=-1)
for i in range(1,23):
y=658-628*(1-2**(-i/12))
width=43+(660-y)/540*13
@@ -268,21 +261,15 @@ for i in range(1,23):
for side in [-1,1]:
for i in range(3):
yy=58+i*36
- y=660+yy*math.cos(math.radians(13))
- z=48-yy*math.sin(math.radians(13))+15*math.cos(math.radians(13))
- part(f'TunerPost{side+1}{i}','Drum<R:4mm,H:8mm>',x=side*27,y=y,z=z)
- part(f'TunerWasher{side+1}{i}','Drum<R:7mm,H:1.5mm>',x=side*27,y=y,z=z)
- part(f'TunerButton{side+1}{i}','Panel<L:15mm,W:19mm,H:6mm,R:5mm>',x=side*49,y=y,z=z-7)
+ y=660+yy*math.cos(math.radians(13))+20*math.sin(math.radians(13))
+ z=48-yy*math.sin(math.radians(13))+20*math.cos(math.radians(13))
string_index=i if side==-1 else 5-i
- formed_string(f'String{string_index}',((string_index-2.5)*10.2,-75,65),((string_index-2.5)*7.2,658,65),(side*27,y,z+5),.28+string_index*.08)
+ formed_string(f'String{string_index}',((string_index-2.5)*10.2,-75,65),((string_index-2.5)*7.2,658,65),(side*27,y,z),.28+string_index*.08)
# Finite keyed occurrence families. Values remain ordinary checked Firmament
# Records; the compiler owns expansion, identities, and definition sharing.
catalog=[]
for family,matcher in [
- ('Saddles',r'Saddle[0-5]'),
- ('TunerPosts',r'TunerPost[02][0-2]'),
- ('TunerWashers',r'TunerWasher[02][0-2]'),
- ('TunerButtons',r'TunerButton[02][0-2]')]:
+ ('Saddles',r'Saddle[0-5]')]:
selected=[]
for declaration in parts:
match=re.fullmatch(r'\s*<Part (\w+) = (.+)>\n\s*Placement \{ From: Origin; To: World; TranslateLocal: \[([^,]+),([^,]+),([^]]+)\]; \}\n\s*</Part>',declaration)
@@ -308,15 +295,12 @@ def write_module(filename, name, members, rows=(), includes=(), relations='', ex
text+='}\n'
(ROOT/filename).write_text(text)
-groups={name:[] for name in ('Body','Neck','Tuners','Pickups','Electronics','Bridge','Strings')}
+groups={name:[] for name in ('Body','Neck','Bridge','Strings')}
for declaration in parts:
name=re.search(r'(?:<Part|Pattern)\s+(\w+)',declaration)[1]
if name in ('MahoganyBack','IvoryBinding','CarvedMaple'): group='Body'
- elif name.startswith('Tuner'):group='Tuners'
- elif name.startswith('Pickup'):group='Pickups'
elif name in ('Bridge','Tailpiece','Saddles'):group='Bridge'
elif name.startswith('String'):group='Strings'
- elif name.startswith(('Knob','AmberKnob','Selector','ControlCover')):group='Electronics'
else:group='Neck'
groups[group].append(declaration)
@@ -345,11 +329,15 @@ write_module('body-assembly.firmament','GuitarBody',groups['Body'],includes=('ha
Interface<Fixed> BodyDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarBody.CarvedMaple.TopSeat] }
Mate BodyOnDeck: BodyDeckSeat { Member: GuitarBody.CarvedMaple.TopSeat; At: GuitarLayout.BodySeat; Orientation: SameDirection; Support: true; }
''')
-write_module('tuners-assembly.firmament','GuitarTuners',groups['Tuners'],rows_for(('Tuner',)))
+# Tuner, knob and selector modules are directly authored Firmament components.
+# Preserve their site recipes and local mounting ports rather than generating coordinates.
neck_relations=''' FrameTransform NutWorld { From: GuitarNeck.Neck.NutMount.Frame; Normal: [0,1,0]; Up: [0,0,1]; TranslateLocal: [0mm,-7mm,0mm]; }
FrameTransform HeadTilt { From: NutWorld.Frame; RotateLocal: { Axis: X; Angle: -13deg } }
Interface<Fixed> VeneerSeat { A: GuitarNeck.Headstock.Front.Frame; B: GuitarNeck.HeadVeneer.Base.Frame; Gap: 0mm; Clocking: 0deg; }'''
-write_module('neck-assembly.firmament','GuitarNeck',groups['Neck']+[occurrence('Tuners','GuitarTuners')],
+write_module('neck-assembly.firmament','GuitarNeck',groups['Neck']+['''<Assembly Tuners = GuitarTuners>
+ // Front includes the 14mm headstock; 1mm seats on its veneer.
+ Placement { From: Origin; To: GuitarNeck.Headstock.Front.Frame; TranslateLocal: [0mm,0mm,1mm]; }
+</Assembly>'''],
includes=('tuners-assembly.firmament',),relations=neck_relations,
exposes='DatumFrame NutMount = Neck.NutMount.Frame; DatumFrame HeelMount = Neck.HeelMount.Frame; DatumFrame HeadFront = Headstock.Front.Frame;')
# Pickup construction is authored in Firmament, not generated pole/coil coordinates.
@@ -364,8 +352,7 @@ write_module('pickups-assembly.firmament','GuitarPickups',[
pickup_source=(ROOT/'pickup.firmament').read_text()
pickup_source=re.sub(r' Expose \{ Semantic Mount \{[^\n]+\n','',pickup_source)
(ROOT.parents[1]/'Feature'/'pickup-functional.firmament').write_text('schema Mechanical\nModel PickupFunctional {\n Units: mm\n'+pickup_source+'\n Struct Product = Humbucker<Spec: StandardPickup>\n}\n')
-write_module('electronics-assembly.firmament','GuitarElectronics',groups['Electronics']+[occurrence('Pickups','GuitarPickups')],
- includes=('pickups-assembly.firmament',))
+# electronics-assembly.firmament owns the named control seats and component occurrences.
groups['Bridge']=[re.sub(r'\s*Placement\s*\{[^}]*\}', '', p) if '<Part Bridge ' in p else p for p in groups['Bridge']]
write_module('bridge-assembly.firmament','GuitarBridge',groups['Bridge'],rows_for(('Saddles',)),includes=('hardware-layout.firmament',),relations='''
Interface<Fixed> BridgeDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarBridge.Bridge.BottomSeat] }