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

engine/src/RHI/D3D12/D3D12Device.cpp

@@ -36,24 +36,24 @@ D3D12Device::~D3D12Device() {
     Shutdown();
 }
 
-bool D3D12Device::Initialize(bool enableDebugLayer) {
+bool D3D12Device::Initialize(const RHIDeviceDesc& desc) {
     if (m_initialized) {
         return true;
     }
 
-    if (!CreateDXGIFactory(enableDebugLayer)) {
+    if (!CreateDXGIFactory(desc.enableDebugLayer)) {
         return false;
     }
 
     ComPtr<IDXGIAdapter1> adapter;
-    int adapterIndex = 0;
+    int adapterIndex = desc.adapterIndex;
     bool adapterFound = false;
 
     while (m_factory->EnumAdapters1(adapterIndex, &adapter) != DXGI_ERROR_NOT_FOUND) {
-        DXGI_ADAPTER_DESC1 desc;
-        adapter->GetDesc1(&desc);
+        DXGI_ADAPTER_DESC1 descAdapter;
+        adapter->GetDesc1(&descAdapter);
 
-        if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) {
+        if (descAdapter.Flags & DXGI_ADAPTER_FLAG_SOFTWARE) {
             adapterIndex++;
             continue;
         }
@@ -185,5 +185,100 @@ void* D3D12Device::GetNativeHandle() const {
     return m_device.Get();
 }
 
+void* D3D12Device::GetNativeDevice() {
+    return m_device.Get();
+}
+
+const RHICapabilities& D3D12Device::GetCapabilities() const {
+    return m_capabilities;
+}
+
+const RHIDeviceInfo& D3D12Device::GetDeviceInfo() const {
+    return m_deviceInfo;
+}
+
+RHIBuffer* D3D12Device::CreateBuffer(const BufferDesc& desc) {
+    auto* buffer = new D3D12Buffer();
+    if (buffer->Initialize(m_device.Get(), desc.size, desc.stride, desc.bufferType)) {
+        return buffer;
+    }
+    delete buffer;
+    return nullptr;
+}
+
+RHITexture* D3D12Device::CreateTexture(const TextureDesc& desc) {
+    auto* texture = new D3D12Texture();
+    if (texture->Initialize(m_device.Get(), desc)) {
+        return texture;
+    }
+    delete texture;
+    return nullptr;
+}
+
+RHIShader* D3D12Device::CompileShader(const ShaderCompileDesc& desc) {
+    auto* shader = new D3D12Shader();
+    if (shader->CompileFromFile(desc.fileName.c_str(), desc.entryPoint.c_str(), desc.profile.c_str())) {
+        return shader;
+    }
+    delete shader;
+    return nullptr;
+}
+
+RHISampler* D3D12Device::CreateSampler(const SamplerDesc& desc) {
+    auto* sampler = new D3D12Sampler();
+    if (sampler->Initialize(m_device.Get(), desc)) {
+        return sampler;
+    }
+    delete sampler;
+    return nullptr;
+}
+
+RHIFence* D3D12Device::CreateFence(const FenceDesc& desc) {
+    auto* fence = new D3D12Fence();
+    if (fence->Initialize(m_device.Get(), desc.initialValue)) {
+        return fence;
+    }
+    delete fence;
+    return nullptr;
+}
+
+RHISwapChain* D3D12Device::CreateSwapChain(const SwapChainDesc& desc) {
+    return nullptr;
+}
+
+RHICommandList* D3D12Device::CreateCommandList(const CommandListDesc& desc) {
+    return nullptr;
+}
+
+RHICommandQueue* D3D12Device::CreateCommandQueue(const CommandQueueDesc& desc) {
+    return nullptr;
+}
+
+RHIPipelineState* D3D12Device::CreatePipelineState(const PipelineStateDesc& desc) {
+    return nullptr;
+}
+
+bool D3D12Device::PollEvents() {
+    return false;
+}
+
+void D3D12Device::SwapBuffers() {
+}
+
+bool D3D12Device::ShouldClose() const {
+    return false;
+}
+
+void D3D12Device::SetShouldClose(bool shouldClose) {
+}
+
+D3D12CommandQueue* D3D12Device::CreateCommandQueueImpl(const CommandQueueDesc& desc) {
+    return nullptr;
+}
+
+D3D12CommandList* D3D12Device::CreateCommandListImpl(const CommandListDesc& desc) {
+    return nullptr;
+}
+
 } // namespace RHI
 } // namespace XCEngine

engine/src/RHI/OpenGL/OpenGLDevice.cpp

@@ -16,6 +16,23 @@ OpenGLDevice::~OpenGLDevice() {
     Shutdown();
 }
 
+bool OpenGLDevice::Initialize(const RHIDeviceDesc& desc) {
+    if (m_initialized) {
+        return true;
+    }
+
+    if (desc.windowHandle) {
+        return InitializeWithExistingWindow(static_cast<GLFWwindow*>(desc.windowHandle));
+    }
+
+    std::string titleStr = "XCEngine";
+    if (!desc.appName.empty()) {
+        titleStr = std::string(desc.appName.begin(), desc.appName.end());
+    }
+    
+    return CreateRenderWindow(desc.width, desc.height, titleStr.c_str(), desc.enableDebugLayer);
+}
+
 bool OpenGLDevice::CreateRenderWindow(int width, int height, const char* title, bool enableDebug) {
     if (m_initialized) {
         return true;
@@ -99,5 +116,61 @@ bool OpenGLDevice::ShouldClose() const {
     return m_window && glfwWindowShouldClose(m_window) == GLFW_TRUE;
 }
 
+RHIBuffer* OpenGLDevice::CreateBuffer(const BufferDesc& desc) {
+    return nullptr;
+}
+
+RHITexture* OpenGLDevice::CreateTexture(const TextureDesc& desc) {
+    return nullptr;
+}
+
+RHISwapChain* OpenGLDevice::CreateSwapChain(const SwapChainDesc& desc) {
+    return nullptr;
+}
+
+RHICommandList* OpenGLDevice::CreateCommandList(const CommandListDesc& desc) {
+    return nullptr;
+}
+
+RHICommandQueue* OpenGLDevice::CreateCommandQueue(const CommandQueueDesc& desc) {
+    return nullptr;
+}
+
+RHIShader* OpenGLDevice::CompileShader(const ShaderCompileDesc& desc) {
+    return nullptr;
+}
+
+RHIPipelineState* OpenGLDevice::CreatePipelineState(const PipelineStateDesc& desc) {
+    return nullptr;
+}
+
+RHIFence* OpenGLDevice::CreateFence(const FenceDesc& desc) {
+    return nullptr;
+}
+
+RHISampler* OpenGLDevice::CreateSampler(const SamplerDesc& desc) {
+    return nullptr;
+}
+
+const RHICapabilities& OpenGLDevice::GetCapabilities() const {
+    return m_capabilities;
+}
+
+const RHIDeviceInfo& OpenGLDevice::GetDeviceInfo() const {
+    m_deviceInfoBase.description = L"OpenGL Device";
+    m_deviceInfoBase.vendor = std::wstring(m_deviceInfo.vendor.begin(), m_deviceInfo.vendor.end());
+    m_deviceInfoBase.renderer = std::wstring(m_deviceInfo.renderer.begin(), m_deviceInfo.renderer.end());
+    m_deviceInfoBase.version = std::wstring(m_deviceInfo.version.begin(), m_deviceInfo.version.end());
+    return m_deviceInfoBase;
+}
+
+void* OpenGLDevice::GetNativeDevice() {
+    return nullptr;
+}
+
+void* OpenGLDevice::GetNativeHandle() const {
+    return nullptr;
+}
+
 } // namespace RHI
 } // namespace XCEngine