Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
using System.Buffers.Binary;
using System.Text.Json;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Firmament.Assembly;
using Aetheris.Kernel.Firmament.FirmamentV2;
using Aetheris.Kernel.Firmament.Scene;
namespace Aetheris.Kernel.Firmament.Tests;
public sealed class SceneAuthoringTests
{
private static string PathFor(string name) => FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/Scene/"+name+".firmament");
private static string Source(string name) => File.ReadAllText(PathFor(name));
private static CompiledScene Compile(string name)
{ using var session=new FirmamentSceneSession(); var r=session.CompileFile(PathFor(name)); Assert.True(r.IsSuccess,string.Join("\n",r.Diagnostics)); return r.Scene!; }
[Fact]
public void RoomMetresNormalizeToMmAndPublishOwnedStableBoundaries()
{
var s=Compile("room"); var room=Assert.Single(s.Source.Rooms);
Assert.Equal(new[] {10000d,8000,4000},room.SizeMm);
Assert.Equal(6,s.Boundaries.Count); Assert.Contains(s.Boundaries,b => b.Path == "hall.floor");
var south=Assert.Single(s.Boundaries,b => b.Path == "hall.southWall");
Assert.Equal(new[] {1000d,2000,0},south.Frame.Skip(12).Take(3)); Assert.Equal("loading",Assert.Single(south.Openings));
Assert.Equal(new[] {900d,1900,-100},s.MinimumMm); Assert.Equal(new[] {11100d,10100,4100},s.MaximumMm);
}
[Fact]
public void RoomDisplayPublishesTwelveUniqueBoundaryEdgesWithoutTriangleDiagonals()
{
var scene = Compile("room");
foreach (var definition in scene.Display.Definitions.Where(d => d.MeshPipeline == "SceneRectangularBoundary"))
{
Assert.Equal(12, definition.Edges.Count);
Assert.Equal(12, definition.Edges.Select(e => e.EdgeId).Distinct().Count());
foreach (var edge in definition.Edges)
{
Assert.Equal(2, edge.Points.Length);
Assert.Equal(1, Enumerable.Range(0, 3).Count(axis => edge.Points[0][axis] != edge.Points[1][axis]));
foreach (var point in edge.Points)
Assert.Contains(Enumerable.Range(0, definition.Positions.Length / 3), index =>
Enumerable.Range(0, 3).All(axis => definition.Positions[index * 3 + axis] == point[axis]));
}
}
Assert.NotEmpty(scene.Display.Definitions);
}
[Fact]
public void ActualWallDisplayVolumeExcludesDoorAndWindowApertures()
{
var s=Compile("room"); var defs=s.Display.Definitions.ToDictionary(d => d.Id);
double Volume(string wall) => s.Display.Occurrences.Where(o => o.Path.StartsWith("RoomProof.hall."+wall+".panel",StringComparison.Ordinal)).Sum(o =>
{
var p=defs[o.DefinitionId!].Positions;
return Enumerable.Range(0,3).Select(a => Enumerable.Range(0,p.Length/3).Max(i => p[i*3+a])-Enumerable.Range(0,p.Length/3).Min(i => p[i*3+a])).Aggregate(1d,(a,b) => a*b);
});
Assert.Equal((10000d*4000-2000*3000)*100,Volume("southWall"));
Assert.Equal((8000d*4000-2000*1000)*100,Volume("eastWall"));
var opening=Assert.Single(s.Source.Openings,o => o.Kind == "Window"); Assert.Equal(1500,opening.SillMm);
Assert.Contains(s.Nodes,n => n.Path == "RoomProof.hall.eastWall.glazing" && n.Kind == "Window");
}
[Theory]
[InlineData("[10m, 8m, 4m]","[10000mm, 8000mm, 4000mm]")]
[InlineData("units: m","units: mm")]
public void MmCompatibilityAndExplicitSuffixesPreserveGeometry(string before,string after)
{
using var session=new FirmamentSceneSession(); var baseline=session.Compile(Source("room")); var changed=session.Compile(Source("room").Replace(before,after,StringComparison.Ordinal));
Assert.True(changed.IsSuccess); Assert.Equal(baseline.Scene!.MinimumMm,changed.Scene!.MinimumMm); Assert.Equal(baseline.Scene.MaximumMm,changed.Scene.MaximumMm);
}
[Theory]
[InlineData("[10m, 8m, 4m]","[10, 8m, 4m]","scene-length-unit-required")]
[InlineData("width: 2m; height: 3m","width: 11m; height: 3m","scene-opening-outside-wall")]
[InlineData("hall.southWall","hall.floor","scene-opening-boundary-invalid")]
[InlineData("thickness: 100mm","thickness: 0mm","scene-room-size-invalid")]
[InlineData("fov: 45deg","fov: 180deg","scene-camera-invalid")]
[InlineData("size: [10m, 8m, 4m]","size: [10m, 8m, 4m]; Size: [10m,8m,4m]","scene-duplicate-field")]
public void InvalidSceneIntentFailsWithSpecificDiagnostics(string before,string after,string code)
{
var r=SceneAuthoring.Parse(Source("room").Replace(before,after,StringComparison.Ordinal)); Assert.False(r.IsSuccess); Assert.Contains(r.Diagnostics,d => d.Code == code);
}
[Fact]
public void PatternKeysSourceSpansAndSharedGeometrySurviveCameraPlacementAndCountEdits()
{
using var session=new FirmamentSceneSession(); var source=Source("parts-and-pattern");
var first=session.Compile(source,PathFor("parts-and-pattern")); Assert.True(first.IsSuccess,string.Join("\n",first.Diagnostics));
Assert.Single(first.Scene!.Display.Definitions); Assert.Equal(2,first.Scene.Source.Occurrences.Count);
var bodies=first.Scene.Display.Occurrences.Where(o => o.DefinitionId is not null).ToArray(); Assert.Equal(bodies[0].DefinitionId,bodies[1].DefinitionId);
Assert.Equal(1000,bodies[0].Transform[12]); Assert.Equal(2000,bodies[1].Transform[12]);
foreach(var o in first.Scene.Source.Occurrences) { Assert.NotNull(o.PatternKey); Assert.StartsWith("Pattern packages",source.Substring(o.Span.Start,o.Span.Length)); }
var edited=source.Replace("[3m, -2m, 1m]","[4m, -2m, 1m]",StringComparison.Ordinal).Replace("x: 2m","x: 2.5m",StringComparison.Ordinal);
var second=session.Compile(edited,PathFor("parts-and-pattern")); Assert.True(second.IsSuccess);
Assert.Equal(0,second.Scene!.Performance.RebuiltEngineeringDefinitions); Assert.Equal(1,second.Scene.Performance.ReusedEngineeringDefinitions);
Assert.Equal(bodies.Select(o => o.Id),second.Scene.Display.Occurrences.Where(o => o.DefinitionId is not null).Select(o => o.Id));
var third=session.Compile(edited.Replace("second => Site", "third => Site { x: 3m; }\n second => Site",StringComparison.Ordinal),PathFor("parts-and-pattern"));
Assert.True(third.IsSuccess); Assert.Equal(3,third.Scene!.Source.Occurrences.Count); Assert.Equal(0,third.Scene.Performance.RebuiltEngineeringDefinitions);
}
[Fact]
public void SceneEditorProjectsSchemaHoverDiagnosticsAndCommentSafePreferredFormatting()
{
var source=Source("room"); var entries=FirmamentLanguageService.Complete("", "scene","r",0).Entries!;
Assert.Contains(entries,e => e.Name == "Scene");
Assert.DoesNotContain(entries,e => e.Name is "Room" or "Door" or "Window" or "Camera");
var sceneEntries=FirmamentLanguageService.Complete("Scene Factory {\n", "scene", "r", "Scene Factory {\n".Length).Entries!;
foreach(var kind in new[] {"Room","Door","Window","Camera"}) Assert.Contains(sceneEntries,e => e.Name == kind);
var prefix="Scene Factory { units: m; Room hall { "; var completion=FirmamentLanguageService.Complete(prefix,"scene","r",prefix.Length);
Assert.Equal("Room",completion.Context); Assert.Contains(completion.Fields,f => f.Name == "Size");
var scenePrefix="Scene Factory { units: m;\n Ro";
Assert.Contains(FirmamentLanguageService.Complete(scenePrefix,"scene","r",scenePrefix.Length).Entries!,e => e.Name == "Room");
Assert.NotNull(FirmamentLanguageAnalysisService.Hover(source,"scene","r",source.IndexOf("Room hall",StringComparison.Ordinal)));
Assert.DoesNotContain(FirmamentLanguageAnalysisService.Analyze(source,"scene","r").Diagnostics,d => d.Severity == "error");
var pascal=source.Replace("units:","Units:",StringComparison.Ordinal).Replace("size:","Size:",StringComparison.Ordinal);
var formatted=FirmamentLanguageAnalysisService.Format(pascal,"scene","r").Text;
Assert.Equal(source,formatted); Assert.Equal(formatted,FirmamentLanguageAnalysisService.Format(formatted,"scene","r").Text);
Assert.Contains("// A semantic room",formatted); Assert.Equal("RoomProof",SceneAuthoring.Parse(formatted).Source!.Name);
}
[Theory]
[InlineData("Scene test { units: m; <Part unfinished = }")]
[InlineData("Scene test { units: m; <Part unfinished = ></Part> }")]
public void UnfinishedOccurrenceDefinitionsReturnSyntaxDiagnostics(string source)
{
var parsed=SceneAuthoring.Parse(source);
Assert.False(parsed.IsSuccess);
Assert.Contains(parsed.Diagnostics,d => d.Code == "scene-syntax-invalid");
}
[Fact]
public void SceneUsdAndGlbPreserveHierarchyCamerasAndInstancing()
{
var s=Compile("parts-and-pattern"); var usd=SceneExport.Usd(s);
Assert.Contains("defaultPrim = \"Scene\"",usd); Assert.Contains("instanceable = true",usd); Assert.Contains("def Camera",usd);
Assert.DoesNotContain("PhysicsRigidBodyAPI",usd); Assert.DoesNotContain("PhysicsFixedJoint",usd);
var bytes=SceneExport.Glb(s); Assert.Equal(bytes,SceneExport.Glb(s));
var length=BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(12,4)); using var json=JsonDocument.Parse(bytes.AsMemory(20,length));
Assert.Single(json.RootElement.GetProperty("meshes").EnumerateArray()); Assert.Single(json.RootElement.GetProperty("cameras").EnumerateArray());
var bodyNodes=json.RootElement.GetProperty("nodes").EnumerateArray().Where(n => n.TryGetProperty("mesh",out _)).ToArray();
Assert.Equal(bodyNodes[0].GetProperty("mesh").GetInt32(),bodyNodes[1].GetProperty("mesh").GetInt32());
}
[Fact]
public void PascalCompatibilityAndPreferredFieldsHaveByteIdenticalPresentationArtifacts()
{
using var session=new FirmamentSceneSession(); var source=Source("room");
var preferred=session.Compile(source); var pascal=session.Compile(FirmamentSourceSpelling.Normalize(source));
Assert.True(preferred.IsSuccess); Assert.True(pascal.IsSuccess);
Assert.Equal(SceneExport.Usd(preferred.Scene!),SceneExport.Usd(pascal.Scene!));
Assert.Equal(SceneExport.Glb(preferred.Scene!),SceneExport.Glb(pascal.Scene!));
}
[Fact]
public void WarehousePlacesThreeExistingRobotsWithoutSolvingMechanicalRelationshipsAtSceneRoot()
{
var s=Compile("warehouse"); Assert.Equal(3,s.Source.Occurrences.Count(o => o.Kind == "Assembly")); Assert.Equal(5,s.Source.Occurrences.Count(o => o.Path.Contains(".packages.",StringComparison.Ordinal)));
var robot=s.Display.Occurrences.Single(o => o.Path == "WarehouseX0.robots.sorting.robot"); Assert.Equal(2500,robot.Transform[12]); Assert.Equal(2000,robot.Transform[13]);
Assert.Single(s.Source.Cameras); Assert.All(s.Nodes,n => Assert.Equal("SceneFrame",n.PlacementAuthority));
var shared=s.Display.Occurrences.Where(o => o.Path.EndsWith(".robot.Base",StringComparison.Ordinal)).Select(o => o.DefinitionId).Distinct().ToArray(); Assert.Single(shared);
}
[Fact]
public void WarehouseCameraAndPlacementEditsReuseEveryEngineeringDefinition()
{
using var session=new FirmamentSceneSession(); var path=PathFor("warehouse"); var source=Source("warehouse");
var first=session.Compile(source,path); Assert.True(first.IsSuccess,string.Join("\n",first.Diagnostics));
var changed=source.Replace("position: [5.6m","position: [5.4m",StringComparison.Ordinal)
.Replace("x: 2500mm","x: 2600mm",StringComparison.Ordinal);
var second=session.Compile(changed,path); Assert.True(second.IsSuccess,string.Join("\n",second.Diagnostics));
Assert.Equal(0,second.Scene!.Performance.RebuiltEngineeringDefinitions);
Assert.Equal(first.Scene!.Performance.UniqueEngineeringDefinitions,second.Scene.Performance.ReusedEngineeringDefinitions);
foreach(var d in first.Scene.Display.Definitions)
{
var reused=second.Scene.Display.Definitions.Single(v => v.Id == d.Id);
Assert.Equal(d.Positions,reused.Positions); Assert.Equal(d.Indices,reused.Indices);
}
Assert.Equal(2600,second.Scene.Display.Occurrences.Single(o => o.Path == "WarehouseX0.robots.sorting.robot").Transform[12]);
Assert.Equal(2500,first.Scene.Display.Occurrences.Single(o => o.Path == "WarehouseX0.robots.sorting.robot").Transform[12]);
}
}