Julian/GhostEngine
1
0
Fork 0
forked from Misaki/GhostEngine
Code Pull Requests Activity

feat: Implement D3D12 resource factory and improve swap chain management

Browse Source 
- Added D3D12ResourceFactory for creating render targets, textures, and buffers.
- Enhanced D3D12SwapChain to manage back buffer render targets and provide access to them.
- Updated D3D12Texture to utilize resource handles for better resource management.
- Removed legacy ResourceAllocator and integrated improvements for resource handling.
- Introduced new interfaces for resource factory and swap chain to streamline resource creation.
- Added support for mip levels and texture dimensions in render target and texture descriptions.
- Created new markdown files to document allocator and swap chain improvements.
This commit is contained in:
Misaki
2025-09-02 19:39:34 +09:00
parent 5385141f14
commit 78cc64b1d2
20 changed files with 848 additions and 680 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
Ghost.Graphics/REFACTORING_SUMMARY.md
View File

@@ -1,160 +0,0 @@
# 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.