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

feat: add explicit camera stack ordering

Browse Source
This commit is contained in:
ssdfasd
2026-04-01 13:10:32 +08:00
parent f80fb9860e
commit a908e61ecb
6 changed files with 100 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
engine/include/XCEngine/Components/CameraComponent.h
View File

@@ -19,6 +19,11 @@ enum class CameraClearMode {
None
};
enum class CameraStackType {
Base = 0,
Overlay
};
class CameraComponent : public Component {
public:
std::string GetName() const override { return "Camera"; }
@@ -47,6 +52,9 @@ public:
CameraClearMode GetClearMode() const { return m_clearMode; }
void SetClearMode(CameraClearMode value) { m_clearMode = value; }
CameraStackType GetStackType() const { return m_stackType; }
void SetStackType(CameraStackType value) { m_stackType = value; }
uint32_t GetCullingMask() const { return m_cullingMask; }
void SetCullingMask(uint32_t value) { m_cullingMask = value; }
@@ -68,6 +76,7 @@ private:
float m_depth = 0.0f;
bool m_primary = true;
CameraClearMode m_clearMode = CameraClearMode::Auto;
CameraStackType m_stackType = CameraStackType::Base;
uint32_t m_cullingMask = 0xFFFFFFFFu;
Math::Rect m_viewportRect = Math::Rect(0.0f, 0.0f, 1.0f, 1.0f);
Math::Color m_clearColor = Math::Color(0.192f, 0.302f, 0.475f, 1.0f);

1
engine/include/XCEngine/Rendering/CameraRenderRequest.h
View File

@@ -19,6 +19,7 @@ struct CameraRenderRequest {
RenderContext context;
RenderSurface surface;
float cameraDepth = 0.0f;
uint8_t cameraStackOrder = 0;
RenderClearFlags clearFlags = RenderClearFlags::All;
RenderPassSequence* preScenePasses = nullptr;
RenderPassSequence* postScenePasses = nullptr;

3
engine/src/Components/CameraComponent.cpp
View File

@@ -44,6 +44,7 @@ void CameraComponent::Serialize(std::ostream& os) const {
os << "depth=" << m_depth << ";";
os << "primary=" << (m_primary ? 1 : 0) << ";";
os << "clearMode=" << static_cast<int>(m_clearMode) << ";";
os << "stackType=" << static_cast<int>(m_stackType) << ";";
os << "cullingMask=" << m_cullingMask << ";";
os << "viewportRect=" << m_viewportRect.x << "," << m_viewportRect.y << "," << m_viewportRect.width << "," << m_viewportRect.height << ";";
os << "clearColor=" << m_clearColor.r << "," << m_clearColor.g << "," << m_clearColor.b << "," << m_clearColor.a << ";";
@@ -80,6 +81,8 @@ void CameraComponent::Deserialize(std::istream& is) {
m_primary = (std::stoi(value) != 0);
} else if (key == "clearMode") {
m_clearMode = static_cast<CameraClearMode>(std::stoi(value));
} else if (key == "stackType") {
m_stackType = static_cast<CameraStackType>(std::stoi(value));
} else if (key == "cullingMask") {
m_cullingMask = static_cast<uint32_t>(std::stoul(value));
} else if (key == "viewportRect") {

29
engine/src/Rendering/SceneRenderer.cpp
View File

@@ -13,6 +13,10 @@ namespace Rendering {
namespace {
bool CompareCameraRenderRequest(const CameraRenderRequest& lhs, const CameraRenderRequest& rhs) {
if (lhs.cameraStackOrder != rhs.cameraStackOrder) {
return lhs.cameraStackOrder < rhs.cameraStackOrder;
}
if (lhs.cameraDepth != rhs.cameraDepth) {
return lhs.cameraDepth < rhs.cameraDepth;
}
@@ -27,7 +31,10 @@ bool IsUsableCamera(const Components::CameraComponent* camera) {
camera->GetGameObject()->IsActiveInHierarchy();
}
RenderClearFlags ResolveClearFlags(const Components::CameraComponent& camera, size_t cameraIndex) {
RenderClearFlags ResolveClearFlags(
const Components::CameraComponent& camera,
size_t renderedBaseCameraCount,
size_t renderedRequestCount) {
switch (camera.GetClearMode()) {
case Components::CameraClearMode::ColorAndDepth:
return RenderClearFlags::All;
@@ -37,7 +44,11 @@ RenderClearFlags ResolveClearFlags(const Components::CameraComponent& camera, si
return RenderClearFlags::None;
case Components::CameraClearMode::Auto:
default:
return cameraIndex == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
if (camera.GetStackType() == Components::CameraStackType::Overlay) {
return renderedRequestCount == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
}
return renderedBaseCameraCount == 0 ? RenderClearFlags::All : RenderClearFlags::Depth;
}
}
@@ -101,6 +112,10 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
cameras.begin(),
cameras.end(),
[](const Components::CameraComponent* lhs, const Components::CameraComponent* rhs) {
if (lhs->GetStackType() != rhs->GetStackType()) {
return static_cast<int>(lhs->GetStackType()) < static_cast<int>(rhs->GetStackType());
}
if (lhs->GetDepth() != rhs->GetDepth()) {
return lhs->GetDepth() < rhs->GetDepth();
}
@@ -108,8 +123,8 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
return lhs < rhs;
});
for (size_t cameraIndex = 0; cameraIndex < cameras.size(); ++cameraIndex) {
Components::CameraComponent* camera = cameras[cameraIndex];
size_t renderedBaseCameraCount = 0;
for (Components::CameraComponent* camera : cameras) {
CameraRenderRequest request;
request.scene = &scene;
@@ -118,10 +133,14 @@ std::vector<CameraRenderRequest> SceneRenderer::BuildRenderRequests(
request.surface = surface;
request.surface.SetRenderArea(ResolveCameraRenderArea(*camera, surface));
request.cameraDepth = camera->GetDepth();
request.clearFlags = ResolveClearFlags(*camera, cameraIndex);
request.cameraStackOrder = static_cast<uint8_t>(camera->GetStackType());
request.clearFlags = ResolveClearFlags(*camera, renderedBaseCameraCount, requests.size());
if (request.surface.GetRenderAreaWidth() > 0 &&
request.surface.GetRenderAreaHeight() > 0) {
requests.push_back(request);
if (camera->GetStackType() == Components::CameraStackType::Base) {
++renderedBaseCameraCount;
}
}
}

3
tests/Components/test_camera_light_component.cpp
View File

@@ -19,6 +19,7 @@ TEST(CameraComponent_Test, DefaultValues) {
EXPECT_FLOAT_EQ(camera.GetFarClipPlane(), 1000.0f);
EXPECT_TRUE(camera.IsPrimary());
EXPECT_EQ(camera.GetClearMode(), CameraClearMode::Auto);
EXPECT_EQ(camera.GetStackType(), CameraStackType::Base);
EXPECT_EQ(camera.GetCullingMask(), 0xFFFFFFFFu);
EXPECT_FLOAT_EQ(camera.GetViewportRect().x, 0.0f);
EXPECT_FLOAT_EQ(camera.GetViewportRect().y, 0.0f);
@@ -53,6 +54,7 @@ TEST(CameraComponent_Test, ViewportRectIsClampedToNormalizedSurfaceRange) {
TEST(CameraComponent_Test, SerializeRoundTripPreservesViewportAndClearState) {
CameraComponent source;
source.SetClearMode(CameraClearMode::DepthOnly);
source.SetStackType(CameraStackType::Overlay);
source.SetCullingMask(0x0000000Fu);
source.SetViewportRect(XCEngine::Math::Rect(0.25f, 0.125f, 0.5f, 0.625f));
@@ -63,6 +65,7 @@ TEST(CameraComponent_Test, SerializeRoundTripPreservesViewportAndClearState) {
target.Deserialize(stream);
EXPECT_EQ(target.GetClearMode(), CameraClearMode::DepthOnly);
EXPECT_EQ(target.GetStackType(), CameraStackType::Overlay);
EXPECT_EQ(target.GetCullingMask(), 0x0000000Fu);
EXPECT_FLOAT_EQ(target.GetViewportRect().x, 0.25f);
EXPECT_FLOAT_EQ(target.GetViewportRect().y, 0.125f);

60
tests/Rendering/unit/test_camera_scene_renderer.cpp
View File

@@ -331,6 +331,64 @@ TEST(SceneRenderer_Test, BuildsSortedRequestsForAllUsableCamerasAndHonorsOverrid
EXPECT_EQ(overrideRequests[0].clearFlags, RenderClearFlags::All);
}
TEST(SceneRenderer_Test, RendersBaseCamerasBeforeOverlayCamerasAndResolvesAutoClearPerStackType) {
Scene scene("SceneRendererCameraStackScene");
GameObject* lateBaseCameraObject = scene.CreateGameObject("LateBaseCamera");
auto* lateBaseCamera = lateBaseCameraObject->AddComponent<CameraComponent>();
lateBaseCamera->SetDepth(10.0f);
lateBaseCamera->SetStackType(CameraStackType::Base);
GameObject* earlyBaseCameraObject = scene.CreateGameObject("EarlyBaseCamera");
auto* earlyBaseCamera = earlyBaseCameraObject->AddComponent<CameraComponent>();
earlyBaseCamera->SetDepth(1.0f);
earlyBaseCamera->SetStackType(CameraStackType::Base);
GameObject* overlayCameraObject = scene.CreateGameObject("OverlayCamera");
auto* overlayCamera = overlayCameraObject->AddComponent<CameraComponent>();
overlayCamera->SetDepth(-10.0f);
overlayCamera->SetStackType(CameraStackType::Overlay);
SceneRenderer renderer;
const std::vector<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(640, 360));
ASSERT_EQ(requests.size(), 3u);
EXPECT_EQ(requests[0].camera, earlyBaseCamera);
EXPECT_EQ(requests[0].cameraStackOrder, 0u);
EXPECT_EQ(requests[0].clearFlags, RenderClearFlags::All);
EXPECT_EQ(requests[1].camera, lateBaseCamera);
EXPECT_EQ(requests[1].cameraStackOrder, 0u);
EXPECT_EQ(requests[1].clearFlags, RenderClearFlags::Depth);
EXPECT_EQ(requests[2].camera, overlayCamera);
EXPECT_EQ(requests[2].cameraStackOrder, 1u);
EXPECT_EQ(requests[2].clearFlags, RenderClearFlags::Depth);
}
TEST(SceneRenderer_Test, FallsBackToColorClearForFirstOverlayCameraWhenNoBaseCameraExists) {
Scene scene("SceneRendererOverlayOnlyScene");
GameObject* firstOverlayObject = scene.CreateGameObject("FirstOverlay");
auto* firstOverlay = firstOverlayObject->AddComponent<CameraComponent>();
firstOverlay->SetDepth(1.0f);
firstOverlay->SetStackType(CameraStackType::Overlay);
GameObject* secondOverlayObject = scene.CreateGameObject("SecondOverlay");
auto* secondOverlay = secondOverlayObject->AddComponent<CameraComponent>();
secondOverlay->SetDepth(2.0f);
secondOverlay->SetStackType(CameraStackType::Overlay);
SceneRenderer renderer;
const std::vector<CameraRenderRequest> requests =
renderer.BuildRenderRequests(scene, nullptr, CreateValidContext(), RenderSurface(320, 180));
ASSERT_EQ(requests.size(), 2u);
EXPECT_EQ(requests[0].camera, firstOverlay);
EXPECT_EQ(requests[0].clearFlags, RenderClearFlags::All);
EXPECT_EQ(requests[1].camera, secondOverlay);
EXPECT_EQ(requests[1].clearFlags, RenderClearFlags::Depth);
}
TEST(SceneRenderer_Test, HonorsExplicitOverrideCameraClearMode) {
Scene scene("SceneRendererOverrideClearModeScene");
@@ -493,11 +551,13 @@ TEST(SceneRenderer_Test, SortsManualCameraRequestsByDepthBeforeRendering) {
farRequest.context = CreateValidContext();
farRequest.surface = RenderSurface(800, 600);
farRequest.cameraDepth = farCamera->GetDepth();
farRequest.cameraStackOrder = 1;
farRequest.clearFlags = RenderClearFlags::None;
CameraRenderRequest nearRequest = farRequest;
nearRequest.camera = nearCamera;
nearRequest.cameraDepth = nearCamera->GetDepth();
nearRequest.cameraStackOrder = 0;
nearRequest.clearFlags = RenderClearFlags::Depth;
const std::vector<CameraRenderRequest> requests = { farRequest, nearRequest };