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

refactor(srp): remove native directional shadow planning policy seam

Browse Source
This commit is contained in:
ssdfasd
2026-04-21 18:19:27 +08:00
parent f75164a4fa
commit 0a4c782122
8 changed files with 117 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -45,8 +45,6 @@ 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 CameraFramePlanPolicyRegistry =
std::unordered_map<std::string, CameraFramePlanPolicy>;
using DirectionalShadowExecutionPolicyRegistry =
@@ -62,12 +60,6 @@ CameraFrameStandalonePassRegistry& GetCameraFrameStandalonePassRegistry() {
return registry;
}
DirectionalShadowPlanningPolicyRegistry&
GetDirectionalShadowPlanningPolicyRegistry() {
static DirectionalShadowPlanningPolicyRegistry registry = {};
return registry;
}
CameraFramePlanPolicyRegistry& GetCameraFramePlanPolicyRegistry() {
static CameraFramePlanPolicyRegistry registry = {};
return registry;
@@ -89,11 +81,6 @@ 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>& GetBuiltinCameraFramePlanPolicyKeys() {
static std::unordered_set<std::string> builtinKeys = {};
return builtinKeys;
@@ -115,11 +102,6 @@ std::mutex& GetCameraFrameStandalonePassRegistryMutex() {
return mutex;
}
std::mutex& GetDirectionalShadowPlanningPolicyRegistryMutex() {
static std::mutex mutex;
return mutex;
}
std::mutex& GetCameraFramePlanPolicyRegistryMutex() {
static std::mutex mutex;
return mutex;
@@ -166,29 +148,6 @@ 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 EnsureBuiltinCameraFramePlanPolicyRegistryInitialized() {
static const bool initialized = []() {
CameraFramePlanPolicyRegistry& registry =
@@ -383,76 +342,6 @@ 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 RegisterCameraFramePlanPolicy(
const std::string& key,
CameraFramePlanPolicy policy) {

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

@@ -11,10 +11,8 @@ class NativeSceneRenderer;
class RenderPipeline;
class RenderPipelineAsset;
class RenderPass;
struct CameraRenderRequest;
struct CameraFramePlan;
struct FinalColorSettings;
struct DirectionalShadowPlanningSettings;
struct DirectionalShadowExecutionState;
struct DirectionalShadowSurfaceAllocation;
@@ -24,12 +22,6 @@ 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 CameraFramePlanPolicy =
std::function<void(
CameraFramePlan&,
@@ -55,17 +47,6 @@ 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 RegisterCameraFramePlanPolicy(
const std::string& key,
CameraFramePlanPolicy policy);

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

@@ -1,8 +1,6 @@
#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
#include "Debug/Logger.h"
#include "Rendering/GraphicsSettingsState.h"
#include "Rendering/Internal/RenderPipelineFactory.h"
#include <utility>
@@ -10,39 +8,6 @@ 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)) {
@@ -127,12 +92,6 @@ void ManagedScriptableRenderPipelineAsset::ConfigureCameraRenderRequest(
if (const std::shared_ptr<const ManagedRenderPipelineAssetRuntime> runtime =
ResolveManagedAssetRuntime();
runtime != nullptr) {
ApplyManagedDirectionalShadowPlanningPolicyOrDefault(
runtime->GetDirectionalShadowPlanningPolicyAssetKey(),
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
runtime->ConfigureCameraRenderRequest(
request,
renderedBaseCameraCount,

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

@@ -133,7 +133,6 @@ struct ManagedCameraRenderRequestContextState {
size_t renderedRequestCount = 0u;
Rendering::DirectionalShadowPlanningSettings
directionalShadowPlanningSettings = {};
bool directionalShadowPlanningSettingsDirty = false;
bool suppressDirectionalShadow = false;
};
@@ -1505,8 +1504,6 @@ public:
bool UsesNativeCameraFramePlanBaseline() const override;
bool UsesNativeCameraFramePlanBaseline(
int32_t rendererIndex) const override;
std::string GetDirectionalShadowPlanningPolicyAssetKey() const
override;
std::string GetCameraFrameStandalonePassAssetKey(
Rendering::CameraFrameStage stage) const override;
std::string GetCameraFrameStandalonePassAssetKey(
@@ -1554,8 +1551,6 @@ private:
MonoObject* assetObject) const;
MonoMethod* ResolveConfigureDirectionalShadowExecutionStateMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveGetCameraFrameStandalonePassAssetKeyMethod(
MonoObject* assetObject) const;
MonoMethod*
@@ -1586,8 +1581,6 @@ private:
nullptr;
mutable MonoMethod*
m_configureDirectionalShadowExecutionStateMethod = nullptr;
mutable MonoMethod*
m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
mutable MonoMethod* m_getCameraFrameStandalonePassAssetKeyMethod =
nullptr;
mutable MonoMethod*
@@ -2006,6 +1999,12 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraRenderRequest(
const Rendering::DirectionalShadowPlanningSettings&
directionalShadowSettings) const {
if (!EnsureManagedAsset()) {
request.directionalShadow = {};
Rendering::ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
return;
}
@@ -2013,6 +2012,12 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraRenderRequest(
MonoMethod* const method =
ResolveConfigureCameraRenderRequestMethod(assetObject);
if (assetObject == nullptr || method == nullptr) {
request.directionalShadow = {};
Rendering::ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
return;
}
@@ -2032,6 +2037,12 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraRenderRequest(
if (requestContextObject == nullptr) {
UnregisterManagedCameraRenderRequestContextState(
requestContextHandle);
request.directionalShadow = {};
Rendering::ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
directionalShadowSettings);
return;
}
@@ -2041,30 +2052,14 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraRenderRequest(
method,
args,
nullptr);
const std::string directionalShadowPlanningPolicyAssetKey =
GetDirectionalShadowPlanningPolicyAssetKey();
request.directionalShadow = {};
if (requestContextState.suppressDirectionalShadow) {
request.directionalShadow = {};
} else if (requestContextState.directionalShadowPlanningSettingsDirty) {
request.directionalShadow = {};
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());
}
} else {
Rendering::ApplyDefaultRenderPipelineAssetCameraRenderRequestPolicy(
request,
renderedBaseCameraCount,
renderedRequestCount,
requestContextState.directionalShadowPlanningSettings);
}
UnregisterManagedCameraRenderRequestContextState(
requestContextHandle);
@@ -2385,37 +2380,6 @@ bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline(
usesBaseline;
}
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::
GetCameraFrameStandalonePassAssetKey(
Rendering::CameraFrameStage stage) const {
@@ -2693,7 +2657,6 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr;
m_configureRenderSceneSetupMethod = nullptr;
m_configureDirectionalShadowExecutionStateMethod = nullptr;
m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
m_getCameraFrameStandalonePassAssetKeyMethod = nullptr;
m_getCameraFrameStandalonePassAssetKeyContextualMethod = nullptr;
m_pipelineRendererAsset.reset();
@@ -2906,22 +2869,6 @@ MonoManagedRenderPipelineAssetRuntime::
return m_configureDirectionalShadowExecutionStateMethod;
}
MonoMethod*
MonoManagedRenderPipelineAssetRuntime::
ResolveGetDirectionalShadowPlanningPolicyAssetKeyMethod(
MonoObject* assetObject) const {
if (m_getDirectionalShadowPlanningPolicyAssetKeyMethod ==
nullptr) {
m_getDirectionalShadowPlanningPolicyAssetKeyMethod =
m_runtime->ResolveManagedMethod(
assetObject,
"GetDirectionalShadowPlanningPolicyAssetKey",
0);
}
return m_getDirectionalShadowPlanningPolicyAssetKeyMethod;
}
MonoMethod*
MonoManagedRenderPipelineAssetRuntime::
ResolveGetCameraFrameStandalonePassAssetKeyMethod(
@@ -5806,7 +5753,6 @@ InternalCall_Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSe
state->directionalShadowPlanningSettings =
*reinterpret_cast<const Rendering::DirectionalShadowPlanningSettings*>(
settings);
state->directionalShadowPlanningSettingsDirty = true;
}
void InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow(