Refactor rendering projects

src/Runtime/Ghost.Graphics.D3D12/D3D12GraphicsEngine.cs

@@ -0,0 +1,174 @@
+#if DEBUG
+#define ENABLE_DEBUG
+#endif
+
+using Ghost.Core;
+using Ghost.Graphics.Core;
+using Ghost.Graphics.RHI;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Ghost.Graphics.D3D12;
+
+public static class D3D12GraphicsEngineFactory
+{
+    public static IGraphicsEngine Create(IRenderSystem renderSystem)
+    {
+        return new D3D12GraphicsEngine(renderSystem);
+    }
+}
+
+internal class D3D12GraphicsEngine : IGraphicsEngine
+{
+    private GCHandle _thisHandle;
+
+    private readonly IRenderSystem _renderSystem;
+
+#if ENABLE_DEBUG
+    private readonly D3D12DebugLayer _debugLayer;
+#endif
+    private readonly D3D12RenderDevice _device;
+    private readonly DxcShaderCompiler _shaderCompiler;
+    private readonly D3D12DescriptorAllocator _descriptorAllocator;
+    private readonly D3D12ResourceDatabase _resourceDatabase;
+    private readonly D3D12PipelineLibrary _pipelineLibrary;
+    private readonly D3D12ResourceAllocator _resourceAllocator;
+
+    private ImmutableArray<IRenderer> _renderers;
+
+    private bool _disposed;
+
+    public IRenderDevice Device => _device;
+    public IShaderCompiler ShaderCompiler => _shaderCompiler;
+    public IPipelineLibrary PipelineLibrary => _pipelineLibrary;
+    public IResourceDatabase ResourceDatabase => _resourceDatabase;
+    public IResourceAllocator ResourceAllocator => _resourceAllocator;
+
+    public D3D12GraphicsEngine(IRenderSystem renderSystem)
+    {
+        _renderSystem = renderSystem;
+
+#if ENABLE_DEBUG
+        _debugLayer = new D3D12DebugLayer();
+#endif
+        _device = new D3D12RenderDevice();
+        _shaderCompiler = new DxcShaderCompiler();
+        _descriptorAllocator = new D3D12DescriptorAllocator(_device);
+
+        _resourceDatabase = new D3D12ResourceDatabase(renderSystem, _descriptorAllocator);
+        _pipelineLibrary = new D3D12PipelineLibrary(_device, _resourceDatabase);
+        _resourceAllocator = new D3D12ResourceAllocator(_device, _descriptorAllocator, _resourceDatabase, _pipelineLibrary);
+
+        _renderers = ImmutableArray<IRenderer>.Empty;
+
+        _pipelineLibrary.InitializeLibrary(null);
+    }
+
+    ~D3D12GraphicsEngine()
+    {
+        Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private void ThrowIfDisposed()
+    {
+        ObjectDisposedException.ThrowIf(_disposed, this);
+    }
+
+    public IRenderer CreateRenderer()
+    {
+        ThrowIfDisposed();
+
+        var renderer = new D3D12Renderer(this);
+        ImmutableInterlocked.Update(ref _renderers, renderers => renderers.Add(renderer));
+        return renderer;
+    }
+
+    public void RemoveRenderer(IRenderer renderer)
+    {
+        ThrowIfDisposed();
+        ImmutableInterlocked.Update(ref _renderers, renderers => renderers.Remove(renderer));
+    }
+
+    public void ClearRenderers()
+    {
+        ThrowIfDisposed();
+        ImmutableInterlocked.Update(ref _renderers, renderers => renderers.Clear());
+    }
+
+    public ICommandAllocator CreateCommandAllocator(CommandBufferType type = CommandBufferType.Graphics)
+    {
+        return new D3D12CommandAllocator(_device, type);
+    }
+
+    public ICommandBuffer CreateCommandBuffer(CommandBufferType type = CommandBufferType.Graphics)
+    {
+        ThrowIfDisposed();
+
+        return new D3D12CommandBuffer(
+            _device,
+            _pipelineLibrary,
+            _resourceDatabase,
+            _resourceAllocator,
+            _descriptorAllocator,
+            type);
+    }
+
+    public ISwapChain CreateSwapChain(SwapChainDesc desc)
+    {
+        ThrowIfDisposed();
+        return new D3D12SwapChain(_resourceDatabase, _descriptorAllocator, _device, desc, _renderSystem.MaxFrameLatency);
+    }
+
+    public Result RenderFrame(ICommandAllocator commandAllocator)
+    {
+        ThrowIfDisposed();
+
+        var r = Result.Success();
+
+        foreach (var renderer in _renderers)
+        {
+            r = renderer.Render(commandAllocator);
+            if (r.IsFailure)
+            {
+                break;
+            }
+        }
+
+        _resourceDatabase.EndFrame();
+
+        return r;
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        foreach (var renderer in _renderers)
+        {
+            renderer.Dispose();
+        }
+
+        _resourceDatabase.ReleaseAllResourcesImmediately();
+
+        _resourceAllocator.Dispose();
+        _pipelineLibrary.Dispose();
+        _resourceDatabase.Dispose();
+
+        _descriptorAllocator.Dispose();
+        _shaderCompiler.Dispose();
+        _device.Dispose();
+#if ENABLE_DEBUG
+        _debugLayer.Dispose();
+#endif
+
+        _thisHandle.Free();
+
+        _disposed = true;
+        GC.SuppressFinalize(this);
+    }
+}