RHI: Removed "Rhi::IResource::setDebugName()" and added an optional p…

…arameter for resource creation to be able to set the resource debug name at once and only once

Example/Source/Examples/Private/Basics/FirstTriangle/FirstTriangle.cpp

@@ -53,7 +53,7 @@ void FirstTriangle::onInitialization()
 			rootSignature.initialize(0, nullptr, 0, nullptr, Rhi::RootSignatureFlags::ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
 
 			// Create the instance
-			mRootSignature = rhi->createRootSignature(rootSignature);
+			mRootSignature = rhi->createRootSignature(rootSignature RHI_RESOURCE_DEBUG_NAME("Triangle"));
 		}
 
 		// Vertex input layout
@@ -83,8 +83,7 @@ void FirstTriangle::onInitialization()
 				 1.0f, 0.0f,	// 1			   .   .
 				-0.5f, 0.0f		// 2			  2.......1
 			};
-			Rhi::IVertexBufferPtr vertexBuffer(mBufferManager->createVertexBuffer(sizeof(VERTEX_POSITION), VERTEX_POSITION));
-			RHI_SET_RESOURCE_DEBUG_NAME(vertexBuffer, "Triangle VBO")
+			Rhi::IVertexBufferPtr vertexBuffer(mBufferManager->createVertexBuffer(sizeof(VERTEX_POSITION), VERTEX_POSITION, 0, Rhi::BufferUsage::STATIC_DRAW RHI_RESOURCE_DEBUG_NAME("Triangle")));
 
 			// Create vertex array object (VAO)
 			// -> The vertex array object (VAO) keeps a reference to the used vertex buffer object (VBO)
@@ -93,8 +92,7 @@ void FirstTriangle::onInitialization()
 			//    reference of the used vertex buffer objects (VBO). If the reference counter of a
 			//    vertex buffer object (VBO) reaches zero, it's automatically destroyed.
 			const Rhi::VertexArrayVertexBuffer vertexArrayVertexBuffers[] = { vertexBuffer };
-			mVertexArray = mBufferManager->createVertexArray(vertexAttributes, static_cast<uint32_t>(GLM_COUNTOF(vertexArrayVertexBuffers)), vertexArrayVertexBuffers);
-			RHI_SET_RESOURCE_DEBUG_NAME(mVertexArray, "Triangle VAO")
+			mVertexArray = mBufferManager->createVertexArray(vertexAttributes, static_cast<uint32_t>(GLM_COUNTOF(vertexArrayVertexBuffers)), vertexArrayVertexBuffers, nullptr RHI_RESOURCE_DEBUG_NAME("Triangle"));
 		}
 
 		{
@@ -110,25 +108,20 @@ void FirstTriangle::onInitialization()
 				#include "FirstTriangle_HLSL_D3D9_D3D10_D3D11_D3D12.h"
 				#include "FirstTriangle_Null.h"
 
-				// Create the vertex shader
-				Rhi::IShaderLanguage& shaderLanguage = rhi->getDefaultShaderLanguage();
-				Rhi::IVertexShader* vertexShader = shaderLanguage.createVertexShaderFromSourceCode(vertexAttributes, vertexShaderSourceCode);
-				RHI_SET_RESOURCE_DEBUG_NAME(vertexShader, "Triangle VS")
-
-				// Create the fragment shader
-				Rhi::IFragmentShader* fragmentShader = shaderLanguage.createFragmentShaderFromSourceCode(fragmentShaderSourceCode);
-				RHI_SET_RESOURCE_DEBUG_NAME(fragmentShader, "Triangle FS")
-
 				// Create the graphics program
-				graphicsProgram = shaderLanguage.createGraphicsProgram(*mRootSignature, vertexAttributes, vertexShader, fragmentShader);
-				RHI_SET_RESOURCE_DEBUG_NAME(graphicsProgram, "Triangle graphics program")
+				Rhi::IShaderLanguage& shaderLanguage = rhi->getDefaultShaderLanguage();
+				graphicsProgram = shaderLanguage.createGraphicsProgram(
+					*mRootSignature,
+					vertexAttributes,
+					shaderLanguage.createVertexShaderFromSourceCode(vertexAttributes, vertexShaderSourceCode, nullptr RHI_RESOURCE_DEBUG_NAME("Triangle")),
+					shaderLanguage.createFragmentShaderFromSourceCode(fragmentShaderSourceCode, nullptr RHI_RESOURCE_DEBUG_NAME("Triangle"))
+					RHI_RESOURCE_DEBUG_NAME("Triangle"));
 			}
 
 			// Create the graphics pipeline state object (PSO)
 			if (nullptr != graphicsProgram)
 			{
-				mGraphicsPipelineState = rhi->createGraphicsPipelineState(Rhi::GraphicsPipelineStateBuilder(mRootSignature, graphicsProgram, vertexAttributes, getMainRenderTarget()->getRenderPass()));
-				RHI_SET_RESOURCE_DEBUG_NAME(mGraphicsPipelineState, "Triangle PSO")
+				mGraphicsPipelineState = rhi->createGraphicsPipelineState(Rhi::GraphicsPipelineStateBuilder(mRootSignature, graphicsProgram, vertexAttributes, getMainRenderTarget()->getRenderPass()) RHI_RESOURCE_DEBUG_NAME("Triangle"));
 			}
 		}
 

