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

refactor(srp): move directional shadow planning policy into managed urp

Browse Source
This commit is contained in:
ssdfasd
2026-04-21 03:01:56 +08:00
parent 1f01f45bee
commit db08861183
8 changed files with 334 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
engine/src/Rendering/Internal/RenderPipelineFactory.cpp
View File

@@ -1,5 +1,7 @@
#include "Rendering/Internal/RenderPipelineFactory.h"
#include <XCEngine/Rendering/RenderPipelineAsset.h>
#include "Rendering/Execution/DirectionalShadowExecutionState.h"
#include "Rendering/Pipelines/BuiltinForwardPipeline.h"
#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
@@ -42,6 +44,8 @@ using PipelineRendererAssetRegistry =
std::unordered_map<std::string, PipelineRendererAssetFactory>;
using CameraFrameStandalonePassRegistry =
std::unordered_map<std::string, CameraFrameStandalonePassFactory>;
using DirectionalShadowPlanningPolicyRegistry =
std::unordered_map<std::string, DirectionalShadowPlanningPolicy>;
using DirectionalShadowExecutionPolicyRegistry =
std::unordered_map<std::string, DirectionalShadowExecutionPolicy>;
@@ -55,6 +59,12 @@ CameraFrameStandalonePassRegistry& GetCameraFrameStandalonePassRegistry() {
return registry;
}
DirectionalShadowPlanningPolicyRegistry&
GetDirectionalShadowPlanningPolicyRegistry() {
static DirectionalShadowPlanningPolicyRegistry registry = {};
return registry;
}
DirectionalShadowExecutionPolicyRegistry&
GetDirectionalShadowExecutionPolicyRegistry() {
static DirectionalShadowExecutionPolicyRegistry registry = {};
@@ -71,6 +81,11 @@ std::unordered_set<std::string>& GetBuiltinCameraFrameStandalonePassKeys() {
return builtinKeys;
}
std::unordered_set<std::string>& GetBuiltinDirectionalShadowPlanningPolicyKeys() {
static std::unordered_set<std::string> builtinKeys = {};
return builtinKeys;
}
std::unordered_set<std::string>&
GetBuiltinDirectionalShadowExecutionPolicyKeys() {
static std::unordered_set<std::string> builtinKeys = {};
@@ -87,6 +102,11 @@ std::mutex& GetCameraFrameStandalonePassRegistryMutex() {
return mutex;
}
std::mutex& GetDirectionalShadowPlanningPolicyRegistryMutex() {
static std::mutex mutex;
return mutex;
}
std::mutex& GetDirectionalShadowExecutionPolicyRegistryMutex() {
static std::mutex mutex;
return mutex;
@@ -128,6 +148,29 @@ void EnsureBuiltinCameraFrameStandalonePassRegistryInitialized() {
(void)initialized;
}
void EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized() {
static const bool initialized = []() {
DirectionalShadowPlanningPolicyRegistry& registry =
GetDirectionalShadowPlanningPolicyRegistry();
registry.emplace(
"BuiltinDirectionalShadowPlanning",
[](CameraRenderRequest& request,
size_t renderedBaseCameraCount,
size_t renderedRequestCount,
const DirectionalShadowPlanningSettings& settings) {
ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
settings);
});
GetBuiltinDirectionalShadowPlanningPolicyKeys().insert(
"BuiltinDirectionalShadowPlanning");
return true;
}();
(void)initialized;
}
void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() {
static const bool initialized = []() {
DirectionalShadowExecutionPolicyRegistry& registry =
@@ -303,6 +346,76 @@ std::unique_ptr<RenderPass> CreateCameraFrameStandalonePassByKey(
return it->second();
}
bool RegisterDirectionalShadowPlanningPolicy(
const std::string& key,
DirectionalShadowPlanningPolicy policy) {
if (key.empty() || !policy) {
return false;
}
EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized();
std::lock_guard<std::mutex> lock(
GetDirectionalShadowPlanningPolicyRegistryMutex());
DirectionalShadowPlanningPolicyRegistry& registry =
GetDirectionalShadowPlanningPolicyRegistry();
if (registry.find(key) != registry.end()) {
return false;
}
registry.emplace(key, std::move(policy));
return true;
}
bool UnregisterDirectionalShadowPlanningPolicy(
const std::string& key) {
if (key.empty()) {
return false;
}
EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized();
std::lock_guard<std::mutex> lock(
GetDirectionalShadowPlanningPolicyRegistryMutex());
if (GetBuiltinDirectionalShadowPlanningPolicyKeys().find(key) !=
GetBuiltinDirectionalShadowPlanningPolicyKeys().end()) {
return false;
}
DirectionalShadowPlanningPolicyRegistry& registry =
GetDirectionalShadowPlanningPolicyRegistry();
return registry.erase(key) != 0u;
}
bool ApplyDirectionalShadowPlanningPolicyByKey(
const std::string& key,
CameraRenderRequest& request,
size_t renderedBaseCameraCount,
size_t renderedRequestCount,
const DirectionalShadowPlanningSettings& settings) {
if (key.empty()) {
return false;
}
EnsureBuiltinDirectionalShadowPlanningPolicyRegistryInitialized();
std::lock_guard<std::mutex> lock(
GetDirectionalShadowPlanningPolicyRegistryMutex());
const DirectionalShadowPlanningPolicyRegistry& registry =
GetDirectionalShadowPlanningPolicyRegistry();
const auto it = registry.find(key);
if (it == registry.end() || !it->second) {
return false;
}
it->second(
request,
renderedBaseCameraCount,
renderedRequestCount,
settings);
return true;
}
bool RegisterDirectionalShadowExecutionPolicy(
const std::string& key,
DirectionalShadowExecutionPolicy policy) {

19
engine/src/Rendering/Internal/RenderPipelineFactory.h
View File

@@ -11,7 +11,9 @@ class NativeSceneRenderer;
class RenderPipeline;
class RenderPipelineAsset;
class RenderPass;
struct CameraRenderRequest;
struct CameraFramePlan;
struct DirectionalShadowPlanningSettings;
struct DirectionalShadowExecutionState;
struct DirectionalShadowSurfaceAllocation;
@@ -21,6 +23,12 @@ using PipelineRendererAssetFactory =
std::function<std::shared_ptr<const RenderPipelineAsset>()>;
using CameraFrameStandalonePassFactory =
std::function<std::unique_ptr<RenderPass>()>;
using DirectionalShadowPlanningPolicy =
std::function<void(
CameraRenderRequest&,
size_t,
size_t,
const DirectionalShadowPlanningSettings&)>;
using DirectionalShadowExecutionPolicy =
std::function<bool(
const CameraFramePlan&,
@@ -42,6 +50,17 @@ bool UnregisterCameraFrameStandalonePassFactory(
const std::string& key);
std::unique_ptr<RenderPass> CreateCameraFrameStandalonePassByKey(
const std::string& key);
bool RegisterDirectionalShadowPlanningPolicy(
const std::string& key,
DirectionalShadowPlanningPolicy policy);
bool UnregisterDirectionalShadowPlanningPolicy(
const std::string& key);
bool ApplyDirectionalShadowPlanningPolicyByKey(
const std::string& key,
CameraRenderRequest& request,
size_t renderedBaseCameraCount,
size_t renderedRequestCount,
const DirectionalShadowPlanningSettings& settings);
bool RegisterDirectionalShadowExecutionPolicy(
const std::string& key,
DirectionalShadowExecutionPolicy policy);

54
engine/src/Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.cpp
View File

@@ -1,6 +1,8 @@
#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
#include "Debug/Logger.h"
#include "Rendering/GraphicsSettingsState.h"
#include "Rendering/Internal/RenderPipelineFactory.h"
#include <utility>
@@ -8,6 +10,39 @@ namespace XCEngine {
namespace Rendering {
namespace Pipelines {
namespace {
void ApplyManagedDirectionalShadowPlanningPolicyOrDefault(
const std::string& assetKey,
CameraRenderRequest& request,
size_t renderedBaseCameraCount,
size_t renderedRequestCount,
const DirectionalShadowPlanningSettings& directionalShadowSettings) {
if (assetKey.empty()) {
ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
return;
}
if (!Rendering::Internal::ApplyDirectionalShadowPlanningPolicyByKey(
assetKey,
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings)) {
Debug::Logger::Get().Error(
Debug::LogCategory::Rendering,
Containers::String(
"ManagedScriptableRenderPipelineAsset failed to resolve directional shadow planning policy asset key: ") +
assetKey.c_str());
}
}
} // namespace
ManagedScriptableRenderPipelineAsset::ManagedScriptableRenderPipelineAsset(
ManagedRenderPipelineAssetDescriptor descriptor)
: m_descriptor(std::move(descriptor)) {
@@ -89,21 +124,28 @@ void ManagedScriptableRenderPipelineAsset::ConfigureCameraRenderRequest(
size_t renderedBaseCameraCount,
size_t renderedRequestCount,
const DirectionalShadowPlanningSettings& directionalShadowSettings) const {
RenderPipelineAsset::ConfigureCameraRenderRequest(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
ResolveManagedAssetRuntime();
runtime != nullptr) {
ApplyManagedDirectionalShadowPlanningPolicyOrDefault(
runtime->GetDirectionalShadowPlanningPolicyAssetKey(),
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
runtime->ConfigureCameraRenderRequest(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
return;
}
RenderPipelineAsset::ConfigureCameraRenderRequest(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
}
void ManagedScriptableRenderPipelineAsset::ConfigureCameraFramePlan(

81
engine/src/Scripting/Mono/MonoScriptRuntime.cpp
View File

@@ -1319,6 +1319,8 @@ public:
GetPipelineRendererAsset() const override;
std::shared_ptr<const Rendering::RenderPipelineAsset>
GetPipelineRendererAsset(int32_t rendererIndex) const override;
std::string GetDirectionalShadowPlanningPolicyAssetKey() const
override;
std::string GetDirectionalShadowExecutionPolicyAssetKey() const
override;
std::string GetDirectionalShadowExecutionPolicyAssetKey(
@@ -1362,6 +1364,8 @@ private:
MonoObject* assetObject) const;
MonoMethod* ResolveGetPipelineRendererAssetKeyContextualMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveGetDirectionalShadowExecutionPolicyAssetKeyMethod(
MonoObject* assetObject) const;
MonoMethod*
@@ -1388,6 +1392,8 @@ private:
mutable MonoMethod* m_getPipelineRendererAssetKeyMethod = nullptr;
mutable MonoMethod* m_getPipelineRendererAssetKeyContextualMethod =
nullptr;
mutable MonoMethod*
m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
mutable MonoMethod*
m_getDirectionalShadowExecutionPolicyAssetKeyMethod = nullptr;
mutable MonoMethod*
@@ -1846,15 +1852,30 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraRenderRequest(
method,
args,
nullptr);
const std::string directionalShadowPlanningPolicyAssetKey =
GetDirectionalShadowPlanningPolicyAssetKey();
if (requestContextState.suppressDirectionalShadow) {
request.directionalShadow = {};
} else if (requestContextState.directionalShadowPlanningSettingsDirty) {
request.directionalShadow = {};
Rendering::ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
requestContextState.directionalShadowPlanningSettings);
if (directionalShadowPlanningPolicyAssetKey.empty()) {
Rendering::ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
requestContextState.directionalShadowPlanningSettings);
} else if (!Rendering::Internal::ApplyDirectionalShadowPlanningPolicyByKey(
directionalShadowPlanningPolicyAssetKey,
request,
renderedBaseCameraCount,
renderedRequestCount,
requestContextState.directionalShadowPlanningSettings)) {
Debug::Logger::Get().Error(
Debug::LogCategory::Rendering,
Containers::String(
"MonoManagedRenderPipelineAssetRuntime failed to resolve directional shadow planning policy asset key: ") +
directionalShadowPlanningPolicyAssetKey.c_str());
}
}
UnregisterManagedCameraRenderRequestContextState(
requestContextHandle);
@@ -1935,7 +1956,7 @@ MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset() const {
std::shared_ptr<const Rendering::RenderPipelineAsset>
MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset(
int32_t rendererIndex) const {
int32_t rendererIndex) const {
if (!SyncManagedAssetRuntimeState()) {
return nullptr;
}
@@ -2029,6 +2050,37 @@ MonoManagedRenderPipelineAssetRuntime::GetPipelineRendererAsset(
return m_pipelineRendererAsset;
}
std::string MonoManagedRenderPipelineAssetRuntime::
GetDirectionalShadowPlanningPolicyAssetKey() const {
if (!SyncManagedAssetRuntimeState()) {
return {};
}
MonoObject* const assetObject = GetManagedAssetObject();
if (assetObject == nullptr) {
return {};
}
MonoMethod* const method =
ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(
assetObject);
if (method == nullptr) {
return {};
}
MonoObject* managedKeyObject = nullptr;
if (!m_runtime->InvokeManagedMethod(
assetObject,
method,
nullptr,
&managedKeyObject)) {
return {};
}
return MonoStringToUtf8(
reinterpret_cast<MonoString*>(managedKeyObject));
}
std::string MonoManagedRenderPipelineAssetRuntime::
GetDirectionalShadowExecutionPolicyAssetKey() const {
return GetDirectionalShadowExecutionPolicyAssetKey(-1);
@@ -2357,6 +2409,7 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
m_getRuntimeResourceVersionMethod = nullptr;
m_getPipelineRendererAssetKeyMethod = nullptr;
m_getPipelineRendererAssetKeyContextualMethod = nullptr;
m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
m_getDirectionalShadowExecutionPolicyAssetKeyMethod = nullptr;
m_getDirectionalShadowExecutionPolicyAssetKeyContextualMethod =
nullptr;
@@ -2510,6 +2563,22 @@ MonoManagedRenderPipelineAssetRuntime::ResolveGetPipelineRendererAssetKeyContext
return m_getPipelineRendererAssetKeyContextualMethod;
}
MonoMethod*
MonoManagedRenderPipelineAssetRuntime::
ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(
MonoObject* assetObject) const {
if (m_getDirectionalShadowPlanningPolicyAssetKeyMethod ==
nullptr) {
m_getDirectionalShadowPlanningPolicyAssetKeyMethod =
m_runtime->ResolveManagedMethod(
assetObject,
"GetDirectionalShadowPlanningPolicyAssetKey",
0);
}
return m_getDirectionalShadowPlanningPolicyAssetKeyMethod;
}
MonoMethod*
MonoManagedRenderPipelineAssetRuntime::
ResolveGetDirectionalShadowExecutionPolicyAssetKeyMethod(