diff --git a/editor/src/Viewport/SceneViewportSelectionUtils.h b/editor/src/Viewport/SceneViewportSelectionUtils.h
deleted file mode 100644
index 8575fabe..00000000
--- a/editor/src/Viewport/SceneViewportSelectionUtils.h
+++ /dev/null
@@ -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
diff --git a/engine/CMakeLists.txt b/engine/CMakeLists.txt
index 18f3a090..18f8ac2e 100644
--- a/engine/CMakeLists.txt
+++ b/engine/CMakeLists.txt
@@ -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
diff --git a/engine/include/XCEngine/Rendering/RenderSceneExtractor.h b/engine/include/XCEngine/Rendering/RenderSceneExtractor.h
index e5a30aef..a795f4c9 100644
--- a/engine/include/XCEngine/Rendering/RenderSceneExtractor.h
+++ b/engine/include/XCEngine/Rendering/RenderSceneExtractor.h
@@ -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;
diff --git a/engine/include/XCEngine/Rendering/RenderSceneUtility.h b/engine/include/XCEngine/Rendering/RenderSceneUtility.h
new file mode 100644
index 00000000..5831c9ed
--- /dev/null
+++ b/engine/include/XCEngine/Rendering/RenderSceneUtility.h
@@ -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
diff --git a/engine/src/Rendering/RenderSceneExtractor.cpp b/engine/src/Rendering/RenderSceneExtractor.cpp
index c7804d5b..e6fe213e 100644
--- a/engine/src/Rendering/RenderSceneExtractor.cpp
+++ b/engine/src/Rendering/RenderSceneExtractor.cpp
@@ -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()) {
diff --git a/engine/src/Rendering/RenderSceneUtility.cpp b/engine/src/Rendering/RenderSceneUtility.cpp
new file mode 100644
index 00000000..e0e9a017
--- /dev/null
+++ b/engine/src/Rendering/RenderSceneUtility.cpp
@@ -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
diff --git a/tests/Rendering/unit/CMakeLists.txt b/tests/Rendering/unit/CMakeLists.txt
index a050811f..af236005 100644
--- a/tests/Rendering/unit/CMakeLists.txt
+++ b/tests/Rendering/unit/CMakeLists.txt
@@ -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
 )
 
diff --git a/tests/editor/test_scene_viewport_selection_utils.cpp b/tests/Rendering/unit/test_render_scene_utility.cpp
similarity index 73%
rename from tests/editor/test_scene_viewport_selection_utils.cpp
rename to tests/Rendering/unit/test_render_scene_utility.cpp
index d3ce626d..35d40dce 100644
--- a/tests/editor/test_scene_viewport_selection_utils.cpp
+++ b/tests/Rendering/unit/test_render_scene_utility.cpp
@@ -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);
diff --git a/tests/editor/CMakeLists.txt b/tests/editor/CMakeLists.txt
index 5dde6a17..4d12d8d4 100644
--- a/tests/editor/CMakeLists.txt
+++ b/tests/editor/CMakeLists.txt
@@ -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