Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add scene boundary visibility and transparent window finishes

Yuechen Li0bf5b896e1db
diff --git a/Aetheris.CLI.Tests/SceneCommandTests.cs b/Aetheris.CLI.Tests/SceneCommandTests.cs
index 97b89f08..a7603be4 100644
--- a/Aetheris.CLI.Tests/SceneCommandTests.cs
+++ b/Aetheris.CLI.Tests/SceneCommandTests.cs
@@ -18,6 +18,13 @@ public sealed class SceneCommandTests
stdout.GetStringBuilder().Clear();
Assert.True(CliRunner.Run(["scene","export-glb",input,output,"--json"],stdout,stderr) == 0,stderr.ToString());
var bytes=File.ReadAllBytes(output);
+ stdout.GetStringBuilder().Clear();
+ Assert.Equal(0,CliRunner.Run(["scene","export-glb",input,output,"--hide-boundary","hall.ceiling","--json"],stdout,stderr));
+ using(var report=JsonDocument.Parse(stdout.ToString()))
+ Assert.Equal("hall.ceiling",report.RootElement.GetProperty("hiddenBoundaries")[0].GetString());
+ bytes=File.ReadAllBytes(output);
+ Assert.NotEqual(0,CliRunner.Run(["scene","export-glb",input,output,"--hide-boundary","missing.ceiling"],stdout,stderr));
+ Assert.Equal(bytes,File.ReadAllBytes(output));
Assert.NotEqual(0,CliRunner.Run(["scene","export-glb",input,output,"--repeat","0"],stdout,stderr));
Assert.Equal(bytes,File.ReadAllBytes(output));
Assert.NotEqual(0,CliRunner.Run(["build",input,"--json"],stdout,stderr));
diff --git a/Aetheris.CLI/SceneCommand.cs b/Aetheris.CLI/SceneCommand.cs
index 1cacb86a..0a839507 100644
--- a/Aetheris.CLI/SceneCommand.cs
+++ b/Aetheris.CLI/SceneCommand.cs
@@ -7,7 +7,7 @@ namespace Aetheris.CLI;
internal static class SceneCommand
{
- internal const string Usage="aetheris scene <inspect|export-usd|export-glb> <scene.firmament> [out.usda|out.glb] [--repeat 1..16] [--json]";
+ internal const string Usage="aetheris scene <inspect|export-usd|export-glb> <scene.firmament> [out.usda|out.glb] [--repeat 1..16] [--hide-boundary room.boundary] [--json]";
internal static int Run(string[] args,TextWriter stdout,TextWriter stderr)
{
if (args.Length == 0 || args[0] is "--help" or "-h") { stdout.WriteLine(Usage); return args.Length == 0 ? 1 : 0; }
@@ -15,9 +15,11 @@ internal static class SceneCommand
{
if (args.Length < 2 || args[0] is not ("inspect" or "export-usd" or "export-glb")) throw new ArgumentException(Usage);
var operation=args[0]; var path=Path.GetFullPath(args[1]); var json=false; var repeat=1; string? output=null;
+ var hiddenBoundaries=new HashSet<string>(StringComparer.Ordinal);
for(var i=2;i<args.Length;i++)
{
if(args[i] == "--json") json=true;
+ else if(args[i] == "--hide-boundary" && i+1<args.Length && operation != "inspect") hiddenBoundaries.Add(args[++i]);
else if(args[i] == "--repeat" && i+1<args.Length && int.TryParse(args[++i],out repeat) && repeat is >=1 and <=16) { }
else if(!args[i].StartsWith('-') && output is null && operation != "inspect") output=args[i];
else throw new ArgumentException("Unknown or incomplete Scene option: "+args[i]);
@@ -49,15 +51,15 @@ internal static class SceneCommand
if(scene.Source.Occurrences.Any(o => o.Definition.Contains('"') && o.Definition.Contains(Path.GetFileName(output),StringComparison.Ordinal)))
throw new ArgumentException("Output must differ from engineering definition inputs.");
Directory.CreateDirectory(Path.GetDirectoryName(output)!);
- if(operation == "export-usd") File.WriteAllText(output,SceneExport.Usd(scene),new UTF8Encoding(false));
- else File.WriteAllBytes(output,SceneExport.Glb(scene));
+ if(operation == "export-usd") File.WriteAllText(output,SceneExport.Usd(scene,hiddenBoundaries),new UTF8Encoding(false));
+ else File.WriteAllBytes(output,SceneExport.Glb(scene,hiddenBoundaries));
bytes=new FileInfo(output).Length;
}
var report=new {success=true,scene=scene.Source.Name,authoringUnits=scene.Source.Units,internalUnits="mm",rooms=scene.Source.Rooms.Count,
assemblies=scene.Source.Occurrences.Count(o => o.Kind == "Assembly"),parts=scene.Source.Occurrences.Count(o => o.Kind == "Part"),
definitions=scene.Display.Definitions.Count,occurrences=scene.Display.Occurrences.Count,cameras=scene.Source.Cameras.Count,
bounds=new {minimumMm=scene.MinimumMm,maximumMm=scene.MaximumMm},boundaries=scene.Boundaries,openings=scene.Source.Openings,
- nodes=scene.Nodes,builds,output,bytes,exportMilliseconds=output is null ? 0 : export.Elapsed.TotalMilliseconds};
+ nodes=scene.Nodes,layoutFrames=scene.Source.LayoutFrames,builds,output,bytes,hiddenBoundaries,exportMilliseconds=output is null ? 0 : export.Elapsed.TotalMilliseconds};
stdout.WriteLine(json ? JsonSerializer.Serialize(report,CliRunner.JsonOptions) : $"Scene {scene.Source.Name}: {scene.Source.Rooms.Count} rooms, {scene.Source.Occurrences.Count} authored placements, {scene.Display.Definitions.Count} shared display definitions"+(output is null ? "." : $"; exported {output}."));
return 0;
}
diff --git a/Aetheris.Kernel.Firmament.Tests/ArchvizSceneTests.cs b/Aetheris.Kernel.Firmament.Tests/ArchvizSceneTests.cs
new file mode 100644
index 00000000..d3780f7e
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/ArchvizSceneTests.cs
@@ -0,0 +1,166 @@
+using System.Buffers.Binary;
+using System.Text.Json;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Firmament.FirmamentV2;
+using Aetheris.Kernel.Firmament.Scene;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class ArchvizSceneTests
+{
+ private const string Finishes = """
+ Appearance wall { color: [.8,.8,.8]; metallic: 0; roughness: .8; }
+ Appearance floor { color: [.5,.3,.1]; metallic: 0; roughness: .5; }
+ Appearance glass { color: [.8,.9,.9]; metallic: 0; roughness: .1; opacity: .2; }
+ Scene FinishProof {
+ units: m;
+ Room room { size: [4m,3m,2.8m]; appearance: wall; floorAppearance: floor; ceilingAppearance: wall; }
+ Window opening { on: room.WALL; along: .5m; width: 2m; height: 2m; sill: .3m;
+ glazingAppearance: glass; frameAppearance: floor; frameWidth: 50mm; glassThickness: 6mm; }
+ }
+ """;
+ private static string HousePath => FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/Scene/WarmModernHouse/house.firmament");
+
+ [Theory]
+ [InlineData("southWall", -50d, 1)]
+ [InlineData("northWall", 3050d, 1)]
+ [InlineData("westWall", -50d, 0)]
+ [InlineData("eastWall", 4050d, 0)]
+ public void WindowFrameAndGlazingFollowTheirOwnedApertureAndWallSkin(string wall,double normalCentre,int axis)
+ {
+ using var session = new FirmamentSceneSession();
+ var result = session.Compile(Finishes.Replace("WALL",wall,StringComparison.Ordinal));
+ Assert.True(result.IsSuccess,string.Join("\n",result.Diagnostics));
+ var scene = result.Scene!;
+ Assert.Equal(5,scene.Nodes.Count(n => n.Kind == "WindowFinish"));
+ var pane = scene.Display.Occurrences.Single(o => o.Path.EndsWith(".pane",StringComparison.Ordinal));
+ var definition = scene.Display.Definitions.Single(d => d.Id == pane.DefinitionId);
+ Assert.Equal(new[] {1900d,1900,6},Enumerable.Range(0,3).Select(a => Enumerable.Range(0,definition.Positions.Length/3)
+ .Max(i => definition.Positions[3*i+a])-Enumerable.Range(0,definition.Positions.Length/3).Min(i => definition.Positions[3*i+a])));
+ var centre = Transform3D.FromRowMajor(pane.Transform).Apply(new Point3D(950,950,3));
+ Assert.Equal(normalCentre,axis == 0 ? centre.X : centre.Y);
+ Assert.Equal(.2,scene.Appearances[pane.Id].Preview.Opacity);
+ var floor = scene.Display.Occurrences.Single(o => o.Path.EndsWith(".floor.panel0",StringComparison.Ordinal));
+ Assert.Equal("floor",scene.Appearances[floor.Id].Appearance);
+ Assert.Contains("inputs:opacity = 0.2",SceneExport.Usd(scene));
+ var bytes = SceneExport.Glb(scene);
+ using var json = JsonDocument.Parse(bytes.AsMemory(20,BinaryPrimitives.ReadInt32LittleEndian(bytes.AsSpan(12,4))));
+ var material = json.RootElement.GetProperty("materials").EnumerateArray().Single(m => m.GetProperty("name").GetString() == "glass");
+ Assert.Equal("BLEND",material.GetProperty("alphaMode").GetString());
+ Assert.Equal(.2,material.GetProperty("pbrMetallicRoughness").GetProperty("baseColorFactor")[3].GetDouble());
+ }
+
+ [Theory]
+ [InlineData("frameWidth: 50mm", "frameWidth: 1m", "scene-window-finish-invalid")]
+ [InlineData("glassThickness: 6mm", "glassThickness: 101mm", "scene-window-finish-invalid")]
+ [InlineData("glazingAppearance: glass", "glazingAppearance: missing", "scene-appearance-unknown")]
+ [InlineData("floorAppearance: floor", "floorAppearance: missing", "scene-appearance-unknown")]
+ [InlineData("opacity: .2", "opacity: 1.1", "assembly-appearance-values-invalid")]
+ [InlineData("frameAppearance: floor;", "", "scene-window-finish-invalid")]
+ public void InvalidNewIntentHasActionableSourceDiagnostics(string before,string after,string code)
+ {
+ var result = SceneAuthoring.Parse(Finishes.Replace("WALL","southWall",StringComparison.Ordinal).Replace(before,after,StringComparison.Ordinal));
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics,d => d.Code == code);
+ }
+
+ [Fact]
+ public void HouseGuidesShareFurnitureAndPresentationEditsReuseEveryEngineeringDefinition()
+ {
+ using var session = new FirmamentSceneSession();
+ var source = File.ReadAllText(HousePath);
+ var first = session.Compile(source,HousePath);
+ Assert.True(first.IsSuccess,string.Join("\n",first.Diagnostics));
+ var scene = first.Scene!;
+ Assert.Equal(2,scene.Source.Rooms.Count);
+ Assert.Equal(3,scene.Source.Cameras.Count);
+ Assert.Equal(8,scene.Source.LayoutFrames.Count);
+ Assert.Equal(4,scene.Display.Occurrences.Count(o => o.Path.Contains(".chairs.",StringComparison.Ordinal) && o.Path.EndsWith(".chair.seat",StringComparison.Ordinal)));
+ Assert.Single(scene.Display.Occurrences.Where(o => o.Path.Contains(".chairs.",StringComparison.Ordinal) && o.Path.EndsWith(".chair.seat",StringComparison.Ordinal)).Select(o => o.DefinitionId).Distinct());
+ Assert.Equal(6,scene.Display.Occurrences.Count(o => o.Path.Contains(".cabinetry.",StringComparison.Ordinal) && o.Path.EndsWith(".cabinet.door",StringComparison.Ordinal)));
+ Assert.Single(scene.Display.Occurrences.Where(o => o.Path.Contains(".cabinetry.",StringComparison.Ordinal) && o.Path.EndsWith(".cabinet.door",StringComparison.Ordinal)).Select(o => o.DefinitionId).Distinct());
+ foreach (var edit in new[] {
+ source.Replace("[8.1m, .65m, 1.65m]","[8m, .65m, 1.65m]",StringComparison.Ordinal),
+ source.Replace("[2500mm, 1450mm]","[2600mm, 1450mm]",StringComparison.Ordinal),
+ source.Replace("color: [.55, .35, .18]","color: [.58, .38, .2]",StringComparison.Ordinal),
+ source.Replace("size: [2.4m, 2.2m, 3.1m]","size: [2.5m, 2.2m, 3.1m]",StringComparison.Ordinal) })
+ {
+ var changed = session.Compile(edit,HousePath);
+ Assert.True(changed.IsSuccess,string.Join("\n",changed.Diagnostics));
+ Assert.Equal(0,changed.Scene!.Performance.RebuiltEngineeringDefinitions);
+ Assert.Equal(scene.Performance.UniqueEngineeringDefinitions,changed.Scene.Performance.ReusedEngineeringDefinitions);
+ foreach (var definition in scene.Display.Definitions.Where(d => !d.Identity.StartsWith("scene-box:",StringComparison.Ordinal)))
+ {
+ var reused = changed.Scene.Display.Definitions.Single(d => d.Id == definition.Id);
+ Assert.Equal(definition.Positions,reused.Positions);
+ Assert.Equal(definition.Indices,reused.Indices);
+ }
+ }
+ var formatted = FirmamentLanguageAnalysisService.Format(source,HousePath,"1").Text;
+ Assert.Equal(source,formatted);
+ Assert.DoesNotContain(FirmamentLanguageAnalysisService.Analyze(source,HousePath,"1").Diagnostics,d => d.Severity == "error");
+ foreach (var field in new[] {"FloorAppearance","CeilingAppearance","GlazingAppearance","FrameAppearance","FrameWidth","GlassThickness","Opacity"})
+ {
+ var owner = field switch { "Opacity" => "Appearance", "FloorAppearance" or "CeilingAppearance" => "Room", _ => "Window" };
+ Assert.Contains(FirmamentLanguageService.Complete(owner+" test { ",HousePath,"1",owner.Length+8).Fields,f => f.Name == field);
+ var label = char.ToLowerInvariant(field[0])+field[1..];
+ var hoverSource = source.Contains(label,StringComparison.Ordinal) ? source : Finishes.Replace("WALL","southWall",StringComparison.Ordinal);
+ var offset = hoverSource.IndexOf(label,StringComparison.Ordinal);
+ Assert.True(offset >= 0,field+" requires a real hover specimen.");
+ Assert.NotNull(FirmamentLanguageAnalysisService.Hover(hoverSource,HousePath,"1",offset));
+ }
+ }
+
+ [Fact]
+ public void CutawayIsAnExplicitExportProjectionWithoutMutationOrRecompilation()
+ {
+ using var session = new FirmamentSceneSession();
+ var result = session.Compile(Finishes.Replace("WALL","southWall",StringComparison.Ordinal));
+ Assert.True(result.IsSuccess);
+ var scene = result.Scene!;
+ var original = SceneExport.Glb(scene);
+ var cutaway = SceneExport.Glb(scene,["room.ceiling","room.southWall"]);
+ using var json = JsonDocument.Parse(cutaway.AsMemory(20,BinaryPrimitives.ReadInt32LittleEndian(cutaway.AsSpan(12,4))));
+ foreach (var node in json.RootElement.GetProperty("nodes").EnumerateArray()
+ .Where(n => n.GetProperty("name").GetString()!.StartsWith("FinishProof.room.ceiling.",StringComparison.Ordinal)
+ || n.GetProperty("name").GetString()!.StartsWith("FinishProof.room.southWall.",StringComparison.Ordinal)))
+ Assert.False(node.TryGetProperty("mesh",out _));
+ Assert.NotEqual(SceneExport.Usd(scene),SceneExport.Usd(scene,["room.ceiling"]));
+ Assert.Equal(original,SceneExport.Glb(scene));
+ Assert.Throws<ArgumentException>(() => SceneExport.Glb(scene,["missing.ceiling"]));
+ }
+
+ [Fact]
+ public void ConceptGuidesDeriveFromTranslatedRoomAndNeverMaterialize()
+ {
+ const string source = """
+ Template<H: Length> Struct Block {
+ RoundedRect2 outline { center: [0mm,0mm]; size: [100mm,100mm]; radius: 10mm; }
+ Profile section { Loop Outer { outline |> TraceLoop } }
+ Extrude body { profile: section; from: 0mm; to: H; }
+ }
+ Concept Struct Layout {
+ Plane floor { from: room.floor; }
+ DatumFrame seat { on: floor; at: [200mm,300mm]; x: [0,1]; }
+ }
+ Scene Guides {
+ units: m;
+ Room room { size: [2m,2m,2m]; at: [1m,2m,0mm]; }
+ <Part block = Block<H:200mm>> Placement { from: Origin; to: Layout.seat; } </Part>
+ }
+ """;
+ using var session = new FirmamentSceneSession();
+ var result = session.Compile(source);
+ Assert.True(result.IsSuccess,string.Join("\n",result.Diagnostics));
+ var block = result.Scene!.Display.Occurrences.Single(o => o.Path == "Guides.block");
+ Assert.Equal(new[] {1200d,2300,0},block.Transform.Skip(12).Take(3));
+ Assert.Equal(1,block.Transform[1],8);
+ Assert.DoesNotContain(result.Scene.Nodes,n => n.Path.Contains("Layout",StringComparison.Ordinal));
+ var unknown = SceneAuthoring.Parse(source.Replace("from: room.floor","from: missing.floor",StringComparison.Ordinal));
+ Assert.False(unknown.IsSuccess);
+ Assert.Contains(unknown.Diagnostics,d => d.Code == "scene-frame-unresolved");
+ var cycle = SceneAuthoring.Parse(source.Replace("from: room.floor","from: Layout.seat",StringComparison.Ordinal));
+ Assert.False(cycle.IsSuccess);
+ Assert.Contains(cycle.Diagnostics,d => d.Code == "assembly-datum-dependency-cycle");
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyAppearanceAuthoring.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyAppearanceAuthoring.cs
index 8d5c120d..929f6dc4 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyAppearanceAuthoring.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyAppearanceAuthoring.cs
@@ -8,6 +8,7 @@ namespace Aetheris.Kernel.Firmament.Assembly;
[FirmamentField("Color", "Color", FirmamentSchemaValueKind.Vector, Required = true)]
[FirmamentField("Metallic", "Metallic", FirmamentSchemaValueKind.Scalar, Required = true)]
[FirmamentField("Roughness", "Roughness", FirmamentSchemaValueKind.Scalar, Required = true)]
+[FirmamentField("Opacity", "Opacity", FirmamentSchemaValueKind.Scalar, Default = "1")]
public static class AssemblyAppearanceDeclaration { }
public sealed record AssemblyAppearance(string Name, AssemblyUsdMaterial Preview);
@@ -39,15 +40,18 @@ internal static class AssemblyAppearanceAuthoring
var body = source[(header.Index + header.Length)..close]; var name = header.Groups["name"].Value;
if (body.Contains('{')) { Error("declaration-fields-invalid", name); continue; }
var fields = Fields(body);
- var allowed = header.Groups["kind"].Value == "Appearance" ? new[] { "Color", "Metallic", "Roughness" } : new[] { "Identity", "Appearance" };
- if (fields.Count != allowed.Length || !allowed.All(fields.ContainsKey)) { Error("declaration-fields-invalid", name); continue; }
- if (allowed.Length == 3)
+ var isAppearance = header.Groups["kind"].Value == "Appearance";
+ var required = isAppearance ? new[] { "Color", "Metallic", "Roughness" } : new[] { "Identity", "Appearance" };
+ var allowed = isAppearance ? required.Append("Opacity").ToArray() : required;
+ if (!required.All(fields.ContainsKey) || fields.Keys.Except(allowed).Any()) { Error("declaration-fields-invalid", name); continue; }
+ if (isAppearance)
{
var color = Regex.Match(fields["Color"], @"^\[(?<v>[^]]+)\]$");
var rgb = color.Success ? color.Groups["v"].Value.Split(',').Select(Number).ToArray() : [];
var metal = Number(fields["Metallic"]); var rough = Number(fields["Roughness"]);
- if (rgb.Length != 3 || rgb.Concat([metal, rough]).Any(v => !double.IsFinite(v) || v < 0 || v > 1)) Error("values-invalid", name);
- else if (!appearances.TryAdd(name, new(name, new(rgb[0], rgb[1], rgb[2], metal, rough)))) Error("duplicate-appearance", name);
+ var opacity = Number(fields.GetValueOrDefault("Opacity", "1"));
+ if (rgb.Length != 3 || rgb.Concat([metal, rough, opacity]).Any(v => !double.IsFinite(v) || v < 0 || v > 1)) Error("values-invalid", name);
+ else if (!appearances.TryAdd(name, new(name, new(rgb[0], rgb[1], rgb[2], metal, rough, opacity)))) Error("duplicate-appearance", name);
}
else
{
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyGlbExporter.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyGlbExporter.cs
index a1b9b550..3cf22fa5 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyGlbExporter.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyGlbExporter.cs
@@ -12,6 +12,12 @@ public sealed record AssemblyGlbAppearance(AssemblyUsdMaterial? Material = null,
/// BRep/STEP remains engineering authority. No tessellation, shading graph, or animation here.</summary>
public static class AssemblyGlbExporter
{
+ private static Dictionary<string,object> Material(string name,object pbr,double opacity)
+ {
+ var result=new Dictionary<string,object> { ["name"]=name,["pbrMetallicRoughness"]=pbr };
+ if (opacity < 1) { result["alphaMode"]="BLEND"; result["doubleSided"]=true; }
+ return result;
+ }
public static byte[] Export(AssemblyM1CompilationResult compilation,
IReadOnlyDictionary<string, double>? state = null,
IReadOnlyDictionary<string, AssemblyGlbAppearance>? appearances = null)
@@ -90,9 +96,9 @@ public static class AssemblyGlbExporter
throw new InvalidOperationException("assembly-glb-invalid-normal:" + d.Identity);
var appearance = appearances?.GetValueOrDefault(d.Identity) ?? new();
var m = appearance.Material ?? new();
- if (new[] { m.Red, m.Green, m.Blue, m.Metallic, m.Roughness }.Any(v => !double.IsFinite(v) || v < 0 || v > 1))
+ if (new[] { m.Red, m.Green, m.Blue, m.Metallic, m.Roughness, m.Opacity }.Any(v => !double.IsFinite(v) || v < 0 || v > 1))
throw new InvalidOperationException("assembly-glb-invalid-material");
- var pbr = new Dictionary<string, object> { ["baseColorFactor"] = new[] { m.Red, m.Green, m.Blue, 1 }, ["metallicFactor"] = m.Metallic, ["roughnessFactor"] = m.Roughness };
+ var pbr = new Dictionary<string, object> { ["baseColorFactor"] = new[] { m.Red, m.Green, m.Blue, m.Opacity }, ["metallicFactor"] = m.Metallic, ["roughnessFactor"] = m.Roughness };
var attributes = new Dictionary<string, object> { ["POSITION"] = Floats(d.Positions, 3, true), ["NORMAL"] = Floats(d.Normals, 3) };
if (appearance.BaseColorTexture is not null)
{
@@ -110,7 +116,7 @@ public static class AssemblyGlbExporter
}
else if (appearance.TextureCoordinates is not null || appearance.TextureMimeType is not null)
throw new InvalidOperationException("assembly-glb-texture-missing");
- materials.Add(new { name = d.Identity, pbrMetallicRoughness = pbr });
+ materials.Add(Material(d.Identity,pbr,m.Opacity));
var indexView = AddView(() => { foreach (var index in d.Indices) writer.Write((uint)index); }, 34963);
var indexAccessor = accessors.Count;
accessors.Add(new { bufferView = indexView, componentType = 5125, count = d.Indices.Length, type = "SCALAR" });
@@ -132,13 +138,13 @@ public static class AssemblyGlbExporter
if (occurrenceLooks?.GetValueOrDefault(o.Id) is { } look)
{
var m = look.Preview;
- if (new[] {m.Red,m.Green,m.Blue,m.Metallic,m.Roughness}.Any(v => !double.IsFinite(v) || v < 0 || v > 1))
+ if (new[] {m.Red,m.Green,m.Blue,m.Metallic,m.Roughness,m.Opacity}.Any(v => !double.IsFinite(v) || v < 0 || v > 1))
throw new InvalidOperationException("assembly-glb-invalid-material");
if (!variants.TryGetValue((o.DefinitionId,m),out var variant))
{
// Material variants share all accessors and buffer views.
var primitive = primitiveTemplates[meshIndex];
- materials.Add(new {name=look.Appearance,pbrMetallicRoughness=new {baseColorFactor=new[] {m.Red,m.Green,m.Blue,1},metallicFactor=m.Metallic,roughnessFactor=m.Roughness}});
+ materials.Add(Material(look.Appearance,new {baseColorFactor=new[] {m.Red,m.Green,m.Blue,m.Opacity},metallicFactor=m.Metallic,roughnessFactor=m.Roughness},m.Opacity));
meshes.Add(new {name=definitions[meshIndex].Identity,primitives=new[] {new {attributes=primitive.Attributes,indices=primitive.Indices,material=materials.Count-1}}});
variants[(o.DefinitionId,m)]=variant=meshes.Count-1;
}
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyUsdExporter.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyUsdExporter.cs
index cf273f4a..90d542c7 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyUsdExporter.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyUsdExporter.cs
@@ -7,7 +7,7 @@ namespace Aetheris.Kernel.Firmament.Assembly;
/// <summary>Downstream preview appearance, never engineering material or density authority.</summary>
public sealed record AssemblyUsdMaterial(double Red = .48, double Green = .55, double Blue = .63,
- double Metallic = .8, double Roughness = .28);
+ double Metallic = .8, double Roughness = .28, double Opacity = 1);
public sealed record AssemblyUsdSample(double Time, IReadOnlyDictionary<string, double> State);
public sealed record AssemblyUsdOptions(IReadOnlyDictionary<string, double>? State = null,
IReadOnlyList<AssemblyUsdSample>? Samples = null,
@@ -125,6 +125,7 @@ public static class AssemblyUsdExporter
Line(" def Shader \"Shader\" {"); Line(" uniform token info:id = \"UsdPreviewSurface\"");
Line($" color3f inputs:diffuseColor = ({F(m.Red)}, {F(m.Green)}, {F(m.Blue)})");
Line($" float inputs:metallic = {F(m.Metallic)}"); Line($" float inputs:roughness = {F(m.Roughness)}");
+ if (m.Opacity != 1) Line($" float inputs:opacity = {F(m.Opacity)}");
Line(" token outputs:surface"); Line(" }"); Line(" }");
}
foreach (var look in authoredLooks)
@@ -137,6 +138,7 @@ public static class AssemblyUsdExporter
Line(" def Shader \"Shader\" {"); Line(" uniform token info:id = \"UsdPreviewSurface\"");
Line($" color3f inputs:diffuseColor = ({F(m.Red)}, {F(m.Green)}, {F(m.Blue)})");
Line($" float inputs:metallic = {F(m.Metallic)}"); Line($" float inputs:roughness = {F(m.Roughness)}");
+ if (m.Opacity != 1) Line($" float inputs:opacity = {F(m.Opacity)}");
Line(" token outputs:surface"); Line(" }"); Line(" }");
}
Line("}");
@@ -253,7 +255,7 @@ public static class AssemblyUsdExporter
private static void ValidateMaterial(AssemblyUsdMaterial m)
{
- if (new[] { m.Red, m.Green, m.Blue, m.Metallic, m.Roughness }.Any(v => !double.IsFinite(v) || v < 0 || v > 1))
+ if (new[] { m.Red, m.Green, m.Blue, m.Metallic, m.Roughness, m.Opacity }.Any(v => !double.IsFinite(v) || v < 0 || v > 1))
throw new InvalidOperationException("assembly-usd-invalid-material");
}
private static string Identifier(string value) => "N_" + new string(value.Select(c => char.IsAsciiLetterOrDigit(c) || c == '_' ? c : '_').ToArray());
diff --git a/Aetheris.Kernel.Firmament/Scene/SceneAuthoring.cs b/Aetheris.Kernel.Firmament/Scene/SceneAuthoring.cs
index 803399bf..08befe28 100644
--- a/Aetheris.Kernel.Firmament/Scene/SceneAuthoring.cs
+++ b/Aetheris.Kernel.Firmament/Scene/SceneAuthoring.cs
@@ -16,6 +16,8 @@ public static class SceneDeclaration { }
[FirmamentField("At", "At", FirmamentSchemaValueKind.Vector, Unit = FirmamentUnitKind.Length)]
[FirmamentField("Thickness", "Thickness", FirmamentSchemaValueKind.Length, Unit = FirmamentUnitKind.Length, Default = "100mm")]
[FirmamentField("Appearance", "Appearance", FirmamentSchemaValueKind.ConstructReference)]
+[FirmamentField("FloorAppearance", "FloorAppearance", FirmamentSchemaValueKind.ConstructReference)]
+[FirmamentField("CeilingAppearance", "CeilingAppearance", FirmamentSchemaValueKind.ConstructReference)]
[FirmamentOutput("floor", "floor", "SceneBoundary", SourceAddressable = true)]
[FirmamentOutput("ceiling", "ceiling", "SceneBoundary", SourceAddressable = true)]
[FirmamentOutput("northWall", "northWall", "SceneBoundary", SourceAddressable = true)]
@@ -31,12 +33,16 @@ public static class RoomDeclaration { }
[FirmamentField("Along", "Along", FirmamentSchemaValueKind.Length, Required = true, Unit = FirmamentUnitKind.Length)]
public static class DoorDeclaration { }
-[FirmamentConstruct("Window", "Window", Context = "Scene", Entry = "Window officeGlass { On: warehouse.eastWall; Width: 6m; Height: 2.5m; Sill: 1m; Along: 4m; }", Description = "Room-owned rectangular wall aperture; no glazing or curtain-wall system.")]
+[FirmamentConstruct("Window", "Window", Context = "Scene", Entry = "Window officeGlass { On: warehouse.eastWall; Width: 6m; Height: 2.5m; Sill: 1m; Along: 4m; }", Description = "Room-owned rectangular aperture with optional inset frame and glazing; all geometry follows the opening dimensions.")]
[FirmamentField("On", "On", FirmamentSchemaValueKind.ConstructReference, Required = true)]
[FirmamentField("Width", "Width", FirmamentSchemaValueKind.Length, Required = true, Unit = FirmamentUnitKind.Length)]
[FirmamentField("Height", "Height", FirmamentSchemaValueKind.Length, Required = true, Unit = FirmamentUnitKind.Length)]
[FirmamentField("Along", "Along", FirmamentSchemaValueKind.Length, Required = true, Unit = FirmamentUnitKind.Length)]
[FirmamentField("Sill", "Sill", FirmamentSchemaValueKind.Length, Required = true, Unit = FirmamentUnitKind.Length)]
+[FirmamentField("GlazingAppearance", "GlazingAppearance", FirmamentSchemaValueKind.ConstructReference)]
+[FirmamentField("FrameAppearance", "FrameAppearance", FirmamentSchemaValueKind.ConstructReference)]
+[FirmamentField("FrameWidth", "FrameWidth", FirmamentSchemaValueKind.Length, Unit = FirmamentUnitKind.Length, Default = "40mm")]
+[FirmamentField("GlassThickness", "GlassThickness", FirmamentSchemaValueKind.Length, Unit = FirmamentUnitKind.Length, Default = "6mm")]
public static class WindowDeclaration { }
[FirmamentConstruct("SceneCamera", "Camera", Context = "Scene", Entry = "Camera hero { Position: [35m, -15m, 20m]; LookAt: [15m, 9m, 1m]; Fov: 45deg; }", Description = "Presentation state in a Z-up world; independent of engineering geometry.")]
@@ -45,8 +51,11 @@ public static class WindowDeclaration { }
[FirmamentField("Fov", "Fov", FirmamentSchemaValueKind.Angle, Required = true, Unit = FirmamentUnitKind.Angle)]
public static class SceneCameraDeclaration { }
-public sealed record SceneRoom(string Name, double[] SizeMm, double[] AtMm, double ThicknessMm, string? Appearance, SemanticSourceSpan Span);
-public sealed record SceneOpening(string Name, string Kind, string Boundary, double WidthMm, double HeightMm, double AlongMm, double SillMm, SemanticSourceSpan Span);
+public sealed record SceneRoom(string Name, double[] SizeMm, double[] AtMm, double ThicknessMm, string? Appearance, SemanticSourceSpan Span,
+ string? FloorAppearance = null, string? CeilingAppearance = null);
+public sealed record SceneWindowFinish(string? GlazingAppearance, string? FrameAppearance, double FrameWidthMm, double GlassThicknessMm);
+public sealed record SceneOpening(string Name, string Kind, string Boundary, double WidthMm, double HeightMm, double AlongMm, double SillMm, SemanticSourceSpan Span,
+ SceneWindowFinish? Finish = null);
public sealed record SceneCamera(string Name, double[] PositionMm, double[] LookAtMm, double FovDegrees, SemanticSourceSpan Span)
{
public double[] WorldTransform()
@@ -60,10 +69,11 @@ public sealed record SceneCamera(string Name, double[] PositionMm, double[] Look
}
public sealed record SceneOccurrenceSource(string Path, string Kind, string Definition, AssemblyFrameTransformSource Placement,
string From, string? Appearance, SemanticSourceSpan Span, string? PatternKey = null);
+public sealed record SceneLayoutFrame(string Identity, AssemblyFrameTransformSource Transform);
public sealed record SceneSource(string Name, string Units, string DefinitionSource, string SourceIdentity,
IReadOnlyList<SceneRoom> Rooms, IReadOnlyList<SceneOpening> Openings, IReadOnlyList<SceneCamera> Cameras,
IReadOnlyList<SceneOccurrenceSource> Occurrences, AssemblyAppearanceCatalog Looks,
- IReadOnlyList<FirmamentV2CanonicalPatternDecl> Patterns);
+ IReadOnlyList<FirmamentV2CanonicalPatternDecl> Patterns, IReadOnlyList<SceneLayoutFrame> LayoutFrames);
public sealed record SceneParseResult(SceneSource? Source, IReadOnlyList<AssemblyDiagnostic> Diagnostics)
{ public bool IsSuccess => Source is not null && Diagnostics.All(d => d.Severity != AssemblyDiagnosticSeverity.Error); }
@@ -102,16 +112,23 @@ public static class SceneAuthoring
var original = new Reader(text, identity);
var definitionEnd = 0;
var geometryDeclarations = new List<string>();
+ var conceptNames = new List<string>();
while (!original.End && original.Peek != "Scene")
{
var kind = original.Peek;
- if (kind is not ("Template" or "Record" or "Static" or "Function" or "Appearance" or "Material"))
+ if (kind is not ("Template" or "Record" or "Static" or "Function" or "Appearance" or "Material" or "Concept"))
Fail("scene-declaration-unsupported", $"Unsupported Scene module declaration '{kind}'. Use AssemblyFile for independently compiled assemblies.");
var declarationStart = original.Position;
original.SkipDeclaration(); definitionEnd = original.Position;
var declaration = text[declarationStart..definitionEnd];
+ if (kind == "Concept")
+ {
+ var concept = Regex.Match(declaration,@"^Concept\s+Struct\s+(?<name>\w+)\s*\{");
+ if (!concept.Success) Fail("scene-concept-layout-unsupported", "Scene admits existing Concept Struct Plane/Axis/DatumFrame layout guides.");
+ conceptNames.Add(concept.Groups["name"].Value);
+ }
// Scene keyed Sets and preview looks are composition inputs, not geometry inputs.
- if (kind is not ("Appearance" or "Material") && !Regex.IsMatch(declaration,@"^Static\s+\w+\s*:\s*Set\s*<"))
+ if (kind is not ("Appearance" or "Material" or "Concept") && !Regex.IsMatch(declaration,@"^Static\s+\w+\s*:\s*Set\s*<"))
geometryDeclarations.Add(declaration);
}
if (original.End) Fail("scene-root-missing", "Expected one Scene root.");
@@ -119,6 +136,12 @@ public static class SceneAuthoring
original.Block(); original.Optional(";");
if (!original.End) Fail("scene-multiple-roots", "A Scene document requires exactly one Scene root and no trailing declarations.");
var definitionSource = string.Join("\n",geometryDeclarations);
+ var layout = AssemblyDatumAuthoring.ParseLayouts(text,identity,diagnostics,out _);
+ // Concept layouts are erased design scaffolding. The existing datum parser owns
+ // their members, units, bases, derivation and cycle diagnostics.
+ if (diagnostics.Any(d => d.Severity == AssemblyDiagnosticSeverity.Error)) return new(null,diagnostics);
+ if (conceptNames.Any(n => !layout.Any(d => d.Identity.StartsWith(n+".",StringComparison.Ordinal))))
+ Fail("scene-concept-layout-unsupported", "Each Scene Concept Struct requires an admitted Plane or Axis and optional DatumFrame members.");
var errors = new List<string>();
var expanded = CanonicalStaticAuthoring.ExpandAssemblyPatterns(text, errors, spatial: true);
foreach (var error in errors) diagnostics.Add(new("scene-pattern-invalid", error));
@@ -150,14 +173,27 @@ public static class SceneAuthoring
switch (kind)
{
case "Room":
- Check(f, "Size At Thickness Appearance", "Size");
+ Check(f, "Size At Thickness Appearance FloorAppearance CeilingAppearance", "Size");
var size = Vector(f["Size"]); var at = Vector(f.GetValueOrDefault("At", "[0mm,0mm,0mm]"));
var thickness = Length(f.GetValueOrDefault("Thickness", "100mm"));
if (size.Any(v => v <= 0) || thickness <= 0) Fail("scene-room-size-invalid", "Room dimensions and thickness must be positive.");
- rooms.Add(new(id,size,at,thickness,f.GetValueOrDefault("Appearance"),span)); break;
+ rooms.Add(new(id,size,at,thickness,f.GetValueOrDefault("Appearance"),span,
+ f.GetValueOrDefault("FloorAppearance"),f.GetValueOrDefault("CeilingAppearance"))); break;
case "Door": case "Window":
- Check(f, kind == "Door" ? "On Width Height Along" : "On Width Height Along Sill", kind == "Door" ? "On Width Height Along" : "On Width Height Along Sill");
- openings.Add(new(id,kind,f["On"],Length(f["Width"]),Length(f["Height"]),Length(f["Along"]),kind == "Window" ? Length(f["Sill"]) : 0,span)); break;
+ Check(f, kind == "Door" ? "On Width Height Along" : "On Width Height Along Sill GlazingAppearance FrameAppearance FrameWidth GlassThickness", kind == "Door" ? "On Width Height Along" : "On Width Height Along Sill");
+ SceneWindowFinish? finish = null;
+ if (kind == "Window" && f.Keys.Any(k => k is "GlazingAppearance" or "FrameAppearance" or "FrameWidth" or "GlassThickness"))
+ {
+ var glazing = f.GetValueOrDefault("GlazingAppearance"); var frame = f.GetValueOrDefault("FrameAppearance");
+ if ((glazing is null && frame is null) || (f.ContainsKey("FrameWidth") && frame is null) || (f.ContainsKey("GlassThickness") && glazing is null))
+ Fail("scene-window-finish-invalid", "Window finish dimensions require their corresponding glazingAppearance or frameAppearance.");
+ var frameWidth = frame is null ? 0 : Length(f.GetValueOrDefault("FrameWidth", "40mm"));
+ var glassThickness = Length(f.GetValueOrDefault("GlassThickness", "6mm"));
+ if ((frame is not null && frameWidth <= 0) || glassThickness <= 0 || frameWidth * 2 >= Math.Min(Length(f["Width"]),Length(f["Height"])))
+ Fail("scene-window-finish-invalid", "Window frame must leave a positive clear pane; frame width and glass thickness must be positive.");
+ finish = new(glazing,frame,frameWidth,glassThickness);
+ }
+ openings.Add(new(id,kind,f["On"],Length(f["Width"]),Length(f["Height"]),Length(f["Along"]),kind == "Window" ? Length(f["Sill"]) : 0,span,finish)); break;
case "Camera":
Check(f,"Position LookAt Fov","Position LookAt Fov");
var position = Vector(f["Position"]); var target = Vector(f["LookAt"]); var fov = Angle(f["Fov"]);
@@ -177,14 +213,23 @@ public static class SceneAuthoring
if (opening.WidthMm <= 0 || opening.HeightMm <= 0 || opening.AlongMm < 0 || opening.SillMm < 0
|| opening.AlongMm+opening.WidthMm > extent || opening.SillMm+opening.HeightMm > room.SizeMm[2])
Fail("scene-opening-outside-wall", $"Opening '{opening.Name}' must lie inside its wall bounds.");
+ if (opening.Finish is { GlazingAppearance: not null } windowFinish && windowFinish.GlassThicknessMm > room.ThicknessMm)
+ Fail("scene-window-finish-invalid", "Window glass thickness must fit inside its owning wall thickness.");
foreach (var other in openings.Where(o => o != opening && o.Boundary == opening.Boundary))
if (opening.AlongMm < other.AlongMm+other.WidthMm && other.AlongMm < opening.AlongMm+opening.WidthMm
&& opening.SillMm < other.SillMm+other.HeightMm && other.SillMm < opening.SillMm+opening.HeightMm)
Fail("scene-openings-overlap", $"Openings '{opening.Name}' and '{other.Name}' overlap.");
}
- foreach (var look in rooms.Select(r => r.Appearance).Concat(occurrences.Select(o => o.Appearance)).OfType<string>())
+ foreach (var look in rooms.SelectMany(r => new[] {r.Appearance,r.FloorAppearance,r.CeilingAppearance})
+ .Concat(openings.SelectMany(o => new[] {o.Finish?.GlazingAppearance,o.Finish?.FrameAppearance}))
+ .Concat(occurrences.Select(o => o.Appearance)).OfType<string>())
if (!looks.Appearances.ContainsKey(look)) Fail("scene-appearance-unknown", $"Unknown Appearance '{look}'.");
- return new(new(name,units,definitionSource,identity,rooms,openings,cameras,occurrences,looks,patterns),diagnostics);
+ var frameNames = rooms.SelectMany(r => new[] {"floor","ceiling","northWall","southWall","eastWall","westWall"}.Select(b => r.Name+"."+b))
+ .Concat(layout.Select(d => d.Identity)).Append("World").ToHashSet(StringComparer.Ordinal);
+ foreach (var reference in layout.Select(d => d.Transform.From).Concat(occurrences.Select(o => o.Placement.From)))
+ if (!frameNames.Contains(reference)) Fail("scene-frame-unresolved", $"Unknown Scene frame '{reference}'. Use World, a Room boundary or a Concept datum.");
+ return new(new(name,units,definitionSource,identity,rooms,openings,cameras,occurrences,looks,patterns,
+ layout.Select(d => new SceneLayoutFrame(d.Identity,d.Transform)).ToArray()),diagnostics);
void ReadOccurrence(Reader r, string parent)
{
diff --git a/Aetheris.Kernel.Firmament/Scene/SceneCompilation.cs b/Aetheris.Kernel.Firmament/Scene/SceneCompilation.cs
index f81583bc..ceecb4c9 100644
--- a/Aetheris.Kernel.Firmament/Scene/SceneCompilation.cs
+++ b/Aetheris.Kernel.Firmament/Scene/SceneCompilation.cs
@@ -81,6 +81,26 @@ public sealed class FirmamentSceneSession : IDisposable
var definitionMs=watch.Elapsed.TotalMilliseconds; watch.Restart();
if (diagnostics.Any(d => d.Severity == AssemblyDiagnosticSeverity.Error)) return new(null,diagnostics);
var boundaries=s.Rooms.SelectMany(RoomBoundaries).ToArray();
+ var layoutFrames=s.LayoutFrames.ToDictionary(f => f.Identity,StringComparer.Ordinal);
+ var resolvedFrames=new Dictionary<string,Transform3D>(StringComparer.Ordinal);
+ Transform3D? ResolveFrame(string path,HashSet<string> active)
+ {
+ if (path == "World") return Transform3D.Identity;
+ if (boundaries.SingleOrDefault(b => b.Path == path) is { } boundary) return Transform3D.FromRowMajor(boundary.Frame);
+ if (resolvedFrames.TryGetValue(path,out var cached)) return cached;
+ if (!layoutFrames.TryGetValue(path,out var layout))
+ { Error("scene-frame-unresolved",$"Unknown Scene target frame '{path}'. Use World, a Room boundary or a Concept datum."); return null; }
+ if (!active.Add(path)) { Error("scene-frame-cycle",$"Scene Concept frame cycle at '{path}'."); return null; }
+ var basis=ResolveFrame(layout.Transform.From,active);
+ active.Remove(path);
+ if (basis is null) return null;
+ var frame=AssemblyFrameAuthoring.Compose(basis.Value,layout.Transform,diagnostics);
+ resolvedFrames[path]=frame;
+ return frame;
+ }
+ // Validate unused guides too, so invalid scaffolding cannot hide behind a
+ // placement edit. They never become display/product occurrences.
+ foreach (var layout in s.LayoutFrames) ResolveFrame(layout.Identity,[]);
AddNode(s.Name,"Scene",s.Name,null,Transform3D.Identity.ToRowMajor(),null,new(sourceIdentity,0,source.Length));
foreach (var room in s.Rooms)
{
@@ -97,24 +117,32 @@ public sealed class FirmamentSceneSession : IDisposable
var panelPath=wallPath+".panel"+panel.Index;
var world=Transform3D.CreateTranslation(new(panel.At[0],panel.At[1],panel.At[2]))*transform;
AddNode(panelPath,"EnvironmentPanel",key,wallPath,world.ToRowMajor(),id,room.Span);
- ApplyLook(panelPath,room.Appearance);
+ ApplyLook(panelPath,boundary.Kind switch { "floor" => room.FloorAppearance ?? room.Appearance, "ceiling" => room.CeilingAppearance ?? room.Appearance, _ => room.Appearance });
}
foreach (var opening in s.Openings.Where(o => o.Boundary == boundary.Path))
{
var frame=Transform3D.FromRowMajor(boundary.Frame);
var aperture=Transform3D.CreateTranslation(new(opening.AlongMm,opening.SillMm,0))*frame;
- AddNode(wallPath+"."+opening.Name,opening.Kind,opening.Name,wallPath,aperture.ToRowMajor(),null,opening.Span);
+ var openingPath=wallPath+"."+opening.Name;
+ AddNode(openingPath,opening.Kind,opening.Name,wallPath,aperture.ToRowMajor(),null,opening.Span);
+ foreach (var piece in WindowPieces(opening,room.ThicknessMm,boundary.Kind))
+ {
+ var key="scene-box:"+string.Join(":",piece.Size.Select(F)); var id=Id(key);
+ if (!definitions.ContainsKey(id)) definitions.Add(id,Box(id,key,piece.Size));
+ var path=openingPath+"."+piece.Name;
+ var world=Transform3D.CreateTranslation(new(piece.At[0],piece.At[1],piece.At[2]))*aperture;
+ AddNode(path,"WindowFinish",key,openingPath,world.ToRowMajor(),id,opening.Span);
+ ApplyLook(path,piece.Appearance);
+ }
}
}
}
foreach (var item in s.Occurrences)
{
// Existing frame composition owns rotation/basis/translation; no Mate is synthesized.
- Transform3D target;
- if (item.Placement.From == "World") target=Transform3D.Identity;
- else if (boundaries.SingleOrDefault(b => b.Path == item.Placement.From) is { } boundary) target=Transform3D.FromRowMajor(boundary.Frame);
- else { Error("scene-frame-unresolved",$"Unknown Scene target frame '{item.Placement.From}'."); continue; }
- var world=AssemblyFrameAuthoring.Compose(target,item.Placement,diagnostics);
+ var target=ResolveFrame(item.Placement.From,[]);
+ if (target is null) continue;
+ var world=AssemblyFrameAuthoring.Compose(target.Value,item.Placement,diagnostics);
var segments=item.Path.Split('.');
for (var n=2;n<segments.Length;n++)
{
@@ -196,6 +224,24 @@ public sealed class FirmamentSceneSession : IDisposable
private static string F(double value) => value.ToString("R",CultureInfo.InvariantCulture);
private static string Id(string value) => "scene:"+Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value)))[..24];
private sealed record Panel(int Index,double[] At,double[] Size);
+ private sealed record WindowPiece(string Name,double[] At,double[] Size,string Appearance);
+ private static IEnumerable<WindowPiece> WindowPieces(SceneOpening opening,double wallThickness,string wall)
+ {
+ if (opening.Finish is not { } finish) yield break;
+ var w=opening.WidthMm; var h=opening.HeightMm; var b=finish.FrameWidthMm;
+ // Boundary chart +Z is -Y for north/south and +X for east/west.
+ var center=wall is "southWall" or "eastWall" ? wallThickness/2 : -wallThickness/2;
+ if (finish.FrameAppearance is { } frame)
+ {
+ var z=center-wallThickness/2;
+ yield return new("leftJamb",[0,0,z],[b,h,wallThickness],frame);
+ yield return new("rightJamb",[w-b,0,z],[b,h,wallThickness],frame);
+ yield return new("sill",[b,0,z],[w-2*b,b,wallThickness],frame);
+ yield return new("head",[b,h-b,z],[w-2*b,b,wallThickness],frame);
+ }
+ if (finish.GlazingAppearance is { } glass)
+ yield return new("pane",[b,b,center-finish.GlassThicknessMm/2],[w-2*b,h-2*b,finish.GlassThicknessMm],glass);
+ }
private static IEnumerable<Panel> Panels(SceneRoom r,string wall,IReadOnlyList<SceneOpening> openings)
{
var w=r.SizeMm[0]; var d=r.SizeMm[1]; var h=r.SizeMm[2]; var t=r.ThicknessMm;
diff --git a/Aetheris.Kernel.Firmament/Scene/SceneExport.cs b/Aetheris.Kernel.Firmament/Scene/SceneExport.cs
index 195255f5..598456c5 100644
--- a/Aetheris.Kernel.Firmament/Scene/SceneExport.cs
+++ b/Aetheris.Kernel.Firmament/Scene/SceneExport.cs
@@ -5,7 +5,20 @@ namespace Aetheris.Kernel.Firmament.Scene;
public static class SceneExport
{
- public static string Usd(CompiledScene scene)
+ /// <summary>A presentation projection over owned Room boundaries. Geometry and
+ /// authored room validity remain unchanged; unknown boundaries fail closed.</summary>
+ private static AssemblyDisplayMeshDocument Project(CompiledScene scene,IReadOnlyCollection<string>? hiddenBoundaries)
+ {
+ if (hiddenBoundaries is null || hiddenBoundaries.Count == 0) return scene.Display;
+ var known=scene.Boundaries.Select(b => b.Path).ToHashSet(StringComparer.Ordinal);
+ foreach (var boundary in hiddenBoundaries)
+ if (!known.Contains(boundary)) throw new ArgumentException($"scene-presentation-boundary-unknown: '{boundary}'.");
+ var prefixes=hiddenBoundaries.Select(b => scene.Source.Name+"."+b+".").ToArray();
+ return scene.Display with { Occurrences=scene.Display.Occurrences.Select(o =>
+ prefixes.Any(p => o.Path.StartsWith(p,StringComparison.Ordinal)) ? o with { DefinitionId=null } : o).ToArray() };
+ }
+
+ public static string Usd(CompiledScene scene,IReadOnlyCollection<string>? hiddenBoundaries = null)
{
var ids=scene.Display.Occurrences.ToDictionary(o => o.Path,o => o.Id,StringComparer.Ordinal);
var identities=scene.Nodes.ToDictionary(n => ids[n.Path],n => n.DefinitionIdentity,StringComparer.Ordinal);
@@ -17,9 +30,10 @@ public static class SceneExport
var id=ids[scene.Source.Name+"."+o.Boundary+"."+o.Name];
properties[id]=new Dictionary<string,string>(properties[id]) { ["widthMm"]=F(o.WidthMm),["heightMm"]=F(o.HeightMm),["alongMm"]=F(o.AlongMm),["sillMm"]=F(o.SillMm),["boundary"]=o.Boundary };
}
- return AssemblyUsdExporter.SerializeSpatial(scene.Display,new(identities,scene.Appearances,properties,Cameras(scene)));
+ return AssemblyUsdExporter.SerializeSpatial(Project(scene,hiddenBoundaries),new(identities,scene.Appearances,properties,Cameras(scene)));
}
- public static byte[] Glb(CompiledScene scene) => AssemblyGlbExporter.Serialize(scene.Display,occurrenceLooks:scene.Appearances,cameras:Cameras(scene));
+ public static byte[] Glb(CompiledScene scene,IReadOnlyCollection<string>? hiddenBoundaries = null) =>
+ AssemblyGlbExporter.Serialize(Project(scene,hiddenBoundaries),occurrenceLooks:scene.Appearances,cameras:Cameras(scene));
private static DisplayCamera[] Cameras(CompiledScene scene) => scene.Source.Cameras.Select(c => new DisplayCamera(c.Name,c.WorldTransform(),c.FovDegrees)).ToArray();
private static string F(double v) => v.ToString("R",CultureInfo.InvariantCulture);
}
diff --git a/docs/public/firmament/scenes.md b/docs/public/firmament/scenes.md
index b9b21782..33f8ae64 100644
--- a/docs/public/firmament/scenes.md
+++ b/docs/public/firmament/scenes.md
@@ -50,16 +50,55 @@ third axis is not an inward/outward wall-normal classification.
Door bottom is the floor. Window bottom is its `sill`. Openings must fit inside
the selected wall and cannot overlap. They lower to actual missing wall volume
by a deterministic rectangular partition. No authored subtraction is required.
-Windows are apertures in X0; glazing and door leaves are not synthesized.
+Windows remain apertures by default. Optional `glazingAppearance` and
+`frameAppearance` synthesize a single inset pane and four frame members from
+the aperture's owned dimensions. `frameWidth` defaults to 40mm;
+`glassThickness` defaults to 6mm. A frame must leave positive clear width/height,
+and glass must fit within the Room's wall thickness. Dimensions require the
+corresponding finish. Unknown finishes fail. Door leaves remain unsynthesized.
The semantic hierarchy is Room → boundary → opening, even when the boundary's
display consists of multiple panels. Panel names are derived display structure;
the named boundary and opening retain authority.
## Placement, sharing and presentation
+Room `appearance` is the default wall/enclosure finish. Optional
+`floorAppearance` and `ceilingAppearance` override those two surfaces without
+adding overlay geometry or changing engineering Material. For example:
+
+```firmament
+Room main {
+ size: [9m, 7m, 3.1m];
+ appearance: plasterWhite; floorAppearance: warmOak; ceilingAppearance: ceilingWhite;
+}
+Window garden {
+ on: main.westWall; along: 1.1m; width: 4.4m; height: 2.6m; sill: .12m;
+ glazingAppearance: clearGlass; frameAppearance: charcoalMetal; frameWidth: 45mm;
+}
+```
+
+The existing top-level `Concept Struct` Plane/Axis/DatumFrame vocabulary also
+supplies Scene placement guides. The existing datum parser owns units, bases,
+derivation and cycle checks; Concept coordinates retain its **mm** contract.
+Planes may derive from a Room boundary or another same-document Concept datum.
+Published engineering-port derivation remains with Assembly. Unresolved guides
+fail during source analysis, including unused guides. Concepts produce no solids
+or product occurrences and stay outside engineering definition cache inputs.
+
+```firmament
+Concept Struct HouseLayout {
+ Plane floor { from: main.floor; }
+ DatumFrame dining { on: floor; at: [6800mm, 5350mm]; x: [1, 0]; }
+}
+// In the Scene:
+<Assembly dining = AssemblyFile<"dining.firmament">>
+ Placement { from: Origin; to: HouseLayout.dining; }
+</Assembly>
+```
+
Scene `Placement` reuses the existing `translateLocal`, `rotateLocal`, `normal`,
-`up`, and frame composition implementation. `to` may name `World` or a Room
-boundary. `from: Origin` is available on Parts and Assemblies; Assemblies may
+`up`, and frame composition implementation. `to` may name `World`, a Room
+boundary, or a same-document Concept datum. `from: Origin` is available on Parts and Assemblies; Assemblies may
also name an exact published DatumFrame. Rotation retains the existing form
`rotateLocal: { axis: Z; angle: 90deg; }`. There are no authored matrices.
Named Scene `FrameTransform` declarations and Part source-port alignment are
@@ -82,6 +121,9 @@ vertical `fov` in degrees. Export uses Z-up camera orientation. Cameras never
modify engineering geometry. Scene `Appearance` definitions and occurrence
`appearance` overrides reuse the existing finite preview material values.
Physical material/density selection remains in engineering definitions.
+Appearance also admits optional `opacity` in `[0,1]`, default one. USD emits
+`UsdPreviewSurface` opacity; GLB emits alpha and `BLEND` for translucent looks.
+Opacity does not encode refraction, physical glass properties, or a shader graph.
## CLI and exports
@@ -90,6 +132,7 @@ aetheris validate fixtures/Canonical/Scene/warehouse.firmament --json
aetheris inspect fixtures/Canonical/Scene/warehouse.firmament --repeat 2 --json
aetheris scene export-usd fixtures/Canonical/Scene/warehouse.firmament --json
aetheris scene export-glb fixtures/Canonical/Scene/warehouse.firmament --json
+aetheris scene export-glb fixtures/Canonical/Scene/WarmModernHouse/house.firmament artifacts/local/scene/house-cutaway.glb --hide-boundary main.ceiling --hide-boundary main.southWall --hide-boundary main.eastWall --json
```
Default output is ignored `artifacts/local/scene/`. USD preserves spatial
@@ -103,6 +146,18 @@ The existing PowerPoint 3D pipeline can embed the generated GLB and a rendered
fallback PNG. Desktop rotation/save/reopen is a separate manual qualification.
Whole-scene manufacturing STEP is deliberately unsupported.
+Repeated `--hide-boundary room.boundary` options select an explicit USD/GLB
+presentation cutaway. All display geometry under those exact owned boundaries
+is omitted from the projection. The compiled Scene and complete room geometry
+stay unchanged; unknown boundary names fail before output is written. Inspection
+always describes the full Scene. This allows an interior model to be useful in
+an orbit-only viewer such as PowerPoint without deleting architecture in source.
+
+The [warm modern house](../../../fixtures/Canonical/Scene/WarmModernHouse/house.firmament)
+demonstrates top-down Concept layout, bottom-up furniture components, then Scene
+composition. Its [qualification report](../../release/ARCHVIZ-HOUSE-X0.md) records
+the exact presentation and retained-session evidence.
+
Completion, hover and source diagnostics use compiler-owned schemas. Scene
formatting safely prefers camelCase field labels while preserving layout,
comments, generic specialization spelling and authored identities. It is
diff --git a/docs/release/ARCHVIZ-HOUSE-X0.md b/docs/release/ARCHVIZ-HOUSE-X0.md
new file mode 100644
index 00000000..a91a5675
--- /dev/null
+++ b/docs/release/ARCHVIZ-HOUSE-X0.md
@@ -0,0 +1,276 @@
+# ARCHVIZ-HOUSE-X0 — InteriorDesignerGPT
+
+Qualification date: 2026-10-04. **Verdict: Accepted.**
+
+Codex can use Firmament Scene as a pleasant programmable environment language
+for this bounded warm-modern home. The actual Concept-guided source compiles,
+shared furniture renders coherently, external USD/GLB validation succeeds, and
+the resulting PowerPoint model rotates, saves, reopens and remains interactive.
+The reusable authoring gaps were addressed in their existing semantic owners;
+the remaining deliberate simplifications and justified defers are explicit.
+
+## Design and authoring story
+
+The brief was a compact warm modern home: Scandinavian/Japanese restraint,
+warm oak, off-white plaster, forest-green cabinetry, cream upholstery, black
+metal and large glass openings. The resulting 63 m² open-plan room contains a
+sectional living area, an island kitchen and four-seat dining area; a 5.28 m²
+entry room makes the transition legible. Clear room height is 3.1 m. Three
+large windows, two pendant fixtures, floating shelves and a media bench provide
+depth without a large asset collection or elaborate architectural detailing.
+
+The human supplied the design intent and the working strategy: top-down Concept
+layout, bottom-up furniture, then composition using those guides. Codex authored
+and reviewed the finite Firmament source. Aetheris compiled semantic rooms,
+openings and shared engineering definitions into Scene display data. The same
+display representation exported OpenUSD and GLB. Blender imported the complete
+GLB for Cycles lighting/shading; the existing Presentation-3D writer embedded
+the presentation GLB and rendered PNG fallbacks in PowerPoint.
+
+```text
+Human warm-modern brief
+ → Concept Struct room-relative layout
+ → shared Firmament furniture templates/subassemblies
+ → Room / Door / Window / placed Assembly / Camera
+ → compiled Scene
+ → OpenUSD + GLB
+ → Cycles renders + interactive PowerPoint
+```
+
+Python only imports, shades, lights, renders and verifies compiled outputs. It
+does not generate Firmament, house geometry, furniture placement or camera
+transforms. A before/after hash of imported mesh vertices, polygons and world
+transforms checks this boundary. The overview is an explicitly disclosed
+presentation cutaway; the complete enclosure remains in source, USD, the
+enclosed GLB and the saved Blender scene.
+
+## Reviewed source structure
+
+Source project: [WarmModernHouse](../../fixtures/Canonical/Scene/WarmModernHouse/house.firmament).
+
+| File | Semantic ownership |
+| --- | --- |
+| `house.firmament` | `HouseLayout` guides, architecture palette, two Rooms, three Doors, three Windows, six placed furniture groups, Hero/Kitchen/Overview cameras |
+| `components.firmament` | Rounded profile/extrusion Panel and cylindrical Drum templates; published `TopSeat.Frame`; palette/material identities; shared DiningChair |
+| `living.firmament` | Complete Sofa, CoffeeTable and SideTable subassemblies; rug and their local composition |
+| `kitchen.firmament` | Shared BaseCabinet, six cabinetry occurrences, counter, repeated shelves, sink/cooktop placeholders |
+| `island.firmament` | Island body/top, supported decorative objects, two shared pendants |
+| `dining.firmament` | Table, four shared chairs with keyed local orientations, centerpiece |
+| `media.firmament` | Wall-facing media bench and screen |
+| `entry.firmament` | Entry bench and cushion |
+| `house-presentation.json` | Two slides, local GLB/preview references and presentation view parameters |
+
+`HouseLayout` has two Room-derived planes and six furniture datum frames.
+Scene placement references those names. Each furniture group owns its internal
+dimensions and offsets. Repeated chairs, cabinets, cushions, feet, shelves and
+pendants use existing finite keyed Sets/Patterns and shared definitions.
+
+## Reusable capability admission and ownership
+
+No new general construct, scripting facility or house-specific keyword was
+added. The changes extend existing semantic owners:
+
+| Motivation and syntax | Semantic owner / lowering owner | Reuse and boundedness | House use / verification |
+| --- | --- | --- | --- |
+| Room has different wall, floor and ceiling finishes: `floorAppearance: warmOak; ceilingAppearance: ceilingWhite;` | `SceneRoom` and Room schema / Scene panel appearance binding | Optional finite look references; omitted fields inherit Room appearance; no extra slab geometry | Both Rooms; floor binding and invalid look tests |
+| An aperture should own its glazing/frame: `glazingAppearance: clearGlass; frameAppearance: charcoalMetal; frameWidth: 45mm;` with optional `glassThickness` | `SceneOpening` / `SceneWindowFinish`, Window schema / Scene window pieces using existing shared box definitions | Four inset frame pieces and one optional pane; dimensions derive from opening/wall; rejects nonpositive clear panes and glass thicker than wall | Three large windows; all four wall orientations, dimensions, material refs, invalid intent and external three-pane checks |
+| Glass needs portable transparency: `Appearance clearGlass { ... opacity: .18; }` | Existing Appearance schema and `AssemblyUsdMaterial` / existing USD and GLB material exporters | Finite scalar in `[0,1]`, default one; no shader graph or physical glass solver | Three panes; USD opacity and glTF alpha/BLEND tests plus external material inspection |
+| Top-down Concept guides must place Scene objects: `Plane mainFloor { from: main.floor; }`, `Placement { from: Origin; to: HouseLayout.living; }` | Existing `AssemblyDatumAuthoring` Plane/Axis/DatumFrame parser; Scene owns boundary references / existing `AssemblyFrameAuthoring.Compose` | Erased finite spatial scaffolding; no runtime state or geometry generation; existing cycle checks, unresolved guides rejected even when unused | Eight guides; translated/clocked room placement, no Concept occurrences, diagnostic and retained placement tests |
+| Orbit-only presentation needs a disclosed cutaway: `scene export-glb ... --hide-boundary main.ceiling` | Scene boundary selection / `SceneExport` projection and CLI | Exact existing boundary paths; immutable projection, unchanged compiled scene; no new Firmament syntax | Six hidden boundaries in presentation GLB; mutation/unknown-boundary tests and CLI output protection |
+
+Window finish geometry remains Scene display/environment geometry, like Room
+panels. Furniture remains independently compiled engineering assembly geometry.
+No parallel tessellator, datum parser, cache, naming migration or furniture
+runtime was introduced. There is no strategy selection needing JudgmentEngine:
+these are deterministic transformations of explicit authored intent.
+
+Compiler-owned schema attributes expose every new field through existing
+completion, hover, diagnostics and convention formatter paths. Tests cover the
+schema and real house; CLI formatting of all eight source documents reports
+`changed: false`. Existing Concept/Pattern/Placement vocabulary retains its
+established language-service owner.
+
+## Friction log
+
+| Attempt / awkward existing source | Workaround possible? | Permanent fix / disposition and reuse rationale |
+| --- | --- | --- |
+| One Room appearance paints walls, floor and ceiling alike; separate floor overlays duplicate room geometry | Yes, overlay Parts | Added Room finish overrides. Surface finish is normal environment intent and should follow the owned boundary |
+| Windows were holes only; independently placed strips/panes repeat opening width, height, sill and wall coordinates | Yes, duplicate Parts | Added bounded optional Window finish. Editing an opening keeps its pane/frame coherent on every wall orientation |
+| Appearance was opaque, making authored glazing a painted panel | Renderer-only override possible | Added portable optional opacity to the existing look and exporters. Renderer refraction remains downstream |
+| Scene could not consume the existing Concept Struct furniture stations; direct placement repeated room offsets | Yes, raw room/world translations | Reused the datum parser and frame composition, extending Scene reference resolution to Room-derived Concept guides |
+| Furniture-on-support placement repeated cushion, countertop, tray and vase Z heights | Yes, coordinate arithmetic | Refactored complete local subassemblies around existing published `TopSeat.Frame`; no new capability needed |
+| Full roof/walls hide interiors when PowerPoint only offers orbit interaction | Yes, destructive source deletion | Added explicit boundary export projection; full source/exports remain available and cutaway is disclosed |
+| A template specimen using RoundedBox was rejected with `firmament-v2-phase3-edge-finish-syntax-invalid` | Analytic rounded profile/extrusion is admitted | Deliberately use RoundedRect2/Profile/Extrude for plan-rounded furniture. Full three-dimensional upholstered edge fillets are deferred; the chosen simple stylized geometry is intentional, not hidden renderer geometry |
+| Architecture and independent AssemblyFile modules have separate look catalogs | Two matching warmOak/charcoal declarations | Keep the tiny architecture palette owned by Scene and the shared furniture palette in one included module. General Scene includes/palette imports are a justified defer; avoid extending module resolution for two readable palette entries |
+| Retained geometry reuse still reimports exact bodies and prepares display meshes | Mutable cached bodies or renderer geometry would bypass authority | Preserve immutable STEP cache ownership. Retained display preparation remains a measured future optimization; zero geometry rebuild is not zero compile work |
+| Renderer daylight initially matched `.pane` inside `.panel`, causing excessive lighting | Reduce light power blindly | Corrected the renderer to match the terminal `pane` segment; final evidence reports three window lights rather than illuminating wall panels |
+| Machine-wide CLI was older than the checkout and did not expose Scene | Assume capabilities from stale CLI | Build/use `Aetheris.CLI` from this checkout for every qualification command |
+
+## Dedicated source-quality review
+
+The source was revisited after the first working scene. Complete sofa, coffee
+table and side table compositions now have named local owners. Cushions, arms,
+chaise seating, tabletop decorations and island layers reference support frames
+instead of copying surface heights. Chair/cabinet repeats use keyed Patterns;
+the root only composes six meaningful furniture groups. The media screen was
+moved against its wall-facing local guide after visual review.
+
+There are no authored matrices, renderer geometry names, generated source
+blobs or anonymous room-sized boxes. Explicit numbers that remain describe
+design dimensions or component-local spacing. Paired hallway openings are
+separate owned wall apertures: X0 does not infer an inter-room adjacency
+constraint, and that simplification is visible in source. Camera names are
+presentation/domain names, not renderer ownership.
+
+Constructs/types use PascalCase and fields use camelCase. Published domain
+symbols (`World`, `Origin`, `TopSeat.Frame`, Site `X/Y/Z`) are preserved. Concept
+layout coordinates retain the existing millimetre contract despite the Scene's
+metre authoring convention; examples deliberately show units. This mixed unit
+contract is discoverable and tested, but deserves continued documentation. No
+general naming migration was reopened.
+
+## Dedicated code-quality review
+
+The Scene extension delegates Concept parsing, unit checks, basis handling and
+cycle diagnostics to the existing datum owner. Scene resolves only its own
+boundary/guide graph, with build-local resolution state. Window finish lowering
+is one dimension-driven helper using the existing Scene box definition path.
+Optional opacity follows the single existing look record to both exporters;
+GLB material creation is shared between default and appearance-variant paths.
+The cutaway creates a display projection without mutating source or compiled
+occurrences. No component-specific compiler cases were added.
+
+## Performance and qualification evidence
+
+One final-process measurement on Windows, .NET SDK 10.0.401, with rendering
+finished before measurement. These are single observations, not percentile or
+universal speed claims. Raw source hashes and per-phase measurements are in
+`artifacts/local/archviz-house-x0/timings.json`.
+
+| Operation | Total ms | Display preparation ms | Engineering definitions reused / rebuilt |
+| --- | ---: | ---: | ---: |
+| Cold, new process/session | 2367.23 | 399.21 | 0 / 49 |
+| Warm process, new uncached session | 2343.21 | 697.38 | 0 / 49 |
+| Retained, unchanged | 964.59 | 552.53 | 49 / 0 |
+| Retained, camera-only edit | 713.29 | 416.13 | 49 / 0 |
+| Retained, furniture Concept-guide edit | 662.65 | 395.58 | 49 / 0 |
+| Retained, Scene appearance edit | 644.08 | 387.91 | 49 / 0 |
+| Retained, one Room size edit | 533.69 | 318.32 | 49 / 0 |
+| Retained, one island body height edit | 586.85 | 304.14 | 48 / 1 |
+
+Full Scene: **49 engineering definitions, 94 display definitions, 254 total
+occurrences, 161 mesh occurrences**. Four chairs share their seat definition;
+six cabinets share their door definition. The island top follows its body's
+published support frame when the body height changes. Room panels/window pieces
+are analytical Scene display definitions, outside the engineering cache counts.
+Retained appearance/camera/placement tests also compare unchanged display vertex
+and index arrays. Reuse reimports fresh exact bodies and currently repeats
+display preparation, so camera edits remain measurable work even with zero
+engineering rebuilds.
+
+Serialization after compilation: **USD 53.04 ms; enclosed GLB 89.22 ms;
+presentation cutaway GLB 37.41 ms**. The 5,115,927-byte two-slide deck compiles
+through the existing writer in **131.65 ms**. This deck timing includes package
+writing; serializer measurements exclude compilation and file I/O.
+
+Cycles 5.2.2 LTS on NVIDIA RTX 3070 rendered 1920×1200, 80 samples with denoising:
+Hero **340.97 s**, Kitchen **239.37 s**, Overview **15.57 s**; complete rendering
+run **596.69 s**. The complete scene imported as 161 mesh objects / 96 mesh
+datablocks (material variants can split imported datablocks). Mesh geometry and
+world-transform hash stays unchanged through presentation finishing. There are
+seven downstream lights, with three derived from the semantic panes and two
+from pendant diffusers.
+
+| Gate | Observed result / local evidence |
+| --- | --- |
+| Real CLI compile/validate | `success: true`, Scene domain, empty diagnostics; `source-validation.json` |
+| Formatter/LX | All eight files unchanged by convention formatter; completion/hover for every new field, actionable invalid specimens; `formatter.json`, new 13-case `ArchvizSceneTests` |
+| Focused Scene/Appearance/GLB tests | 37 passed; `focused.log` |
+| Core fast lane | 1005 passed, zero failures/skips; `fast.log` |
+| Full solution Release build | Zero errors; four warnings in unchanged guitar tests and WebAssembly SQLite varargs; `build.log` |
+| Full serial solution tests | **4298 passed, zero failed, zero skipped**, 20 populated test assemblies; `full-tests.log`, `regression-summary.json`. Existing FrictionLab assembly reports no discoverable tests |
+| Repository layout / whitespace | Repository guard and `git diff --check` pass; generated STEP corpus rewrite restored after tests |
+| OpenUSD 25.08 | `usdchecker`: Success; no composition errors; 94 shared prototypes, 161 mesh occurrences, 12 bound looks, three authored cameras and three opacity-.18 panes; physical bounds agree with CLI to 0.01 mm; `usdchecker.log`, `external-validation.json` |
+| usdview | Actual stage opens in HdStorm with `/Scene/N_Hero_0`; viewport/hierarchy captured through existing viewer API; `usdview/`. Default viewer lighting/material-display settings are not the Cycles presentation |
+| Khronos glTF Validator 2.0.0-dev.3.10 | Both final GLBs: **zero errors, zero warnings**, 117 informational default-matrix/unused-base-mesh messages each; `*.validator.json` |
+| Blender | Positive-handed transforms; expected physical bounds, three imported authored cameras; geometry hash unchanged; `blender-validation.json` |
+| PPTX package | Two Model3D elements and two fallback pictures; embedded model bytes equal final `house.glb`; previews equal hero/overview PNGs; zero external relationships; `external-validation.json` |
+| Desktop PowerPoint 16.0.20430.20118 | Compiled `house.pptx` opens without repair/missing-media warning. Both 3D controls rotate/tilt. Saved separate `house-office-roundtrip.pptx`, closed, reopened and observed further orbit interaction; two model elements survive and Office deduplicates to one exact original GLB payload |
+
+PowerPoint initially displays the authored render preview; after first orbit it
+regenerates a view of the interactive GLB. Its scalar-PBR render and viewport
+framing differ from Cycles, as expected. The deterministic `house.pptx` retains
+the original presentation-quality fallbacks; the Office roundtrip is evidence.
+
+![PowerPoint overview after orbit](../../artifacts/local/archviz-house-x0/powerpoint-overview.png)
+
+![PowerPoint after save/reopen and further orbit](../../artifacts/local/archviz-house-x0/powerpoint-reopened-rotated.png)
+
+All raw JSON, logs, viewer captures and desktop screenshots remain in ignored
+`artifacts/local/archviz-house-x0/`. No source/layout-generation Python path was
+accepted, and no renderer geometry was substituted for compiled product data.
+
+## Renders and deliverables
+
+![Hero](../../artifacts/local/archviz-house-x0/hero.png)
+
+![Kitchen](../../artifacts/local/archviz-house-x0/kitchen.png)
+
+![Overview cutaway](../../artifacts/local/archviz-house-x0/overview.png)
+
+Local generated deliverables:
+
+- [house.usda](../../artifacts/local/archviz-house-x0/house.usda): complete enclosure, semantic hierarchy, shared prototypes and cameras.
+- [house-enclosed.glb](../../artifacts/local/archviz-house-x0/house-enclosed.glb): complete portable scene.
+- [house.glb](../../artifacts/local/archviz-house-x0/house.glb): explicitly projected presentation cutaway for web/orbit and PowerPoint.
+- [house.pptx](../../artifacts/local/archviz-house-x0/house.pptx): two interactive views with exact rendered fallbacks.
+- [house.blend](../../artifacts/local/archviz-house-x0/house.blend): imported full geometry, authored cameras and downstream Cycles finishing.
+
+These links are local run evidence, intentionally excluded from Git. Source,
+tests, reproduction scripts and this compact report are tracked candidates.
+
+## Reproduction
+
+Run from the repository root with its .NET 10 SDK. The installed global tool
+may be older; the commands below use the built checkout.
+
+```powershell
+dotnet build Aetheris.slnx -c Release -m:1
+$taskCli = 'Aetheris.CLI/bin/Release/net10.0/aetheris.dll'
+$taskHouse = 'fixtures/Canonical/Scene/WarmModernHouse/house.firmament'
+$taskOutput = 'artifacts/local/archviz-house-x0'
+dotnet $taskCli validate $taskHouse --json
+dotnet $taskCli scene export-usd $taskHouse "$taskOutput/house.usda" --json
+dotnet $taskCli scene export-glb $taskHouse "$taskOutput/house-enclosed.glb" --repeat 2 --json
+dotnet $taskCli scene export-glb $taskHouse "$taskOutput/house.glb" --hide-boundary main.ceiling --hide-boundary main.southWall --hide-boundary main.eastWall --hide-boundary hall.ceiling --hide-boundary hall.southWall --hide-boundary hall.eastWall --json
+dotnet run scripts/measure-archviz-house.cs -- $taskHouse $taskOutput
+blender --background --factory-startup --python-exit-code 1 --python scripts/render-archviz-house.py -- "$taskOutput/house-enclosed.glb" $taskOutput
+dotnet $taskCli presentation compile fixtures/Canonical/Scene/WarmModernHouse/house-presentation.json "$taskOutput/house.pptx" --json
+node scripts/validate-presentation-glb.cjs artifacts/local/presentation-3d-x0/tools/node_modules/gltf-validator "$taskOutput/house.glb" "$taskOutput/house-enclosed.glb"
+# In the existing OpenUSD Python environment, with pxr available:
+python scripts/validate-archviz-house.py $taskOutput
+dotnet test Aetheris.Kernel.Core.Tests -c Release --no-build --filter 'Category!=SlowCorpus'
+dotnet test Aetheris.slnx -c Release --no-build -m:1 -- RunConfiguration.MaxCpuCount=1
+```
+
+The existing validator script writes the two `*.validator.json` files consumed
+by the external script. Run the existing OpenUSD `usdchecker`
+against the complete USDA. The existing `capture-usd-export-x0.py` can capture
+usdview with `USD_X0_FRAMES=0`, a local capture directory, and the authored Hero
+camera path from `external-validation.json`. Desktop PowerPoint opening and
+interaction are direct observations, not inferred from package structure.
+
+## Known simplifications
+
+Single storey; no staircase, roof design, curtains, mullion system, appliance
+internals, tiny hardware, simulated upholstery or exterior landscape. Doors are
+semantic open passages, without leaves/hinges. Sink/cooktop and decorative
+objects are deliberate stylized placeholders. Glass uses portable opacity;
+Cycles supplies a simple dielectric finish. Floor boards, subtle grain/fabric
+bump and seven presentation lights are shader/lighting detail over compiled
+geometry. GLB/PowerPoint uses authored scalar PBR rather than those procedural
+textures, so it matches layout, silhouettes and palette but not Cycles lighting.
+No IFC, BIM, MEP, structural analysis, general scripting or runtime mutation.
+
+The house is intended as a scene-authoring showcase, not construction
+documentation or a photorealism benchmark.
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/components.firmament b/fixtures/Canonical/Scene/WarmModernHouse/components.firmament
new file mode 100644
index 00000000..485b2c91
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/components.firmament
@@ -0,0 +1,64 @@
+// Shared analytic furniture vocabulary. Millimetres; origin at the base centre.
+// Panel corners describe the silhouette; no claim of upholstered edge fillets.
+Template<L: Length, W: Length, H: Length, R: Length = 2mm> Struct Panel {
+ expose {
+ Semantic TopSeat { DatumFrame Frame = [0mm,0mm,H] x [1,0,0] y [0,1,0] z [0,0,1]; }
+ }
+ RoundedRect2 outline { center: [0mm, 0mm]; size: [L, W]; radius: R; }
+ Profile section { Loop Outer { outline |> TraceLoop } }
+ Extrude body { profile: section; from: 0mm; to: H; }
+}
+Template<R: Length, H: Length> Struct Drum {
+ expose {
+ Semantic TopSeat { DatumFrame Frame = [0mm,0mm,H] x [1,0,0] y [0,1,0] z [0,0,1]; }
+ }
+ Circle2 outline { center: [0mm, 0mm]; radius: R; }
+ Profile section { Loop Outer { outline |> TraceLoop } }
+ Extrude body { profile: section; from: 0mm; to: H; }
+}
+Appearance warmOak { color: [.55, .35, .18]; metallic: 0; roughness: .48; }
+Appearance forestGreen { color: [.035, .075, .055]; metallic: 0; roughness: .48; }
+Appearance creamFabric { color: [.78, .71, .60]; metallic: 0; roughness: .92; }
+Appearance linenRug { color: [.57, .51, .42]; metallic: 0; roughness: .98; }
+Appearance charcoalMetal { color: [.018, .025, .022]; metallic: .65; roughness: .32; }
+Appearance limestone { color: [.73, .68, .57]; metallic: 0; roughness: .48; }
+Appearance ceramicIvory { color: [.84, .79, .67]; metallic: 0; roughness: .38; }
+Appearance clay { color: [.37, .17, .095]; metallic: 0; roughness: .76; }
+Appearance brushedSteel { color: [.42, .46, .45]; metallic: .9; roughness: .28; }
+Material Oak { identity: "wood.oak.presentation"; appearance: warmOak; }
+Material PaintedWood { identity: "wood.painted.presentation"; appearance: forestGreen; }
+Material Upholstery { identity: "upholstery.linen.presentation"; appearance: creamFabric; }
+Material RugTextile { identity: "textile.presentation"; appearance: linenRug; }
+Material BlackSteel { identity: "steel.presentation"; appearance: charcoalMetal; }
+Material Stone { identity: "stone.presentation"; appearance: limestone; }
+Material Ceramic { identity: "ceramic.presentation"; appearance: ceramicIvory; }
+Material Terracotta { identity: "ceramic.terracotta.presentation"; appearance: clay; }
+Material Steel { identity: "steel.presentation"; appearance: brushedSteel; }
+
+// Complete reusable chair; its four feet are one keyed occurrence pattern.
+Subassembly DiningChair {
+ <Assembly DiningChair>
+ Pattern legs over chairFeet {
+ foot => <Part leg = Drum<R:24mm,H:430mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [foot.x, foot.y, 0mm]; }
+ </Part>
+ }
+ <Part seat = Panel<L:500mm,W:480mm,H:70mm,R:75mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 430mm]; }
+ </Part>
+ <Part back = Panel<L:500mm,W:55mm,H:330mm,R:20mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [0mm, -220mm, 500mm]; }
+ </Part>
+ </Assembly>
+ anchor: DiningChair;
+}
+Record Foot { x: Length; y: Length; }
+Static chairFeet: Set<Foot> {
+ frontLeft => Foot { x: -190mm; y: 170mm; }
+ frontRight => Foot { x: 190mm; y: 170mm; }
+ backLeft => Foot { x: -190mm; y: -170mm; }
+ backRight => Foot { x: 190mm; y: -170mm; }
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/dining.firmament b/fixtures/Canonical/Scene/WarmModernHouse/dining.firmament
new file mode 100644
index 00000000..8bd2cafe
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/dining.firmament
@@ -0,0 +1,38 @@
+include "components.firmament";
+Record ChairSite { x: Length; y: Length; angle: Angle; }
+Static chairSites: Set<ChairSite> {
+ nearLeft => ChairSite { x: -550mm; y: -850mm; angle: 0deg; }
+ nearRight => ChairSite { x: 550mm; y: -850mm; angle: 0deg; }
+ farLeft => ChairSite { x: -550mm; y: 850mm; angle: 180deg; }
+ farRight => ChairSite { x: 550mm; y: 850mm; angle: 180deg; }
+}
+Static tableFeet: Set<Foot> {
+ nearLeft => Foot { x: -780mm; y: -300mm; }
+ nearRight => Foot { x: 780mm; y: -300mm; }
+ farLeft => Foot { x: -780mm; y: 300mm; }
+ farRight => Foot { x: 780mm; y: 300mm; }
+}
+Assembly Dining {
+ <Assembly Dining>
+ <Part top = Panel<L:2000mm,W:950mm,H:65mm,R:180mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 720mm]; }
+ </Part>
+ Pattern tableLegs over tableFeet {
+ foot => <Part leg = Drum<R:55mm,H:720mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [foot.x, foot.y, 0mm]; }
+ </Part>
+ }
+ Pattern chairs over chairSites {
+ site => <Assembly chair = DiningChair>
+ Placement { from: Origin; to: World; translateLocal: [site.x, site.y, 0mm]; rotateLocal: { axis: Z; angle: site.angle; } }
+ </Assembly>
+ }
+ <Part centrepiece = Drum<R:85mm,H:190mm>>
+ material: Terracotta;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 785mm]; }
+ </Part>
+ </Assembly>
+ anchor: Dining;
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/entry.firmament b/fixtures/Canonical/Scene/WarmModernHouse/entry.firmament
new file mode 100644
index 00000000..3a72986e
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/entry.firmament
@@ -0,0 +1,14 @@
+include "components.firmament";
+Assembly Entry {
+ <Assembly Entry>
+ <Part benchBase = Panel<L:1800mm,W:420mm,H:420mm,R:25mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; }
+ </Part>
+ <Part benchSeat = Panel<L:1700mm,W:400mm,H:70mm,R:60mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 420mm]; }
+ </Part>
+ </Assembly>
+ anchor: Entry;
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/house-presentation.json b/fixtures/Canonical/Scene/WarmModernHouse/house-presentation.json
new file mode 100644
index 00000000..36518e3b
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/house-presentation.json
@@ -0,0 +1,37 @@
+{
+ "title": "InteriorDesignerGPT · Warm modern house",
+ "slides": [
+ {
+ "title": "InteriorDesignerGPT",
+ "subtitle": "A warm modern home authored in Firmament",
+ "caption": "Concept layout guides place shared furniture definitions. This slide contains the compiled interior model.",
+ "models": [{
+ "name": "WarmModernHouse interactive interior",
+ "source": "../../../../artifacts/local/archviz-house-x0/house.glb",
+ "preview": "../../../../artifacts/local/archviz-house-x0/hero.png",
+ "x": 79.3, "y": 58, "width": 180, "height": 112.5,
+ "camera": {
+ "centerXMetres": 5.8, "centerYMetres": 1.55, "centerZMetres": -3.5,
+ "presentationScale": 0.13, "rotationXDegrees": 28, "rotationYDegrees": 32, "rotationZDegrees": 0,
+ "cameraDistanceMetres": 2.2, "fieldOfViewDegrees": 45
+ }
+ }]
+ },
+ {
+ "title": "The authored environment",
+ "subtitle": "Natural-language intent becomes a compiled Scene, OpenUSD, GLB and an interactive PowerPoint model",
+ "caption": "Presentation cutaway: ceiling and front/right walls hidden. Complete enclosure preserved in Firmament and house.usda.",
+ "models": [{
+ "name": "WarmModernHouse overview",
+ "source": "../../../../artifacts/local/archviz-house-x0/house.glb",
+ "preview": "../../../../artifacts/local/archviz-house-x0/overview.png",
+ "x": 79.3, "y": 58, "width": 180, "height": 112.5,
+ "camera": {
+ "centerXMetres": 5.8, "centerYMetres": 1.55, "centerZMetres": -3.5,
+ "presentationScale": 0.13, "rotationXDegrees": 38, "rotationYDegrees": -28, "rotationZDegrees": 0,
+ "cameraDistanceMetres": 2.2, "fieldOfViewDegrees": 45
+ }
+ }]
+ }
+ ]
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/house.firmament b/fixtures/Canonical/Scene/WarmModernHouse/house.firmament
new file mode 100644
index 00000000..b110eab5
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/house.firmament
@@ -0,0 +1,69 @@
+// ARCHVIZ-HOUSE-X0 · human design intent, Codex-authored Firmament layout.
+// Clear interior dimensions; Z-up. The Room owns its boundaries, the Concept
+// owns furniture stations, and each complete component owns its internal offsets.
+Concept Struct HouseLayout {
+ Plane mainFloor { from: main.floor; }
+ DatumFrame living { on: mainFloor; at: [2500mm, 1450mm]; x: [1, 0]; }
+ DatumFrame kitchen { on: mainFloor; at: [2600mm, 6600mm]; x: [1, 0]; }
+ DatumFrame island { on: mainFloor; at: [2900mm, 4600mm]; x: [1, 0]; }
+ DatumFrame dining { on: mainFloor; at: [6800mm, 5350mm]; x: [1, 0]; }
+ DatumFrame media { on: mainFloor; at: [8750mm, 2350mm]; x: [0, 1]; }
+ Plane entryFloor { from: hall.floor; }
+ DatumFrame entryBench { on: entryFloor; at: [1200mm, 1900mm]; x: [1, 0]; }
+}
+// Architecture palette. Furniture carries physical identity/default finishes
+// in its shared component module. These are visual finishes, not FEA properties.
+Appearance warmOak { color: [.55, .35, .18]; metallic: 0; roughness: .48; }
+Appearance plasterWhite { color: [.82, .79, .72]; metallic: 0; roughness: .88; }
+Appearance ceilingWhite { color: [.88, .86, .80]; metallic: 0; roughness: .9; }
+Appearance charcoalMetal { color: [.018, .025, .022]; metallic: .65; roughness: .32; }
+Appearance clearGlass { color: [.72, .85, .84]; metallic: 0; roughness: .08; opacity: .18; }
+
+Scene WarmModernHouse {
+ units: m;
+ Room main {
+ size: [9m, 7m, 3.1m]; thickness: 100mm;
+ appearance: plasterWhite; floorAppearance: warmOak; ceilingAppearance: ceilingWhite;
+ }
+ Room hall {
+ at: [9.2m, 4.8m, 0mm]; size: [2.4m, 2.2m, 3.1m]; thickness: 100mm;
+ appearance: plasterWhite; floorAppearance: warmOak; ceilingAppearance: ceilingWhite;
+ }
+ // Paired openings cross the two adjacent wall skins, with one clear passage.
+ Door hallPassage { on: main.eastWall; along: 4.85m; width: 1.1m; height: 2.5m; }
+ Door livingPassage { on: hall.westWall; along: .05m; width: 1.1m; height: 2.5m; }
+ Door frontDoor { on: hall.eastWall; along: .3m; width: 1m; height: 2.5m; }
+ Window gardenGlazing {
+ on: main.westWall; along: 1.1m; width: 4.4m; height: 2.6m; sill: .12m;
+ glazingAppearance: clearGlass; frameAppearance: charcoalMetal; frameWidth: 45mm;
+ }
+ Window diningGlazing {
+ on: main.northWall; along: 5.2m; width: 3.15m; height: 2.4m; sill: .3m;
+ glazingAppearance: clearGlass; frameAppearance: charcoalMetal; frameWidth: 45mm;
+ }
+ Window terraceGlazing {
+ on: main.southWall; along: .8m; width: 5.8m; height: 2.75m; sill: 0mm;
+ glazingAppearance: clearGlass; frameAppearance: charcoalMetal; frameWidth: 45mm;
+ }
+ <Assembly living = AssemblyFile<"living.firmament">>
+ Placement { from: Origin; to: HouseLayout.living; }
+ </Assembly>
+ <Assembly kitchen = AssemblyFile<"kitchen.firmament">>
+ Placement { from: Origin; to: HouseLayout.kitchen; }
+ </Assembly>
+ <Assembly island = AssemblyFile<"island.firmament">>
+ Placement { from: Origin; to: HouseLayout.island; }
+ </Assembly>
+ <Assembly dining = AssemblyFile<"dining.firmament">>
+ Placement { from: Origin; to: HouseLayout.dining; }
+ </Assembly>
+ <Assembly media = AssemblyFile<"media.firmament">>
+ Placement { from: Origin; to: HouseLayout.media; }
+ </Assembly>
+ <Assembly entryBench = AssemblyFile<"entry.firmament">>
+ Placement { from: Origin; to: HouseLayout.entryBench; }
+ </Assembly>
+ Camera Hero { position: [8.1m, .65m, 1.65m]; lookAt: [4.1m, 4.4m, 1.25m]; fov: 67deg; }
+ Camera Kitchen { position: [5.8m, 3.2m, 1.75m]; lookAt: [2.7m, 6.25m, 1.45m]; fov: 58deg; }
+ Camera Overview { position: [15m, -10m, 14m]; lookAt: [5.4m, 3.6m, .3m]; fov: 45deg; }
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/island.firmament b/fixtures/Canonical/Scene/WarmModernHouse/island.firmament
new file mode 100644
index 00000000..680d3b9e
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/island.firmament
@@ -0,0 +1,53 @@
+include "components.firmament";
+Linear Sites pendantSites { keys: [left, right]; start: [-600mm, 0mm, 0mm]; step: [1200mm, 0mm, 0mm]; }
+Subassembly Pendant {
+ <Assembly Pendant>
+ <Part shade = Drum<R:150mm,H:150mm>>
+ material: Ceramic;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 2450mm]; }
+ </Part>
+ <Part diffuser = Drum<R:135mm,H:8mm>>
+ material: Ceramic;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 2442mm]; }
+ </Part>
+ <Part cord = Drum<R:4mm,H:470mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 2600mm]; }
+ </Part>
+ <Part canopy = Drum<R:55mm,H:30mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 3070mm]; }
+ </Part>
+ </Assembly>
+ anchor: Pendant;
+}
+Assembly Island {
+ <Assembly Island>
+ <Part plinth = Panel<L:2050mm,W:720mm,H:100mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; }
+ </Part>
+ <Part base = Panel<L:2200mm,W:850mm,H:700mm,R:20mm>>
+ material: PaintedWood;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 100mm]; }
+ </Part>
+ <Part top = Panel<L:2400mm,W:1000mm,H:60mm,R:30mm>>
+ material: Stone;
+ Placement { from: Origin; to: Island.base.TopSeat.Frame; }
+ </Part>
+ Pattern pendants over pendantSites {
+ site => <Assembly light = Pendant>
+ Placement { from: Origin; to: World; translateLocal: [site.X, site.Y, site.Z]; }
+ </Assembly>
+ }
+ <Part servingBoard = Panel<L:430mm,W:260mm,H:20mm,R:50mm>>
+ material: Oak;
+ Placement { from: Origin; to: Island.top.TopSeat.Frame; translateLocal: [-700mm, 0mm, 0mm]; }
+ </Part>
+ <Part bowl = Drum<R:135mm,H:90mm>>
+ material: Ceramic;
+ Placement { from: Origin; to: Island.servingBoard.TopSeat.Frame; }
+ </Part>
+ </Assembly>
+ anchor: Island;
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/kitchen.firmament b/fixtures/Canonical/Scene/WarmModernHouse/kitchen.firmament
new file mode 100644
index 00000000..497195b3
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/kitchen.firmament
@@ -0,0 +1,77 @@
+include "components.firmament";
+// A cabinet is a complete reusable object. The row owns spacing; the door owns its handle.
+Subassembly BaseCabinet {
+ <Assembly BaseCabinet>
+ <Part plinth = Panel<L:580mm,W:500mm,H:90mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; }
+ </Part>
+ <Part carcass = Panel<L:580mm,W:560mm,H:720mm>>
+ material: PaintedWood;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 90mm]; }
+ </Part>
+ <Part door = Panel<L:580mm,W:22mm,H:720mm,R:3mm>>
+ material: PaintedWood;
+ Placement { from: Origin; to: World; translateLocal: [0mm, -291mm, 90mm]; }
+ </Part>
+ <Part handle = Panel<L:220mm,W:24mm,H:12mm,R:5mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; translateLocal: [0mm, -314mm, 760mm]; }
+ </Part>
+ </Assembly>
+ anchor: BaseCabinet;
+}
+Linear Sites cabinetSites { keys: [pantry, drawers, hob, prep, sink, dishes]; start: [-1500mm, 0mm, 0mm]; step: [600mm, 0mm, 0mm]; }
+Linear Sites shelfLevels { keys: [lower, upper]; start: [0mm, 220mm, 1500mm]; step: [0mm, 0mm, 450mm]; }
+Assembly Kitchen {
+ <Assembly Kitchen>
+ Pattern cabinetry over cabinetSites {
+ site => <Assembly cabinet = BaseCabinet>
+ Placement { from: Origin; to: World; translateLocal: [site.X, site.Y, site.Z]; }
+ </Assembly>
+ }
+ <Part counter = Panel<L:3600mm,W:640mm,H:60mm,R:10mm>>
+ material: Stone;
+ Placement { from: Origin; to: World; translateLocal: [0mm, -10mm, 810mm]; }
+ </Part>
+ <Part backsplash = Panel<L:3600mm,W:18mm,H:700mm,R:4mm>>
+ material: Stone;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 391mm, 870mm]; }
+ </Part>
+ Pattern openShelves over shelfLevels {
+ site => <Part shelf = Panel<L:3400mm,W:350mm,H:35mm,R:8mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [site.X, site.Y, site.Z]; }
+ </Part>
+ }
+ <Part cooktop = Panel<L:650mm,W:420mm,H:12mm,R:20mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; translateLocal: [-900mm, -35mm, 870mm]; }
+ </Part>
+ <Part sink = Panel<L:650mm,W:400mm,H:12mm,R:55mm>>
+ material: Steel;
+ Placement { from: Origin; to: World; translateLocal: [900mm, -35mm, 870mm]; }
+ </Part>
+ <Part sinkWell = Panel<L:570mm,W:320mm,H:4mm,R:45mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; translateLocal: [900mm, -35mm, 882mm]; }
+ </Part>
+ <Part faucetStem = Drum<R:18mm,H:250mm>>
+ material: Steel;
+ Placement { from: Origin; to: World; translateLocal: [900mm, 205mm, 870mm]; }
+ </Part>
+ <Part faucetSpout = Drum<R:18mm,H:180mm>>
+ material: Steel;
+ Placement { from: Origin; to: World; translateLocal: [900mm, 205mm, 1102mm]; rotateLocal: { axis: X; angle: 90deg; } }
+ </Part>
+ <Part bowl = Drum<R:125mm,H:70mm>>
+ material: Ceramic;
+ Placement { from: Origin; to: World; translateLocal: [1450mm, 100mm, 1535mm]; }
+ </Part>
+ <Part vessel = Drum<R:70mm,H:220mm>>
+ material: Terracotta;
+ Placement { from: Origin; to: World; translateLocal: [-1200mm, 220mm, 1535mm]; }
+ </Part>
+ </Assembly>
+ anchor: Kitchen;
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/living.firmament b/fixtures/Canonical/Scene/WarmModernHouse/living.firmament
new file mode 100644
index 00000000..81231b04
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/living.firmament
@@ -0,0 +1,104 @@
+include "components.firmament";
+// The room guide locates this complete composition. All offsets are furniture-local.
+Record Seat { x: Length; }
+Static sofaSeats: Set<Seat> {
+ left => Seat { x: -730mm; }
+ right => Seat { x: 730mm; }
+}
+Static sofaFeet: Set<Foot> {
+ frontLeft => Foot { x: -1370mm; y: 350mm; }
+ frontRight => Foot { x: 1370mm; y: 350mm; }
+ backLeft => Foot { x: -1370mm; y: -350mm; }
+ backRight => Foot { x: 1370mm; y: -350mm; }
+}
+Subassembly Sofa {
+ <Assembly Sofa>
+ Pattern feet over sofaFeet {
+ foot => <Part foot = Drum<R:40mm,H:118mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [foot.x, foot.y, 12mm]; }
+ </Part>
+ }
+ <Part frame = Panel<L:3100mm,W:970mm,H:210mm,R:70mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 130mm]; }
+ </Part>
+ Pattern cushions over sofaSeats {
+ seat => <Part cushion = Panel<L:1420mm,W:830mm,H:150mm,R:100mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: Sofa.frame.TopSeat.Frame; translateLocal: [seat.x, 55mm, 0mm]; }
+ </Part>
+ <Part back = Panel<L:1420mm,W:180mm,H:450mm,R:70mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: Sofa.frame.TopSeat.Frame; translateLocal: [seat.x, -400mm, 0mm]; }
+ </Part>
+ }
+ <Part leftArm = Panel<L:180mm,W:970mm,H:340mm,R:70mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: Sofa.frame.TopSeat.Frame; translateLocal: [-1530mm, 0mm, 0mm]; }
+ </Part>
+ <Part rightArm = Panel<L:180mm,W:970mm,H:340mm,R:70mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: Sofa.frame.TopSeat.Frame; translateLocal: [1530mm, 0mm, 0mm]; }
+ </Part>
+ <Part chaiseBase = Panel<L:950mm,W:1000mm,H:328mm,R:70mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [1000mm, 950mm, 12mm]; }
+ </Part>
+ <Part chaiseSeat = Panel<L:950mm,W:1000mm,H:150mm,R:100mm>>
+ material: Upholstery;
+ Placement { from: Origin; to: Sofa.chaiseBase.TopSeat.Frame; }
+ </Part>
+ </Assembly>
+ anchor: Sofa;
+}
+Subassembly CoffeeTable {
+ <Assembly CoffeeTable>
+ <Part pedestal = Drum<R:270mm,H:325mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; }
+ </Part>
+ <Part top = Panel<L:1300mm,W:850mm,H:55mm,R:300mm>>
+ material: Oak;
+ Placement { from: Origin; to: CoffeeTable.pedestal.TopSeat.Frame; }
+ </Part>
+ <Part tray = Drum<R:150mm,H:20mm>>
+ material: Ceramic;
+ Placement { from: Origin; to: CoffeeTable.top.TopSeat.Frame; translateLocal: [-200mm, 0mm, 0mm]; }
+ </Part>
+ <Part vase = Drum<R:65mm,H:180mm>>
+ material: Terracotta;
+ Placement { from: Origin; to: CoffeeTable.tray.TopSeat.Frame; }
+ </Part>
+ </Assembly>
+ anchor: CoffeeTable;
+}
+Subassembly SideTable {
+ <Assembly SideTable>
+ <Part base = Drum<R:180mm,H:430mm>>
+ material: PaintedWood;
+ Placement { from: Origin; to: World; }
+ </Part>
+ <Part top = Drum<R:260mm,H:35mm>>
+ material: Oak;
+ Placement { from: Origin; to: SideTable.base.TopSeat.Frame; }
+ </Part>
+ </Assembly>
+ anchor: SideTable;
+}
+Assembly Living {
+ <Assembly Living>
+ <Part rug = Panel<L:4300mm,W:3200mm,H:12mm,R:100mm>>
+ material: RugTextile;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 700mm, 0mm]; }
+ </Part>
+ <Assembly sofa = Sofa> Placement { from: Origin; to: World; } </Assembly>
+ <Assembly coffeeTable = CoffeeTable>
+ Placement { from: Origin; to: Living.rug.TopSeat.Frame; translateLocal: [-450mm, 1050mm, 0mm]; }
+ </Assembly>
+ <Assembly sideTable = SideTable>
+ Placement { from: Origin; to: Living.rug.TopSeat.Frame; translateLocal: [-1950mm, -300mm, 0mm]; }
+ </Assembly>
+ </Assembly>
+ anchor: Living;
+}
diff --git a/fixtures/Canonical/Scene/WarmModernHouse/media.firmament b/fixtures/Canonical/Scene/WarmModernHouse/media.firmament
new file mode 100644
index 00000000..fcd15736
--- /dev/null
+++ b/fixtures/Canonical/Scene/WarmModernHouse/media.firmament
@@ -0,0 +1,22 @@
+include "components.firmament";
+Assembly Media {
+ <Assembly Media>
+ <Part plinth = Panel<L:2200mm,W:300mm,H:100mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; }
+ </Part>
+ <Part cabinet = Panel<L:2400mm,W:400mm,H:330mm,R:15mm>>
+ material: Oak;
+ Placement { from: Origin; to: World; translateLocal: [0mm, 0mm, 100mm]; }
+ </Part>
+ <Part screen = Panel<L:1450mm,W:35mm,H:800mm,R:12mm>>
+ material: BlackSteel;
+ Placement { from: Origin; to: World; translateLocal: [0mm, -225mm, 650mm]; }
+ </Part>
+ <Part vessel = Drum<R:95mm,H:260mm>>
+ material: Ceramic;
+ Placement { from: Origin; to: World; translateLocal: [-1000mm, 0mm, 430mm]; }
+ </Part>
+ </Assembly>
+ anchor: Media;
+}
diff --git a/scripts/measure-archviz-house.cs b/scripts/measure-archviz-house.cs
new file mode 100644
index 00000000..6ccc3d66
--- /dev/null
+++ b/scripts/measure-archviz-house.cs
@@ -0,0 +1,67 @@
+#:project ../Aetheris.Kernel.Firmament/Aetheris.Kernel.Firmament.csproj
+#:property PublishAot=false
+#:property JsonSerializerIsReflectionEnabledByDefault=true
+// Evidence orchestration only. Layout and furniture remain in reviewed Firmament.
+using System.Diagnostics;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using Aetheris.Kernel.Firmament.Scene;
+
+var fixture = Path.GetFullPath(args.Length > 0 ? args[0] : "fixtures/Canonical/Scene/WarmModernHouse/house.firmament");
+var output = Path.GetFullPath(args.Length > 1 ? args[1] : "artifacts/local/archviz-house-x0");
+Directory.CreateDirectory(output);
+var project = Path.Combine(output,"retained-evidence-project");
+Directory.CreateDirectory(project);
+foreach (var file in Directory.GetFiles(Path.GetDirectoryName(fixture)!,"*.firmament"))
+ File.Copy(file,Path.Combine(project,Path.GetFileName(file)),true);
+var path = Path.Combine(project,"house.firmament");
+var source = File.ReadAllText(path);
+var records = new List<object>();
+using var retained = new FirmamentSceneSession();
+CompiledScene Measure(string name,FirmamentSceneSession session,string text)
+{
+ var watch = Stopwatch.StartNew();
+ var compiled = session.Compile(text,path);
+ var milliseconds = watch.Elapsed.TotalMilliseconds;
+ if (!compiled.IsSuccess) throw new InvalidOperationException(string.Join("\n",compiled.Diagnostics));
+ var scene = compiled.Scene!;
+ records.Add(new { name, milliseconds, scene.Performance,
+ displayDefinitions=scene.Display.Definitions.Count, displayOccurrences=scene.Display.Occurrences.Count,
+ meshOccurrences=scene.Display.Occurrences.Count(o => o.DefinitionId is not null) });
+ return scene;
+}
+var cold = Measure("cold-new-process",retained,source);
+using (var warm = new FirmamentSceneSession()) Measure("warm-uncached-session",warm,source);
+Measure("retained-unchanged",retained,source);
+void ReuseEdit(string name,string changed)
+{
+ var scene=Measure(name,retained,changed);
+ if (scene.Performance.RebuiltEngineeringDefinitions != 0)
+ throw new InvalidOperationException(name+" unexpectedly rebuilt engineering geometry.");
+}
+ReuseEdit("camera-only",source.Replace("[8.1m, .65m, 1.65m]","[8m, .65m, 1.65m]",StringComparison.Ordinal));
+ReuseEdit("furniture-guide-only",source.Replace("[2500mm, 1450mm]","[2600mm, 1450mm]",StringComparison.Ordinal));
+ReuseEdit("appearance-only",source.Replace("color: [.55, .35, .18]","color: [.58, .38, .2]",StringComparison.Ordinal));
+ReuseEdit("room-size-only",source.Replace("size: [2.4m, 2.2m, 3.1m]","size: [2.5m, 2.2m, 3.1m]",StringComparison.Ordinal));
+var island = Path.Combine(project,"island.firmament");
+File.WriteAllText(island,File.ReadAllText(island).Replace("W:850mm,H:700mm","W:850mm,H:720mm",StringComparison.Ordinal));
+var changedObject=Measure("one-island-body-definition",retained,source);
+if (changedObject.Performance.RebuiltEngineeringDefinitions != 1 || changedObject.Performance.ReusedEngineeringDefinitions != cold.Performance.UniqueEngineeringDefinitions-1)
+ throw new InvalidOperationException("A single island body edit must rebuild one definition and reuse every unchanged definition.");
+var watchExport=Stopwatch.StartNew();
+var usd=SceneExport.Usd(cold);
+var usdMilliseconds=watchExport.Elapsed.TotalMilliseconds;
+watchExport.Restart();
+var glb=SceneExport.Glb(cold);
+var glbMilliseconds=watchExport.Elapsed.TotalMilliseconds;
+watchExport.Restart();
+var cutaway=SceneExport.Glb(cold,["main.ceiling","main.southWall","main.eastWall","hall.ceiling","hall.southWall","hall.eastWall"]);
+var cutawayMilliseconds=watchExport.Elapsed.TotalMilliseconds;
+var tree=Directory.GetFiles(Path.GetDirectoryName(fixture)!,"*.firmament").OrderBy(p => p,StringComparer.Ordinal)
+ .Select(p => new {file=Path.GetFileName(p),sha256=Convert.ToHexString(SHA256.HashData(File.ReadAllBytes(p)))}).ToArray();
+var report=new { milestone="ARCHVIZ-HOUSE-X0", sources=tree, builds=records,
+ usdExportMilliseconds=usdMilliseconds, glbExportMilliseconds=glbMilliseconds,
+ cutawayGlbExportMilliseconds=cutawayMilliseconds, usdBytes=Encoding.UTF8.GetByteCount(usd), glbBytes=glb.Length };
+File.WriteAllText(Path.Combine(output,"timings.json"),JsonSerializer.Serialize(report,new JsonSerializerOptions { WriteIndented=true })+"\n");
+Console.WriteLine(JsonSerializer.Serialize(report));
diff --git a/scripts/render-archviz-house.py b/scripts/render-archviz-house.py
new file mode 100644
index 00000000..381f0094
--- /dev/null
+++ b/scripts/render-archviz-house.py
@@ -0,0 +1,192 @@
+"""Render the compiled house GLB; no layout, furniture, or replacement meshes.
+
+blender --background --factory-startup --python-exit-code 1 --python
+ scripts/render-archviz-house.py -- house.glb output-directory [--preview]
+Presentation owns shader detail, daylight and a disclosed overview cutaway.
+All camera transforms, materials and physical geometry come from Firmament.
+"""
+import argparse
+import hashlib
+import json
+import math
+import sys
+import time
+from pathlib import Path
+
+import bpy
+from mathutils import Vector
+
+parser = argparse.ArgumentParser()
+parser.add_argument('source', type=Path)
+parser.add_argument('output', type=Path)
+parser.add_argument('--preview', action='store_true')
+parser.add_argument('--view', choices=['Hero', 'Kitchen', 'Overview'])
+args = parser.parse_args(sys.argv[sys.argv.index('--') + 1:])
+args.output.mkdir(parents=True, exist_ok=True)
+bpy.ops.wm.read_factory_settings(use_empty=True)
+start = time.perf_counter()
+bpy.ops.import_scene.gltf(filepath=str(args.source.resolve()))
+scene = bpy.context.scene
+products = [o for o in scene.objects if o.type == 'MESH']
+cameras = {o.name: o for o in scene.objects if o.type == 'CAMERA'}
+assert all(name in cameras for name in ('Hero', 'Kitchen', 'Overview'))
+points = [o.matrix_world @ Vector(c) for o in products for c in o.bound_box]
+lo = Vector([min(p[i] for p in points) for i in range(3)])
+hi = Vector([max(p[i] for p in points) for i in range(3)])
+assert all(o.matrix_world.determinant() > 0 for o in products)
+
+def geometry_hash():
+ result = hashlib.sha256()
+ for obj in sorted(products, key=lambda o: o.name):
+ result.update(obj.name.encode())
+ for vertex in obj.data.vertices:
+ result.update(str(tuple(vertex.co)).encode())
+ for polygon in obj.data.polygons:
+ result.update(str(tuple(polygon.vertices)).encode())
+ result.update(str(tuple(tuple(row) for row in obj.matrix_world)).encode())
+ return result.hexdigest()
+
+before = geometry_hash()
+for obj in products:
+ if '.floor.panel' not in obj.name:
+ continue
+ for slot in obj.material_slots:
+ if slot.material and slot.material.name.startswith('warmOak'):
+ slot.material = slot.material.copy()
+ slot.material.name = 'warmOak.floor'
+for material in bpy.data.materials:
+ if not material.use_nodes:
+ continue
+ nodes = material.node_tree.nodes
+ links = material.node_tree.links
+ bsdf = next((n for n in nodes if n.type == 'BSDF_PRINCIPLED'), None)
+ if bsdf is None:
+ continue
+ name = material.name.split('.')[0]
+ if name == 'clearGlass':
+ # Portable authored opacity becomes an ordinary dielectric downstream.
+ bsdf.inputs['Alpha'].default_value = 1
+ bsdf.inputs['Transmission Weight'].default_value = 1
+ bsdf.inputs['IOR'].default_value = 1.12
+ bsdf.inputs['Base Color'].default_value = (.94, .98, .97, 1)
+ if name in ('warmOak', 'creamFabric', 'linenRug'):
+ tex = nodes.new('ShaderNodeTexNoise')
+ mapping = nodes.new('ShaderNodeVectorMath')
+ mapping.operation = 'MULTIPLY'
+ coordinates = nodes.new('ShaderNodeTexCoord')
+ mapping.inputs[1].default_value = (2, 85, 4) if name == 'warmOak' else (180, 180, 180)
+ links.new(coordinates.outputs['Generated'], mapping.inputs[0])
+ links.new(mapping.outputs[0], tex.inputs['Vector'])
+ tex.inputs['Scale'].default_value = 2
+ tex.inputs['Detail'].default_value = 2
+ bump = nodes.new('ShaderNodeBump')
+ bump.inputs['Strength'].default_value = .12 if name == 'warmOak' else .18
+ bump.inputs['Distance'].default_value = .001 if name == 'warmOak' else .0006
+ links.new(tex.outputs['Fac'], bump.inputs['Height'])
+ links.new(bump.outputs['Normal'], bsdf.inputs['Normal'])
+ if name == 'warmOak':
+ ramp = nodes.new('ShaderNodeValToRGB')
+ base = tuple(bsdf.inputs['Base Color'].default_value)
+ ramp.color_ramp.elements[0].color = tuple(v * .72 for v in base[:3]) + (1,)
+ ramp.color_ramp.elements[1].color = tuple(min(1, v * 1.17) for v in base[:3]) + (1,)
+ links.new(tex.outputs['Fac'], ramp.inputs[0])
+ links.new(ramp.outputs[0], bsdf.inputs['Base Color'])
+ if material.name.startswith('warmOak.floor'):
+ # A restrained board pattern is shader detail over the room slab.
+ geometry = nodes.new('ShaderNodeNewGeometry')
+ brick = nodes.new('ShaderNodeTexBrick')
+ links.new(geometry.outputs['Position'], brick.inputs['Vector'])
+ brick.inputs['Scale'].default_value = 1
+ brick.inputs['Brick Width'].default_value = 1.6
+ brick.inputs['Row Height'].default_value = .18
+ brick.inputs['Mortar Size'].default_value = .002
+ brick.inputs['Mortar Smooth'].default_value = .001
+ brick.inputs['Color1'].default_value = (.41, .27, .135, 1)
+ brick.inputs['Color2'].default_value = (.61, .42, .23, 1)
+ brick.inputs['Mortar'].default_value = (.26, .17, .095, 1)
+ links.new(brick.outputs['Color'], bsdf.inputs['Base Color'])
+
+# Light fixtures are authored geometry; renderer lights derive from their diffusers.
+def area(name, position, target, energy, size, color=(1, .87, .68)):
+ data = bpy.data.lights.new(name, 'AREA')
+ data.energy, data.size, data.color = energy, size, color
+ obj = bpy.data.objects.new(name, data)
+ scene.collection.objects.link(obj)
+ obj.location = position
+ obj.rotation_euler = (Vector(target) - obj.location).to_track_quat('-Z', 'Y').to_euler()
+ return obj
+
+centre = (lo + hi) / 2
+for obj in products:
+ if '.diffuser' in obj.name:
+ p = sum((obj.matrix_world @ Vector(c) for c in obj.bound_box), Vector()) / 8
+ area('Pendant illumination ' + obj.name, p - Vector((0, 0, .02)), p - Vector((0, 0, 1)), 55, .23)
+ if obj.name.rsplit('.', 1)[-1] == 'pane':
+ p = sum((obj.matrix_world @ Vector(c) for c in obj.bound_box), Vector()) / 8
+ # Place daylight just inside each compiled aperture, aimed into its room.
+ inward = Vector((centre.x - p.x, centre.y - p.y, 0)).normalized()
+ area('Window daylight ' + obj.name, p + inward * .06, p + inward,
+ 650, 3.5, (1, .94, .82))
+area('Soft ceiling bounce', (centre.x, centre.y, hi.z - .18), (centre.x, centre.y, 0), 160, 5)
+scene.world = bpy.data.worlds.new('Warm daylight')
+scene.world.use_nodes = True
+scene.world.node_tree.nodes['Background'].inputs['Color'].default_value = (.78, .84, .87, 1)
+scene.world.node_tree.nodes['Background'].inputs['Strength'].default_value = .45
+sun_data = bpy.data.lights.new('Late afternoon', 'SUN')
+sun_data.energy, sun_data.angle = .8, math.radians(12)
+sun_data.color = (1, .87, .66)
+sun = bpy.data.objects.new(sun_data.name, sun_data)
+scene.collection.objects.link(sun)
+sun.rotation_euler = (math.radians(32), math.radians(-24), math.radians(-35))
+
+scene.render.engine = 'CYCLES'
+scene.cycles.samples = 16 if args.preview else 80
+scene.cycles.use_denoising = True
+device = 'CPU'
+try:
+ preferences = bpy.context.preferences.addons['cycles'].preferences
+ preferences.compute_device_type = 'OPTIX'
+ preferences.get_devices()
+ for available in preferences.devices:
+ available.use = available.type == preferences.compute_device_type
+ if any(d.use for d in preferences.devices):
+ scene.cycles.device = 'GPU'
+ device = ', '.join(d.name for d in preferences.devices if d.use)
+except Exception:
+ pass
+scene.render.resolution_x = 960 if args.preview else 1920
+scene.render.resolution_y = 600 if args.preview else 1200
+scene.render.resolution_percentage = 100
+scene.render.image_settings.file_format = 'PNG'
+scene.view_settings.view_transform = 'AgX'
+scene.view_settings.look = 'AgX - Medium High Contrast'
+scene.view_settings.exposure = 0
+timings = {}
+hidden = []
+for name in ([args.view] if args.view else ['Hero', 'Kitchen', 'Overview']):
+ for obj in products:
+ # Disclosed presentation cutaway. Full authored enclosure stays in USD/GLB.
+ obj.hide_render = name == 'Overview' and any('.' + b + '.' in obj.name for b in ('ceiling', 'southWall', 'eastWall'))
+ if name == 'Overview':
+ hidden = [o.name for o in products if o.hide_render]
+ scene.camera = cameras[name]
+ scene.camera.data.clip_start = .01
+ scene.camera.data.clip_end = 200
+ scene.render.filepath = str((args.output / (name.lower() + '.png')).resolve())
+ timer = time.perf_counter()
+ bpy.ops.render.render(write_still=True)
+ timings[name] = time.perf_counter() - timer
+for obj in products:
+ obj.hide_render = False
+scene.camera = cameras['Hero']
+assert geometry_hash() == before, 'Renderer changed compiled geometry'
+bpy.ops.wm.save_as_mainfile(filepath=str((args.output / 'house.blend').resolve()))
+report = dict(tool='Blender', version=bpy.app.version_string, device=device,
+ sourceSha256=hashlib.sha256(args.source.read_bytes()).hexdigest(),
+ geometryHash=before, geometryUnchanged=True,
+ meshOccurrences=len(products), sharedMeshData=len({o.data.as_pointer() for o in products}),
+ presentationLights=len([o for o in scene.objects if o.type == 'LIGHT']),
+ boundsMetres=dict(min=list(lo), max=list(hi)), cameras=list(cameras),
+ overviewHiddenBoundaries=hidden, renderSeconds=timings, totalSeconds=time.perf_counter() - start)
+(args.output / 'blender-validation.json').write_text(json.dumps(report, indent=2) + '\n')
+print(json.dumps(report))
diff --git a/scripts/validate-archviz-house.py b/scripts/validate-archviz-house.py
new file mode 100644
index 00000000..cfa60a06
--- /dev/null
+++ b/scripts/validate-archviz-house.py
@@ -0,0 +1,90 @@
+"""Read-only external OpenUSD and embedded-PowerPoint evidence, no house authoring.
+Run with the qualified OpenUSD Python environment after CLI exports/deck compilation.
+"""
+import hashlib
+import json
+import math
+import sys
+import xml.etree.ElementTree as ET
+import zipfile
+from pathlib import Path
+from pxr import Usd, UsdGeom, UsdShade
+
+output = Path(sys.argv[1] if len(sys.argv) > 1 else 'artifacts/local/archviz-house-x0').resolve()
+stage = Usd.Stage.Open(str(output / 'house.usda'))
+assert stage and not stage.GetCompositionErrors()
+assert UsdGeom.GetStageUpAxis(stage) == 'Z'
+unit = UsdGeom.GetStageMetersPerUnit(stage)
+assert abs(unit - .001) < 1e-12
+prims = list(Usd.PrimRange.Stage(stage, Usd.TraverseInstanceProxies()))
+meshes = [p for p in prims if p.IsA(UsdGeom.Mesh)]
+cameras = [p for p in prims if p.IsA(UsdGeom.Camera)]
+assert len(cameras) == 3
+looks = set()
+translucent = []
+for prim in meshes:
+ mesh = UsdGeom.Mesh(prim)
+ points = mesh.GetPointsAttr().Get()
+ indices = mesh.GetFaceVertexIndicesAttr().Get()
+ assert points and indices and all(0 <= i < len(points) for i in indices)
+ assert all(math.isfinite(v) for point in points for v in point)
+ material, _ = UsdShade.MaterialBindingAPI(prim).ComputeBoundMaterial()
+ assert material, str(prim.GetPath())
+ looks.add(str(material.GetPath()))
+ surface = material.ComputeSurfaceSource()[0]
+ opacity = surface.GetInput('opacity').Get()
+ if opacity is not None and opacity < 1:
+ translucent.append(str(prim.GetPath()))
+ assert abs(opacity - .18) < 1e-6
+assert len(translucent) == 3
+inspection = json.loads((output / 'usd-export.json').read_text(encoding='utf-8-sig'))
+assert len(meshes) == sum(n['kind'] in ('Part', 'EnvironmentPanel', 'WindowFinish') for n in inspection['nodes'])
+box = UsdGeom.BBoxCache(Usd.TimeCode.Default(), ['default', 'render']).ComputeWorldBound(stage.GetDefaultPrim()).ComputeAlignedRange()
+lo = list(box.GetMin()); hi = list(box.GetMax())
+for actual, expected in zip(lo + hi, inspection['bounds']['minimumMm'] + inspection['bounds']['maximumMm']):
+ assert abs(actual - expected) < .01, (actual, expected)
+
+def sha(data):
+ return hashlib.sha256(data).hexdigest()
+
+ns = {'m': 'http://schemas.microsoft.com/office/drawing/2017/model3d',
+ 'p': 'http://schemas.openxmlformats.org/presentationml/2006/main',
+ 'mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006'}
+models = 0
+fallbacks = 0
+with zipfile.ZipFile(output / 'house.pptx') as archive:
+ names = archive.namelist()
+ for name in names:
+ if name.endswith('.rels'):
+ assert not any(r.attrib.get('TargetMode') == 'External' for r in ET.fromstring(archive.read(name)))
+ if name.startswith('ppt/slides/slide') and name.endswith('.xml'):
+ xml = ET.fromstring(archive.read(name))
+ models += len(xml.findall('.//m:model3d', ns))
+ fallbacks += len(xml.findall('.//mc:Fallback/p:pic', ns))
+ for slide, preview in [(1, 'hero.png'), (2, 'overview.png')]:
+ assert archive.read(f'ppt/media/model3d-{slide}-1.glb') == (output / 'house.glb').read_bytes()
+ assert archive.read(f'ppt/media/model3d-{slide}-1.png') == (output / preview).read_bytes()
+assert models == fallbacks == 2
+roundtrip = None
+if (output / 'house-office-roundtrip.pptx').exists():
+ with zipfile.ZipFile(output / 'house-office-roundtrip.pptx') as archive:
+ assets = [name for name in archive.namelist() if name.endswith('.glb')]
+ assert assets and all(archive.read(name) == (output / 'house.glb').read_bytes() for name in assets)
+ model_count = sum(len(ET.fromstring(archive.read(name)).findall('.//m:model3d', ns))
+ for name in archive.namelist() if name.startswith('ppt/slides/slide') and name.endswith('.xml'))
+ assert model_count == 2
+ roundtrip = dict(model3d=model_count, embeddedGlbParts=len(assets), exactModelBytes=True)
+validators = {}
+for name in ('house', 'house-enclosed'):
+ issues = json.loads((output / (name + '.validator.json')).read_text())['issues']
+ assert issues['numErrors'] == 0
+ validators[name] = {k: issues[k] for k in ('numErrors', 'numWarnings', 'numInfos')}
+report = dict(openUsd=dict(version=Usd.GetVersion(), compositionErrors=0, meshOccurrences=len(meshes),
+ sharedPrototypes=len(stage.GetPrototypes()), cameras=[str(p.GetPath()) for p in cameras],
+ boundLooks=len(looks), translucentPanes=len(translucent), boundsMm=dict(min=lo,max=hi)),
+ glb=validators,
+ powerpointPackage=dict(slides=2, model3d=models, fallbackPictures=fallbacks,
+ embeddedModelSha256=sha((output / 'house.glb').read_bytes()), externalRelationships=0,
+ officeRoundtrip=roundtrip))
+(output / 'external-validation.json').write_text(json.dumps(report, indent=2) + '\n')
+print(json.dumps(report))