Example/Source/Examples/Private/Framework/IApplicationRhi.cpp

@@ -228,11 +228,10 @@ void IApplicationRhi::createRhi()
 	{
 		// Create render pass using the preferred swap chain texture format
 		const Rhi::Capabilities& capabilities = mRhi->getCapabilities();
-		Rhi::IRenderPass* renderPass = mRhi->createRenderPass(1, &capabilities.preferredSwapChainColorTextureFormat, capabilities.preferredSwapChainDepthStencilTextureFormat);
+		Rhi::IRenderPass* renderPass = mRhi->createRenderPass(1, &capabilities.preferredSwapChainColorTextureFormat, capabilities.preferredSwapChainDepthStencilTextureFormat, 1 RHI_RESOURCE_DEBUG_NAME("Main"));
 
 		// Create a main swap chain instance
-		mMainSwapChain = mRhi->createSwapChain(*renderPass, Rhi::WindowHandle{getNativeWindowHandle(), nullptr, nullptr}, mRhi->getContext().isUsingExternalContext());
-		RHI_SET_RESOURCE_DEBUG_NAME(mMainSwapChain, "Main swap chain")
+		mMainSwapChain = mRhi->createSwapChain(*renderPass, Rhi::WindowHandle{getNativeWindowHandle(), nullptr, nullptr}, mRhi->getContext().isUsingExternalContext() RHI_RESOURCE_DEBUG_NAME("Main"));
 		mMainSwapChain->addReference();	// Internal RHI reference
 	}
 }

README.md

@@ -41,10 +41,11 @@ Features
 			- Efficiency and responsiveness over flexibility (were it isn't useful in practice)
 			- Intended to be controlled by a high-level entity-component system, no unused implementation feature overkill in the basic renderer
 		- Toolkit designed with developer fast iterations in mind: Asset source flexibility, asset background compilation, hot-reloading
-	- Interfaces for log, assert, memory allocator, graphics debugger and profiler so the user has the control over those things
+	- Interfaces for log, assert, memory allocator, graphics debugger, profiler and file so the user has the control over those things
 		- Standard implementations are provided
 		- Standard graphics debugger implementation using [RenderDoc](https://renderdoc.org/) is provided
 		- Standard profiler implementation using [Remotery](https://github.com/Celtoys/Remotery) is provided
+		- Standard file implementation using UTF-8 STD file streams as well as [PhysicsFS](https://icculus.org/physfs/) for shipping packed asset packages are provided
 - Cross-platform
 	- Microsoft Windows x86 and x64
 	- Currently unmaintained
@@ -87,7 +88,7 @@ Rendering hardware interface (RHI) and implementations
 		- Vertex buffer object (VBO, input-assembler (IA) stage)
 		- Index buffer object (IBO, input-assembler (IA) stage)
 	- Texture buffer object (TBO)
-	- Structured buffer object
+	- Structured buffer object (SBO)
 	- Indirect buffer object with optional internal emulation, draw methods always use an indirect buffer to have an unified draw call API
 	- Uniform buffer object (UBO, "constant buffer" in Direct3D terminology)
 	- Command buffer mandatory by design, not just build on top
@@ -101,7 +102,7 @@ Rendering hardware interface (RHI) and implementations
 - Instancing support
 	- Instanced arrays (shader model 3 feature, vertex array element advancing per-instance instead of per-vertex)
 	- Draw instanced (shader model 4 feature, build in shader variable holding the current instance ID)
-- Debug methods
+- Debug methods and RHI debug resource names
 	- When using Direct3D <11.1, those methods map to the Direct3D 9 PIX functions (D3DPERF_* functions, also works directly within VisualStudio 2019 out-of-the-box)
 	- Used inside the RHI implementations for better RHI debugging
 - Supported asynchronous queries: Occlusion, pipeline statistics and timestamp
@@ -143,8 +144,6 @@ Renderer (e.g. "The Game")
 	- Animated controller visualization supported
 	- Single pass stereo rendering via instancing
 	- Hidden area mesh supported
-- Abstract file interface so the Unrimp user has control over the file handling
-	- Optional header-only standard implementations for UTF-8 STD file streams as well as [PhysicsFS](https://icculus.org/physfs/) for shipping packed asset packages are provided
 - Texture top mipmap removal support while loading textures for efficient texture quality reduction
 - Light
 	- Types: Directional, point and spot
@@ -241,6 +240,7 @@ Terminology and Acronyms
 	- Vertex array object (VAO)
 	- Uniform buffer object (UBO), "constant buffer" in Direct3D terminology
 	- Texture buffer object (TBO)
+	- Structured buffer object (SBO)
 	- Sampler state object (SO)
 	- Root signature (Direct3D terminology) = pipeline layout in Vulkan terminology
 	- Pipeline state object (PSO, there's a graphics PSO and a compute PSO)

Source/Renderer/Public/Context.h

@@ -207,11 +207,11 @@ namespace Renderer
 	//[ Private data                                          ]
 	//[-------------------------------------------------------]
 	private:
-		Rhi::ILog&			  mLog;
-		Rhi::IAssert&		  mAssert;
-		Rhi::IAllocator&	  mAllocator;
-		Rhi::IRhi&			  mRhi;
-		IFileManager&		  mFileManager;
+		Rhi::ILog&		 mLog;
+		Rhi::IAssert&	 mAssert;
+		Rhi::IAllocator& mAllocator;
+		Rhi::IRhi&		 mRhi;
+		IFileManager&	 mFileManager;
 		#ifdef RENDERER_GRAPHICS_DEBUGGER
 			IGraphicsDebugger& mGraphicsDebugger;
 		#endif

Source/Renderer/Public/Core/Renderer/FramebufferManager.cpp

@@ -203,8 +203,7 @@ namespace Renderer
 
 						// Create the framebuffer object (FBO) instance
 						// -> The framebuffer automatically adds a reference to the provided textures
-						framebufferElement.framebuffer = mRenderTargetTextureManager.getRenderer().getRhi().createFramebuffer(*renderPass, colorFramebufferAttachments, (nullptr != depthStencilFramebufferAttachment.texture) ? &depthStencilFramebufferAttachment : nullptr);
-						RHI_SET_RESOURCE_DEBUG_NAME(framebufferElement.framebuffer, "Framebuffer manager")
+						framebufferElement.framebuffer = mRenderTargetTextureManager.getRenderer().getRhi().createFramebuffer(*renderPass, colorFramebufferAttachments, ((nullptr != depthStencilFramebufferAttachment.texture) ? &depthStencilFramebufferAttachment : nullptr) RHI_RESOURCE_DEBUG_NAME("Framebuffer manager"));
 						framebufferElement.framebuffer->addReference();
 					}
 					framebuffer = framebufferElement.framebuffer;

Source/Renderer/Public/Core/Renderer/RenderPassManager.cpp

@@ -65,7 +65,7 @@ namespace Renderer
 		else
 		{
 			// Create the render pass instance
-			Rhi::IRenderPass* renderPass = mRhi.createRenderPass(numberOfColorAttachments, colorAttachmentTextureFormats, depthStencilAttachmentTextureFormat, numberOfMultisamples);
+			Rhi::IRenderPass* renderPass = mRhi.createRenderPass(numberOfColorAttachments, colorAttachmentTextureFormats, depthStencilAttachmentTextureFormat, numberOfMultisamples RHI_RESOURCE_DEBUG_NAME("Render pass manager"));
 			renderPass->addReference();
 			mRenderPasses.emplace(renderPassSignature, renderPass);
 			return renderPass;

Source/Renderer/Public/Core/Renderer/RenderTargetTextureManager.cpp

@@ -207,8 +207,7 @@ namespace Renderer
 					// -> Required for Vulkan, Direct3D 9, Direct3D 10, Direct3D 11 and Direct3D 12
 					// -> Not required for OpenGL and OpenGL ES 3
 					// -> The optimized texture clear value is a Direct3D 12 related option
-					renderTargetTextureElement.texture = mRenderer.getTextureManager().createTexture2D(width, height, renderTargetTextureSignature.getTextureFormat(), nullptr, textureFlags, Rhi::TextureUsage::DEFAULT, ((renderTargetTextureSignature.getFlags() & RenderTargetTextureSignature::Flag::ALLOW_MULTISAMPLE) != 0) ? numberOfMultisamples : 1u);
-					RHI_SET_RESOURCE_DEBUG_NAME(renderTargetTextureElement.texture, "Render target texture manager")
+					renderTargetTextureElement.texture = mRenderer.getTextureManager().createTexture2D(width, height, renderTargetTextureSignature.getTextureFormat(), nullptr, textureFlags, Rhi::TextureUsage::DEFAULT, (((renderTargetTextureSignature.getFlags() & RenderTargetTextureSignature::Flag::ALLOW_MULTISAMPLE) != 0) ? numberOfMultisamples : 1u), nullptr RHI_RESOURCE_DEBUG_NAME("Render target texture manager"));
 					renderTargetTextureElement.texture->addReference();
 
 					{ // Tell the texture resource manager about our render target texture so it can be referenced inside e.g. compositor nodes

Source/Renderer/Public/DebugGui/DebugGuiManager.cpp

@@ -185,15 +185,13 @@ namespace Renderer
 				if (nullptr == mVertexBufferPtr || mNumberOfAllocatedVertices < static_cast<uint32_t>(imDrawData->TotalVtxCount))
 				{
 					mNumberOfAllocatedVertices = static_cast<uint32_t>(imDrawData->TotalVtxCount + 5000);	// Add some reserve to reduce reallocations
-					mVertexBufferPtr = bufferManager.createVertexBuffer(mNumberOfAllocatedVertices * sizeof(ImDrawVert), nullptr, 0, Rhi::BufferUsage::DYNAMIC_DRAW);
-					RHI_SET_RESOURCE_DEBUG_NAME(mVertexBufferPtr, "Debug GUI")
+					mVertexBufferPtr = bufferManager.createVertexBuffer(mNumberOfAllocatedVertices * sizeof(ImDrawVert), nullptr, 0, Rhi::BufferUsage::DYNAMIC_DRAW RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 					mVertexArrayPtr = nullptr;
 				}
 				if (nullptr == mIndexBufferPtr || mNumberOfAllocatedIndices < static_cast<uint32_t>(imDrawData->TotalIdxCount))
 				{
 					mNumberOfAllocatedIndices = static_cast<uint32_t>(imDrawData->TotalIdxCount + 10000);	// Add some reserve to reduce reallocations
-					mIndexBufferPtr = bufferManager.createIndexBuffer(mNumberOfAllocatedIndices * sizeof(ImDrawIdx), nullptr, 0, Rhi::BufferUsage::DYNAMIC_DRAW);
-					RHI_SET_RESOURCE_DEBUG_NAME(mIndexBufferPtr, "Debug GUI")
+					mIndexBufferPtr = bufferManager.createIndexBuffer(mNumberOfAllocatedIndices * sizeof(ImDrawIdx), nullptr, 0, Rhi::BufferUsage::DYNAMIC_DRAW, Rhi::IndexBufferFormat::UNSIGNED_SHORT RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 					mVertexArrayPtr = nullptr;
 				}
 				if (nullptr == mVertexArrayPtr)
@@ -203,8 +201,7 @@ namespace Renderer
 
 					// Create vertex array object (VAO)
 					const Rhi::VertexArrayVertexBuffer vertexArrayVertexBuffers[] = { mVertexBufferPtr };
-					mVertexArrayPtr = bufferManager.createVertexArray(::detail::VertexAttributes, static_cast<uint32_t>(GLM_COUNTOF(vertexArrayVertexBuffers)), vertexArrayVertexBuffers, mIndexBufferPtr);
-					RHI_SET_RESOURCE_DEBUG_NAME(mVertexArrayPtr, "Debug GUI")
+					mVertexArrayPtr = bufferManager.createVertexArray(::detail::VertexAttributes, static_cast<uint32_t>(GLM_COUNTOF(vertexArrayVertexBuffers)), vertexArrayVertexBuffers, mIndexBufferPtr RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 				}
 
 				{ // Copy and convert all vertices and indices into a single contiguous buffer
@@ -355,8 +352,7 @@ namespace Renderer
 			ImGui::GetIO().Fonts->GetTexDataAsAlpha8(&pixels, &width, &height);
 
 			// Upload texture to RHI
-			mTexture2D = mRenderer.getTextureManager().createTexture2D(static_cast<uint32_t>(width), static_cast<uint32_t>(height), Rhi::TextureFormat::R8, pixels, Rhi::TextureFlag::GENERATE_MIPMAPS | Rhi::TextureFlag::SHADER_RESOURCE);
-			RHI_SET_RESOURCE_DEBUG_NAME(mTexture2D, "Debug 2D GUI glyph texture atlas")
+			mTexture2D = mRenderer.getTextureManager().createTexture2D(static_cast<uint32_t>(width), static_cast<uint32_t>(height), Rhi::TextureFormat::R8, pixels, Rhi::TextureFlag::GENERATE_MIPMAPS | Rhi::TextureFlag::SHADER_RESOURCE, Rhi::TextureUsage::DEFAULT, 1, nullptr RHI_RESOURCE_DEBUG_NAME("Debug 2D GUI glyph texture atlas"));
 
 			// Tell the texture resource manager about our render target texture so it can be referenced inside e.g. compositor nodes
 			mRenderer.getTextureResourceManager().createTextureResourceByAssetId(ASSET_ID("Unrimp/Texture/DynamicByCode/ImGuiGlyphMap2D"), *mTexture2D);
@@ -428,8 +424,7 @@ namespace Renderer
 			rootSignature.initialize(static_cast<uint32_t>(GLM_COUNTOF(rootParameters)), rootParameters, 0, nullptr, Rhi::RootSignatureFlags::ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT);
 
 			// Create the instance
-			mRootSignature = rhi.createRootSignature(rootSignature);
-			RHI_SET_RESOURCE_DEBUG_NAME(mRootSignature, "Debug GUI")
+			mRootSignature = rhi.createRootSignature(rootSignature RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 		}
 
 		{ // Create the graphics pipeline state instance
@@ -444,27 +439,21 @@ namespace Renderer
 				#include "Detail/Shader/DebugGui_HLSL_D3D10_D3D11_D3D12.h"
 				#include "Detail/Shader/DebugGui_Null.h"
 
-				// Create the shaders
-				Rhi::IShaderLanguage& shaderLanguage = rhi.getDefaultShaderLanguage();
-				Rhi::IVertexShader* vertexShader = shaderLanguage.createVertexShaderFromSourceCode(::detail::VertexAttributes, vertexShaderSourceCode);
-				RHI_SET_RESOURCE_DEBUG_NAME(vertexShader, "Debug GUI")
-				Rhi::IFragmentShader* fragmentShader = shaderLanguage.createFragmentShaderFromSourceCode(fragmentShaderSourceCode);
-				RHI_SET_RESOURCE_DEBUG_NAME(fragmentShader, "Debug GUI")
-
 				// Create the graphics program
+				Rhi::IShaderLanguage& shaderLanguage = rhi.getDefaultShaderLanguage();
 				mGraphicsProgram = shaderLanguage.createGraphicsProgram(
 					*mRootSignature,
 					::detail::VertexAttributes,
-					vertexShader,
-					fragmentShader);
-				RHI_SET_RESOURCE_DEBUG_NAME(mGraphicsProgram, "Debug GUI")
+					shaderLanguage.createVertexShaderFromSourceCode(::detail::VertexAttributes, vertexShaderSourceCode, nullptr RHI_RESOURCE_DEBUG_NAME("Debug GUI")),
+					shaderLanguage.createFragmentShaderFromSourceCode(fragmentShaderSourceCode, nullptr RHI_RESOURCE_DEBUG_NAME("Debug GUI"))
+					RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 			}
 
 			// Create the graphics pipeline state object (PSO)
 			if (nullptr != mGraphicsProgram)
 			{
 				// TODO(co) Render pass related update, the render pass in here is currently just a dummy so the debug compositor works
-				Rhi::IRenderPass* renderPass = rhi.createRenderPass(1, &rhi.getCapabilities().preferredSwapChainColorTextureFormat, rhi.getCapabilities().preferredSwapChainDepthStencilTextureFormat);
+				Rhi::IRenderPass* renderPass = rhi.createRenderPass(1, &rhi.getCapabilities().preferredSwapChainColorTextureFormat, rhi.getCapabilities().preferredSwapChainDepthStencilTextureFormat, 1 RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 
 				Rhi::GraphicsPipelineState graphicsPipelineState = Rhi::GraphicsPipelineStateBuilder(mRootSignature, mGraphicsProgram, ::detail::VertexAttributes, *renderPass);
 				graphicsPipelineState.rasterizerState.cullMode				   = Rhi::CullMode::NONE;
@@ -475,16 +464,14 @@ namespace Renderer
 				graphicsPipelineState.blendState.renderTarget[0].srcBlend	   = Rhi::Blend::SRC_ALPHA;
 				graphicsPipelineState.blendState.renderTarget[0].destBlend	   = Rhi::Blend::INV_SRC_ALPHA;
 				graphicsPipelineState.blendState.renderTarget[0].srcBlendAlpha = Rhi::Blend::INV_SRC_ALPHA;
-				mGraphicsPipelineState = rhi.createGraphicsPipelineState(graphicsPipelineState);
-				RHI_SET_RESOURCE_DEBUG_NAME(mGraphicsPipelineState, "Debug GUI")
+				mGraphicsPipelineState = rhi.createGraphicsPipelineState(graphicsPipelineState RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 			}
 		}
 
 		// Create vertex uniform buffer instance
 		if (rhi.getCapabilities().maximumUniformBufferSize > 0)
 		{
-			mVertexShaderUniformBuffer = mRenderer.getBufferManager().createUniformBuffer(sizeof(float) * 4 * 4, nullptr, Rhi::BufferUsage::DYNAMIC_DRAW);
-			RHI_SET_RESOURCE_DEBUG_NAME(mVertexShaderUniformBuffer, "Debug GUI")
+			mVertexShaderUniformBuffer = mRenderer.getBufferManager().createUniformBuffer(sizeof(float) * 4 * 4, nullptr, Rhi::BufferUsage::DYNAMIC_DRAW RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 		}
 		else if (nullptr != mGraphicsProgram)
 		{
@@ -497,15 +484,14 @@ namespace Renderer
 			Rhi::SamplerState samplerState = Rhi::ISamplerState::getDefaultSamplerState();
 			samplerState.addressU = Rhi::TextureAddressMode::WRAP;
 			samplerState.addressV = Rhi::TextureAddressMode::WRAP;
-			samplerStateResource = rhi.createSamplerState(samplerState);
-			RHI_SET_RESOURCE_DEBUG_NAME(samplerStateResource, "Debug GUI")
-			mSamplerStateGroup = mRootSignature->createResourceGroup(1, 1, &samplerStateResource);
+			samplerStateResource = rhi.createSamplerState(samplerState RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
+			mSamplerStateGroup = mRootSignature->createResourceGroup(1, 1, &samplerStateResource, nullptr RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 		}
 
 		{ // Create resource group
 			Rhi::IResource* resources[2] = { mVertexShaderUniformBuffer, mTexture2D };
 			Rhi::ISamplerState* samplerStates[2] = { nullptr, static_cast<Rhi::ISamplerState*>(samplerStateResource) };
-			mResourceGroup = mRootSignature->createResourceGroup(0, static_cast<uint32_t>(GLM_COUNTOF(resources)), resources, samplerStates);
+			mResourceGroup = mRootSignature->createResourceGroup(0, static_cast<uint32_t>(GLM_COUNTOF(resources)), resources, samplerStates RHI_RESOURCE_DEBUG_NAME("Debug GUI"));
 		}
 	}
 

Source/Renderer/Public/IRenderer.h

@@ -528,6 +528,7 @@ namespace Renderer
 			mAssetManager(nullptr),
 			mTimeManager(nullptr),
 			// Resource
+			mRendererResourceManager(nullptr),
 			mResourceStreamer(nullptr),
 			mVertexAttributesResourceManager(nullptr),
 			mTextureResourceManager(nullptr),