add wireframe mode

Engine/Source/Editor/ECWorld/ECWorldConsumer.cpp

@@ -199,6 +199,7 @@ void ECWorldConsumer::AddStaticMesh(engine::Entity entity, const cd::Mesh& mesh,
 	staticMeshComponent.SetMeshData(&mesh);
 	staticMeshComponent.SetRequiredVertexFormat(&vertexFormat);
 	staticMeshComponent.Build();
+	staticMeshComponent.Submit();
 }
 
 void ECWorldConsumer::AddSkinMesh(engine::Entity entity, const cd::Mesh& mesh, const cd::VertexFormat& vertexFormat)

Engine/Source/Editor/EditorApp.cpp

@@ -16,7 +16,7 @@
 #ifdef ENABLE_DDGI
 #include "Rendering/DDGIRenderer.h"
 #endif
-#include "Rendering/DebugRenderer.h"
+#include "Rendering/WhiteModelRenderer.h"
 #include "Rendering/ImGuiRenderer.h"
 #include "Rendering/PBRSkyRenderer.h"
 #include "Rendering/BloomRenderer.h"
@@ -169,7 +169,7 @@ void EditorApp::InitEditorUILayers()
 	m_pSceneView = pSceneView.get();
 	pSceneView->SetCameraController(m_pViewportCameraController.get());
 	pSceneView->SetSceneRenderer(m_pSceneRenderer);
-	pSceneView->SetDebugRenderer(m_pDebugRenderer);
+	pSceneView->SetWhiteModelRenderer(m_pWhiteModelRenderer);
 	pSceneView->SetAABBRenderer(m_pAABBRenderer);
 	m_pEditorImGuiContext->AddDynamicLayer(cd::MoveTemp(pSceneView));
 
@@ -319,6 +319,7 @@ void EditorApp::InitSkyEntity()
 	meshComponent.SetMeshData(&optMesh.value());
 	meshComponent.SetRequiredVertexFormat(&vertexFormat);
 	meshComponent.Build();
+	meshComponent.Submit();
 }
 
 void EditorApp::InitShaderVariantCollectionEntity()
@@ -403,11 +404,11 @@ void EditorApp::InitEngineRenderers()
 	pAnimationRenderer->SetSceneWorld(m_pSceneWorld.get());
 	AddEngineRenderer(cd::MoveTemp(pAnimationRenderer));
 
-	auto pDebugRenderer = std::make_unique<engine::DebugRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
-	m_pDebugRenderer = pDebugRenderer.get();
-	pDebugRenderer->SetSceneWorld(m_pSceneWorld.get());
-	pDebugRenderer->SetEnable(false);
-	AddEngineRenderer(cd::MoveTemp(pDebugRenderer));
+	auto pWhiteModelRenderer = std::make_unique<engine::WhiteModelRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
+	m_pWhiteModelRenderer = pWhiteModelRenderer.get();
+	pWhiteModelRenderer->SetSceneWorld(m_pSceneWorld.get());
+	pWhiteModelRenderer->SetEnable(false);
+	AddEngineRenderer(cd::MoveTemp(pWhiteModelRenderer));
 
 	auto pAABBRenderer = std::make_unique<engine::AABBRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
 	m_pAABBRenderer = pAABBRenderer.get();

Engine/Source/Editor/EditorApp.h

@@ -92,7 +92,7 @@ class EditorApp final : public engine::IApplication
 	std::unique_ptr<engine::SceneWorld> m_pSceneWorld;
 	editor::SceneView* m_pSceneView = nullptr;
 	engine::Renderer* m_pSceneRenderer = nullptr;
-	engine::Renderer* m_pDebugRenderer = nullptr;
+	engine::Renderer* m_pWhiteModelRenderer = nullptr;
 	engine::Renderer* m_pPBRSkyRenderer = nullptr;
 	engine::Renderer* m_pIBLSkyRenderer = nullptr;
 	engine::Renderer* m_pTerrainRenderer = nullptr;

