Checkpoint workspace changes

editor/app/Features/Scene/SceneViewportSceneOverlay.cpp

@@ -4,12 +4,6 @@
 #include "Assets/EditorIconService.h"
 #include "Scene/EditorSceneRuntime.h"
 
-#include <XCEngine/Components/CameraComponent.h>
-#include <XCEngine/Components/GameObject.h>
-#include <XCEngine/Components/LightComponent.h>
-#include <XCEngine/Components/TransformComponent.h>
-#include <XCEngine/Scene/Scene.h>
-
 #include <algorithm>
 #include <utility>
 
@@ -17,11 +11,6 @@ namespace XCEngine::UI::Editor::App {
 
 namespace {
 
-using ::XCEngine::Components::CameraComponent;
-using ::XCEngine::Components::GameObject;
-using ::XCEngine::Components::LightComponent;
-using ::XCEngine::Components::Scene;
-using ::XCEngine::Components::TransformComponent;
 using ::XCEngine::Math::Vector2;
 using ::XCEngine::UI::UIPoint;
 using ::XCEngine::UI::UIRect;
@@ -30,12 +19,6 @@ namespace SceneViewportGizmoSupport = ::XCEngine::UI::Editor::App::SceneViewport
 constexpr Vector2 kCameraIconSize(90.0f, 90.0f);
 constexpr Vector2 kLightIconSize(100.0f, 100.0f);
 
-bool CanBuildSceneIcon(const GameObject* gameObject) {
-    return gameObject != nullptr &&
-        gameObject->GetTransform() != nullptr &&
-        gameObject->IsActiveInHierarchy();
-}
-
 bool ContainsPoint(const UIRect& rect, const UIPoint& point) {
     return point.x >= rect.x &&
         point.x <= rect.x + rect.width &&
@@ -46,53 +29,51 @@ bool ContainsPoint(const UIRect& rect, const UIPoint& point) {
 SceneViewportGizmoSupport::SceneViewportOverlayData BuildOverlayData(
     const EditorSceneRuntime& sceneRuntime) {
     SceneViewportGizmoSupport::SceneViewportOverlayData overlay = {};
-    const CameraComponent* camera = sceneRuntime.GetSceneViewCamera();
-    if (camera == nullptr || camera->GetGameObject() == nullptr) {
-        return overlay;
-    }
-
-    const TransformComponent* transform = camera->GetGameObject()->GetTransform();
-    if (transform == nullptr) {
+    const EditorSceneCameraSnapshot snapshot =
+        sceneRuntime.BuildSceneViewCameraSnapshot();
+    if (!snapshot.valid) {
         return overlay;
     }
 
     overlay.valid = true;
-    overlay.cameraPosition = transform->GetPosition();
-    overlay.cameraForward = transform->GetForward();
-    overlay.cameraRight = transform->GetRight();
-    overlay.cameraUp = transform->GetUp();
-    overlay.verticalFovDegrees = camera->GetFieldOfView();
-    overlay.nearClipPlane = camera->GetNearClipPlane();
-    overlay.farClipPlane = camera->GetFarClipPlane();
-    overlay.orbitDistance = sceneRuntime.GetSceneViewOrbitDistance();
+    overlay.cameraPosition = snapshot.position;
+    overlay.cameraForward = snapshot.forward;
+    overlay.cameraRight = snapshot.right;
+    overlay.cameraUp = snapshot.up;
+    overlay.verticalFovDegrees = snapshot.verticalFovDegrees;
+    overlay.nearClipPlane = snapshot.nearClipPlane;
+    overlay.farClipPlane = snapshot.farClipPlane;
+    overlay.orbitDistance = snapshot.orbitDistance;
     return overlay;
 }
 
-::XCEngine::UI::UITextureHandle ResolveCameraIcon(const EditorIconService* icons) {
-    return icons != nullptr
-        ? icons->Resolve(BuiltInIconKind::CameraGizmo)
-        : ::XCEngine::UI::UITextureHandle();
-}
-
-::XCEngine::UI::UITextureHandle ResolveLightIcon(
+::XCEngine::UI::UITextureHandle ResolveViewportIcon(
     const EditorIconService* icons,
-    const LightComponent& light) {
+    EditorSceneViewportIconKind kind) {
     if (icons == nullptr) {
         return {};
     }
 
-    switch (light.GetLightType()) {
-    case ::XCEngine::Components::LightType::Directional:
+    switch (kind) {
+    case EditorSceneViewportIconKind::Camera:
+        return icons->Resolve(BuiltInIconKind::CameraGizmo);
+    case EditorSceneViewportIconKind::DirectionalLight:
         return icons->Resolve(BuiltInIconKind::DirectionalLightGizmo);
-    case ::XCEngine::Components::LightType::Point:
+    case EditorSceneViewportIconKind::PointLight:
         return icons->Resolve(BuiltInIconKind::PointLightGizmo);
-    case ::XCEngine::Components::LightType::Spot:
+    case EditorSceneViewportIconKind::SpotLight:
         return icons->Resolve(BuiltInIconKind::SpotLightGizmo);
     default:
         return {};
     }
 }
 
+Vector2 ResolveViewportIconSize(EditorSceneViewportIconKind kind) {
+    return kind == EditorSceneViewportIconKind::Camera
+        ? kCameraIconSize
+        : kLightIconSize;
+}
+
 } // namespace
 
 void SceneViewportSceneOverlay::SetIconService(const EditorIconService* icons) {
@@ -118,11 +99,6 @@ void SceneViewportSceneOverlay::Refresh(
         return;
     }
 
-    Scene* scene = sceneRuntime.GetActiveScene();
-    if (scene == nullptr) {
-        return;
-    }
-
     const SceneViewportGizmoSupport::SceneViewportOverlayData overlay =
         BuildOverlayData(sceneRuntime);
     if (!overlay.valid) {
@@ -131,30 +107,26 @@ void SceneViewportSceneOverlay::Refresh(
 
     std::vector<IconFrame> icons = {};
     const auto tryAppendIcon =
-        [&](const GameObject& gameObject,
-            const Vector2& iconSize,
-            const ::XCEngine::UI::UITextureHandle& texture) {
+        [&](const EditorSceneViewportIconSnapshot& snapshot) {
+            const ::XCEngine::UI::UITextureHandle texture =
+                ResolveViewportIcon(m_icons, snapshot.kind);
             if (!texture.IsValid()) {
                 return;
             }
 
-            const TransformComponent* transform = gameObject.GetTransform();
-            if (transform == nullptr) {
-                return;
-            }
-
+            const Vector2 iconSize = ResolveViewportIconSize(snapshot.kind);
             const SceneViewportGizmoSupport::SceneViewportProjectedPoint projectedPoint =
                 SceneViewportGizmoSupport::ProjectSceneViewportWorldPoint(
                     overlay,
                     viewportRect.width,
                     viewportRect.height,
-                    transform->GetPosition());
+                    snapshot.worldPosition);
             if (!projectedPoint.visible) {
                 return;
             }
 
             IconFrame icon = {};
-            icon.entityId = gameObject.GetID();
+            icon.entityId = snapshot.entityId;
             icon.rect = UIRect(
                 viewportRect.x + projectedPoint.screenPosition.x - iconSize.x * 0.5f,
                 viewportRect.y + projectedPoint.screenPosition.y - iconSize.y * 0.5f,
@@ -165,34 +137,13 @@ void SceneViewportSceneOverlay::Refresh(
             icons.push_back(std::move(icon));
         };
 
-    const ::XCEngine::UI::UITextureHandle cameraIcon = ResolveCameraIcon(m_icons);
-    for (CameraComponent* camera : scene->FindObjectsOfType<CameraComponent>()) {
-        if (camera == nullptr || !camera->IsEnabled()) {
+    for (const EditorSceneViewportIconSnapshot& snapshot :
+         sceneRuntime.BuildSceneViewportIconSnapshots()) {
+        if (!snapshot.IsValid()) {
             continue;
         }
 
-        GameObject* gameObject = camera->GetGameObject();
-        if (!CanBuildSceneIcon(gameObject)) {
-            continue;
-        }
-
-        tryAppendIcon(*gameObject, kCameraIconSize, cameraIcon);
-    }
-
-    for (LightComponent* light : scene->FindObjectsOfType<LightComponent>()) {
-        if (light == nullptr || !light->IsEnabled()) {
-            continue;
-        }
-
-        GameObject* gameObject = light->GetGameObject();
-        if (!CanBuildSceneIcon(gameObject)) {
-            continue;
-        }
-
-        tryAppendIcon(
-            *gameObject,
-            kLightIconSize,
-            ResolveLightIcon(m_icons, *light));
+        tryAppendIcon(snapshot);
     }
 
     if (icons.empty()) {