xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor renderer draw extraction to section-level items

Browse Source
This commit is contained in:
ssdfasd
2026-03-27 11:56:23 +08:00
parent f68da2e3f9
commit 90961f01aa
7 changed files with 389 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

177
tests/Rendering/unit/test_render_scene_extractor.cpp
View File

@@ -6,11 +6,14 @@
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Rendering/RenderMaterialUtility.h>
#include <XCEngine/Rendering/RenderSceneExtractor.h>
#include <XCEngine/Scene/Scene.h>
#include <XCEngine/Resources/Material/Material.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Scene/Scene.h>
using namespace XCEngine::Components;
using namespace XCEngine::Core;
using namespace XCEngine::Math;
using namespace XCEngine::Rendering;
using namespace XCEngine::Resources;
@@ -27,6 +30,40 @@ Mesh* CreateTestMesh(const char* path) {
return mesh;
}
Mesh* CreateSectionedTestMesh(const char* path, std::initializer_list<uint32_t> materialIds) {
Mesh* mesh = CreateTestMesh(path);
uint32_t startIndex = 0;
for (uint32_t materialId : materialIds) {
MeshSection section = {};
section.baseVertex = 0;
section.vertexCount = 3;
section.startIndex = startIndex;
section.indexCount = 3;
section.materialID = materialId;
mesh->AddSection(section);
startIndex += 3;
}
return mesh;
}
Material* CreateTestMaterial(const char* path, int32_t renderQueue, const char* shaderPass = nullptr, const char* lightMode = nullptr) {
auto* material = new Material();
IResource::ConstructParams params = {};
params.name = "TestMaterial";
params.path = path;
params.guid = ResourceGUID::Generate(path);
material->Initialize(params);
material->SetRenderQueue(renderQueue);
if (shaderPass != nullptr) {
material->SetShaderPass(shaderPass);
}
if (lightMode != nullptr) {
material->SetTag("LightMode", lightMode);
}
return material;
}
TEST(RenderSceneExtractor_Test, SelectsHighestDepthPrimaryCameraAndVisibleObjects) {
Scene scene("RenderScene");
@@ -64,10 +101,12 @@ TEST(RenderSceneExtractor_Test, SelectsHighestDepthPrimaryCameraAndVisibleObject
EXPECT_EQ(sceneData.cameraData.viewportHeight, 720u);
EXPECT_EQ(sceneData.cameraData.worldPosition, Vector3(2.0f, 3.0f, 4.0f));
ASSERT_EQ(sceneData.visibleObjects.size(), 1u);
EXPECT_EQ(sceneData.visibleObjects[0].gameObject, visibleObject);
EXPECT_EQ(sceneData.visibleObjects[0].mesh, visibleMesh);
EXPECT_EQ(sceneData.visibleObjects[0].localToWorld.GetTranslation(), Vector3(1.0f, 2.0f, 3.0f));
ASSERT_EQ(sceneData.visibleItems.size(), 1u);
EXPECT_EQ(sceneData.visibleItems[0].gameObject, visibleObject);
EXPECT_EQ(sceneData.visibleItems[0].mesh, visibleMesh);
EXPECT_EQ(sceneData.visibleItems[0].localToWorld.GetTranslation(), Vector3(1.0f, 2.0f, 3.0f));
EXPECT_FALSE(sceneData.visibleItems[0].hasSection);
EXPECT_EQ(sceneData.visibleItems[0].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Geometry));
meshFilter->ClearMesh();
hiddenMeshFilter->ClearMesh();
@@ -98,4 +137,132 @@ TEST(RenderSceneExtractor_Test, OverrideCameraTakesPriority) {
EXPECT_EQ(sceneData.cameraData.viewportHeight, 480u);
}
TEST(RenderSceneExtractor_Test, ExtractsSectionLevelVisibleItemsAndSortsByRenderQueue) {
Scene scene("SectionScene");
GameObject* cameraObject = scene.CreateGameObject("Camera");
auto* camera = cameraObject->AddComponent<CameraComponent>();
camera->SetPrimary(true);
GameObject* renderObject = scene.CreateGameObject("MultiSectionMesh");
renderObject->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, 5.0f));
auto* meshFilter = renderObject->AddComponent<MeshFilterComponent>();
auto* meshRenderer = renderObject->AddComponent<MeshRendererComponent>();
Mesh* mesh = CreateSectionedTestMesh("Meshes/sectioned.mesh", { 1u, 0u });
Material* opaqueMaterial = CreateTestMaterial(
"Materials/opaque.mat",
static_cast<int32_t>(MaterialRenderQueue::Geometry),
"ForwardLit",
"ForwardBase");
Material* transparentMaterial = CreateTestMaterial(
"Materials/transparent.mat",
static_cast<int32_t>(MaterialRenderQueue::Transparent),
"ForwardLit",
"ForwardBase");
meshFilter->SetMesh(mesh);
meshRenderer->SetMaterial(0, opaqueMaterial);
meshRenderer->SetMaterial(1, transparentMaterial);
RenderSceneExtractor extractor;
const RenderSceneData sceneData = extractor.Extract(scene, nullptr, 800, 600);
ASSERT_TRUE(sceneData.HasCamera());
ASSERT_EQ(sceneData.visibleItems.size(), 2u);
EXPECT_TRUE(sceneData.visibleItems[0].hasSection);
EXPECT_EQ(sceneData.visibleItems[0].sectionIndex, 1u);
EXPECT_EQ(sceneData.visibleItems[0].materialIndex, 0u);
EXPECT_EQ(sceneData.visibleItems[0].material, opaqueMaterial);
EXPECT_EQ(sceneData.visibleItems[0].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Geometry));
EXPECT_TRUE(sceneData.visibleItems[1].hasSection);
EXPECT_EQ(sceneData.visibleItems[1].sectionIndex, 0u);
EXPECT_EQ(sceneData.visibleItems[1].materialIndex, 1u);
EXPECT_EQ(sceneData.visibleItems[1].material, transparentMaterial);
EXPECT_EQ(sceneData.visibleItems[1].renderQueue, static_cast<int32_t>(MaterialRenderQueue::Transparent));
meshRenderer->ClearMaterials();
meshFilter->ClearMesh();
delete opaqueMaterial;
delete transparentMaterial;
delete mesh;
}
TEST(RenderSceneExtractor_Test, SortsOpaqueFrontToBackAndTransparentBackToFront) {
Scene scene("QueueSortScene");
GameObject* cameraObject = scene.CreateGameObject("Camera");
auto* camera = cameraObject->AddComponent<CameraComponent>();
camera->SetPrimary(true);
auto createRenderable = [&](const char* name, float z, int32_t renderQueue) -> Mesh* {
GameObject* object = scene.CreateGameObject(name);
object->GetTransform()->SetLocalPosition(Vector3(0.0f, 0.0f, z));
auto* meshFilter = object->AddComponent<MeshFilterComponent>();
auto* meshRenderer = object->AddComponent<MeshRendererComponent>();
Mesh* mesh = CreateTestMesh(name);
Material* material = CreateTestMaterial(name, renderQueue, "ForwardLit", "ForwardBase");
meshFilter->SetMesh(mesh);
meshRenderer->SetMaterial(0, material);
return mesh;
};
Mesh* opaqueFarMesh = createRenderable("OpaqueFar", 10.0f, static_cast<int32_t>(MaterialRenderQueue::Geometry));
Mesh* transparentNearMesh = createRenderable("TransparentNear", 2.0f, static_cast<int32_t>(MaterialRenderQueue::Transparent));
Mesh* opaqueNearMesh = createRenderable("OpaqueNear", 2.0f, static_cast<int32_t>(MaterialRenderQueue::Geometry));
Mesh* transparentFarMesh = createRenderable("TransparentFar", 10.0f, static_cast<int32_t>(MaterialRenderQueue::Transparent));
RenderSceneExtractor extractor;
const RenderSceneData sceneData = extractor.Extract(scene, nullptr, 800, 600);
ASSERT_EQ(sceneData.visibleItems.size(), 4u);
EXPECT_STREQ(sceneData.visibleItems[0].gameObject->GetName().c_str(), "OpaqueNear");
EXPECT_STREQ(sceneData.visibleItems[1].gameObject->GetName().c_str(), "OpaqueFar");
EXPECT_STREQ(sceneData.visibleItems[2].gameObject->GetName().c_str(), "TransparentFar");
EXPECT_STREQ(sceneData.visibleItems[3].gameObject->GetName().c_str(), "TransparentNear");
auto cleanupObject = [](GameObject* object) {
auto* meshFilter = object->GetComponent<MeshFilterComponent>();
auto* meshRenderer = object->GetComponent<MeshRendererComponent>();
Material* material = meshRenderer != nullptr ? meshRenderer->GetMaterial(0) : nullptr;
if (meshRenderer != nullptr) {
meshRenderer->ClearMaterials();
}
if (meshFilter != nullptr) {
meshFilter->ClearMesh();
}
delete material;
};
cleanupObject(scene.Find("OpaqueFar"));
cleanupObject(scene.Find("TransparentNear"));
cleanupObject(scene.Find("OpaqueNear"));
cleanupObject(scene.Find("TransparentFar"));
delete opaqueFarMesh;
delete transparentNearMesh;
delete opaqueNearMesh;
delete transparentFarMesh;
}
TEST(RenderMaterialUtility_Test, MatchesBuiltinForwardPassMetadata) {
Material forwardMaterial;
forwardMaterial.SetShaderPass("ForwardLit");
forwardMaterial.SetTag("LightMode", "ForwardBase");
EXPECT_TRUE(MatchesBuiltinPass(&forwardMaterial, BuiltinMaterialPass::Forward));
Material noMetadataMaterial;
EXPECT_TRUE(MatchesBuiltinPass(&noMetadataMaterial, BuiltinMaterialPass::Forward));
Material shadowMaterial;
shadowMaterial.SetShaderPass("ShadowCaster");
EXPECT_FALSE(MatchesBuiltinPass(&shadowMaterial, BuiltinMaterialPass::Forward));
Material depthOnlyMaterial;
depthOnlyMaterial.SetTag("LightMode", "DepthOnly");
EXPECT_FALSE(MatchesBuiltinPass(&depthOnlyMaterial, BuiltinMaterialPass::Forward));
}
} // namespace