Engine/Source/Editor/UILayers/EntityList.cpp

@@ -51,6 +51,7 @@ void EntityList::AddEntity(engine::SceneWorld* pSceneWorld)
         staticMeshComponent.SetMeshData(&mesh);
         staticMeshComponent.SetRequiredVertexFormat(&pMaterialType->GetRequiredVertexFormat());
         staticMeshComponent.Build();
+        staticMeshComponent.Submit();
 
         mesh.SetName(pSceneWorld->GetNameComponent(entity)->GetName());
         mesh.SetID(cd::MeshID(pSceneDatabase->GetMeshCount()));
@@ -113,6 +114,7 @@ void EntityList::AddEntity(engine::SceneWorld* pSceneWorld)
         meshComponent.SetMeshData(&mesh);
         meshComponent.SetRequiredVertexFormat(&pTerrainMaterialType->GetRequiredVertexFormat());//to do : modify vertexFormat
         meshComponent.Build();
+        meshComponent.Submit();
 
         mesh.SetName(pSceneWorld->GetNameComponent(entity)->GetName());
         mesh.SetID(cd::MeshID(pSceneDatabase->GetMeshCount()));

Engine/Source/Editor/UILayers/SceneView.cpp

@@ -134,14 +134,19 @@ void SceneView::UpdateDebugCombo()
 	{
 		if (DebugModeType::NoDebug == m_debugMode)
 		{
-			m_pSceneRenderer->SetEnable(true);
-			m_pDebugRenderer->SetEnable(false);
+			m_pWhiteModelRenderer->SetEnable(false);
 		}
 		else if (DebugModeType::WhiteModel == m_debugMode)
 		{
-			m_pSceneRenderer->SetEnable(false);
-			m_pDebugRenderer->SetEnable(true);
+			m_pWhiteModelRenderer->SetEnable(true);
 		}
+		else if (DebugModeType::Wireframe == m_debugMode)
+		{
+
+		}
+
+		// white model
+		m_pSceneRenderer->SetEnable(!m_pWhiteModelRenderer->IsEnable());
 	}
 	ImGui::PushItemWidth(130);
 }

Engine/Source/Editor/UILayers/SceneView.h

@@ -3,7 +3,7 @@
 #include "ECWorld/Entity.h"
 #include "ImGui/ImGuiBaseLayer.h"
 #include "Rendering/AABBRenderer.h"
-#include "Rendering/DebugRenderer.h"
+#include "Rendering/WhiteModelRenderer.h"
 
 #include <imgui/imgui.h>
 #define IMGUI_DEFINE_MATH_OPERATORS
