Added new RHI abstraction layer;

Added new console debug page to UnitTest;
2025-08-25 10:48:59 +09:00
parent eafbfb2fa1
commit 5385141f14
44 changed files with 3473 additions and 357 deletions
--- a/Ghost.Graphics/REFACTORING_SUMMARY.md
+++ b/Ghost.Graphics/REFACTORING_SUMMARY.md
@@ -0,0 +1,160 @@
+# Ghost Engine Graphics Refactoring Summary
+
+## 🎯 Refactoring Goals Completed
+
+✅ **1. Create a new RHI folder with interfaces for all abstractions**
+- Created clean D3D12-native RHI interfaces in `Ghost.Graphics\RHI\`
+- Interfaces include: `IRenderDevice`, `ICommandBuffer`, `ICommandQueue`, `ISwapChain`, `IRenderTarget`, `IDescriptorAllocator`
+
+✅ **2. Move all D3D12-specific code into D3D12 implementations**
+- All D3D12 implementations moved to `Ghost.Graphics\D3D12\`
+- Clean separation between interface and implementation
+
+✅ **3. Delete the current Renderer class and rewrite it to use interfaces**
+- ❌ Removed legacy `Renderer.cs` (was tightly coupled to D3D12)
+- ✅ Created new `D3D12Renderer` that implements `IRenderer` interface
+
+✅ **4. Extract SwapChain logic from Renderer into its own class**
+- ✅ Created `D3D12SwapChain` implementing `ISwapChain`
+- SwapChain now manages presentation independently of rendering
+
+✅ **5. Remove renderer management from GraphicsDevice - make it a pure device factory**
+- ❌ Marked legacy `GraphicsDevice` as obsolete
+- ✅ Created new `D3D12RenderDevice` as clean factory for D3D12 resources
+
+✅ **6. Create separate CommandQueue classes for Graphics/Compute/Copy queues**
+- ✅ Created `D3D12CommandQueue` supporting all three queue types
+- `D3D12RenderDevice` exposes separate queues via properties
+
+✅ **7. Abstract descriptor allocation behind an interface**
+- ✅ Created `IDescriptorAllocator` interface
+- ✅ Implemented `D3D12DescriptorAllocator`
+
+✅ **8. Move frame synchronization to application level, not RHI level**
+- ✅ Created `RenderSystem` class for application-level frame management
+- ❌ Marked legacy `GraphicsPipeline` as obsolete
+- Frame synchronization now handled by `RenderSystem`, not buried in graphics device
+
+## 🏗️ New Architecture
+
+### Core RHI Interfaces
+```
+Ghost.Graphics\RHI\
+├── IRenderDevice.cs      # Device factory for creating resources
+├── ICommandBuffer.cs     # Command recording interface
+├── ICommandQueue.cs      # Command submission interface  
+├── ISwapChain.cs         # Presentation interface
+├── IRenderTarget.cs      # Render target interface (color OR depth only)
+├── IRenderer.cs          # High-level renderer interface
+├── IDescriptorAllocator.cs # Descriptor management
+└── IResource.cs          # Base resource interfaces
+```
+
+### D3D12 Implementations
+```
+Ghost.Graphics\D3D12\
+├── D3D12RenderDevice.cs     # Main device factory
+├── D3D12CommandBuffer.cs    # Command list wrapper
+├── D3D12CommandQueue.cs     # Command queue wrapper
+├── D3D12SwapChain.cs        # Swap chain management
+├── D3D12RenderTarget.cs     # Render target (single type: color OR depth)
+├── D3D12Renderer.cs         # High-level renderer implementation
+├── D3D12DescriptorAllocator.cs # Descriptor heap management
+├── D3D12Texture.cs          # Texture implementation
+└── D3D12Buffer.cs           # Buffer implementation
+```
+
+### Application Level
+```
+Ghost.Graphics\
+├── RenderSystem.cs          # Frame synchronization & renderer management
+└── Examples\
+    └── ModernRenderingExample.cs # Usage examples
+```
+
+## 🎯 Key Improvements
+
+### **1. Clean Separation of Concerns**
+- **SwapChain**: Only handles presentation
+- **Renderer**: Only handles rendering logic
+- **RenderDevice**: Only creates resources
+- **RenderSystem**: Only manages frame synchronization
+
+### **2. Simplified Render Target Design**
+- Render targets now support **either color OR depth**, not both
+- Use `RenderTargetDesc.Color()` or `RenderTargetDesc.Depth()` factory methods
+- Cleaner API, less complex state management
+
+### **3. D3D12-Native RHI Design**
+- No abstraction overhead - direct mapping to D3D12 concepts
+- Command buffers, resource states, pipeline state objects
+- Descriptor heaps and bindless rendering support
+- Access to all D3D12 features without compromise
+
+### **4. Application-Level Frame Management**
+```csharp
+// OLD: Frame sync buried in GraphicsPipeline
+GraphicsPipeline.SignalCPUReady();
+GraphicsPipeline.WaitForGPUReady();
+
+// NEW: Clear application-level control
+renderSystem.SignalCPUReady();
+renderSystem.WaitForGPUReady();
+```
+
+### **5. Multiple Renderer Support**
+```csharp
+var renderSystem = new RenderSystem(device);
+
+// Add multiple renderers
+renderSystem.AddRenderer(forwardRenderer);   // Main scene
+renderSystem.AddRenderer(shadowRenderer);    // Shadow maps  
+renderSystem.AddRenderer(postProcessRenderer); // Post effects
+
+renderSystem.Start(); // Manages all renderers
+```
+
+## 📖 Usage Examples
+
+### **Modern Approach**
+```csharp
+// Create device and render system
+var device = new D3D12RenderDevice();
+var renderSystem = new RenderSystem(device);
+
+// Create renderer with swap chain
+var renderer = new D3D12Renderer(device);
+var swapChain = device.CreateSwapChain(swapChainDesc);
+renderer.SetSwapChain(swapChain);
+
+// Or render to off-screen target
+var colorTarget = device.CreateRenderTarget(
+    RenderTargetDesc.Color(1024, 1024, TextureFormat.R8G8B8A8_UNorm));
+renderer.SetRenderTarget(colorTarget);
+
+// Start rendering
+renderSystem.AddRenderer(renderer);
+renderSystem.Start();
+```
+
+### **Legacy Compatibility**
+```csharp
+// Legacy code still works (with obsolete warnings)
+GraphicsPipeline.Initialize(); // ⚠️ Obsolete
+GraphicsPipeline.Start();      // ⚠️ Obsolete
+
+// But modern API is preferred
+var device = GraphicsPipeline.RenderDevice;      // ✅ New
+var renderSystem = GraphicsPipeline.RenderSystem; // ✅ New
+```
+
+## 🎯 Benefits Achieved
+
+1. **Cleaner Code**: High-level rendering code no longer knows about D3D12 specifics
+2. **Better Testing**: All components can be mocked via interfaces  
+3. **Flexible Rendering**: Easy to support multiple renderers and render targets
+4. **Future-Proof**: Clean abstraction allows adding Vulkan/Metal later
+5. **Performance**: Zero abstraction overhead with D3D12-native design
+6. **Maintainability**: Clear separation of concerns and responsibilities
+
+The refactoring successfully transforms a monolithic, tightly-coupled graphics system into a clean, modular, and flexible RHI architecture while maintaining backward compatibility and achieving all the stated goals.