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

Extract bounded additional scene lights

Browse Source
This commit is contained in:
ssdfasd
2026-04-05 15:55:48 +08:00
parent 2c96f0d164
commit 18f53bd920
6 changed files with 555 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

277
engine/src/Rendering/SceneRenderRequestPlanner.cpp
View File

@@ -1,12 +1,19 @@
#include "Rendering/SceneRenderRequestPlanner.h"
#include "Components/GameObject.h"
#include "Components/LightComponent.h"
#include "Components/MeshFilterComponent.h"
#include "Components/MeshRendererComponent.h"
#include "Core/Math/Matrix4.h"
#include "Core/Math/Quaternion.h"
#include "Rendering/RenderSceneUtility.h"
#include "Rendering/SceneRenderRequestUtils.h"
#include "Scene/Scene.h"
#include <array>
#include <algorithm>
#include <limits>
namespace XCEngine {
namespace Rendering {
@@ -15,42 +22,12 @@ namespace {
constexpr uint32_t kDirectionalShadowMapDimension = 1024;
constexpr float kMinShadowFocusDistance = 5.0f;
constexpr float kMaxShadowFocusDistance = 25.0f;
constexpr float kPerspectiveShadowFocusFactor = 0.25f;
constexpr float kMaxShadowFocusDistance = 64.0f;
constexpr float kPerspectiveShadowFocusFactor = 1.0f;
constexpr float kOrthographicShadowFocusFactor = 2.0f;
constexpr float kMinShadowHalfExtent = 10.0f;
constexpr float kMaxShadowHalfExtent = 40.0f;
constexpr float kPerspectiveShadowCoverageFactor = 0.20f;
constexpr float kOrthographicShadowCoverageFactor = 2.0f;
constexpr float kShadowNearClipPlane = 0.1f;
constexpr float kMinShadowDepthRange = 20.0f;
bool IsUsableDirectionalLight(const Components::LightComponent* light) {
return light != nullptr &&
light->IsEnabled() &&
light->GetGameObject() != nullptr &&
light->GetGameObject()->IsActiveInHierarchy() &&
light->GetLightType() == Components::LightType::Directional;
}
Components::LightComponent* FindMainDirectionalLight(const Components::Scene& scene) {
const std::vector<Components::LightComponent*> lights =
scene.FindObjectsOfType<Components::LightComponent>();
Components::LightComponent* mainDirectionalLight = nullptr;
for (Components::LightComponent* light : lights) {
if (!IsUsableDirectionalLight(light)) {
continue;
}
if (mainDirectionalLight == nullptr ||
light->GetIntensity() > mainDirectionalLight->GetIntensity()) {
mainDirectionalLight = light;
}
}
return mainDirectionalLight;
}
constexpr float kShadowBoundsPadding = 1.0f;
constexpr float kMinShadowDepthPadding = 2.0f;
bool ShouldPlanDirectionalShadowForCamera(
const Components::CameraComponent& camera,
@@ -64,9 +41,68 @@ bool ShouldPlanDirectionalShadowForCamera(
return true;
}
std::array<Math::Vector3, 8> BuildBoundsCorners(const Math::Bounds& bounds) {
const Math::Vector3 min = bounds.GetMin();
const Math::Vector3 max = bounds.GetMax();
return {
min,
Math::Vector3(max.x, min.y, min.z),
Math::Vector3(min.x, max.y, min.z),
Math::Vector3(min.x, min.y, max.z),
max,
Math::Vector3(min.x, max.y, max.z),
Math::Vector3(max.x, min.y, max.z),
Math::Vector3(max.x, max.y, min.z)
};
}
Math::Bounds TransformBoundsToWorldSpace(
const Math::Bounds& localBounds,
const Math::Matrix4x4& localToWorld,
std::array<Math::Vector3, 8>* outWorldCorners = nullptr) {
const std::array<Math::Vector3, 8> localCorners = BuildBoundsCorners(localBounds);
std::array<Math::Vector3, 8> worldCorners = {};
for (size_t index = 0; index < localCorners.size(); ++index) {
worldCorners[index] = localToWorld.MultiplyPoint(localCorners[index]);
}
Math::Bounds worldBounds(worldCorners[0], Math::Vector3::Zero());
for (size_t index = 1; index < worldCorners.size(); ++index) {
worldBounds.Encapsulate(worldCorners[index]);
}
if (outWorldCorners != nullptr) {
*outWorldCorners = worldCorners;
}
return worldBounds;
}
void ExpandLightSpaceBounds(
const Math::Matrix4x4& view,
const std::array<Math::Vector3, 8>& worldCorners,
float& minX,
float& maxX,
float& minY,
float& maxY,
float& minZ,
float& maxZ) {
for (const Math::Vector3& corner : worldCorners) {
const Math::Vector3 cornerLS = view.MultiplyPoint(corner);
minX = std::min(minX, cornerLS.x);
maxX = std::max(maxX, cornerLS.x);
minY = std::min(minY, cornerLS.y);
maxY = std::max(maxY, cornerLS.y);
minZ = std::min(minZ, cornerLS.z);
maxZ = std::max(maxZ, cornerLS.z);
}
}
DirectionalShadowRenderPlan BuildDirectionalShadowRenderPlan(
const Components::Scene& scene,
const Components::CameraComponent& camera,
const Components::LightComponent& light) {
const Components::LightComponent& light,
float viewportAspect) {
DirectionalShadowRenderPlan plan = {};
if (!light.GetCastsShadows()) {
return plan;
@@ -82,9 +118,16 @@ DirectionalShadowRenderPlan BuildDirectionalShadowRenderPlan(
const Math::Vector3 viewForward = camera.transform().GetForward().SqrMagnitude() <= Math::EPSILON
? Math::Vector3::Forward()
: camera.transform().GetForward().Normalized();
const Math::Vector3 viewRight = camera.transform().GetRight().SqrMagnitude() <= Math::EPSILON
? Math::Vector3::Right()
: camera.transform().GetRight().Normalized();
const Math::Vector3 viewUp = camera.transform().GetUp().SqrMagnitude() <= Math::EPSILON
? Math::Vector3::Up()
: camera.transform().GetUp().Normalized();
const Math::Vector3 cameraPosition = camera.transform().GetPosition();
const float aspect = viewportAspect > Math::EPSILON ? viewportAspect : 1.0f;
const float focusDistance = camera.GetProjectionType() == Components::CameraProjectionType::Perspective
const float shadowDistance = camera.GetProjectionType() == Components::CameraProjectionType::Perspective
? std::clamp(
camera.GetFarClipPlane() * kPerspectiveShadowFocusFactor,
kMinShadowFocusDistance,
@@ -93,42 +136,151 @@ DirectionalShadowRenderPlan BuildDirectionalShadowRenderPlan(
camera.GetOrthographicSize() * kOrthographicShadowFocusFactor,
kMinShadowFocusDistance,
kMaxShadowFocusDistance);
const Math::Vector3 focusPoint = cameraPosition + viewForward * focusDistance;
const float sliceNear = std::max(camera.GetNearClipPlane(), 0.1f);
const float sliceFar = std::max(sliceNear + 0.1f, shadowDistance);
const float shadowHalfExtent = camera.GetProjectionType() == Components::CameraProjectionType::Perspective
? std::clamp(
camera.GetFarClipPlane() * kPerspectiveShadowCoverageFactor,
kMinShadowHalfExtent,
kMaxShadowHalfExtent)
: std::clamp(
camera.GetOrthographicSize() * kOrthographicShadowCoverageFactor,
kMinShadowHalfExtent,
kMaxShadowHalfExtent);
const float shadowDepthRange = std::max(shadowHalfExtent * 4.0f, kMinShadowDepthRange);
std::array<Math::Vector3, 8> frustumCorners = {};
if (camera.GetProjectionType() == Components::CameraProjectionType::Perspective) {
const float tanHalfFov = std::tan(camera.GetFieldOfView() * Math::DEG_TO_RAD * 0.5f);
const float nearHalfHeight = tanHalfFov * sliceNear;
const float nearHalfWidth = nearHalfHeight * aspect;
const float farHalfHeight = tanHalfFov * sliceFar;
const float farHalfWidth = farHalfHeight * aspect;
const Math::Vector3 nearCenter = cameraPosition + viewForward * sliceNear;
const Math::Vector3 farCenter = cameraPosition + viewForward * sliceFar;
frustumCorners[0] = nearCenter - viewRight * nearHalfWidth - viewUp * nearHalfHeight;
frustumCorners[1] = nearCenter + viewRight * nearHalfWidth - viewUp * nearHalfHeight;
frustumCorners[2] = nearCenter - viewRight * nearHalfWidth + viewUp * nearHalfHeight;
frustumCorners[3] = nearCenter + viewRight * nearHalfWidth + viewUp * nearHalfHeight;
frustumCorners[4] = farCenter - viewRight * farHalfWidth - viewUp * farHalfHeight;
frustumCorners[5] = farCenter + viewRight * farHalfWidth - viewUp * farHalfHeight;
frustumCorners[6] = farCenter - viewRight * farHalfWidth + viewUp * farHalfHeight;
frustumCorners[7] = farCenter + viewRight * farHalfWidth + viewUp * farHalfHeight;
} else {
const float orthoHalfHeight = camera.GetOrthographicSize();
const float orthoHalfWidth = orthoHalfHeight * aspect;
const Math::Vector3 nearCenter = cameraPosition + viewForward * sliceNear;
const Math::Vector3 farCenter = cameraPosition + viewForward * sliceFar;
frustumCorners[0] = nearCenter - viewRight * orthoHalfWidth - viewUp * orthoHalfHeight;
frustumCorners[1] = nearCenter + viewRight * orthoHalfWidth - viewUp * orthoHalfHeight;
frustumCorners[2] = nearCenter - viewRight * orthoHalfWidth + viewUp * orthoHalfHeight;
frustumCorners[3] = nearCenter + viewRight * orthoHalfWidth + viewUp * orthoHalfHeight;
frustumCorners[4] = farCenter - viewRight * orthoHalfWidth - viewUp * orthoHalfHeight;
frustumCorners[5] = farCenter + viewRight * orthoHalfWidth - viewUp * orthoHalfHeight;
frustumCorners[6] = farCenter - viewRight * orthoHalfWidth + viewUp * orthoHalfHeight;
frustumCorners[7] = farCenter + viewRight * orthoHalfWidth + viewUp * orthoHalfHeight;
}
Math::Vector3 focusPoint = Math::Vector3::Zero();
for (const Math::Vector3& corner : frustumCorners) {
focusPoint += corner;
}
focusPoint /= static_cast<float>(frustumCorners.size());
Math::Bounds frustumWorldBounds(frustumCorners[0], Math::Vector3::Zero());
for (size_t index = 1; index < frustumCorners.size(); ++index) {
frustumWorldBounds.Encapsulate(frustumCorners[index]);
}
const float shadowViewDistance = std::max(sliceFar, kMinShadowDepthRange * 0.5f);
const Math::Vector3 shadowWorldPosition =
focusPoint - lightDirection * (shadowDepthRange * 0.5f);
focusPoint + lightDirection * shadowViewDistance;
Math::Vector3 shadowUp = Math::Vector3::Up();
if (std::abs(Math::Vector3::Dot(lightDirection, shadowUp)) > 0.98f) {
shadowUp = Math::Vector3::Forward();
}
const Math::Matrix4x4 view =
Math::Matrix4x4::LookAt(shadowWorldPosition, focusPoint, shadowUp);
const Math::Vector3 shadowForward = (focusPoint - shadowWorldPosition).SqrMagnitude() <= Math::EPSILON
? (lightDirection * -1.0f)
: (focusPoint - shadowWorldPosition).Normalized();
const Math::Quaternion shadowRotation = Math::Quaternion::LookRotation(shadowForward, shadowUp);
const Math::Matrix4x4 view = Math::Matrix4x4::TRS(
shadowWorldPosition,
shadowRotation,
Math::Vector3::One()).Inverse();
float minX = std::numeric_limits<float>::max();
float maxX = std::numeric_limits<float>::lowest();
float minY = std::numeric_limits<float>::max();
float maxY = std::numeric_limits<float>::lowest();
float minZ = std::numeric_limits<float>::max();
float maxZ = std::numeric_limits<float>::lowest();
ExpandLightSpaceBounds(view, frustumCorners, minX, maxX, minY, maxY, minZ, maxZ);
const uint32_t cullingMask = camera.GetCullingMask();
const std::vector<Components::MeshFilterComponent*> meshFilters =
scene.FindObjectsOfType<Components::MeshFilterComponent>();
for (Components::MeshFilterComponent* meshFilter : meshFilters) {
if (meshFilter == nullptr ||
!meshFilter->IsEnabled() ||
meshFilter->GetGameObject() == nullptr) {
continue;
}
Components::GameObject* gameObject = meshFilter->GetGameObject();
if (!gameObject->IsActiveInHierarchy()) {
continue;
}
const uint32_t gameObjectLayerMask = 1u << gameObject->GetLayer();
if ((cullingMask & gameObjectLayerMask) == 0u) {
continue;
}
Components::MeshRendererComponent* meshRenderer =
gameObject->GetComponent<Components::MeshRendererComponent>();
if (meshRenderer == nullptr ||
!meshRenderer->IsEnabled() ||
(!meshRenderer->GetCastShadows() && !meshRenderer->GetReceiveShadows())) {
continue;
}
Resources::Mesh* mesh = meshFilter->GetMesh();
if (mesh == nullptr || !mesh->IsValid()) {
continue;
}
std::array<Math::Vector3, 8> worldCorners = {};
const Math::Bounds worldBounds = TransformBoundsToWorldSpace(
mesh->GetBounds(),
gameObject->GetTransform()->GetLocalToWorldMatrix(),
&worldCorners);
if (!frustumWorldBounds.Intersects(worldBounds)) {
continue;
}
ExpandLightSpaceBounds(view, worldCorners, minX, maxX, minY, maxY, minZ, maxZ);
}
minX -= kShadowBoundsPadding;
maxX += kShadowBoundsPadding;
minY -= kShadowBoundsPadding;
maxY += kShadowBoundsPadding;
minZ -= kMinShadowDepthPadding;
maxZ += kMinShadowDepthPadding;
const float shadowHalfExtent = std::max(
std::max(std::abs(minX), std::abs(maxX)),
std::max(std::abs(minY), std::abs(maxY)));
const float shadowDepthRange = std::max(maxZ - minZ, kMinShadowDepthRange);
const Math::Matrix4x4 projection = Math::Matrix4x4::Orthographic(
-shadowHalfExtent,
shadowHalfExtent,
-shadowHalfExtent,
shadowHalfExtent,
kShadowNearClipPlane,
shadowDepthRange);
minX,
maxX,
minY,
maxY,
minZ,
maxZ);
plan.enabled = true;
plan.lightDirection = lightDirection;
plan.focusPoint = focusPoint;
plan.orthographicHalfExtent = shadowHalfExtent;
plan.nearClipPlane = kShadowNearClipPlane;
plan.farClipPlane = shadowDepthRange;
plan.nearClipPlane = minZ;
plan.farClipPlane = maxZ;
plan.mapWidth = kDirectionalShadowMapDimension;
plan.mapHeight = kDirectionalShadowMapDimension;
plan.cameraData.view = view.Transpose();
@@ -195,11 +347,16 @@ std::vector<CameraRenderRequest> SceneRenderRequestPlanner::BuildRequests(
*camera,
renderedBaseCameraCount,
requests.size())) {
if (Components::LightComponent* mainDirectionalLight = FindMainDirectionalLight(scene);
if (Components::LightComponent* mainDirectionalLight =
FindMainDirectionalLight(scene, camera->GetCullingMask());
mainDirectionalLight != nullptr &&
mainDirectionalLight->GetCastsShadows()) {
const float viewportAspect = surface.GetRenderAreaHeight() > 0
? static_cast<float>(surface.GetRenderAreaWidth()) /
static_cast<float>(surface.GetRenderAreaHeight())
: 1.0f;
request.directionalShadow =
BuildDirectionalShadowRenderPlan(*camera, *mainDirectionalLight);
BuildDirectionalShadowRenderPlan(scene, *camera, *mainDirectionalLight, viewportAspect);
if (request.directionalShadow.IsValid()) {
request.shadowCaster.clearFlags = RenderClearFlags::Depth;
request.shadowCaster.hasCameraDataOverride = true;