Group rendering execution and planning files
This commit is contained in:
378
engine/src/Rendering/Planning/SceneRenderRequestPlanner.cpp
Normal file
378
engine/src/Rendering/Planning/SceneRenderRequestPlanner.cpp
Normal file
@@ -0,0 +1,378 @@
|
||||
#include "Rendering/Planning/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/Planning/SceneRenderRequestUtils.h"
|
||||
|
||||
#include "Scene/Scene.h"
|
||||
|
||||
#include <array>
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
|
||||
namespace XCEngine {
|
||||
namespace Rendering {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr uint32_t kDirectionalShadowMapDimension = 1024;
|
||||
constexpr float kMinShadowFocusDistance = 5.0f;
|
||||
constexpr float kMaxShadowFocusDistance = 64.0f;
|
||||
constexpr float kPerspectiveShadowFocusFactor = 1.0f;
|
||||
constexpr float kOrthographicShadowFocusFactor = 2.0f;
|
||||
constexpr float kMinShadowDepthRange = 20.0f;
|
||||
constexpr float kShadowBoundsPadding = 1.0f;
|
||||
constexpr float kMinShadowDepthPadding = 2.0f;
|
||||
|
||||
bool ShouldPlanDirectionalShadowForCamera(
|
||||
const Components::CameraComponent& camera,
|
||||
size_t renderedBaseCameraCount,
|
||||
size_t renderedRequestCount) {
|
||||
if (camera.GetStackType() == Components::CameraStackType::Overlay) {
|
||||
return renderedBaseCameraCount == 0u &&
|
||||
renderedRequestCount == 0u;
|
||||
}
|
||||
|
||||
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,
|
||||
float viewportAspect) {
|
||||
DirectionalShadowRenderPlan plan = {};
|
||||
if (!light.GetCastsShadows()) {
|
||||
return plan;
|
||||
}
|
||||
|
||||
Math::Vector3 lightDirection = light.transform().GetForward() * -1.0f;
|
||||
if (lightDirection.SqrMagnitude() <= Math::EPSILON) {
|
||||
lightDirection = Math::Vector3::Back();
|
||||
} else {
|
||||
lightDirection = lightDirection.Normalized();
|
||||
}
|
||||
|
||||
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 shadowDistance = camera.GetProjectionType() == Components::CameraProjectionType::Perspective
|
||||
? std::clamp(
|
||||
camera.GetFarClipPlane() * kPerspectiveShadowFocusFactor,
|
||||
kMinShadowFocusDistance,
|
||||
kMaxShadowFocusDistance)
|
||||
: std::clamp(
|
||||
camera.GetOrthographicSize() * kOrthographicShadowFocusFactor,
|
||||
kMinShadowFocusDistance,
|
||||
kMaxShadowFocusDistance);
|
||||
const float sliceNear = std::max(camera.GetNearClipPlane(), 0.1f);
|
||||
const float sliceFar = std::max(sliceNear + 0.1f, shadowDistance);
|
||||
|
||||
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 * shadowViewDistance;
|
||||
|
||||
Math::Vector3 shadowUp = Math::Vector3::Up();
|
||||
if (std::abs(Math::Vector3::Dot(lightDirection, shadowUp)) > 0.98f) {
|
||||
shadowUp = Math::Vector3::Forward();
|
||||
}
|
||||
|
||||
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(
|
||||
minX,
|
||||
maxX,
|
||||
minY,
|
||||
maxY,
|
||||
minZ,
|
||||
maxZ);
|
||||
|
||||
plan.enabled = true;
|
||||
plan.lightDirection = lightDirection;
|
||||
plan.focusPoint = focusPoint;
|
||||
plan.orthographicHalfExtent = shadowHalfExtent;
|
||||
plan.nearClipPlane = minZ;
|
||||
plan.farClipPlane = maxZ;
|
||||
plan.mapWidth = kDirectionalShadowMapDimension;
|
||||
plan.mapHeight = kDirectionalShadowMapDimension;
|
||||
plan.cameraData.view = view.Transpose();
|
||||
plan.cameraData.projection = projection.Transpose();
|
||||
plan.cameraData.viewProjection = (projection * view).Transpose();
|
||||
plan.cameraData.worldPosition = shadowWorldPosition;
|
||||
plan.cameraData.clearColor = Math::Color::Black();
|
||||
plan.cameraData.clearFlags = RenderClearFlags::Depth;
|
||||
plan.cameraData.viewportWidth = plan.mapWidth;
|
||||
plan.cameraData.viewportHeight = plan.mapHeight;
|
||||
return plan;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
std::vector<Components::CameraComponent*> SceneRenderRequestPlanner::CollectCameras(
|
||||
const Components::Scene& scene,
|
||||
Components::CameraComponent* overrideCamera) const {
|
||||
std::vector<Components::CameraComponent*> cameras;
|
||||
|
||||
if (SceneRenderRequestUtils::IsUsableCamera(overrideCamera)) {
|
||||
cameras.push_back(overrideCamera);
|
||||
return cameras;
|
||||
}
|
||||
|
||||
cameras = scene.FindObjectsOfType<Components::CameraComponent>();
|
||||
cameras.erase(
|
||||
std::remove_if(
|
||||
cameras.begin(),
|
||||
cameras.end(),
|
||||
[](const Components::CameraComponent* camera) {
|
||||
return !SceneRenderRequestUtils::IsUsableCamera(camera);
|
||||
}),
|
||||
cameras.end());
|
||||
|
||||
SceneRenderRequestUtils::SortSceneCamerasForRendering(cameras);
|
||||
return cameras;
|
||||
}
|
||||
|
||||
std::vector<CameraRenderRequest> SceneRenderRequestPlanner::BuildRequests(
|
||||
const Components::Scene& scene,
|
||||
Components::CameraComponent* overrideCamera,
|
||||
const RenderContext& context,
|
||||
const RenderSurface& surface) const {
|
||||
std::vector<CameraRenderRequest> requests;
|
||||
const std::vector<Components::CameraComponent*> cameras =
|
||||
CollectCameras(scene, overrideCamera);
|
||||
|
||||
size_t renderedBaseCameraCount = 0;
|
||||
for (Components::CameraComponent* camera : cameras) {
|
||||
CameraRenderRequest request;
|
||||
if (!SceneRenderRequestUtils::BuildCameraRenderRequest(
|
||||
scene,
|
||||
*camera,
|
||||
context,
|
||||
surface,
|
||||
renderedBaseCameraCount,
|
||||
requests.size(),
|
||||
request)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ShouldPlanDirectionalShadowForCamera(
|
||||
*camera,
|
||||
renderedBaseCameraCount,
|
||||
requests.size())) {
|
||||
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(scene, *camera, *mainDirectionalLight, viewportAspect);
|
||||
if (request.directionalShadow.IsValid()) {
|
||||
request.shadowCaster.clearFlags = RenderClearFlags::Depth;
|
||||
request.shadowCaster.hasCameraDataOverride = true;
|
||||
request.shadowCaster.cameraDataOverride = request.directionalShadow.cameraData;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
requests.push_back(request);
|
||||
if (camera->GetStackType() == Components::CameraStackType::Base) {
|
||||
++renderedBaseCameraCount;
|
||||
}
|
||||
}
|
||||
|
||||
return requests;
|
||||
}
|
||||
|
||||
} // namespace Rendering
|
||||
} // namespace XCEngine
|
||||
Reference in New Issue
Block a user