Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

10.0 KB
Raw Blame
using System.Text.Json;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Firmament.Assembly;
using Aetheris.Kernel.Firmament.Scene;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class DisplayProjectionTests
{
    private static string PathFor(string relative) => FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/"+relative);
    [Theory]
    [InlineData("Basics/box.firmament")]
    [InlineData("Basics/cylinder.firmament")]
    [InlineData("DisplayProjection/sphere.firmament")]
    [InlineData("DisplayProjection/cone.firmament")]
    [InlineData("DisplayProjection/torus.firmament")]
    public void V2RetainsQualifiedEvaluableCirBesideBrepAndSerializesOnlySafeMetadata(string fixture)
    {
        var source = File.ReadAllText(PathFor(fixture));
        var built = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(built.IsSuccess, string.Join("\n", built.Diagnostics));
        Assert.NotNull(built.Value.RuntimeBody);
        var cir = Assert.IsType<FirmamentCirRetention>(built.Value.Cir);
        Assert.Equal("cir-qualified", cir.Qualification);
        Assert.NotNull(cir.RuntimeRoot);
        Assert.Equal(cir.DefinitionId, FirmamentBuildAndExport.CompileSource(source).Value.Cir!.DefinitionId);
        Assert.Contains("function Field", cir.FieldSource);
        Assert.DoesNotContain("RuntimeRoot", JsonSerializer.Serialize(cir));
        Assert.DoesNotContain("RuntimeBody", JsonSerializer.Serialize(built.Value));
        var outside = new Point3D(cir.MaximumMm![0]+100, cir.MaximumMm[1]+100, cir.MaximumMm[2]+100);
        Assert.True(cir.RuntimeRoot!.Evaluate(outside)>0);
        var shader = CirShaderArtifactProvider.Resolve(cir);
        Assert.Equal("shader-artifact-bound", shader.Status);
        Assert.NotNull(shader.Artifact);
        Assert.Equal(cir.StructuralIdentity, shader.Artifact.SourceIdentity);
        Assert.Contains("@fragment", shader.Artifact.Wgsl);
        Assert.Equal(32, Assert.Single(shader.Artifact.Bindings).ByteSize);
        Assert.True(CirShaderArtifactProvider.Resolve(cir).CacheHit);
        var roundtrip = JsonSerializer.Deserialize<DisplayShaderArtifact>(JsonSerializer.Serialize(shader.Artifact))!;
        Assert.Equal(shader.Artifact.ShaderId, roundtrip.ShaderId);
        Assert.Equal(shader.Artifact.Wgsl, roundtrip.Wgsl);
    }

    [Fact]
    public void ExistingBoundedCsgMirrorRetainsItsEvaluableRootWithoutSerializingAst()
    {
        var compilation = FirmamentCorpusHarness.Compile(FirmamentCorpusHarness.ReadFixtureText("fixtures/Compatibility/LegacyV1/Examples/w2_cylinder_root_blind_bore_semantic.firmament"));
        Assert.True(compilation.Compilation.IsSuccess);
        var mirror = compilation.Compilation.Value.PrimitiveExecutionResult!.NativeGeometryState.CirMirror;
        Assert.NotNull(mirror.RuntimeRoot);
        Assert.DoesNotContain("RuntimeRoot", JsonSerializer.Serialize(mirror));
        var retained = FirmamentCirRetention.FromRoot(mirror.RuntimeRoot, "compatibility-csg-test");
        Assert.Equal("cir-qualified",retained.Qualification);
        Assert.Equal("shader-artifact-bound",CirShaderArtifactProvider.Resolve(retained).Status);
        var normal = FirmamentBuildAndExport.CompileSource(FirmamentCorpusHarness.ReadFixtureText("fixtures/Compatibility/LegacyV1/Examples/w2_cylinder_root_blind_bore_semantic.firmament"));
        Assert.False(normal.IsSuccess);
        Assert.Contains(normal.Diagnostics,d=>d.Message.StartsWith("firmament-v2-source-required",StringComparison.Ordinal));
    }

    [Fact]
    public void HouseProjectsTheSameOwnedEnvironmentMaterialsAndCamerasFromSnapshot()
    {
        var root = PathFor("Scene/WarmModernHouse/house.firmament");
        var documents = Directory.GetFiles(Path.GetDirectoryName(root)!, "*.firmament")
            .ToDictionary(p => Path.GetFileName(p), File.ReadAllText);
        using var session = new FirmamentSceneSession();
        var result = session.CompileProject(new("house.firmament", documents!));
        Assert.True(result.IsSuccess, string.Join("\n",result.Diagnostics));
        var compiled = result.Scene!;
        var display = DisplayProjection.Project(compiled);
        Assert.Equal(94,display.Definitions.Count);
        Assert.Equal(254,display.Occurrences.Count);
        Assert.Equal(3,display.Cameras.Count);
        Assert.Equal(compiled.MinimumMm, display.MinimumMm);
        Assert.Equal(compiled.Appearances.Count, display.Occurrences.Count(o=>o.Material is not null));
        Assert.Contains(display.Occurrences,o=>o.Kind=="WindowFinish" && o.Material?.Opacity<1);
        Assert.Contains(display.Occurrences,o=>o.Kind=="EnvironmentPanel");
        Assert.Throws<ArgumentException>(()=>DisplayProjection.Project(compiled,["main.notABoundary"]));
        var repeated = session.CompileProject(new("house.firmament", documents!));
        Assert.Equal(0,repeated.Scene!.Performance.RebuiltEngineeringDefinitions);
        Assert.Equal(display.Occurrences.Select(o=>o.Id), repeated.Scene.Display.Occurrences.Select(o=>o.Id));
        var changedDocuments = new Dictionary<string,string>(documents!)
        { ["house.firmament"] = documents["house.firmament"].Replace("[.55, .35, .18]", "[.25, .35, .18]")
            .Replace("[2500mm, 1450mm]", "[2600mm, 1450mm]")
            .Replace("[8.1m, .65m, 1.65m]", "[8.2m, .65m, 1.65m]") };
        var edited = session.CompileProject(new("house.firmament",changedDocuments));
        Assert.True(edited.IsSuccess, string.Join("\n",edited.Diagnostics));
        var next = DisplayProjection.Project(edited.Scene!);
        Assert.Equal(0,edited.Scene!.Performance.RebuiltEngineeringDefinitions);
        Assert.Equal(display.Definitions.Select(d=>d.GeometryRevision),next.Definitions.Select(d=>d.GeometryRevision));
        Assert.NotEqual(display.Occurrences.Single(o=>o.Path=="WarmModernHouse.main.floor.panel0").Material!.BaseColor[0],
            next.Occurrences.Single(o=>o.Path=="WarmModernHouse.main.floor.panel0").Material!.BaseColor[0]);
        Assert.NotEqual(display.Occurrences.Single(o=>o.Path=="WarmModernHouse.living").Transform[12],next.Occurrences.Single(o=>o.Path=="WarmModernHouse.living").Transform[12]);
        Assert.NotEqual(display.Cameras.Single(c=>c.Name=="Hero").Transform[12], next.Cameras.Single(c=>c.Name=="Hero").Transform[12]);
    }

    [Fact]
    public void MissingSnapshotDependencyNeverFallsBackToDisk()
    {
        var source = File.ReadAllText(PathFor("Scene/WarmModernHouse/house.firmament"));
        using var session = new FirmamentSceneSession();
        var result = session.CompileProject(new("house.firmament", new Dictionary<string,string>{{"house.firmament",source}}));
        Assert.False(result.IsSuccess);
        Assert.Contains(result.Diagnostics,d=>d.Code=="scene-assembly-file-missing");
    }

    [Fact]
    public void ShaderIdentityFollowsGeometryAndRejectsCorruptTransport()
    {
        var source = File.ReadAllText(PathFor("Basics/cylinder.firmament"));
        var first = FirmamentBuildAndExport.CompileSource(source).Value.Cir!;
        var changed = FirmamentBuildAndExport.CompileSource(source.Replace("12mm", "14mm")).Value.Cir!;
        Assert.NotEqual(CirShaderArtifactProvider.Resolve(first).Artifact!.ShaderId, CirShaderArtifactProvider.Resolve(changed).Artifact!.ShaderId);
        Assert.Equal(CirShaderArtifactProvider.Resolve(first).Artifact!.ShaderId, CirShaderArtifactProvider.Resolve(first with { DefinitionId = "another-definition" }).Artifact!.ShaderId);
        var failure = CirShaderArtifactProvider.Resolve(first with { FieldSource = "corrupt" });
        Assert.Null(failure.Artifact);
        Assert.Equal("shader-artifact-generation-failed", failure.Status);
    }

    [Fact]
    public void NormalAssemblySharesBoundArtifactAcrossOccurrencesAndKeepsMeshFallback()
    {
        var compilation = new AssemblyM1Pipeline().CompileFile(PathFor("DisplayProjection/mixed.firmament"));
        Assert.True(compilation.IsSuccess, string.Join("\n",compilation.Diagnostics));
        var display = AssemblyDisplayMeshExporter.Export(compilation);
        Assert.Contains(display.Definitions, d=>d.Shader?.Artifact is not null);
        Assert.Contains(display.Definitions, d=>d.DisplayPath=="mesh");
        var field = Assert.Single(display.Definitions, d=>d.Shader?.Artifact is not null);
        Assert.Equal(2,display.Occurrences.Count(o=>o.DefinitionId==field.Id));
        Assert.NotEmpty(field.Edges);
        Assert.All(field.Ranges!,range=>Assert.Null(range.SemanticEntityId));
        Assert.Contains(display.Occurrences,o=>o.Material?.Metallic==.7);
    }

    [Fact]
    public void SceneMaterialAndPlacementEditsReuseAutomaticShaderArtifact()
    {
        var root = PathFor("DisplayProjection/scene.firmament");
        var assembly = File.ReadAllText(PathFor("DisplayProjection/mixed.firmament"));
        var documents = new Dictionary<string,string> { ["scene.firmament"]=File.ReadAllText(root), ["mixed.firmament"]=assembly };
        using var session = new FirmamentSceneSession();
        var first = session.CompileProject(new("scene.firmament",documents));
        Assert.True(first.IsSuccess,string.Join("\n",first.Diagnostics));
        var display = DisplayProjection.Project(first.Scene!);
        var shader = Assert.Single(display.Definitions,d=>d.Shader?.Artifact is not null).Shader!.Artifact!;
        documents["mixed.firmament"] = assembly.Replace("[.55,.18,.06]","[.1,.5,.2]");
        documents["scene.firmament"] = documents["scene.firmament"].Replace("[0mm,0mm,0mm]","[10mm,0mm,0mm]");
        var edited = session.CompileProject(new("scene.firmament",documents));
        Assert.True(edited.IsSuccess,string.Join("\n",edited.Diagnostics));
        var next = DisplayProjection.Project(edited.Scene!);
        var retained = Assert.Single(next.Definitions,d=>d.Shader?.Artifact is not null).Shader!;
        Assert.Equal(shader.ShaderId,retained.Artifact!.ShaderId);
        Assert.True(retained.CacheHit);
        Assert.Contains(next.Occurrences,o=>o.Material?.BaseColor[0]==.1);
        Assert.NotEqual(display.Occurrences.Last().Transform[12],next.Occurrences.Last().Transform[12]);
    }
}