Elements web assembly API

.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/Elements.Playground/Elements.Playground.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/Elements.Playground/Elements.Playground.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/Elements.Playground/Elements.Playground.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

Elements.Playground/App.razor

@@ -1,10 +1 @@
-<Router AppAssembly="@typeof(Program).Assembly">
-    <Found Context="routeData">
-        <RouteView RouteData="@routeData" DefaultLayout="@typeof(MainLayout)" />
-    </Found>
-    <NotFound>
-        <LayoutView Layout="@typeof(MainLayout)">
-            <p>Sorry, there's nothing at this address.</p>
-        </LayoutView>
-    </NotFound>
-</Router>
+<Elements.Playground.ElementsAPI />

Elements.Playground/Compiler.cs

@@ -12,6 +12,11 @@
 
 namespace Elements.Playground
 {
+    public class Globals
+    {
+        public string InputJson { get; set; }
+    }
+
     public static class Compiler
     {
         class BlazorBoot
@@ -30,42 +35,39 @@ class Resources
             public Dictionary<string, string> pdb { get; set; }
             public Dictionary<string, string> runtime { get; set; }
         }
-
-        private static Task InitializationTask;
         private static List<MetadataReference> References;
 
-        public static void InitializeMetadataReferences(HttpClient client)
-        {
-            async Task InitializeInternal()
-            {
-                var model = new Model();
-                Console.WriteLine("Initializing the code editor...");
+        private static bool _isInitialized = false;
 
-                // TODO: This loads every assembly that is available. We should
-                // see if we can limit this to just the ones that we need.
-                var response = await client.GetFromJsonAsync<BlazorBoot>("_framework/blazor.boot.json");
-                var assemblies = await Task.WhenAll(response.resources.assembly.Keys.Select(x => client.GetAsync("_framework/" + x)));
-                var references = new List<MetadataReference>(assemblies.Length);
-                foreach (var asm in assemblies)
-                {
-                    using var task = await asm.Content.ReadAsStreamAsync();
-                    references.Add(MetadataReference.CreateFromStream(task));
-                }
-                References = references;
-            }
-            InitializationTask = InitializeInternal();
+        public static bool IsReady()
+        {
+            return _isInitialized;
         }
 
-        public static Task WhenReady(Func<Task> action)
+        public static async Task InitializeMetadataReferences(HttpClient client)
         {
-            if (InitializationTask.Status != TaskStatus.RanToCompletion)
+            if (_isInitialized)
             {
-                return InitializationTask.ContinueWith(x => action());
+                return;
             }
-            else
+            var model = new Model();
+            Console.WriteLine("Loading metadata references...");
+            // TODO: Make this conditional on some build flag, so we can easily
+            // deploy to prod or dev, or allow others cloning the project to
+            // spec the URL where they'll be hosting it.
+            var rootUrl = "https://elements.hypar.io/";
+            // TODO: This loads every assembly that is available. We should
+            // see if we can limit this to just the ones that we need.
+            var response = await client.GetFromJsonAsync<BlazorBoot>($"{rootUrl}blazor.boot.json");
+            var assemblies = await Task.WhenAll(response.resources.assembly.Keys.Select(x => client.GetAsync($"{rootUrl}{x}")));
+            var references = new List<MetadataReference>(assemblies.Length);
+            foreach (var asm in assemblies)
             {
-                return action();
+                using var task = await asm.Content.ReadAsStreamAsync();
+                references.Add(MetadataReference.CreateFromStream(task));
             }
+            References = references;
+            _isInitialized = true;
         }
 
         public static (bool success, Assembly asm, Compilation compilation) LoadSource(string source)
@@ -83,11 +85,15 @@ public static (bool success, Assembly asm, Compilation compilation) LoadSource(s
 "System.Collections.Generic",
 "System.Console",
 "System.Linq",
+"System.Text.Json",
+"System.Text.Json.Serialization",
 "Elements",
 "Elements.Geometry",
+"Elements.Geometry.Solids",
+"Elements.Spatial",
 "Elements.Geometry.Profiles",
 "Elements.Validators"
-        }, concurrentBuild: false));
+        }, concurrentBuild: false), globalsType: typeof(Globals));
 
             ImmutableArray<Diagnostic> diagnostics = compilation.GetDiagnostics();
 

Elements.Playground/Elements.Playground.csproj

@@ -1,18 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk.BlazorWebAssembly">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <SatelliteResourceLanguages>en</SatelliteResourceLanguages>
     <BlazorEnableCompression>false</BlazorEnableCompression>
     <BlazorWebAssemblyEnableLinking>false</BlazorWebAssemblyEnableLinking>
     <PublishTrimmed>false</PublishTrimmed>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="5.0.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="5.0.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="3.11.0" />
