BabylonJS and Blazor - Getting Set Up

<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>

@code {
    [Inject]
    public IJSRuntime JSRuntime { get; set; }

    protected override void OnInitialized()
    {
        EventHorizon.Blazor.Interop.EventHorizonBlazorInterop.JSRuntime = JSRuntime;
    }
}

@inherits LayoutComponentBase

<div style="width: 100vw; height: 100vh;">
	@Body
</div>

namespace BabylonJS.Blazor.Game.Tutorial.Client.HTML
{
    using EventHorizon.Blazor.Interop;
    using System.Text.Json.Serialization;

    [JsonConverter(typeof(CachedEntityConverter<Canvas>))]
    public class Canvas : HTMLCanvasElementCachedEntity
    {
        public static Canvas GetElementById(
            string elementId
        ) => EventHorizonBlazorInterop.FuncClass(
            entity => new Canvas(entity),
            new string[] { "document", "getElementById" },
            elementId
        );

        private Canvas(
            ICachedEntity entity
        )
        {
            ___guid = entity.___guid;
        }
    }
}

namespace BabylonJS.Blazor.Game.Tutorial.Client.BabylonJSExtensions
{
    using System.Text.Json.Serialization;
    using BABYLON;
    using EventHorizon.Blazor.Interop;

    [JsonConverter(typeof(CachedEntityConverter<DebugLayerScene>))]
    public class DebugLayerScene : Scene
    {
        private DebugLayer __debugLayer;

        public DebugLayerScene(Engine engine, SceneOptions options = null) 
            : base(engine, options)
        {
        }

        public DebugLayer debugLayer
        {
            get
            {
                if (__debugLayer == null)
                {
                    __debugLayer = EventHorizonBlazorInterop.GetClass<DebugLayer>(
                        this.___guid,
                        "debugLayer",
                        (entity) =>
                        {
                            return new DebugLayer() { ___guid = entity.___guid };
                        }
                    );
                }
                return __debugLayer;
            }
            set
            {
                __debugLayer = null;
                EventHorizonBlazorInterop.Set(
                    this.___guid,
                    "debugLayer",
                    value
                );
            }
        }
    }
}

@page "/"

<canvas id="game-window" style="width:100%; height: 100%;"
		@onkeydown="HandleKeyDown"></canvas>

namespace BabylonJS.Blazor.Game.Tutorial.Client.Pages
{
    using System;
    using System.Threading.Tasks;
    using BABYLON;
    using BabylonJS.Blazor.Game.Tutorial.Client.BabylonJSExtensions;
    using BabylonJS.Blazor.Game.Tutorial.Client.HTML;
    using EventHorizon.Blazor.Interop.Callbacks;
    using Microsoft.AspNetCore.Components.Web;

    public partial class Index : IDisposable
    {
        private Engine _engine;
        private DebugLayerScene _scene;

        protected override void OnAfterRender(bool firstRender)
        {
            if (firstRender)
            {
                CreateScene();
            }
        }

        public void Dispose()
        {
            _engine?.dispose();
        }

        public void CreateScene()
        {
            var canvas = Canvas.GetElementById(
                "game-window"
            );
            var engine = new Engine(
                canvas,
                true
            );
            // We extend the standard Scene with the DebugLayer getter in the DebugLayerScene
            _scene = new DebugLayerScene(
                engine
            );
            var light1 = new HemisphericLight(
                "light1",
                new Vector3(
                    0,
                    2,
                    8
                ),
                _scene
            );
            var camera = new ArcRotateCamera(
                "Camera",
                (decimal)(Math.PI / 2),
                (decimal)(Math.PI / 4),
                2,
                Vector3.Zero(),
                _scene
            );
            _scene.activeCamera = camera;
            camera.attachControl(
                false
            );
            var sphere = MeshBuilder.CreateSphere(
                "sphere",
                new
                {
                    diameter = 1
                },
                _scene
            );

            engine.runRenderLoop(new ActionCallback(
                () => Task.Run(() => _scene.render(true, false))
            ));

            _engine = engine;
        }

        protected void HandleKeyDown(
            KeyboardEventArgs args
        )
        {
            Console.WriteLine(args.Key);
            if (args.ShiftKey && args.CtrlKey && args.AltKey && args.Key.ToLower() == "i")
            {
                if (_scene.debugLayer.isVisible())
                {
                    Console.WriteLine("Hello");
                    _scene.debugLayer.hide();
                }
                else
                {
                    _scene.debugLayer.show();
                }
            }
        }
    }
}