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

refactor: move scene view selection utilities into renderer

Browse Source
This commit is contained in:
ssdfasd
2026-04-01 19:03:58 +08:00
parent 44771d3cc1
commit 55b3021159
9 changed files with 210 additions and 309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

161
editor/src/Viewport/SceneViewportSelectionUtils.h
View File

@@ -1,161 +0,0 @@
#pragma once
#include "IViewportHostService.h"
#include "SceneViewportMath.h"
#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/GameObject.h>
#include <XCEngine/Components/MeshFilterComponent.h>
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Rendering/RenderCameraData.h>
#include <XCEngine/Rendering/RenderMaterialUtility.h>
#include <XCEngine/Rendering/VisibleRenderObject.h>
#include <XCEngine/Scene/Scene.h>
#include <cstdint>
#include <unordered_set>
#include <vector>
namespace XCEngine {
namespace Editor {
inline Rendering::RenderCameraData BuildSceneViewportCameraData(
const SceneViewportOverlayData& overlay,
uint32_t viewportWidth,
uint32_t viewportHeight) {
Rendering::RenderCameraData cameraData = {};
cameraData.viewportWidth = viewportWidth;
cameraData.viewportHeight = viewportHeight;
cameraData.worldPosition = overlay.cameraPosition;
cameraData.clearFlags = Rendering::RenderClearFlags::None;
const Math::Matrix4x4 view = BuildSceneViewportViewMatrix(overlay);
const Math::Matrix4x4 projection = BuildSceneViewportProjectionMatrix(
overlay,
static_cast<float>(viewportWidth),
static_cast<float>(viewportHeight));
cameraData.view = view.Transpose();
cameraData.projection = projection.Transpose();
cameraData.viewProjection = (projection * view).Transpose();
return cameraData;
}
inline Rendering::RenderCameraData BuildSceneViewportCameraData(
const Components::CameraComponent& camera,
uint32_t viewportWidth,
uint32_t viewportHeight) {
Rendering::RenderCameraData cameraData = {};
cameraData.viewportWidth = viewportWidth;
cameraData.viewportHeight = viewportHeight;
cameraData.worldPosition = camera.transform().GetPosition();
cameraData.clearFlags = Rendering::RenderClearFlags::None;
const Math::Matrix4x4 view = camera.transform().GetWorldToLocalMatrix();
const float aspect = viewportHeight > 0
? static_cast<float>(viewportWidth) / static_cast<float>(viewportHeight)
: 1.0f;
Math::Matrix4x4 projection = Math::Matrix4x4::Identity();
if (camera.GetProjectionType() == Components::CameraProjectionType::Perspective) {
projection = Math::Matrix4x4::Perspective(
camera.GetFieldOfView() * Math::DEG_TO_RAD,
aspect,
camera.GetNearClipPlane(),
camera.GetFarClipPlane());
} else {
const float orthoSize = camera.GetOrthographicSize();
projection = Math::Matrix4x4::Orthographic(
-orthoSize * aspect,
orthoSize * aspect,
-orthoSize,
orthoSize,
camera.GetNearClipPlane(),
camera.GetFarClipPlane());
}
cameraData.view = view.Transpose();
cameraData.projection = projection.Transpose();
cameraData.viewProjection = (projection * view).Transpose();
return cameraData;
}
inline std::vector<Rendering::VisibleRenderItem> CollectSceneViewportSelectionRenderables(
const Components::Scene& scene,
const std::vector<uint64_t>& selectedEntityIds,
const Math::Vector3& cameraPosition) {
std::vector<Rendering::VisibleRenderItem> renderables;
std::unordered_set<uint64_t> visitedEntityIds;
visitedEntityIds.reserve(selectedEntityIds.size());
for (uint64_t entityId : selectedEntityIds) {
if (entityId == 0 || !visitedEntityIds.insert(entityId).second) {
continue;
}
Components::GameObject* gameObject = scene.FindByID(entityId);
if (gameObject == nullptr || !gameObject->IsActiveInHierarchy()) {
continue;
}
auto* meshFilter = gameObject->GetComponent<Components::MeshFilterComponent>();
auto* meshRenderer = gameObject->GetComponent<Components::MeshRendererComponent>();
if (meshFilter == nullptr ||
meshRenderer == nullptr ||
!meshFilter->IsEnabled() ||
!meshRenderer->IsEnabled()) {
continue;
}
Resources::Mesh* mesh = meshFilter->GetMesh();
if (mesh == nullptr || !mesh->IsValid()) {
continue;
}
const Math::Matrix4x4 localToWorld = gameObject->GetTransform()->GetLocalToWorldMatrix();
const Math::Vector3 worldPosition = localToWorld.GetTranslation();
const float cameraDistanceSq = (worldPosition - cameraPosition).SqrMagnitude();
const auto& sections = mesh->GetSections();
if (!sections.Empty()) {
for (size_t sectionIndex = 0; sectionIndex < sections.Size(); ++sectionIndex) {
const Resources::MeshSection& section = sections[sectionIndex];
Rendering::VisibleRenderItem renderable = {};
renderable.gameObject = gameObject;
renderable.meshFilter = meshFilter;
renderable.meshRenderer = meshRenderer;
renderable.mesh = mesh;
renderable.materialIndex = section.materialID;
renderable.sectionIndex = static_cast<Core::uint32>(sectionIndex);
renderable.hasSection = true;
renderable.material = Rendering::ResolveMaterial(meshRenderer, mesh, section.materialID);
renderable.renderQueue = Rendering::ResolveMaterialRenderQueue(renderable.material);
renderable.cameraDistanceSq = cameraDistanceSq;
renderable.localToWorld = localToWorld;
renderables.push_back(renderable);
}
continue;
}
Rendering::VisibleRenderItem renderable = {};
renderable.gameObject = gameObject;
renderable.meshFilter = meshFilter;
renderable.meshRenderer = meshRenderer;
renderable.mesh = mesh;
renderable.materialIndex = 0;
renderable.sectionIndex = 0;
renderable.hasSection = false;
renderable.material = Rendering::ResolveMaterial(meshRenderer, mesh, 0);
renderable.renderQueue = Rendering::ResolveMaterialRenderQueue(renderable.material);
renderable.cameraDistanceSq = cameraDistanceSq;
renderable.localToWorld = localToWorld;
renderables.push_back(renderable);
}
return renderables;
}
} // namespace Editor
} // namespace XCEngine