-    <PackageReference Include="System.Net.Http.Json" Version="5.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly" Version="6.0.8" />
+    <PackageReference Include="Microsoft.AspNetCore.Components.WebAssembly.DevServer" Version="6.0.8" />
   </ItemGroup>
 
   <ItemGroup>

Elements.Playground/ElementsAPI.razor

@@ -0,0 +1,152 @@
+@page "/"
+
+@inject IJSRuntime JSRuntime
+
+<div></div>
+
+@code {
+
+    public class Result
+    {
+        public bool Success { get; set; }
+
+        public string Output { get; set; }
+
+        public string ModelJson { get; set; }
+    }
+
+    // Why do we need a component to call Elements compile and
+    // run elements code from the browser?
+    // 1. We need an HttpClient passed in from the framework. We can't
+    // create it because this code runs sandboxed in wasm. It has to
+    // come from blazor and the only way to do that is by injecting it
+    // as a service.
+    // 2. We need the the IJSRuntime to call methods in javascript. This
+    // also needs to be injected as a service.
+
+    private static Globals globals = new Globals();
+    private static IJSRuntime runtime;
+    [Inject] private HttpClient Client { get; set; }
+    private static Func<object[], Task> executionDelegate;
+
+    protected override async Task OnInitializedAsync()
+    {
+        runtime = JSRuntime;
+        await Compiler.InitializeMetadataReferences(Client);
+        await base.OnInitializedAsync();
+        await Task.FromResult(0);
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        await base.OnAfterRenderAsync(firstRender);
+    }
+
+    [JSInvokable]
+    public static async Task<Result> Run()
+    {
+        var sw = Stopwatch.StartNew();
+        var currentOut = Console.Out;
+        var writer = new StringWriter();
+        Console.SetOut(writer);
+        var success = false;
+
+        if (executionDelegate == null)
+        {
+            Console.WriteLine("There is nothing to execute. Try compiling first.");
+            Console.SetOut(currentOut);
+            sw.Stop();
+            return new Result()
+            {
+                Success = success,
+                Output = writer.ToString()
+            };
+        }
+
+        var model = await (Task<object>)executionDelegate(new object[] { globals, null }) as Elements.Model;
+        Console.WriteLine($"Run successful in {sw.ElapsedMilliseconds} ms");
+        sw.Reset();
+
+        await Task.Run(async () =>
+        {
+            sw.Start();
+            var glb = model.ToGlTF();
+            await runtime.InvokeVoidAsync("elements.loadModel", glb);
+            Console.WriteLine($"GlTF loaded in {sw.ElapsedMilliseconds} ms");
+            success = true;
+        });
+
+        Console.SetOut(currentOut);
+
+        sw.Stop();
+
+        return new Result()
+        {
+            Success = success,
+            Output = writer.ToString(),
+            ModelJson = model.ToJson()
+        };
+    }
+
+    [JSInvokable]
+    public static Result Compile(string code)
+    {
+        if (!Compiler.IsReady())
+        {
+            return new Result
+            {
+                Success = false,
+                Output = "Compiler not ready"
+            };
+        }
+        var sw = Stopwatch.StartNew();
+
+        var currentOut = Console.Out;
+        var writer = new StringWriter();
+        Console.SetOut(writer);
+        var compileSuccess = false;
+
+        // Redirect debug to the console.
+        Trace.Listeners.Clear();
+        Trace.Listeners.Add(
+        new TextWriterTraceListener(Console.Out));
+
+        executionDelegate = null;
+
+        // Compilation warnings will be written to console.out
+        // which is redirected here to the writer.
+        var (success, asm, compilation) = Compiler.LoadSource(code);
+        if (success)
+        {
+            var entryPoint = compilation.GetEntryPoint(CancellationToken.None);
+            var type = asm.GetType($"{entryPoint.ContainingNamespace.MetadataName}.{entryPoint.ContainingType.MetadataName}");
+            var entryPointMethod = type.GetMethod(entryPoint.MetadataName);
+
+            executionDelegate = (Func<object[], Task>)entryPointMethod.CreateDelegate(typeof(Func<object[], Task>));
+            Console.WriteLine($"Compilation successful in {sw.ElapsedMilliseconds} ms");
+            compileSuccess = true;
+        }
+        else
+        {
+            Console.WriteLine("Compilation was not successful. The execution will not run.");
+            compileSuccess = false;
+        }
+
+        Console.SetOut(currentOut);
+
+        sw.Stop();
+
+        return new Result()
+        {
+            Success = compileSuccess,
+            Output = writer.ToString()
+        };
+    }
+
+    [JSInvokable]
+    public static void UpdateInputs(string json)
+    {
+        globals.InputJson = json;
+        return;
+    }
+}