feat(RHI): 实现 RHICommandQueue 抽象基类

engine/include/XCEngine/RHI/D3D12/D3D12CommandQueue.h

@@ -3,6 +3,7 @@
 #include <d3d12.h>
 #include <wrl/client.h>
 
+#include "../RHICommandQueue.h"
 #include "../RHIEnums.h"
 #include "D3D12Enum.h"
 
@@ -13,26 +14,29 @@ namespace RHI {
 
 class D3D12Fence;
 
-class D3D12CommandQueue {
+class D3D12CommandQueue : public RHICommandQueue {
 public:
     D3D12CommandQueue();
-    ~D3D12CommandQueue();
+    ~D3D12CommandQueue() override;
 
     bool Initialize(ID3D12Device* device, CommandQueueType type = CommandQueueType::Direct);
-    void Shutdown();
+    void Shutdown() override;
 
-    void ExecuteCommandLists(uint32_t count, ID3D12CommandList** lists);
-    void Signal(D3D12Fence* fence, uint64_t value);
-    void Signal(ID3D12Fence* fence, uint64_t value);
-    void Wait(D3D12Fence* fence, uint64_t value);
-    void Wait(ID3D12Fence* fence, uint64_t value);
-    uint64_t GetCompletedValue();
-    void WaitForIdle();
+    void ExecuteCommandLists(uint32_t count, void** lists) override;
+    void Signal(RHIFence* fence, uint64_t value) override;
+    void Wait(RHIFence* fence, uint64_t value) override;
+    uint64_t GetCompletedValue() override;
+    void WaitForIdle() override;
     
-    CommandQueueType GetType() const { return m_type; }
-    uint64_t GetTimestampFrequency() const { return m_timestampFrequency; }
+    CommandQueueType GetType() const override { return m_type; }
+    uint64_t GetTimestampFrequency() const override { return m_timestampFrequency; }
 
     ID3D12CommandQueue* GetCommandQueue() const { return m_commandQueue.Get(); }
+    void* GetNativeHandle() override { return m_commandQueue.Get(); }
+
+    void ExecuteCommandListsInternal(uint32_t count, ID3D12CommandList** lists);
+    void Signal(ID3D12Fence* fence, uint64_t value);
+    void Wait(ID3D12Fence* fence, uint64_t value);
 
 private:
     ComPtr<ID3D12CommandQueue> m_commandQueue;

engine/include/XCEngine/RHI/OpenGL/OpenGLCommandQueue.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../RHICommandQueue.h"
+
+namespace XCEngine {
+namespace RHI {
+
+class OpenGLCommandQueue : public RHICommandQueue {
+public:
+    OpenGLCommandQueue();
+    ~OpenGLCommandQueue() override;
+
+    void Shutdown() override;
+
+    void ExecuteCommandLists(uint32_t count, void** lists) override;
+    void Signal(RHIFence* fence, uint64_t value) override;
+    void Wait(RHIFence* fence, uint64_t value) override;
+    uint64_t GetCompletedValue() override;
+    void WaitForIdle() override;
+
+    CommandQueueType GetType() const override { return CommandQueueType::Direct; }
+    uint64_t GetTimestampFrequency() const override { return 0; }
+
+    void* GetNativeHandle() override { return nullptr; }
+};
+
+} // namespace RHI
+} // namespace XCEngine

engine/include/XCEngine/RHI/RHICommandQueue.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RHITypes.h"
+
+namespace XCEngine {
+namespace RHI {
+
+class RHIFence;
+
+class RHICommandQueue {
+public:
+    virtual ~RHICommandQueue() = default;
+
+    virtual void Shutdown() = 0;
+
+    virtual void ExecuteCommandLists(uint32_t count, void** lists) = 0;
+    virtual void Signal(RHIFence* fence, uint64_t value) = 0;
+    virtual void Wait(RHIFence* fence, uint64_t value) = 0;
+    virtual uint64_t GetCompletedValue() = 0;
+    virtual void WaitForIdle() = 0;
+
+    virtual CommandQueueType GetType() const = 0;
+    virtual uint64_t GetTimestampFrequency() const = 0;
+
+    virtual void* GetNativeHandle() = 0;
+};
+
+} // namespace RHI
+} // namespace XCEngine