Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement M7d boolean placement execution support

Yuechen Lifac55aae86b4
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
index 101ce3b8..ea09f9a0 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBooleanRequiredFieldValidationTests.cs
@@ -32,7 +32,6 @@ public sealed class FirmamentBooleanRequiredFieldValidationTests
1
1
1
- place: ignored-for-now
""");
[Fact]
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
index ae2656ba..68f7383b 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
@@ -150,6 +150,32 @@ public sealed class FirmamentPlacementValidationTests
Assert.Contains(FirmamentDiagnosticCodes.PlacementInvalidOffsetValue.Value, diagnostic.Message, StringComparison.Ordinal);
}
+
+ [Fact]
+ public void Boolean_With_Origin_Place_Is_Valid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+ }
+
+ [Fact]
+ public void Boolean_With_SelectorShaped_PlaceAnchor_Is_Valid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-valid-boolean-selector-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+ }
+
+ [Fact]
+ public void Boolean_Placement_Runtime_Selector_Resolution_Failure_Is_Diagnostic()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-invalid-boolean-placement-selector-runtime-empty.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.ValidationTargetSelectorResolvedEmpty.Value, diagnostic.Message, StringComparison.Ordinal);
+ Assert.Contains("resolved empty", diagnostic.Message, StringComparison.OrdinalIgnoreCase);
+ }
+
[Fact]
public void Placement_Runtime_Selector_Resolution_Failure_Is_Diagnostic()
{
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
index 7d94faca..00a1d44a 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveExecutionTests.cs
@@ -248,6 +248,63 @@ public sealed class FirmamentPrimitiveExecutionTests
Assert.Equal(Point3D.Origin, surface!.Sphere!.Value.Center);
}
+
+ [Fact]
+ public void Boolean_Without_Placement_Behaves_As_Before()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3d-valid-add-exec.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var executedBoolean = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans);
+ Assert.Equal("joined", executedBoolean.FeatureId);
+ Assert.NotEmpty(executedBoolean.Body.Topology.Faces);
+ }
+
+ [Fact]
+ public void Boolean_Origin_Placement_Translates_Result_Body()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var body = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans).Body;
+ var bounds = GetBounds(body);
+ Assert.Equal(new Point3D(8d, -7d, 1d), bounds.Min);
+ }
+
+ [Fact]
+ public void Boolean_Selector_Placement_Uses_Deterministic_Anchor_Resolution()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-valid-boolean-selector-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var body = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans).Body;
+ var bounds = GetBounds(body);
+ Assert.Equal(new Point3D(1d, -2.25d, -1d), bounds.Min);
+ }
+
+ [Fact]
+ public void Boolean_Placement_Does_Not_Mutate_Referenced_Source_Bodies()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var primitive = Assert.Single(result.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ var primitiveBounds = GetBounds(primitive.Body);
+ Assert.Equal(new Point3D(-2d, -2d, 0d), primitiveBounds.Min);
+ Assert.Equal(new Point3D(2d, 2d, 4d), primitiveBounds.Max);
+ }
+
+ [Fact]
+ public void Chained_Primitive_And_Placed_Boolean_Executes_Deterministically()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7d-valid-boolean-chain-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+
+ var placedBoolean = result.Compilation.Value.PrimitiveExecutionResult!.ExecutedBooleans.Single(b => b.FeatureId == "join2");
+ var bounds = GetBounds(placedBoolean.Body);
+ Assert.Equal(new Point3D(-7d, -1d, -3d), bounds.Min);
+ }
+
[Fact]
public void Origin_Placement_With_Offset_Translates_Primitive()
{
@@ -263,12 +320,11 @@ public sealed class FirmamentPrimitiveExecutionTests
private static (Point3D Min, Point3D Max) GetBounds(BrepBody body)
{
var points = body.Topology.Vertices
- .Select(v =>
- {
- Assert.True(body.TryGetVertexPoint(v.Id, out var p));
- return p;
- })
+ .Select(v => body.TryGetVertexPoint(v.Id, out var p) ? p : (Point3D?)null)
+ .Where(p => p is not null)
+ .Select(p => p!.Value)
.ToArray();
+ Assert.NotEmpty(points);
return (
new Point3D(points.Min(p => p.X), points.Min(p => p.Y), points.Min(p => p.Z)),
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs
index aba44afe..4eb55781 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPrimitiveLoweringTests.cs
@@ -173,6 +173,20 @@ public sealed class FirmamentPrimitiveLoweringTests
});
}
+
+ [Fact]
+ public void Compile_Lowers_Boolean_Placement_Metadata_Using_Primitive_Placement_Model()
+ {
+ var result = Compile(FirmamentCorpusHarness.ReadFixtureText("testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament"));
+
+ Assert.True(result.Compilation.IsSuccess);
+ var boolean = Assert.Single(result.Compilation.Value.PrimitiveLoweringPlan!.Booleans);
+ Assert.NotNull(boolean.Placement);
+ var origin = Assert.IsType<FirmamentLoweredPlacementOriginAnchor>(boolean.Placement!.On);
+ Assert.NotNull(origin);
+ Assert.Equal(new[] { 10d, -5d, 3d }, boolean.Placement.Offset);
+ }
+
[Fact]
public void Compile_Validation_Family_Ops_Remain_Explicitly_NonLowered()
{
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs
index 7f47fed9..de76776a 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPlacementResolver.cs
@@ -25,6 +25,17 @@ internal static class FirmamentPlacementResolver
return KernelResult<Vector3D>.Success((anchorResult.Value - Point3D.Origin) + new Vector3D(o[0], o[1], o[2]));
}
+ public static KernelResult<Vector3D> ResolvePlacementTranslation(FirmamentLoweredBoolean booleanOp, IReadOnlyDictionary<string, BrepBody> featureBodies)
+ {
+ if (booleanOp.Placement is null) return KernelResult<Vector3D>.Success(Vector3D.Zero);
+
+ var anchorResult = ResolveAnchorPoint(booleanOp.Placement.On, featureBodies);
+ if (!anchorResult.IsSuccess) return KernelResult<Vector3D>.Failure(anchorResult.Diagnostics);
+
+ var o = booleanOp.Placement.Offset;
+ return KernelResult<Vector3D>.Success((anchorResult.Value - Point3D.Origin) + new Vector3D(o[0], o[1], o[2]));
+ }
+
private static KernelResult<Point3D> ResolveAnchorPoint(FirmamentLoweredPlacementAnchor anchor, IReadOnlyDictionary<string, BrepBody> featureBodies)
{
if (anchor is FirmamentLoweredPlacementOriginAnchor) return KernelResult<Point3D>.Success(Point3D.Origin);
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
index 28b7233a..aa23beac 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -59,9 +59,18 @@ internal static class FirmamentPrimitiveExecutor
return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(booleanResult.Diagnostics);
}
- executedBooleans.Add(new FirmamentExecutedBoolean(boolean.OpIndex, boolean.FeatureId, boolean.Kind, booleanResult.Value));
- publishedBodiesByFeatureId[boolean.FeatureId] = booleanResult.Value;
- booleanExecutionBodiesByFeatureId[boolean.FeatureId] = booleanResult.Value;
+ var placedBooleanBody = booleanResult.Value;
+ var placementResult = FirmamentPlacementResolver.ResolvePlacementTranslation(boolean, publishedBodiesByFeatureId);
+ if (!placementResult.IsSuccess)
+ {
+ return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(placementResult.Diagnostics);
+ }
+
+ placedBooleanBody = TranslateBody(placedBooleanBody, placementResult.Value);
+
+ executedBooleans.Add(new FirmamentExecutedBoolean(boolean.OpIndex, boolean.FeatureId, boolean.Kind, placedBooleanBody));
+ publishedBodiesByFeatureId[boolean.FeatureId] = placedBooleanBody;
+ booleanExecutionBodiesByFeatureId[boolean.FeatureId] = placedBooleanBody;
}
return KernelResult<FirmamentPrimitiveExecutionResult>.Success(new FirmamentPrimitiveExecutionResult(executedPrimitives, executedBooleans));
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
index fe1c204e..f97af9b0 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLowerer.cs
@@ -116,7 +116,8 @@ internal static class FirmamentPrimitiveLowerer
Kind: booleanKind,
PrimaryReferenceField: primaryFieldName,
PrimaryReferenceFeatureId: entry.RawFields[primaryFieldName],
- Tool: tool);
+ Tool: tool,
+ Placement: LowerPlacement(entry.Placement));
}
private static FirmamentLoweredToolOp ParseTool(string rawWith)
diff --git a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
index 6901dd45..6b7c914b 100644
--- a/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
+++ b/Aetheris.Kernel.Firmament/Lowering/FirmamentPrimitiveLoweringPlan.cs
@@ -30,7 +30,8 @@ public sealed record FirmamentLoweredBoolean(
FirmamentLoweredBooleanKind Kind,
string PrimaryReferenceField,
string PrimaryReferenceFeatureId,
- FirmamentLoweredToolOp Tool);
+ FirmamentLoweredToolOp Tool,
+ FirmamentLoweredPlacement? Placement);
public enum FirmamentLoweredBooleanKind
{
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
index ec65ec5b..6d966bc1 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentBooleanRequiredFieldValidator.cs
@@ -1,4 +1,5 @@
using System.Globalization;
+using System.Linq;
using System.Text.Json;
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Results;
@@ -65,7 +66,13 @@ internal static class FirmamentBooleanRequiredFieldValidator
return InvalidFieldTypeOrShape("with.op", opIndex, entry.OpName, "expected a non-empty scalar/string-like value");
}
- return ValidateNestedPrimitiveToolFields(entry, opIndex, withOpRaw, withFields);
+ var toolValidationResult = ValidateNestedPrimitiveToolFields(entry, opIndex, withOpRaw, withFields);
+ if (!toolValidationResult.IsSuccess)
+ {
+ return toolValidationResult;
+ }
+
+ return ValidatePlacement(entry, opIndex);
}
private static KernelResult<bool> ValidateNestedPrimitiveToolFields(FirmamentParsedOpEntry entry, int opIndex, string withOpRaw, IReadOnlyDictionary<string, string> withFields)
@@ -316,6 +323,135 @@ internal static class FirmamentBooleanRequiredFieldValidator
return trimmed.StartsWith("{", StringComparison.Ordinal) || trimmed.StartsWith("[", StringComparison.Ordinal);
}
+
+ private static KernelResult<bool> ValidatePlacement(FirmamentParsedOpEntry entry, int opIndex)
+ {
+ if (!entry.RawFields.ContainsKey("place"))
+ {
+ return KernelResult<bool>.Success(true);
+ }
+
+ entry.RawFields.TryGetValue("place", out var placeRaw);
+ var hasOn = false;
+ var hasOffset = false;
+ TryReadPlacementFieldPresence(placeRaw ?? string.Empty, out hasOn, out hasOffset);
+
+ if (!hasOn)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementMissingRequiredField,
+ $"Boolean op '{entry.OpName}' at index {opIndex} is missing required field 'place.on'.")]);
+ }
+
+ if (!hasOffset)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementMissingRequiredField,
+ $"Boolean op '{entry.OpName}' at index {opIndex} is missing required field 'place.offset'.")]);
+ }
+
+ if (entry.Placement is null)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementMissingRequiredField,
+ $"Boolean op '{entry.OpName}' at index {opIndex} has invalid field 'place'; expected object-like placement block with required fields 'on' and 'offset'.")]);
+ }
+
+ if (entry.Placement.On is FirmamentParsedPlacementSelectorAnchor selectorAnchor)
+ {
+ if (!FirmamentValidationTargetClassifier.TryClassify(selectorAnchor.Selector, out var shape)
+ || shape != FirmamentValidationTargetShape.SelectorShaped)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidAnchorShape,
+ $"Boolean op '{entry.OpName}' at index {opIndex} has invalid placement anchor in field 'place.on'; expected 'origin' or selector-shaped token 'feature.port'.")]);
+ }
+ }
+ else if (entry.Placement.On is not FirmamentParsedPlacementOriginAnchor)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidAnchorShape,
+ $"Boolean op '{entry.OpName}' at index {opIndex} has invalid placement anchor in field 'place.on'; expected 'origin' or selector-shaped token 'feature.port'.")]);
+ }
+
+ if (entry.RawFields.TryGetValue("place", out var placeRawForOffset)
+ && TryReadOffsetRawTokens(placeRawForOffset, out var offsetTokens)
+ && offsetTokens.Count == 3
+ && offsetTokens.Any(token => !TryParseNumeric(token, out _)))
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidOffsetValue,
+ $"Boolean op '{entry.OpName}' at index {opIndex} has invalid field 'place.offset' value; all components must be numeric.")]);
+ }
+
+ if (entry.Placement.Offset.Count != 3)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidOffsetShape,
+ $"Boolean op '{entry.OpName}' at index {opIndex} has invalid field 'place.offset'; expected exactly 3 numeric components.")]);
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ private static bool TryReadPlacementFieldPresence(string placeRaw, out bool hasOn, out bool hasOffset)
+ {
+ hasOn = false;
+ hasOffset = false;
+
+ var trimmed = placeRaw.Trim();
+ if (!trimmed.StartsWith("{", StringComparison.Ordinal) || !trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ return false;
+ }
+
+ hasOn = trimmed.Contains("on:", StringComparison.Ordinal);
+ hasOffset = trimmed.Contains("offset:", StringComparison.Ordinal)
+ || trimmed.Contains("offset[", StringComparison.Ordinal);
+ return true;
+ }
+
+ private static bool TryReadOffsetRawTokens(string placeRaw, out List<string> tokens)
+ {
+ tokens = [];
+ var trimmed = placeRaw.Trim();
+
+ if (trimmed.StartsWith("{", StringComparison.Ordinal) && trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ var offsetKeyIndex = trimmed.IndexOf("offset", StringComparison.Ordinal);
+ if (offsetKeyIndex < 0)
+ {
+ return false;
+ }
+
+ var offsetSeparator = trimmed.IndexOf(':', offsetKeyIndex);
+ if (offsetSeparator < 0)
+ {
+ return false;
+ }
+
+ var bracketStart = trimmed.IndexOf('[', offsetSeparator + 1);
+ var bracketEnd = trimmed.IndexOf(']', bracketStart + 1);
+ if (bracketStart < 0 || bracketEnd <= bracketStart)
+ {
+ return false;
+ }
+
+ var content = trimmed[(bracketStart + 1)..bracketEnd];
+ tokens = content.Split(',', StringSplitOptions.TrimEntries).ToList();
+ return true;
+ }
+
+ return false;
+ }
+
private static bool TryParseNumeric(string raw, out double value)
{
var trimmed = raw.Trim();
diff --git a/testdata/firmament/fixtures/m7d-invalid-boolean-placement-selector-runtime-empty.firmament b/testdata/firmament/fixtures/m7d-invalid-boolean-placement-selector-runtime-empty.firmament
new file mode 100644
index 00000000..821044ae
--- /dev/null
+++ b/testdata/firmament/fixtures/m7d-invalid-boolean-placement-selector-runtime-empty.firmament
@@ -0,0 +1,43 @@
+firmament:
+ version: 1
+
+model:
+ name: m7d_invalid_boolean_placement_selector_runtime_empty
+ units: mm
+
+ops[3]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: subtract
+ id: cut
+ from: base
+ with:
+ op: box
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: add
+ id: moved
+ to: base
+ with:
+ op: box
+ size[3]:
+ 1
+ 1
+ 1
+ place:
+ on: cut.edges
+ offset[3]:
+ 0
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7d-valid-boolean-chain-placement.firmament b/testdata/firmament/fixtures/m7d-valid-boolean-chain-placement.firmament
new file mode 100644
index 00000000..01548c04
--- /dev/null
+++ b/testdata/firmament/fixtures/m7d-valid-boolean-chain-placement.firmament
@@ -0,0 +1,47 @@
+firmament:
+ version: 1
+
+model:
+ name: m7d_valid_boolean_chain_placement
+ units: mm
+
+ops[4]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 6
+ 6
+ 6
+
+ -
+ op: add
+ id: join1
+ to: base
+ with:
+ op: box
+ size[3]:
+ 1
+ 1
+ 1
+
+ -
+ op: add
+ id: join2
+ to: join1
+ with:
+ op: box
+ size[3]:
+ 1
+ 1
+ 1
+ place:
+ on: origin
+ offset[3]:
+ -4
+ 2
+ 0
+
+ -
+ op: expect_exists
+ target: join2
diff --git a/testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament b/testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament
new file mode 100644
index 00000000..2b1819d3
--- /dev/null
+++ b/testdata/firmament/fixtures/m7d-valid-boolean-origin-placement.firmament
@@ -0,0 +1,32 @@
+firmament:
+ version: 1
+
+model:
+ name: m7d_valid_boolean_origin_placement
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: add
+ id: joined
+ to: base
+ with:
+ op: box
+ size[3]:
+ 2
+ 2
+ 2
+ place:
+ on: origin
+ offset[3]:
+ 10
+ -5
+ 3
diff --git a/testdata/firmament/fixtures/m7d-valid-boolean-selector-placement.firmament b/testdata/firmament/fixtures/m7d-valid-boolean-selector-placement.firmament
new file mode 100644
index 00000000..9ecdaca1
--- /dev/null
+++ b/testdata/firmament/fixtures/m7d-valid-boolean-selector-placement.firmament
@@ -0,0 +1,46 @@
+firmament:
+ version: 1
+
+model:
+ name: m7d_valid_boolean_selector_placement
+ units: mm
+
+ops[3]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 4
+ 4
+ 4
+
+ -
+ op: box
+ id: anchor
+ size[3]:
+ 2
+ 2
+ 2
+ place:
+ on: origin
+ offset[3]:
+ 2
+ 0
+ 0
+
+ -
+ op: add
+ id: moved
+ to: base
+ with:
+ op: box
+ size[3]:
+ 1
+ 1
+ 1
+ place:
+ on: anchor.vertices
+ offset[3]:
+ 1
+ 0
+ 0