2
engine/CMakeLists.txt
View File

@@ -334,6 +334,7 @@ add_library(XCEngine STATIC
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/RenderCameraData.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/CameraRenderRequest.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/VisibleRenderObject.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/RenderSceneUtility.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/RenderPass.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/RenderSceneExtractor.h
${CMAKE_CURRENT_SOURCE_DIR}/include/XCEngine/Rendering/RenderPipeline.h
@@ -355,6 +356,7 @@ add_library(XCEngine STATIC
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Passes/BuiltinObjectIdOutlinePass.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderSurface.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderSceneExtractor.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderSceneUtility.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/RenderResourceCache.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/SceneRenderer.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/Rendering/Pipelines/BuiltinForwardPipeline.cpp

4
engine/include/XCEngine/Rendering/RenderSceneExtractor.h
View File

@@ -57,10 +57,6 @@ public:
Components::CameraComponent* overrideCamera) const;
private:
RenderCameraData BuildCameraData(
const Components::CameraComponent& camera,
uint32_t viewportWidth,
uint32_t viewportHeight) const;
void ExtractLighting(
const Components::Scene& scene,
RenderLightingData& lightingData) const;

35
engine/include/XCEngine/Rendering/RenderSceneUtility.h Normal file
View File

@@ -0,0 +1,35 @@
#pragma once
#include <XCEngine/Core/Math/Vector3.h>
#include <XCEngine/Rendering/RenderCameraData.h>
#include <XCEngine/Rendering/VisibleRenderObject.h>
#include <cstdint>
#include <vector>
namespace XCEngine {
namespace Components {
class CameraComponent;
class GameObject;
class Scene;
} // namespace Components
namespace Rendering {
RenderCameraData BuildRenderCameraData(
const Components::CameraComponent& camera,
uint32_t viewportWidth,
uint32_t viewportHeight);
void AppendRenderItemsForGameObject(
Components::GameObject& gameObject,
const Math::Vector3& cameraPosition,
std::vector<VisibleRenderItem>& outVisibleItems);
std::vector<VisibleRenderItem> CollectRenderItemsForEntityIds(
const Components::Scene& scene,
const std::vector<uint64_t>& entityIds,
const Math::Vector3& cameraPosition);
} // namespace Rendering
} // namespace XCEngine

97
engine/src/Rendering/RenderSceneExtractor.cpp
View File

@@ -3,10 +3,8 @@
#include "Components/CameraComponent.h"
#include "Components/GameObject.h"
#include "Components/LightComponent.h"
#include "Components/MeshFilterComponent.h"
#include "Components/MeshRendererComponent.h"
#include "Components/TransformComponent.h"
#include "Rendering/RenderMaterialUtility.h"
#include "Rendering/RenderSceneUtility.h"
#include "Scene/Scene.h"
#include <algorithm>
@@ -62,7 +60,7 @@ RenderSceneData RenderSceneExtractor::Extract(
return sceneData;
}
sceneData.cameraData = BuildCameraData(*sceneData.camera, viewportWidth, viewportHeight);
sceneData.cameraData = BuildRenderCameraData(*sceneData.camera, viewportWidth, viewportHeight);
const Math::Vector3 cameraPosition = sceneData.cameraData.worldPosition;
const uint32_t cullingMask = sceneData.camera->GetCullingMask();
@@ -91,7 +89,7 @@ RenderSceneData RenderSceneExtractor::ExtractForCamera(
}
sceneData.camera = &camera;
sceneData.cameraData = BuildCameraData(camera, viewportWidth, viewportHeight);
sceneData.cameraData = BuildRenderCameraData(camera, viewportWidth, viewportHeight);
const Math::Vector3 cameraPosition = sceneData.cameraData.worldPosition;
const uint32_t cullingMask = camera.GetCullingMask();
@@ -144,45 +142,6 @@ Components::CameraComponent* RenderSceneExtractor::SelectCamera(
return nullptr;
}
RenderCameraData RenderSceneExtractor::BuildCameraData(
const Components::CameraComponent& camera,
uint32_t viewportWidth,
uint32_t viewportHeight) const {
RenderCameraData cameraData;
cameraData.viewportWidth = viewportWidth;
cameraData.viewportHeight = viewportHeight;
cameraData.worldPosition = camera.transform().GetPosition();
cameraData.clearColor = camera.GetClearColor();
const Math::Matrix4x4 view = camera.transform().GetWorldToLocalMatrix();
const float aspect = viewportHeight > 0
? static_cast<float>(viewportWidth) / static_cast<float>(viewportHeight)
: 1.0f;
Math::Matrix4x4 projection = Math::Matrix4x4::Identity();
if (camera.GetProjectionType() == Components::CameraProjectionType::Perspective) {
projection = Math::Matrix4x4::Perspective(
camera.GetFieldOfView() * Math::DEG_TO_RAD,
aspect,
camera.GetNearClipPlane(),
camera.GetFarClipPlane());
} else {
const float orthoSize = camera.GetOrthographicSize();
projection = Math::Matrix4x4::Orthographic(
-orthoSize * aspect,
orthoSize * aspect,
-orthoSize,
orthoSize,
camera.GetNearClipPlane(),
camera.GetFarClipPlane());
}
cameraData.view = view.Transpose();
cameraData.projection = projection.Transpose();
cameraData.viewProjection = (projection * view).Transpose();
return cameraData;
}
void RenderSceneExtractor::ExtractLighting(
const Components::Scene& scene,
RenderLightingData& lightingData) const {
@@ -235,54 +194,8 @@ void RenderSceneExtractor::ExtractVisibleItems(
const uint32_t gameObjectLayerMask = 1u << gameObject->GetLayer();
const bool isVisibleInCameraMask = (cullingMask & gameObjectLayerMask) != 0;
auto* meshFilter = gameObject->GetComponent<Components::MeshFilterComponent>();
auto* meshRenderer = gameObject->GetComponent<Components::MeshRendererComponent>();
if (meshFilter != nullptr &&
meshRenderer != nullptr &&
isVisibleInCameraMask &&
meshFilter->IsEnabled() &&
meshRenderer->IsEnabled()) {
Resources::Mesh* mesh = meshFilter->GetMesh();
if (mesh != nullptr && mesh->IsValid()) {
const Math::Matrix4x4 localToWorld = gameObject->GetTransform()->GetLocalToWorldMatrix();
const Math::Vector3 worldPosition = localToWorld.GetTranslation();
const float cameraDistanceSq = (worldPosition - cameraPosition).SqrMagnitude();
const Containers::Array<Resources::MeshSection>& sections = mesh->GetSections();
if (!sections.Empty()) {
for (size_t sectionIndex = 0; sectionIndex < sections.Size(); ++sectionIndex) {
const Resources::MeshSection& section = sections[sectionIndex];
VisibleRenderItem visibleItem;
visibleItem.gameObject = gameObject;
visibleItem.meshFilter = meshFilter;
visibleItem.meshRenderer = meshRenderer;
visibleItem.mesh = mesh;
visibleItem.materialIndex = section.materialID;
visibleItem.sectionIndex = static_cast<Core::uint32>(sectionIndex);
visibleItem.hasSection = true;
visibleItem.material = ResolveMaterial(meshRenderer, mesh, section.materialID);
visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
visibleItem.cameraDistanceSq = cameraDistanceSq;
visibleItem.localToWorld = localToWorld;
visibleItems.push_back(visibleItem);
}
} else {
VisibleRenderItem visibleItem;
visibleItem.gameObject = gameObject;
visibleItem.meshFilter = meshFilter;
visibleItem.meshRenderer = meshRenderer;
visibleItem.mesh = mesh;
visibleItem.materialIndex = 0;
visibleItem.sectionIndex = 0;
visibleItem.hasSection = false;
visibleItem.material = ResolveMaterial(meshRenderer, mesh, 0);
visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
visibleItem.cameraDistanceSq = cameraDistanceSq;
visibleItem.localToWorld = localToWorld;
visibleItems.push_back(visibleItem);
}
}
if (isVisibleInCameraMask) {
AppendRenderItemsForGameObject(*gameObject, cameraPosition, visibleItems);
}
for (Components::GameObject* child : gameObject->GetChildren()) {

143
engine/src/Rendering/RenderSceneUtility.cpp Normal file
View File

@@ -0,0 +1,143 @@
#include "Rendering/RenderSceneUtility.h"
#include "Components/CameraComponent.h"
#include "Components/GameObject.h"
#include "Components/MeshFilterComponent.h"
#include "Components/MeshRendererComponent.h"
#include "Components/TransformComponent.h"
#include "Rendering/RenderMaterialUtility.h"
#include "Scene/Scene.h"
#include <unordered_set>
namespace XCEngine {
namespace Rendering {
RenderCameraData BuildRenderCameraData(
const Components::CameraComponent& camera,
uint32_t viewportWidth,
uint32_t viewportHeight) {
RenderCameraData cameraData = {};
cameraData.viewportWidth = viewportWidth;
cameraData.viewportHeight = viewportHeight;
cameraData.worldPosition = camera.transform().GetPosition();
cameraData.clearColor = camera.GetClearColor();
const Math::Matrix4x4 view = camera.transform().GetWorldToLocalMatrix();
const float aspect = viewportHeight > 0
? static_cast<float>(viewportWidth) / static_cast<float>(viewportHeight)
: 1.0f;
Math::Matrix4x4 projection = Math::Matrix4x4::Identity();
if (camera.GetProjectionType() == Components::CameraProjectionType::Perspective) {
projection = Math::Matrix4x4::Perspective(
camera.GetFieldOfView() * Math::DEG_TO_RAD,
aspect,
camera.GetNearClipPlane(),
camera.GetFarClipPlane());
} else {
const float orthoSize = camera.GetOrthographicSize();
projection = Math::Matrix4x4::Orthographic(
-orthoSize * aspect,
orthoSize * aspect,
-orthoSize,
orthoSize,
camera.GetNearClipPlane(),
camera.GetFarClipPlane());
}
cameraData.view = view.Transpose();
cameraData.projection = projection.Transpose();
cameraData.viewProjection = (projection * view).Transpose();
return cameraData;
}
void AppendRenderItemsForGameObject(
Components::GameObject& gameObject,
const Math::Vector3& cameraPosition,
std::vector<VisibleRenderItem>& outVisibleItems) {
if (!gameObject.IsActiveInHierarchy()) {
return;
}
auto* meshFilter = gameObject.GetComponent<Components::MeshFilterComponent>();
auto* meshRenderer = gameObject.GetComponent<Components::MeshRendererComponent>();
if (meshFilter == nullptr ||
meshRenderer == nullptr ||
!meshFilter->IsEnabled() ||
!meshRenderer->IsEnabled()) {
return;
}
Resources::Mesh* mesh = meshFilter->GetMesh();
if (mesh == nullptr || !mesh->IsValid()) {
return;
}
const Math::Matrix4x4 localToWorld = gameObject.GetTransform()->GetLocalToWorldMatrix();
const Math::Vector3 worldPosition = localToWorld.GetTranslation();
const float cameraDistanceSq = (worldPosition - cameraPosition).SqrMagnitude();
const Containers::Array<Resources::MeshSection>& sections = mesh->GetSections();
if (!sections.Empty()) {
for (size_t sectionIndex = 0; sectionIndex < sections.Size(); ++sectionIndex) {
const Resources::MeshSection& section = sections[sectionIndex];
VisibleRenderItem visibleItem = {};
visibleItem.gameObject = &gameObject;
visibleItem.meshFilter = meshFilter;
visibleItem.meshRenderer = meshRenderer;
visibleItem.mesh = mesh;
visibleItem.materialIndex = section.materialID;
visibleItem.sectionIndex = static_cast<Core::uint32>(sectionIndex);
visibleItem.hasSection = true;
visibleItem.material = ResolveMaterial(meshRenderer, mesh, section.materialID);
visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
visibleItem.cameraDistanceSq = cameraDistanceSq;
visibleItem.localToWorld = localToWorld;
outVisibleItems.push_back(visibleItem);
}
return;
}
VisibleRenderItem visibleItem = {};
visibleItem.gameObject = &gameObject;
visibleItem.meshFilter = meshFilter;
visibleItem.meshRenderer = meshRenderer;
visibleItem.mesh = mesh;
visibleItem.materialIndex = 0;
visibleItem.sectionIndex = 0;
visibleItem.hasSection = false;
visibleItem.material = ResolveMaterial(meshRenderer, mesh, 0);
visibleItem.renderQueue = ResolveMaterialRenderQueue(visibleItem.material);
visibleItem.cameraDistanceSq = cameraDistanceSq;
visibleItem.localToWorld = localToWorld;
outVisibleItems.push_back(visibleItem);
}
std::vector<VisibleRenderItem> CollectRenderItemsForEntityIds(
const Components::Scene& scene,
const std::vector<uint64_t>& entityIds,
const Math::Vector3& cameraPosition) {
std::vector<VisibleRenderItem> visibleItems;
std::unordered_set<uint64_t> visitedEntityIds;
visitedEntityIds.reserve(entityIds.size());
for (uint64_t entityId : entityIds) {
if (entityId == 0 || !visitedEntityIds.insert(entityId).second) {
continue;
}
Components::GameObject* gameObject = scene.FindByID(entityId);
if (gameObject == nullptr) {
continue;
}
AppendRenderItemsForGameObject(*gameObject, cameraPosition, visibleItems);
}
return visibleItems;
}
} // namespace Rendering
} // namespace XCEngine

1
tests/Rendering/unit/CMakeLists.txt
View File

@@ -7,6 +7,7 @@ set(RENDERING_UNIT_TEST_SOURCES
test_builtin_forward_pipeline.cpp
test_builtin_scene_view_post_pass_plan.cpp
test_camera_scene_renderer.cpp
test_render_scene_utility.cpp
test_render_scene_extractor.cpp
)

75
tests/editor/test_scene_viewport_selection_utils.cpp → tests/Rendering/unit/test_render_scene_utility.cpp
View File

@@ -1,13 +1,11 @@
#include <gtest/gtest.h>
#include "Viewport/SceneViewportMath.h"
#include "Viewport/SceneViewportSelectionUtils.h"
#include <XCEngine/Components/CameraComponent.h>
#include <XCEngine/Components/MeshFilterComponent.h>
#include <XCEngine/Components/MeshRendererComponent.h>
#include <XCEngine/Core/Asset/IResource.h>
#include <XCEngine/Core/Math/Quaternion.h>
#include <XCEngine/Rendering/RenderSceneUtility.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Scene/Scene.h>
@@ -17,19 +15,16 @@
namespace {
using XCEngine::Components::GameObject;
using XCEngine::Components::CameraComponent;
using XCEngine::Components::CameraProjectionType;
using XCEngine::Components::GameObject;
using XCEngine::Components::MeshFilterComponent;
using XCEngine::Components::MeshRendererComponent;
using XCEngine::Components::Scene;
using XCEngine::Editor::BuildSceneViewportCameraData;
using XCEngine::Editor::BuildSceneViewportProjectionMatrix;
using XCEngine::Editor::BuildSceneViewportViewMatrix;
using XCEngine::Editor::CollectSceneViewportSelectionRenderables;
using XCEngine::Editor::SceneViewportOverlayData;
using XCEngine::Math::Matrix4x4;
using XCEngine::Math::Vector3;
using XCEngine::Rendering::BuildRenderCameraData;
using XCEngine::Rendering::CollectRenderItemsForEntityIds;
using XCEngine::Resources::Mesh;
using XCEngine::Resources::MeshSection;
using XCEngine::Resources::StaticMeshVertex;
@@ -101,21 +96,8 @@ std::unique_ptr<Mesh> CreateSelectionMesh(uint64_t guid, bool splitIntoTwoSectio
return mesh;
}
class SceneViewportSelectionUtilsTest : public ::testing::Test {
class RenderSceneUtilityTest : public ::testing::Test {
protected:
SceneViewportOverlayData CreateOverlay() const {
SceneViewportOverlayData overlay = {};
overlay.valid = true;
overlay.cameraPosition = Vector3(2.0f, 3.0f, -8.0f);
overlay.cameraForward = Vector3::Forward();
overlay.cameraRight = Vector3::Right();
overlay.cameraUp = Vector3::Up();
overlay.verticalFovDegrees = 60.0f;
overlay.nearClipPlane = 0.03f;
overlay.farClipPlane = 2000.0f;
return overlay;
}
GameObject* CreateMeshObject(
Scene& scene,
const std::string& name,
@@ -142,23 +124,8 @@ private:
std::vector<std::unique_ptr<Mesh>> m_meshes;
};
TEST_F(SceneViewportSelectionUtilsTest, BuildSceneViewportCameraDataMatchesViewportMathConvention) {
const SceneViewportOverlayData overlay = CreateOverlay();
const auto cameraData = BuildSceneViewportCameraData(overlay, 1280, 720);
EXPECT_TRUE(NearlyEqual(
cameraData.view.Transpose(),
BuildSceneViewportViewMatrix(overlay)));
EXPECT_TRUE(NearlyEqual(
cameraData.projection.Transpose(),
BuildSceneViewportProjectionMatrix(overlay, 1280.0f, 720.0f)));
EXPECT_EQ(cameraData.viewportWidth, 1280u);
EXPECT_EQ(cameraData.viewportHeight, 720u);
EXPECT_EQ(cameraData.worldPosition, overlay.cameraPosition);
}
TEST_F(SceneViewportSelectionUtilsTest, BuildSceneViewportCameraDataFromCameraMatchesRendererConvention) {
Scene scene("SelectionUtilsScene");
TEST_F(RenderSceneUtilityTest, BuildRenderCameraDataMatchesCameraTransformConvention) {
Scene scene("RenderSceneUtilityScene");
GameObject* cameraObject = scene.CreateGameObject("Camera");
auto* camera = cameraObject->AddComponent<CameraComponent>();
ASSERT_NE(camera, nullptr);
@@ -173,7 +140,7 @@ TEST_F(SceneViewportSelectionUtilsTest, BuildSceneViewportCameraDataFromCameraMa
camera->SetNearClipPlane(0.03f);
camera->SetFarClipPlane(1500.0f);
const auto cameraData = BuildSceneViewportCameraData(*camera, 1280, 720);
const auto cameraData = BuildRenderCameraData(*camera, 1280, 720);
EXPECT_TRUE(NearlyEqual(
cameraData.view.Transpose(),
@@ -185,18 +152,24 @@ TEST_F(SceneViewportSelectionUtilsTest, BuildSceneViewportCameraDataFromCameraMa
1280.0f / 720.0f,
0.03f,
1500.0f)));
EXPECT_EQ(cameraData.viewportWidth, 1280u);
EXPECT_EQ(cameraData.viewportHeight, 720u);
EXPECT_EQ(cameraData.worldPosition, cameraObject->GetTransform()->GetPosition());
EXPECT_FLOAT_EQ(cameraData.clearColor.r, camera->GetClearColor().r);
EXPECT_FLOAT_EQ(cameraData.clearColor.g, camera->GetClearColor().g);
EXPECT_FLOAT_EQ(cameraData.clearColor.b, camera->GetClearColor().b);
EXPECT_FLOAT_EQ(cameraData.clearColor.a, camera->GetClearColor().a);
}
TEST_F(SceneViewportSelectionUtilsTest, CollectSceneViewportSelectionRenderablesFiltersInvalidSelectionTargets) {
Scene scene("SelectionUtilsScene");
TEST_F(RenderSceneUtilityTest, CollectRenderItemsForEntityIdsFiltersInvalidTargets) {
Scene scene("RenderSceneUtilityScene");
GameObject* validObject = CreateMeshObject(scene, "Valid", Vector3(0.0f, 0.0f, 4.0f));
GameObject* disabledObject = CreateMeshObject(scene, "Disabled", Vector3(2.0f, 0.0f, 4.0f), false);
GameObject* inactiveObject = CreateMeshObject(scene, "Inactive", Vector3(-2.0f, 0.0f, 4.0f));
inactiveObject->SetActive(false);
const std::vector<uint64_t> selection = {
const std::vector<uint64_t> entityIds = {
0u,
validObject->GetID(),
disabledObject->GetID(),
@@ -205,10 +178,10 @@ TEST_F(SceneViewportSelectionUtilsTest, CollectSceneViewportSelectionRenderables
987654321u
};
const auto renderables = CollectSceneViewportSelectionRenderables(
const auto renderables = CollectRenderItemsForEntityIds(
scene,
selection,
CreateOverlay().cameraPosition);
entityIds,
Vector3(2.0f, 3.0f, -8.0f));
ASSERT_EQ(renderables.size(), 1u);
EXPECT_EQ(renderables[0].gameObject, validObject);
@@ -216,8 +189,8 @@ TEST_F(SceneViewportSelectionUtilsTest, CollectSceneViewportSelectionRenderables
EXPECT_TRUE(renderables[0].hasSection);
}
TEST_F(SceneViewportSelectionUtilsTest, CollectSceneViewportSelectionRenderablesExpandsMeshSections) {
Scene scene("SelectionUtilsScene");
TEST_F(RenderSceneUtilityTest, CollectRenderItemsForEntityIdsExpandsMeshSections) {
Scene scene("RenderSceneUtilityScene");
GameObject* object = CreateMeshObject(
scene,
"Sectioned",
@@ -225,10 +198,10 @@ TEST_F(SceneViewportSelectionUtilsTest, CollectSceneViewportSelectionRenderables
true,
true);
const auto renderables = CollectSceneViewportSelectionRenderables(
const auto renderables = CollectRenderItemsForEntityIds(
scene,
{ object->GetID() },
CreateOverlay().cameraPosition);
Vector3(2.0f, 3.0f, -8.0f));
ASSERT_EQ(renderables.size(), 2u);
EXPECT_EQ(renderables[0].gameObject, object);

1
tests/editor/CMakeLists.txt
View File

@@ -10,7 +10,6 @@ set(EDITOR_TEST_SOURCES
test_scene_viewport_scale_gizmo.cpp
test_scene_viewport_picker.cpp
test_scene_viewport_overlay_renderer.cpp
test_scene_viewport_selection_utils.cpp
${CMAKE_SOURCE_DIR}/editor/src/Core/UndoManager.cpp
${CMAKE_SOURCE_DIR}/editor/src/Managers/SceneManager.cpp
${CMAKE_SOURCE_DIR}/editor/src/Managers/ProjectManager.cpp