From aaf9cce4185ce1a712ad239ac0cde01e3e8941aa Mon Sep 17 00:00:00 2001 From: ssdfasd <2156608475@qq.com> Date: Wed, 25 Mar 2026 23:07:22 +0800 Subject: [PATCH] Add RHI vertex and index buffer views --- .../include/XCEngine/RHI/D3D12/D3D12Device.h | 2 + .../XCEngine/RHI/D3D12/D3D12ResourceView.h | 13 +++- .../XCEngine/RHI/OpenGL/OpenGLDevice.h | 2 + .../XCEngine/RHI/OpenGL/OpenGLResourceView.h | 14 +++- engine/include/XCEngine/RHI/RHIDevice.h | 2 + engine/include/XCEngine/RHI/RHIEnums.h | 2 + engine/src/RHI/D3D12/D3D12CommandList.cpp | 10 +-- engine/src/RHI/D3D12/D3D12Device.cpp | 54 +++++++++++++-- engine/src/RHI/D3D12/D3D12ResourceView.cpp | 59 ++++++++++++++-- engine/src/RHI/OpenGL/OpenGLCommandList.cpp | 4 +- engine/src/RHI/OpenGL/OpenGLDevice.cpp | 28 ++++++++ engine/src/RHI/OpenGL/OpenGLResourceView.cpp | 50 +++++++++++++- tests/RHI/unit/test_command_list.cpp | 68 ++++++++++++++++++- tests/RHI/unit/test_views.cpp | 53 ++++++++++++++- 14 files changed, 342 insertions(+), 19 deletions(-) diff --git a/engine/include/XCEngine/RHI/D3D12/D3D12Device.h b/engine/include/XCEngine/RHI/D3D12/D3D12Device.h index 3b89f4c4..e4d6ceee 100644 --- a/engine/include/XCEngine/RHI/D3D12/D3D12Device.h +++ b/engine/include/XCEngine/RHI/D3D12/D3D12Device.h @@ -88,6 +88,8 @@ public: RHIDescriptorPool* CreateDescriptorPool(const DescriptorPoolDesc& desc) override; RHIDescriptorSet* CreateDescriptorSet(RHIDescriptorPool* pool, const DescriptorSetLayoutDesc& layout) override; + RHIResourceView* CreateVertexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) override; + RHIResourceView* CreateIndexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) override; RHIResourceView* CreateRenderTargetView(RHITexture* texture, const ResourceViewDesc& desc) override; RHIResourceView* CreateDepthStencilView(RHITexture* texture, const ResourceViewDesc& desc) override; RHIResourceView* CreateShaderResourceView(RHITexture* texture, const ResourceViewDesc& desc) override; diff --git a/engine/include/XCEngine/RHI/D3D12/D3D12ResourceView.h b/engine/include/XCEngine/RHI/D3D12/D3D12ResourceView.h index 0ce05215..e5914043 100644 --- a/engine/include/XCEngine/RHI/D3D12/D3D12ResourceView.h +++ b/engine/include/XCEngine/RHI/D3D12/D3D12ResourceView.h @@ -14,6 +14,7 @@ namespace XCEngine { namespace RHI { class D3D12DescriptorHeap; +class D3D12Buffer; class D3D12ResourceView : public RHIResourceView { public: @@ -46,12 +47,18 @@ public: void InitializeAsConstantBuffer(ID3D12Device* device, ID3D12Resource* resource, const D3D12_CONSTANT_BUFFER_VIEW_DESC* desc, D3D12DescriptorHeap* heap, uint32_t slotIndex); + void InitializeAsVertexBuffer(D3D12Buffer* buffer, const ResourceViewDesc& desc); + void InitializeAsIndexBuffer(D3D12Buffer* buffer, const ResourceViewDesc& desc); D3D12_CPU_DESCRIPTOR_HANDLE GetCPUHandle() const { return m_handle; } GPUDescriptorHandle GetGPUHandle() const; ID3D12Resource* GetResource() const { return m_resource; } D3D12DescriptorHeap* GetHeap() const { return m_heap; } uint32_t GetSlotIndex() const { return m_slotIndex; } + uint64_t GetBufferLocation() const { return m_bufferLocation; } + uint32_t GetBufferSize() const { return m_bufferSize; } + uint32_t GetBufferStride() const { return m_bufferStride; } + uint64_t GetBufferOffset() const { return m_bufferOffset; } static D3D12_RENDER_TARGET_VIEW_DESC CreateRenderTargetDesc(Format format, D3D12_RTV_DIMENSION dimension); static D3D12_DEPTH_STENCIL_VIEW_DESC CreateDepthStencilDesc(Format format, D3D12_DSV_DIMENSION dimension); @@ -67,7 +74,11 @@ private: D3D12DescriptorHeap* m_heap; uint32_t m_slotIndex; std::unique_ptr m_ownedHeap; + uint64_t m_bufferLocation; + uint64_t m_bufferOffset; + uint32_t m_bufferSize; + uint32_t m_bufferStride; }; } // namespace RHI -} // namespace XCEngine \ No newline at end of file +} // namespace XCEngine diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h index 06d17742..bfa83802 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h @@ -59,6 +59,8 @@ public: RHIDescriptorPool* CreateDescriptorPool(const DescriptorPoolDesc& desc) override; RHIDescriptorSet* CreateDescriptorSet(RHIDescriptorPool* pool, const DescriptorSetLayoutDesc& layout) override; + RHIResourceView* CreateVertexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) override; + RHIResourceView* CreateIndexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) override; RHIResourceView* CreateRenderTargetView(RHITexture* texture, const ResourceViewDesc& desc) override; RHIResourceView* CreateDepthStencilView(RHITexture* texture, const ResourceViewDesc& desc) override; RHIResourceView* CreateShaderResourceView(RHITexture* texture, const ResourceViewDesc& desc) override; diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLResourceView.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLResourceView.h index c4e78a6c..62cb2987 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLResourceView.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLResourceView.h @@ -45,6 +45,12 @@ public: OpenGLBuffer* buffer, const ResourceViewDesc& desc, OpenGLUniformBufferManager* manager); + bool InitializeAsVertexBuffer( + OpenGLBuffer* buffer, + const ResourceViewDesc& desc); + bool InitializeAsIndexBuffer( + OpenGLBuffer* buffer, + const ResourceViewDesc& desc); ResourceViewType GetViewType() const override { return m_viewType; } ResourceViewDimension GetDimension() const override { return m_dimension; } @@ -54,6 +60,9 @@ public: int32_t GetBindingPoint() const { return m_bindingPoint; } unsigned int GetTexture() const; unsigned int GetBuffer() const; + uint64_t GetBufferOffset() const { return m_bufferOffset; } + uint32_t GetBufferSize() const { return m_bufferSize; } + uint32_t GetBufferStride() const { return m_bufferStride; } private: ResourceViewType m_viewType; @@ -67,7 +76,10 @@ private: OpenGLFramebuffer* m_framebuffer; OpenGLTextureUnitAllocator* m_textureUnitAllocator; OpenGLUniformBufferManager* m_uniformBufferManager; + uint64_t m_bufferOffset; + uint32_t m_bufferSize; + uint32_t m_bufferStride; }; } // namespace RHI -} // namespace XCEngine \ No newline at end of file +} // namespace XCEngine diff --git a/engine/include/XCEngine/RHI/RHIDevice.h b/engine/include/XCEngine/RHI/RHIDevice.h index 65fa8503..dc0716a4 100644 --- a/engine/include/XCEngine/RHI/RHIDevice.h +++ b/engine/include/XCEngine/RHI/RHIDevice.h @@ -57,6 +57,8 @@ public: virtual RHIDescriptorPool* CreateDescriptorPool(const DescriptorPoolDesc& desc) = 0; virtual RHIDescriptorSet* CreateDescriptorSet(RHIDescriptorPool* pool, const DescriptorSetLayoutDesc& layout) = 0; + virtual RHIResourceView* CreateVertexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) = 0; + virtual RHIResourceView* CreateIndexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) = 0; virtual RHIResourceView* CreateRenderTargetView(RHITexture* texture, const ResourceViewDesc& desc) = 0; virtual RHIResourceView* CreateDepthStencilView(RHITexture* texture, const ResourceViewDesc& desc) = 0; virtual RHIResourceView* CreateShaderResourceView(RHITexture* texture, const ResourceViewDesc& desc) = 0; diff --git a/engine/include/XCEngine/RHI/RHIEnums.h b/engine/include/XCEngine/RHI/RHIEnums.h index d024313e..dffe2314 100644 --- a/engine/include/XCEngine/RHI/RHIEnums.h +++ b/engine/include/XCEngine/RHI/RHIEnums.h @@ -278,6 +278,8 @@ enum class ResourceViewDimension : uint8_t { }; enum class ResourceViewType : uint8_t { + VertexBuffer, + IndexBuffer, RenderTarget, DepthStencil, ShaderResource, diff --git a/engine/src/RHI/D3D12/D3D12CommandList.cpp b/engine/src/RHI/D3D12/D3D12CommandList.cpp index eb810b71..882bcecf 100644 --- a/engine/src/RHI/D3D12/D3D12CommandList.cpp +++ b/engine/src/RHI/D3D12/D3D12CommandList.cpp @@ -408,9 +408,10 @@ void D3D12CommandList::SetVertexBuffers(uint32_t startSlot, uint32_t count, RHIR for (uint32_t i = 0; i < count; ++i) { if (buffers[i] && buffers[i]->IsValid()) { D3D12ResourceView* view = static_cast(buffers[i]); - views[i].BufferLocation = view->GetResource()->GetGPUVirtualAddress() + offsets[i]; - views[i].StrideInBytes = strides[i]; - views[i].SizeInBytes = static_cast(view->GetResource()->GetDesc().Width) - static_cast(offsets[i]); + const uint32_t stride = strides[i] > 0 ? strides[i] : view->GetBufferStride(); + views[i].BufferLocation = view->GetBufferLocation() + offsets[i]; + views[i].StrideInBytes = stride; + views[i].SizeInBytes = view->GetBufferSize() > offsets[i] ? view->GetBufferSize() - static_cast(offsets[i]) : 0; } } SetVertexBuffersInternal(startSlot, count, views.data()); @@ -431,7 +432,8 @@ void D3D12CommandList::SetVertexBuffer(uint32_t slot, ID3D12Resource* resource, void D3D12CommandList::SetIndexBuffer(RHIResourceView* buffer, uint64_t offset) { if (!buffer || !buffer->IsValid()) return; D3D12ResourceView* view = static_cast(buffer); - SetIndexBufferInternal(view->GetResource(), offset, Format::R32_UInt); + const Format format = view->GetFormat() == Format::Unknown ? Format::R32_UInt : view->GetFormat(); + SetIndexBufferInternal(view->GetResource(), view->GetBufferOffset() + offset, format); } void D3D12CommandList::SetIndexBuffer(ID3D12Resource* buffer, uint64_t offset, Format format) { diff --git a/engine/src/RHI/D3D12/D3D12Device.cpp b/engine/src/RHI/D3D12/D3D12Device.cpp index 2b099044..2b8a06d8 100644 --- a/engine/src/RHI/D3D12/D3D12Device.cpp +++ b/engine/src/RHI/D3D12/D3D12Device.cpp @@ -19,6 +19,7 @@ #include "XCEngine/RHI/D3D12/D3D12Framebuffer.h" #include #include +#include #ifdef _DEBUG #include @@ -27,6 +28,19 @@ namespace XCEngine { namespace RHI { +namespace { + +std::string NarrowAscii(const std::wstring& value) { + std::string result; + result.reserve(value.size()); + for (wchar_t ch : value) { + result.push_back(static_cast(ch)); + } + return result; +} + +} // namespace + D3D12Device::D3D12Device() : m_isDeviceRemoved(false) , m_initialized(false) @@ -293,14 +307,16 @@ RHITexture* D3D12Device::CreateTexture(const TextureDesc& desc) { RHIShader* D3D12Device::CreateShader(const ShaderCompileDesc& desc) { auto* shader = new D3D12Shader(); - const char* entryPoint = desc.entryPoint.empty() ? nullptr : reinterpret_cast(desc.entryPoint.c_str()); - const char* profile = desc.profile.empty() ? nullptr : reinterpret_cast(desc.profile.c_str()); + const std::string entryPoint = NarrowAscii(desc.entryPoint); + const std::string profile = NarrowAscii(desc.profile); + const char* entryPointPtr = entryPoint.empty() ? nullptr : entryPoint.c_str(); + const char* profilePtr = profile.empty() ? nullptr : profile.c_str(); bool success = false; if (!desc.source.empty()) { - success = shader->Compile(desc.source.data(), desc.source.size(), entryPoint, profile); + success = shader->Compile(desc.source.data(), desc.source.size(), entryPointPtr, profilePtr); } else if (!desc.fileName.empty()) { - success = shader->CompileFromFile(desc.fileName.c_str(), entryPoint, profile); + success = shader->CompileFromFile(desc.fileName.c_str(), entryPointPtr, profilePtr); } if (success) { @@ -386,6 +402,36 @@ RHIFence* D3D12Device::CreateFence(const FenceDesc& desc) { return nullptr; } +RHIResourceView* D3D12Device::CreateVertexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) { + if (!buffer) { + return nullptr; + } + + auto* view = new D3D12ResourceView(); + view->InitializeAsVertexBuffer(static_cast(buffer), desc); + if (!view->IsValid()) { + delete view; + return nullptr; + } + + return view; +} + +RHIResourceView* D3D12Device::CreateIndexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) { + if (!buffer) { + return nullptr; + } + + auto* view = new D3D12ResourceView(); + view->InitializeAsIndexBuffer(static_cast(buffer), desc); + if (!view->IsValid()) { + delete view; + return nullptr; + } + + return view; +} + RHISwapChain* D3D12Device::CreateSwapChain(const SwapChainDesc& desc, RHICommandQueue* presentQueue) { if (presentQueue == nullptr) { return nullptr; diff --git a/engine/src/RHI/D3D12/D3D12ResourceView.cpp b/engine/src/RHI/D3D12/D3D12ResourceView.cpp index c383f499..6c61590f 100644 --- a/engine/src/RHI/D3D12/D3D12ResourceView.cpp +++ b/engine/src/RHI/D3D12/D3D12ResourceView.cpp @@ -1,4 +1,5 @@ #include "XCEngine/RHI/D3D12/D3D12ResourceView.h" +#include "XCEngine/RHI/D3D12/D3D12Buffer.h" #include "XCEngine/RHI/D3D12/D3D12DescriptorHeap.h" namespace XCEngine { @@ -12,7 +13,11 @@ D3D12ResourceView::D3D12ResourceView() , m_resource(nullptr) , m_heap(nullptr) , m_slotIndex(0) - , m_ownedHeap(nullptr) { + , m_ownedHeap(nullptr) + , m_bufferLocation(0) + , m_bufferOffset(0) + , m_bufferSize(0) + , m_bufferStride(0) { } D3D12ResourceView::~D3D12ResourceView() { @@ -28,14 +33,30 @@ void D3D12ResourceView::Shutdown() { } m_heap = nullptr; m_slotIndex = 0; + m_bufferLocation = 0; + m_bufferOffset = 0; + m_bufferSize = 0; + m_bufferStride = 0; } void* D3D12ResourceView::GetNativeHandle() { - return reinterpret_cast(m_handle.ptr); + switch (m_viewType) { + case ResourceViewType::VertexBuffer: + case ResourceViewType::IndexBuffer: + return m_resource; + default: + return reinterpret_cast(m_handle.ptr); + } } bool D3D12ResourceView::IsValid() const { - return m_handle.ptr != 0 && m_resource != nullptr; + switch (m_viewType) { + case ResourceViewType::VertexBuffer: + case ResourceViewType::IndexBuffer: + return m_resource != nullptr; + default: + return m_handle.ptr != 0 && m_resource != nullptr; + } } void D3D12ResourceView::InitializeAsRenderTarget(ID3D12Device* device, ID3D12Resource* resource, @@ -113,6 +134,36 @@ void D3D12ResourceView::InitializeAsConstantBuffer(ID3D12Device* device, ID3D12R device->CreateConstantBufferView(desc, m_handle); } +void D3D12ResourceView::InitializeAsVertexBuffer(D3D12Buffer* buffer, const ResourceViewDesc& desc) { + if (buffer == nullptr) { + return; + } + + m_viewType = ResourceViewType::VertexBuffer; + m_format = Format::Unknown; + m_dimension = ResourceViewDimension::Buffer; + m_resource = buffer->GetResource(); + m_bufferOffset = desc.bufferLocation; + m_bufferLocation = buffer->GetGPUVirtualAddress() + desc.bufferLocation; + m_bufferSize = static_cast(buffer->GetSize() - desc.bufferLocation); + m_bufferStride = desc.structureByteStride > 0 ? desc.structureByteStride : buffer->GetStride(); +} + +void D3D12ResourceView::InitializeAsIndexBuffer(D3D12Buffer* buffer, const ResourceViewDesc& desc) { + if (buffer == nullptr) { + return; + } + + m_viewType = ResourceViewType::IndexBuffer; + m_format = desc.format != 0 ? static_cast(desc.format) : Format::R32_UInt; + m_dimension = ResourceViewDimension::Buffer; + m_resource = buffer->GetResource(); + m_bufferOffset = desc.bufferLocation; + m_bufferLocation = buffer->GetGPUVirtualAddress() + desc.bufferLocation; + m_bufferSize = static_cast(buffer->GetSize() - desc.bufferLocation); + m_bufferStride = buffer->GetStride(); +} + GPUDescriptorHandle D3D12ResourceView::GetGPUHandle() const { if (m_heap) { return m_heap->GetGPUDescriptorHandle(m_slotIndex); @@ -162,4 +213,4 @@ void D3D12ResourceView::SetOwnedHeap(std::unique_ptr heap) } } // namespace RHI -} // namespace XCEngine \ No newline at end of file +} // namespace XCEngine diff --git a/engine/src/RHI/OpenGL/OpenGLCommandList.cpp b/engine/src/RHI/OpenGL/OpenGLCommandList.cpp index 1d00776e..7e506c1a 100644 --- a/engine/src/RHI/OpenGL/OpenGLCommandList.cpp +++ b/engine/src/RHI/OpenGL/OpenGLCommandList.cpp @@ -641,7 +641,9 @@ void OpenGLCommandList::SetVertexBuffers(uint32_t startSlot, uint32_t count, RHI GLuint glBuffer = view->GetBuffer(); glBindBuffer(GL_ARRAY_BUFFER, glBuffer); glEnableVertexAttribArray(startSlot + i); - glVertexAttribPointer(startSlot + i, strides[i] / sizeof(float), GL_FLOAT, GL_FALSE, strides[i], reinterpret_cast(static_cast(offsets[i]))); + const uint32_t stride = strides[i] > 0 ? strides[i] : view->GetBufferStride(); + const uint64_t offset = view->GetBufferOffset() + offsets[i]; + glVertexAttribPointer(startSlot + i, stride / sizeof(float), GL_FLOAT, GL_FALSE, stride, reinterpret_cast(static_cast(offset))); } glBindBuffer(GL_ARRAY_BUFFER, 0); } diff --git a/engine/src/RHI/OpenGL/OpenGLDevice.cpp b/engine/src/RHI/OpenGL/OpenGLDevice.cpp index b20a3585..36a9902e 100644 --- a/engine/src/RHI/OpenGL/OpenGLDevice.cpp +++ b/engine/src/RHI/OpenGL/OpenGLDevice.cpp @@ -468,6 +468,34 @@ RHIDescriptorSet* OpenGLDevice::CreateDescriptorSet(RHIDescriptorPool* pool, con return pool->AllocateSet(layout); } +RHIResourceView* OpenGLDevice::CreateVertexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) { + if (!buffer) { + return nullptr; + } + + auto* view = new OpenGLResourceView(); + if (!view->InitializeAsVertexBuffer(static_cast(buffer), desc)) { + delete view; + return nullptr; + } + + return view; +} + +RHIResourceView* OpenGLDevice::CreateIndexBufferView(RHIBuffer* buffer, const ResourceViewDesc& desc) { + if (!buffer) { + return nullptr; + } + + auto* view = new OpenGLResourceView(); + if (!view->InitializeAsIndexBuffer(static_cast(buffer), desc)) { + delete view; + return nullptr; + } + + return view; +} + RHIResourceView* OpenGLDevice::CreateRenderTargetView(RHITexture* texture, const ResourceViewDesc& desc) { if (!texture) { return nullptr; diff --git a/engine/src/RHI/OpenGL/OpenGLResourceView.cpp b/engine/src/RHI/OpenGL/OpenGLResourceView.cpp index 1dd47138..3a7f572c 100644 --- a/engine/src/RHI/OpenGL/OpenGLResourceView.cpp +++ b/engine/src/RHI/OpenGL/OpenGLResourceView.cpp @@ -21,7 +21,10 @@ OpenGLResourceView::OpenGLResourceView() , m_buffer(nullptr) , m_framebuffer(nullptr) , m_textureUnitAllocator(nullptr) - , m_uniformBufferManager(nullptr) { + , m_uniformBufferManager(nullptr) + , m_bufferOffset(0) + , m_bufferSize(0) + , m_bufferStride(0) { } OpenGLResourceView::~OpenGLResourceView() { @@ -47,10 +50,16 @@ void OpenGLResourceView::Shutdown() { m_framebufferID = 0; m_texture = nullptr; m_buffer = nullptr; + m_bufferOffset = 0; + m_bufferSize = 0; + m_bufferStride = 0; } void* OpenGLResourceView::GetNativeHandle() { switch (m_viewType) { + case ResourceViewType::VertexBuffer: + case ResourceViewType::IndexBuffer: + return reinterpret_cast(static_cast(m_buffer ? m_buffer->GetID() : 0)); case ResourceViewType::RenderTarget: case ResourceViewType::DepthStencil: return reinterpret_cast(static_cast(m_framebufferID)); @@ -66,6 +75,9 @@ void* OpenGLResourceView::GetNativeHandle() { bool OpenGLResourceView::IsValid() const { switch (m_viewType) { + case ResourceViewType::VertexBuffer: + case ResourceViewType::IndexBuffer: + return m_buffer != nullptr && m_buffer->GetID() != 0; case ResourceViewType::RenderTarget: case ResourceViewType::DepthStencil: return m_framebufferID != 0; @@ -186,6 +198,40 @@ bool OpenGLResourceView::InitializeAsConstantBuffer( return true; } +bool OpenGLResourceView::InitializeAsVertexBuffer( + OpenGLBuffer* buffer, + const ResourceViewDesc& desc) { + if (!buffer) { + return false; + } + + m_viewType = ResourceViewType::VertexBuffer; + m_format = Format::Unknown; + m_dimension = ResourceViewDimension::Buffer; + m_buffer = buffer; + m_bufferOffset = desc.bufferLocation; + m_bufferSize = static_cast(buffer->GetSize()); + m_bufferStride = desc.structureByteStride > 0 ? desc.structureByteStride : buffer->GetStride(); + return true; +} + +bool OpenGLResourceView::InitializeAsIndexBuffer( + OpenGLBuffer* buffer, + const ResourceViewDesc& desc) { + if (!buffer) { + return false; + } + + m_viewType = ResourceViewType::IndexBuffer; + m_format = desc.format != 0 ? static_cast(desc.format) : Format::R32_UInt; + m_dimension = ResourceViewDimension::Buffer; + m_buffer = buffer; + m_bufferOffset = desc.bufferLocation; + m_bufferSize = static_cast(buffer->GetSize()); + m_bufferStride = buffer->GetStride(); + return true; +} + unsigned int OpenGLResourceView::GetFramebuffer() const { return m_framebuffer ? m_framebuffer->GetFramebuffer() : 0; } @@ -199,4 +245,4 @@ unsigned int OpenGLResourceView::GetBuffer() const { } } // namespace RHI -} // namespace XCEngine \ No newline at end of file +} // namespace XCEngine diff --git a/tests/RHI/unit/test_command_list.cpp b/tests/RHI/unit/test_command_list.cpp index 97a6d933..d7ee2741 100644 --- a/tests/RHI/unit/test_command_list.cpp +++ b/tests/RHI/unit/test_command_list.cpp @@ -144,6 +144,73 @@ TEST_P(RHITestFixture, CommandList_DrawIndexed) { delete cmdList; } +TEST_P(RHITestFixture, CommandList_SetVertexBuffers_WithRealView) { + BufferDesc bufferDesc = {}; + bufferDesc.size = 256; + bufferDesc.stride = 32; + bufferDesc.bufferType = static_cast(BufferType::Vertex); + + RHIBuffer* buffer = GetDevice()->CreateBuffer(bufferDesc); + ASSERT_NE(buffer, nullptr); + + ResourceViewDesc viewDesc = {}; + viewDesc.dimension = ResourceViewDimension::Buffer; + viewDesc.structureByteStride = 32; + RHIResourceView* vbv = GetDevice()->CreateVertexBufferView(buffer, viewDesc); + ASSERT_NE(vbv, nullptr); + + CommandListDesc cmdDesc = {}; + cmdDesc.commandListType = static_cast(CommandQueueType::Direct); + RHICommandList* cmdList = GetDevice()->CreateCommandList(cmdDesc); + ASSERT_NE(cmdList, nullptr); + + uint64_t offsets[] = { 0 }; + uint32_t strides[] = { 32 }; + + cmdList->Reset(); + cmdList->SetVertexBuffers(0, 1, &vbv, offsets, strides); + cmdList->Close(); + + cmdList->Shutdown(); + delete cmdList; + vbv->Shutdown(); + delete vbv; + buffer->Shutdown(); + delete buffer; +} + +TEST_P(RHITestFixture, CommandList_SetIndexBuffer_WithRealView) { + BufferDesc bufferDesc = {}; + bufferDesc.size = 256; + bufferDesc.stride = sizeof(uint32_t); + bufferDesc.bufferType = static_cast(BufferType::Index); + + RHIBuffer* buffer = GetDevice()->CreateBuffer(bufferDesc); + ASSERT_NE(buffer, nullptr); + + ResourceViewDesc viewDesc = {}; + viewDesc.dimension = ResourceViewDimension::Buffer; + viewDesc.format = static_cast(Format::R32_UInt); + RHIResourceView* ibv = GetDevice()->CreateIndexBufferView(buffer, viewDesc); + ASSERT_NE(ibv, nullptr); + + CommandListDesc cmdDesc = {}; + cmdDesc.commandListType = static_cast(CommandQueueType::Direct); + RHICommandList* cmdList = GetDevice()->CreateCommandList(cmdDesc); + ASSERT_NE(cmdList, nullptr); + + cmdList->Reset(); + cmdList->SetIndexBuffer(ibv, 0); + cmdList->Close(); + + cmdList->Shutdown(); + delete cmdList; + ibv->Shutdown(); + delete ibv; + buffer->Shutdown(); + delete buffer; +} + TEST_P(RHITestFixture, CommandList_SetStencilRef) { CommandListDesc cmdDesc = {}; cmdDesc.commandListType = static_cast(CommandQueueType::Direct); @@ -454,4 +521,3 @@ TEST_P(RHITestFixture, CommandList_SetShader) { shader->Shutdown(); delete shader; } - diff --git a/tests/RHI/unit/test_views.cpp b/tests/RHI/unit/test_views.cpp index bd0ed8fc..efd7619f 100644 --- a/tests/RHI/unit/test_views.cpp +++ b/tests/RHI/unit/test_views.cpp @@ -1,4 +1,5 @@ #include "fixtures/RHITestFixture.h" +#include "XCEngine/RHI/RHIBuffer.h" #include "XCEngine/RHI/RHIResourceView.h" #include "XCEngine/RHI/RHITexture.h" @@ -121,6 +122,56 @@ TEST_P(RHITestFixture, Device_CreateUnorderedAccessView) { delete texture; } +TEST_P(RHITestFixture, Device_CreateVertexBufferView) { + BufferDesc bufferDesc = {}; + bufferDesc.size = 256; + bufferDesc.stride = 32; + bufferDesc.bufferType = static_cast(BufferType::Vertex); + + RHIBuffer* buffer = GetDevice()->CreateBuffer(bufferDesc); + ASSERT_NE(buffer, nullptr); + + ResourceViewDesc viewDesc = {}; + viewDesc.dimension = ResourceViewDimension::Buffer; + viewDesc.structureByteStride = 32; + + RHIResourceView* vbv = GetDevice()->CreateVertexBufferView(buffer, viewDesc); + ASSERT_NE(vbv, nullptr); + EXPECT_TRUE(vbv->IsValid()); + EXPECT_EQ(vbv->GetViewType(), ResourceViewType::VertexBuffer); + EXPECT_EQ(vbv->GetDimension(), ResourceViewDimension::Buffer); + + vbv->Shutdown(); + delete vbv; + buffer->Shutdown(); + delete buffer; +} + +TEST_P(RHITestFixture, Device_CreateIndexBufferView) { + BufferDesc bufferDesc = {}; + bufferDesc.size = 256; + bufferDesc.stride = sizeof(uint32_t); + bufferDesc.bufferType = static_cast(BufferType::Index); + + RHIBuffer* buffer = GetDevice()->CreateBuffer(bufferDesc); + ASSERT_NE(buffer, nullptr); + + ResourceViewDesc viewDesc = {}; + viewDesc.dimension = ResourceViewDimension::Buffer; + viewDesc.format = static_cast(Format::R32_UInt); + + RHIResourceView* ibv = GetDevice()->CreateIndexBufferView(buffer, viewDesc); + ASSERT_NE(ibv, nullptr); + EXPECT_TRUE(ibv->IsValid()); + EXPECT_EQ(ibv->GetViewType(), ResourceViewType::IndexBuffer); + EXPECT_EQ(ibv->GetDimension(), ResourceViewDimension::Buffer); + + ibv->Shutdown(); + delete ibv; + buffer->Shutdown(); + delete buffer; +} + TEST_P(RHITestFixture, Device_CreateRenderTargetView_Multiple) { TextureDesc texDesc = {}; texDesc.width = 256; @@ -244,4 +295,4 @@ TEST_P(RHITestFixture, Device_CreateDepthStencilView_MipLevels) { texture->Shutdown(); delete texture; -} \ No newline at end of file +}