@@ -27,14 +27,15 @@ enum class DebugModeType
 {
 	NoDebug,
 	WhiteModel,
+	Wireframe,
 
 	Count,
 };
 
 constexpr const char* DebugModes[] = {
 	"NoDebug",
 	"WhiteModel",
-	//"WireFrame" 
+	"Wireframe",
 };
 
 static_assert(static_cast<int>(DebugModeType::Count) == sizeof(DebugModes) / sizeof(char*),
@@ -76,7 +77,7 @@ class SceneView : public engine::ImGuiBaseLayer
 	AABBModeType GetAABBMode() const { return m_AABBMode; }
 
 	void SetSceneRenderer(engine::Renderer* pSceneRenderer) { m_pSceneRenderer = pSceneRenderer; }
-	void SetDebugRenderer(engine::Renderer* pDebugRenderer) { m_pDebugRenderer = pDebugRenderer; }
+	void SetWhiteModelRenderer(engine::Renderer* pWhiteModelRenderer) { m_pWhiteModelRenderer = pWhiteModelRenderer; }
 	void SetAABBRenderer(engine::Renderer* pAABBRenderer) { m_pAABBRenderer = pAABBRenderer; }
 
 	bool IsTerrainEditMode() const { return m_isTerrainEditMode; }
@@ -106,7 +107,7 @@ class SceneView : public engine::ImGuiBaseLayer
 	AABBModeType m_AABBMode = AABBModeType::NoAABB;
 
 	engine::Renderer* m_pSceneRenderer = nullptr;
-	engine::Renderer* m_pDebugRenderer = nullptr;
+	engine::Renderer* m_pWhiteModelRenderer = nullptr;
 	engine::Renderer* m_pAABBRenderer = nullptr;
 
 	engine::RenderTarget* m_pRenderTarget = nullptr;

Engine/Source/Game/GameApp.cpp

@@ -13,7 +13,7 @@
 #ifdef ENABLE_DDGI
 #include "Rendering/DDGIRenderer.h"
 #endif
-#include "Rendering/DebugRenderer.h"
+#include "Rendering/WhiteModelRenderer.h"
 #include "Rendering/ImGuiRenderer.h"
 #include "Rendering/PBRSkyRenderer.h"
 #include "Rendering/PostProcessRenderer.h"
@@ -251,11 +251,11 @@ void GameApp::InitEngineRenderers()
 	pAnimationRenderer->SetSceneWorld(m_pSceneWorld.get());
 	AddEngineRenderer(cd::MoveTemp(pAnimationRenderer));
 
-	auto pDebugRenderer = std::make_unique<engine::DebugRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
-	m_pDebugRenderer = pDebugRenderer.get();
-	pDebugRenderer->SetSceneWorld(m_pSceneWorld.get());
-	pDebugRenderer->SetEnable(false);
-	AddEngineRenderer(cd::MoveTemp(pDebugRenderer));
+	auto pWhiteModelRenderer = std::make_unique<engine::WhiteModelRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);
+	m_pWhiteModelRenderer = pWhiteModelRenderer.get();
+	pWhiteModelRenderer->SetSceneWorld(m_pSceneWorld.get());
+	pWhiteModelRenderer->SetEnable(false);
+	AddEngineRenderer(cd::MoveTemp(pWhiteModelRenderer));
 
 #ifdef ENABLE_DDGI
 	auto pDDGIRenderer = std::make_unique<engine::DDGIRenderer>(m_pRenderContext->CreateView(), pSceneRenderTarget);

Engine/Source/Runtime/ECWorld/StaticMeshComponent.cpp

@@ -22,6 +22,11 @@ void StaticMeshComponent::Reset()
 
 	m_indexBuffer.clear();
 	m_indexBufferHandle = UINT16_MAX;
+
+#ifdef EDITOR_MODE
+	m_wireframeIndexBuffer.clear();
+	m_wireframeIndexBufferHandle = UINT16_MAX;
+#endif
 }
 
 void StaticMeshComponent::Build()
@@ -50,13 +55,12 @@ void StaticMeshComponent::Build()
 
 	m_vertexBuffer.resize(vertexCount * vertexFormatStride);
 
-	uint32_t currentDataSize = 0U;
-	auto currentDataPtr = m_vertexBuffer.data();
-
-	auto FillVertexBuffer = [&currentDataPtr, &currentDataSize](const void* pData, uint32_t dataSize)
+	uint32_t vbDataSize = 0U;
+	auto vbDataPtr = m_vertexBuffer.data();
+	auto FillVertexBuffer = [&vbDataPtr, &vbDataSize](const void* pData, uint32_t dataSize)
 	{
-		std::memcpy(&currentDataPtr[currentDataSize], pData, dataSize);
-		currentDataSize += dataSize;
+		std::memcpy(&vbDataPtr[vbDataSize], pData, dataSize);
+		vbDataSize += dataSize;
 	};
 
 	for (uint32_t vertexIndex = 0; vertexIndex < vertexCount; ++vertexIndex)
@@ -128,25 +132,18 @@ void StaticMeshComponent::Build()
 		}
 	}
 
