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