-	// Create vertex buffer.
-	bgfx::VertexLayout vertexLayout;
-	VertexLayoutUtility::CreateVertexLayout(vertexLayout, m_pRequiredVertexFormat->GetVertexLayout());
-	const bgfx::Memory* pVertexBufferRef = bgfx::makeRef(m_vertexBuffer.data(), static_cast<uint32_t>(m_vertexBuffer.size()));
-	bgfx::VertexBufferHandle vertexBufferHandle = bgfx::createVertexBuffer(pVertexBufferRef, vertexLayout);
-	assert(bgfx::isValid(vertexBufferHandle));
-	m_vertexBufferHandle = vertexBufferHandle.idx;
-
 	// Fill index buffer data.
 	bool useU16Index = vertexCount <= static_cast<uint32_t>(std::numeric_limits<uint16_t>::max()) + 1U;
 	uint32_t indexTypeSize = useU16Index ? sizeof(uint16_t) : sizeof(uint32_t);
-	m_indexBuffer.resize(m_pMeshData->GetPolygonCount() * 3 * indexTypeSize);
+	uint32_t indicesCount = m_pMeshData->GetPolygonCount() * 3U;
+	m_indexBuffer.resize(indicesCount* indexTypeSize);
 
-	currentDataSize = 0U;
-	currentDataPtr = m_indexBuffer.data();
-	auto FillIndexBuffer = [&currentDataPtr, &currentDataSize](const void* pData, uint32_t dataSize)
+	uint32_t ibDataSize = 0U;
+	auto ibDataPtr = m_indexBuffer.data();
+	auto FillIndexBuffer = [&ibDataPtr, &ibDataSize](const void* pData, uint32_t dataSize)
 	{
-		std::memcpy(&currentDataPtr[currentDataSize], pData, dataSize);
-		currentDataSize += dataSize;
+		std::memcpy(&ibDataPtr[ibDataSize], pData, dataSize);
+		ibDataSize += dataSize;
 	};
 
 	for (const auto& polygon : m_pMeshData->GetPolygons())
@@ -166,11 +163,40 @@ void StaticMeshComponent::Build()
 		}
 	}
 
+#ifdef EDITOR_MODE
+	uint32_t wireframeIndicesCount = bgfx::topologyConvert(bgfx::TopologyConvert::TriListToLineList, nullptr, 0U,
+		m_indexBuffer.data(), indicesCount, !useU16Index);
+	m_wireframeIndexBuffer.resize(indicesCount * indexTypeSize);
+	bgfx::topologyConvert(bgfx::TopologyConvert::TriListToLineList, m_wireframeIndexBuffer.data(), static_cast<uint32_t>(m_wireframeIndexBuffer.size()),
+		m_indexBuffer.data(), indicesCount, !useU16Index);
+#endif
+}
+
+void StaticMeshComponent::Submit()
+{
+	// Create vertex buffer.
+	bgfx::VertexLayout vertexLayout;
+	VertexLayoutUtility::CreateVertexLayout(vertexLayout, m_pRequiredVertexFormat->GetVertexLayout());
+	const bgfx::Memory* pVertexBufferRef = bgfx::makeRef(m_vertexBuffer.data(), static_cast<uint32_t>(m_vertexBuffer.size()));
+	bgfx::VertexBufferHandle vertexBufferHandle = bgfx::createVertexBuffer(pVertexBufferRef, vertexLayout);
+	assert(bgfx::isValid(vertexBufferHandle));
+	m_vertexBufferHandle = vertexBufferHandle.idx;
+
+	bool useU16Index = m_pMeshData->GetVertexCount() <= static_cast<uint32_t>(std::numeric_limits<uint16_t>::max()) + 1U;
+	auto SubmitIndexBuffer = [&useU16Index](const std::vector<std::byte>& indexBuffer) -> uint16_t
+	{
+		const bgfx::Memory* pIndexBufferRef = bgfx::makeRef(indexBuffer.data(), static_cast<uint32_t>(indexBuffer.size()));
+		bgfx::IndexBufferHandle indexBufferHandle = bgfx::createIndexBuffer(pIndexBufferRef, useU16Index ? 0U : BGFX_BUFFER_INDEX32);
+		assert(bgfx::isValid(indexBufferHandle));
+		return indexBufferHandle.idx;
+	};
+
 	// Create index buffer.
-	const bgfx::Memory* pIndexBufferRef = bgfx::makeRef(m_indexBuffer.data(), static_cast<uint32_t>(m_indexBuffer.size()));
-	bgfx::IndexBufferHandle indexBufferHandle = bgfx::createIndexBuffer(pIndexBufferRef, useU16Index ? 0U : BGFX_BUFFER_INDEX32);
-	assert(bgfx::isValid(indexBufferHandle));
-	m_indexBufferHandle = indexBufferHandle.idx;
+	m_indexBufferHandle = SubmitIndexBuffer(m_indexBuffer);
+
+#ifdef EDITOR_MODE
+	m_wireframeIndexBufferHandle = SubmitIndexBuffer(m_wireframeIndexBuffer);
+#endif
 }
 
 }

Engine/Source/Runtime/ECWorld/StaticMeshComponent.h

@@ -43,9 +43,13 @@ class StaticMeshComponent final
 
 	uint16_t GetVertexBuffer() const { return m_vertexBufferHandle; }
 	uint16_t GetIndexBuffer() const { return m_indexBufferHandle; }
+#ifdef EDITOR_MODE
+	uint16_t GetWireframeIndexBuffer() const { return m_wireframeIndexBufferHandle; }
+#endif
 
 	void Reset();
 	void Build();
+	void Submit();
 
 private:
 	// Input
@@ -57,6 +61,11 @@ class StaticMeshComponent final
 	std::vector<std::byte> m_indexBuffer;
 	uint16_t m_vertexBufferHandle = UINT16_MAX;
 	uint16_t m_indexBufferHandle = UINT16_MAX;
+
+#ifdef EDITOR_MODE
+	std::vector<std::byte> m_wireframeIndexBuffer;
+	uint16_t m_wireframeIndexBufferHandle = UINT16_MAX;
+#endif
 };
 
 }

Engine/Source/Runtime/Rendering/AABBRenderer.cpp

@@ -24,20 +24,15 @@ void AABBRenderer::UpdateView(const float* pViewMatrix, const float* pProjection
 
 void AABBRenderer::RenderAll(float deltaTime)
 {
-	for (Entity entity : m_pCurrentSceneWorld->GetStaticMeshEntities())
+	for (Entity entity : m_pCurrentSceneWorld->GetCollisionMeshEntities())
 	{
-		auto* pCollisionMesh = m_pCurrentSceneWorld->GetCollisionMeshComponent(entity);
-		if (!pCollisionMesh)
-		{
-			continue;
-		}
-
 		if (auto* pTransformComponent = m_pCurrentSceneWorld->GetTransformComponent(entity))
 		{
 			pTransformComponent->Build();
 			bgfx::setTransform(pTransformComponent->GetWorldMatrix().Begin());
 		}
 
+		auto* pCollisionMesh = m_pCurrentSceneWorld->GetCollisionMeshComponent(entity);
 		bgfx::setVertexBuffer(0, bgfx::VertexBufferHandle{ pCollisionMesh->GetVertexBuffer() });
 		bgfx::setIndexBuffer(bgfx::IndexBufferHandle{ pCollisionMesh->GetIndexBuffer() });
 
@@ -47,7 +42,6 @@ void AABBRenderer::RenderAll(float deltaTime)
 
 		constexpr StringCrc AABBAllProgram("AABBProgram");
 		bgfx::submit(GetViewID(), GetRenderContext()->GetProgram(AABBAllProgram));
-
 	}
 }