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

refactor(srp): move scene setup ownership into managed renderer

Browse Source
This commit is contained in:
ssdfasd
2026-04-21 18:05:33 +08:00
parent 233cf25965
commit f75164a4fa
19 changed files with 623 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -49,8 +49,6 @@ using DirectionalShadowPlanningPolicyRegistry =
std::unordered_map<std::string, DirectionalShadowPlanningPolicy>;
using CameraFramePlanPolicyRegistry =
std::unordered_map<std::string, CameraFramePlanPolicy>;
using RenderSceneSetupPolicyRegistry =
std::unordered_map<std::string, RenderSceneSetupPolicy>;
using DirectionalShadowExecutionPolicyRegistry =
std::unordered_map<std::string, DirectionalShadowExecutionPolicy>;
@@ -70,18 +68,11 @@ GetDirectionalShadowPlanningPolicyRegistry() {
return registry;
}
CameraFramePlanPolicyRegistry&
GetCameraFramePlanPolicyRegistry() {
CameraFramePlanPolicyRegistry& GetCameraFramePlanPolicyRegistry() {
static CameraFramePlanPolicyRegistry registry = {};
return registry;
}
RenderSceneSetupPolicyRegistry&
GetRenderSceneSetupPolicyRegistry() {
static RenderSceneSetupPolicyRegistry registry = {};
return registry;
}
DirectionalShadowExecutionPolicyRegistry&
GetDirectionalShadowExecutionPolicyRegistry() {
static DirectionalShadowExecutionPolicyRegistry registry = {};
@@ -108,11 +99,6 @@ std::unordered_set<std::string>& GetBuiltinCameraFramePlanPolicyKeys() {
return builtinKeys;
}
std::unordered_set<std::string>& GetBuiltinRenderSceneSetupPolicyKeys() {
static std::unordered_set<std::string> builtinKeys = {};
return builtinKeys;
}
std::unordered_set<std::string>&
GetBuiltinDirectionalShadowExecutionPolicyKeys() {
static std::unordered_set<std::string> builtinKeys = {};
@@ -139,11 +125,6 @@ std::mutex& GetCameraFramePlanPolicyRegistryMutex() {
return mutex;
}
std::mutex& GetRenderSceneSetupPolicyRegistryMutex() {
static std::mutex mutex;
return mutex;
}
std::mutex& GetDirectionalShadowExecutionPolicyRegistryMutex() {
static std::mutex mutex;
return mutex;
@@ -227,25 +208,6 @@ void EnsureBuiltinCameraFramePlanPolicyRegistryInitialized() {
(void)initialized;
}
void EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized() {
static const bool initialized = []() {
RenderSceneSetupPolicyRegistry& registry =
GetRenderSceneSetupPolicyRegistry();
registry.emplace(
"BuiltinDefaultSceneSetup",
[](const CameraFramePlan& plan,
RenderSceneData& sceneData) {
ApplyDefaultRenderPipelineSceneSetupPolicy(
plan,
sceneData);
});
GetBuiltinRenderSceneSetupPolicyKeys().insert(
"BuiltinDefaultSceneSetup");
return true;
}();
(void)initialized;
}
void EnsureBuiltinDirectionalShadowExecutionPolicyRegistryInitialized() {
static const bool initialized = []() {
DirectionalShadowExecutionPolicyRegistry& registry =
@@ -557,72 +519,6 @@ bool ApplyCameraFramePlanPolicyByKey(
return true;
}
bool RegisterRenderSceneSetupPolicy(
const std::string& key,
RenderSceneSetupPolicy policy) {
if (key.empty() || !policy) {
return false;
}
EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized();
std::lock_guard<std::mutex> lock(
GetRenderSceneSetupPolicyRegistryMutex());
RenderSceneSetupPolicyRegistry& registry =
GetRenderSceneSetupPolicyRegistry();
if (registry.find(key) != registry.end()) {
return false;
}
registry.emplace(key, std::move(policy));
return true;
}
bool UnregisterRenderSceneSetupPolicy(
const std::string& key) {
if (key.empty()) {
return false;
}
EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized();
std::lock_guard<std::mutex> lock(
GetRenderSceneSetupPolicyRegistryMutex());
if (GetBuiltinRenderSceneSetupPolicyKeys().find(key) !=
GetBuiltinRenderSceneSetupPolicyKeys().end()) {
return false;
}
RenderSceneSetupPolicyRegistry& registry =
GetRenderSceneSetupPolicyRegistry();
return registry.erase(key) != 0u;
}
bool ApplyRenderSceneSetupPolicyByKey(
const std::string& key,
const CameraFramePlan& plan,
RenderSceneData& sceneData) {
if (key.empty()) {
return false;
}
EnsureBuiltinRenderSceneSetupPolicyRegistryInitialized();
std::lock_guard<std::mutex> lock(
GetRenderSceneSetupPolicyRegistryMutex());
const RenderSceneSetupPolicyRegistry& registry =
GetRenderSceneSetupPolicyRegistry();
const auto it = registry.find(key);
if (it == registry.end() || !it->second) {
return false;
}
it->second(
plan,
sceneData);
return true;
}
bool RegisterDirectionalShadowExecutionPolicy(
const std::string& key,
DirectionalShadowExecutionPolicy policy) {

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

@@ -14,7 +14,6 @@ class RenderPass;
struct CameraRenderRequest;
struct CameraFramePlan;
struct FinalColorSettings;
struct RenderSceneData;
struct DirectionalShadowPlanningSettings;
struct DirectionalShadowExecutionState;
struct DirectionalShadowSurfaceAllocation;
@@ -35,10 +34,6 @@ using CameraFramePlanPolicy =
std::function<void(
CameraFramePlan&,
const FinalColorSettings&)>;
using RenderSceneSetupPolicy =
std::function<void(
const CameraFramePlan&,
RenderSceneData&)>;
using DirectionalShadowExecutionPolicy =
std::function<bool(
const CameraFramePlan&,
@@ -80,15 +75,6 @@ bool ApplyCameraFramePlanPolicyByKey(
const std::string& key,
CameraFramePlan& plan,
const FinalColorSettings& defaultFinalColorSettings);
bool RegisterRenderSceneSetupPolicy(
const std::string& key,
RenderSceneSetupPolicy policy);
bool UnregisterRenderSceneSetupPolicy(
const std::string& key);
bool ApplyRenderSceneSetupPolicyByKey(
const std::string& key,
const CameraFramePlan& plan,
RenderSceneData& sceneData);
bool RegisterDirectionalShadowExecutionPolicy(
const std::string& key,
DirectionalShadowExecutionPolicy policy);

35
engine/src/Rendering/Pipelines/ScriptableRenderPipelineHost.cpp
View File

@@ -175,37 +175,16 @@ bool ScriptableRenderPipelineHost::Render(
void ScriptableRenderPipelineHost::ConfigureRenderSceneData(
const CameraFramePlan& plan,
RenderSceneData& sceneData) const {
if (m_managedAssetRuntime == nullptr) {
RenderPipeline::ConfigureRenderSceneData(
plan,
sceneData);
return;
}
const std::string assetKey =
m_managedAssetRuntime
->GetRenderSceneSetupPolicyAssetKey(
plan.request.rendererIndex);
if (assetKey.empty()) {
RenderPipeline::ConfigureRenderSceneData(
plan,
sceneData);
return;
}
if (!Rendering::Internal::ApplyRenderSceneSetupPolicyByKey(
assetKey,
if (m_managedAssetRuntime != nullptr &&
m_managedAssetRuntime->ConfigureRenderSceneSetup(
plan,
sceneData)) {
Debug::Logger::Get().Error(
Debug::LogCategory::Rendering,
Containers::String(
"ScriptableRenderPipelineHost failed to resolve render scene setup policy asset key: ") +
assetKey.c_str());
RenderPipeline::ConfigureRenderSceneData(
plan,
sceneData);
return;
}
RenderPipeline::ConfigureRenderSceneData(
plan,
sceneData);
}
bool ScriptableRenderPipelineHost::ConfigureDirectionalShadowExecutionState(

14
engine/src/Rendering/RenderPipeline.cpp
View File

@@ -10,9 +10,8 @@
namespace XCEngine {
namespace Rendering {
namespace {
Resources::ShaderKeywordSet BuildDefaultSceneGlobalShaderKeywords(
Resources::ShaderKeywordSet
BuildDefaultRenderPipelineSceneGlobalShaderKeywords(
const RenderSceneData& sceneData) {
Resources::ShaderKeywordSet keywords = {};
if (sceneData.lighting.HasMainDirectionalShadow()) {
@@ -23,7 +22,8 @@ Resources::ShaderKeywordSet BuildDefaultSceneGlobalShaderKeywords(
return keywords;
}
RenderEnvironmentData BuildDefaultEnvironmentData(const CameraFramePlan& plan) {
RenderEnvironmentData BuildDefaultRenderPipelineEnvironmentData(
const CameraFramePlan& plan) {
RenderEnvironmentData environment = {};
const RenderSurface& mainSceneSurface = plan.GetMainSceneSurface();
if (plan.request.camera == nullptr ||
@@ -47,8 +47,6 @@ RenderEnvironmentData BuildDefaultEnvironmentData(const CameraFramePlan& plan) {
return environment;
}
} // namespace
void RenderPipeline::ConfigureRenderSceneData(
const CameraFramePlan& plan,
RenderSceneData& sceneData) const {
@@ -61,9 +59,9 @@ void ApplyDefaultRenderPipelineSceneSetupPolicy(
const CameraFramePlan& plan,
RenderSceneData& sceneData) {
sceneData.globalShaderKeywords =
BuildDefaultSceneGlobalShaderKeywords(sceneData);
BuildDefaultRenderPipelineSceneGlobalShaderKeywords(sceneData);
sceneData.environment =
BuildDefaultEnvironmentData(plan);
BuildDefaultRenderPipelineEnvironmentData(plan);
}
void ApplyDefaultRenderPipelineDirectionalShadowExecutionPolicy(

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

@@ -137,6 +137,13 @@ struct ManagedCameraRenderRequestContextState {
bool suppressDirectionalShadow = false;
};
struct ManagedRenderSceneSetupContextState {
uint64_t handle = 0;
const Rendering::CameraFramePlan* plan = nullptr;
Rendering::RenderSceneData* sceneData = nullptr;
bool explicitlyConfigured = false;
};
struct ManagedDirectionalShadowExecutionContextState {
uint64_t handle = 0;
const Rendering::CameraFramePlan* plan = nullptr;
@@ -529,6 +536,52 @@ void UnregisterManagedCameraRenderRequestContextState(
GetManagedCameraRenderRequestContextRegistry().erase(handle);
}
uint64_t& GetManagedRenderSceneSetupContextNextHandle() {
static uint64_t nextHandle = 1;
return nextHandle;
}
std::unordered_map<uint64_t, ManagedRenderSceneSetupContextState*>&
GetManagedRenderSceneSetupContextRegistry() {
static std::unordered_map<uint64_t, ManagedRenderSceneSetupContextState*>
registry;
return registry;
}
ManagedRenderSceneSetupContextState*
FindManagedRenderSceneSetupContextState(
uint64_t handle) {
const auto it =
GetManagedRenderSceneSetupContextRegistry().find(handle);
return it != GetManagedRenderSceneSetupContextRegistry().end()
? it->second
: nullptr;
}
uint64_t RegisterManagedRenderSceneSetupContextState(
ManagedRenderSceneSetupContextState& state) {
uint64_t handle =
GetManagedRenderSceneSetupContextNextHandle()++;
if (handle == 0) {
handle =
GetManagedRenderSceneSetupContextNextHandle()++;
}
state.handle = handle;
GetManagedRenderSceneSetupContextRegistry()[handle] =
&state;
return handle;
}
void UnregisterManagedRenderSceneSetupContextState(
uint64_t handle) {
if (handle == 0) {
return;
}
GetManagedRenderSceneSetupContextRegistry().erase(handle);
}
uint64_t& GetManagedDirectionalShadowExecutionContextNextHandle() {
static uint64_t nextHandle = 1;
return nextHandle;
@@ -1433,6 +1486,9 @@ public:
directionalShadowSettings) const override;
void ConfigureCameraFramePlan(
Rendering::CameraFramePlan& plan) const override;
bool ConfigureRenderSceneSetup(
const Rendering::CameraFramePlan& plan,
Rendering::RenderSceneData& sceneData) const override;
bool ConfigureDirectionalShadowExecutionState(
const Rendering::CameraFramePlan& plan,
const Rendering::DirectionalShadowSurfaceAllocation&
@@ -1449,10 +1505,6 @@ public:
bool UsesNativeCameraFramePlanBaseline() const override;
bool UsesNativeCameraFramePlanBaseline(
int32_t rendererIndex) const override;
std::string GetRenderSceneSetupPolicyAssetKey() const
override;
std::string GetRenderSceneSetupPolicyAssetKey(
int32_t rendererIndex) const override;
std::string GetDirectionalShadowPlanningPolicyAssetKey() const
override;
std::string GetCameraFrameStandalonePassAssetKey(
@@ -1498,9 +1550,7 @@ private:
MonoObject* assetObject) const;
MonoMethod* ResolveUsesNativeCameraFramePlanBaselineContextualMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
MonoMethod* ResolveConfigureRenderSceneSetupMethod(
MonoObject* assetObject) const;
MonoMethod* ResolveConfigureDirectionalShadowExecutionStateMethod(
MonoObject* assetObject) const;
@@ -1532,11 +1582,8 @@ private:
mutable MonoMethod*
m_usesNativeCameraFramePlanBaselineContextualMethod =
nullptr;
mutable MonoMethod* m_getRenderSceneSetupPolicyAssetKeyMethod =
mutable MonoMethod* m_configureRenderSceneSetupMethod =
nullptr;
mutable MonoMethod*
m_getRenderSceneSetupPolicyAssetKeyContextualMethod =
nullptr;
mutable MonoMethod*
m_configureDirectionalShadowExecutionStateMethod = nullptr;
mutable MonoMethod*
@@ -2061,6 +2108,46 @@ void MonoManagedRenderPipelineAssetRuntime::ConfigureCameraFramePlan(
planningContextHandle);
}
bool MonoManagedRenderPipelineAssetRuntime::ConfigureRenderSceneSetup(
const Rendering::CameraFramePlan& plan,
Rendering::RenderSceneData& sceneData) const {
if (!EnsureManagedAsset()) {
return false;
}
MonoObject* const assetObject = GetManagedAssetObject();
MonoMethod* const method =
ResolveConfigureRenderSceneSetupMethod(assetObject);
if (assetObject == nullptr || method == nullptr) {
return false;
}
ManagedRenderSceneSetupContextState setupContextState = {};
setupContextState.plan = &plan;
setupContextState.sceneData = &sceneData;
const uint64_t setupContextHandle =
RegisterManagedRenderSceneSetupContextState(
setupContextState);
MonoObject* const setupContextObject =
m_runtime->CreateManagedRenderSceneSetupContext(
setupContextHandle);
if (setupContextObject == nullptr) {
UnregisterManagedRenderSceneSetupContextState(
setupContextHandle);
return false;
}
void* args[1] = { setupContextObject };
m_runtime->InvokeManagedMethod(
assetObject,
method,
args,
nullptr);
UnregisterManagedRenderSceneSetupContextState(
setupContextHandle);
return setupContextState.explicitlyConfigured;
}
bool MonoManagedRenderPipelineAssetRuntime::
ConfigureDirectionalShadowExecutionState(
const Rendering::CameraFramePlan& plan,
@@ -2298,61 +2385,6 @@ bool MonoManagedRenderPipelineAssetRuntime::UsesNativeCameraFramePlanBaseline(
usesBaseline;
}
std::string MonoManagedRenderPipelineAssetRuntime::
GetRenderSceneSetupPolicyAssetKey() const {
return GetRenderSceneSetupPolicyAssetKey(-1);
}
std::string MonoManagedRenderPipelineAssetRuntime::
GetRenderSceneSetupPolicyAssetKey(
int32_t rendererIndex) const {
if (!SyncManagedAssetRuntimeState()) {
return {};
}
MonoObject* const assetObject = GetManagedAssetObject();
if (assetObject == nullptr) {
return {};
}
MonoMethod* const contextualMethod =
ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
assetObject);
if (contextualMethod != nullptr) {
void* args[1] = { &rendererIndex };
MonoObject* managedKeyObject = nullptr;
if (!m_runtime->InvokeManagedMethod(
assetObject,
contextualMethod,
args,
&managedKeyObject)) {
return {};
}
return MonoStringToUtf8(
reinterpret_cast<MonoString*>(managedKeyObject));
}
MonoMethod* const method =
ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
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::
GetDirectionalShadowPlanningPolicyAssetKey() const {
if (!SyncManagedAssetRuntimeState()) {
@@ -2659,8 +2691,7 @@ void MonoManagedRenderPipelineAssetRuntime::ReleaseManagedAsset() const {
m_getPipelineRendererAssetKeyContextualMethod = nullptr;
m_usesNativeCameraFramePlanBaselineMethod = nullptr;
m_usesNativeCameraFramePlanBaselineContextualMethod = nullptr;
m_getRenderSceneSetupPolicyAssetKeyMethod = nullptr;
m_getRenderSceneSetupPolicyAssetKeyContextualMethod = nullptr;
m_configureRenderSceneSetupMethod = nullptr;
m_configureDirectionalShadowExecutionStateMethod = nullptr;
m_getDirectionalShadowPlanningPolicyAssetKeyMethod = nullptr;
m_getCameraFrameStandalonePassAssetKeyMethod = nullptr;
@@ -2846,33 +2877,17 @@ MonoManagedRenderPipelineAssetRuntime::
MonoMethod*
MonoManagedRenderPipelineAssetRuntime::
ResolveGetRenderSceneSetupPolicyAssetKeyMethod(
ResolveConfigureRenderSceneSetupMethod(
MonoObject* assetObject) const {
if (m_getRenderSceneSetupPolicyAssetKeyMethod == nullptr) {
m_getRenderSceneSetupPolicyAssetKeyMethod =
if (m_configureRenderSceneSetupMethod == nullptr) {
m_configureRenderSceneSetupMethod =
m_runtime->ResolveManagedMethod(
assetObject,
"GetRenderSceneSetupPolicyAssetKey",
0);
}
return m_getRenderSceneSetupPolicyAssetKeyMethod;
}
MonoMethod*
MonoManagedRenderPipelineAssetRuntime::
ResolveGetRenderSceneSetupPolicyAssetKeyContextualMethod(
MonoObject* assetObject) const {
if (m_getRenderSceneSetupPolicyAssetKeyContextualMethod ==
nullptr) {
m_getRenderSceneSetupPolicyAssetKeyContextualMethod =
m_runtime->ResolveManagedMethod(
assetObject,
"GetRenderSceneSetupPolicyAssetKeyContextual",
"ConfigureRenderSceneSetupInstance",
1);
}
return m_getRenderSceneSetupPolicyAssetKeyContextualMethod;
return m_configureRenderSceneSetupMethod;
}
MonoMethod*
@@ -5806,6 +5821,119 @@ void InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow(
state->suppressDirectionalShadow = true;
}
int32_t
InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex(
uint64_t nativeHandle) {
const ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
return state != nullptr &&
state->plan != nullptr
? state->plan->request.rendererIndex
: -1;
}
mono_bool
InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured(
uint64_t nativeHandle) {
const ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
return state != nullptr &&
state->explicitlyConfigured
? 1
: 0;
}
mono_bool
InternalCall_Rendering_RenderSceneSetupContext_UseDefaultSceneSetup(
uint64_t nativeHandle) {
ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
if (state == nullptr ||
state->plan == nullptr ||
state->sceneData == nullptr) {
return 0;
}
Rendering::ApplyDefaultRenderPipelineSceneSetupPolicy(
*state->plan,
*state->sceneData);
state->explicitlyConfigured = true;
return 1;
}
mono_bool
InternalCall_Rendering_RenderSceneSetupContext_UseDefaultEnvironment(
uint64_t nativeHandle) {
ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
if (state == nullptr ||
state->plan == nullptr ||
state->sceneData == nullptr) {
return 0;
}
state->sceneData->environment =
Rendering::BuildDefaultRenderPipelineEnvironmentData(
*state->plan);
state->explicitlyConfigured = true;
return 1;
}
mono_bool
InternalCall_Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords(
uint64_t nativeHandle) {
ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
if (state == nullptr || state->sceneData == nullptr) {
return 0;
}
state->sceneData->globalShaderKeywords =
Rendering::
BuildDefaultRenderPipelineSceneGlobalShaderKeywords(
*state->sceneData);
state->explicitlyConfigured = true;
return 1;
}
void InternalCall_Rendering_RenderSceneSetupContext_ClearEnvironment(
uint64_t nativeHandle) {
ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
if (state == nullptr || state->sceneData == nullptr) {
return;
}
state->sceneData->environment = {};
state->explicitlyConfigured = true;
}
void
InternalCall_Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords(
uint64_t nativeHandle) {
ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
if (state == nullptr || state->sceneData == nullptr) {
return;
}
state->sceneData->globalShaderKeywords = {};
state->explicitlyConfigured = true;
}
void InternalCall_Rendering_RenderSceneSetupContext_ClearSceneSetup(
uint64_t nativeHandle) {
ManagedRenderSceneSetupContextState* const state =
FindManagedRenderSceneSetupContextState(nativeHandle);
if (state == nullptr || state->sceneData == nullptr) {
return;
}
state->sceneData->environment = {};
state->sceneData->globalShaderKeywords = {};
state->explicitlyConfigured = true;
}
mono_bool
InternalCall_Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow(
uint64_t nativeHandle) {
@@ -6332,6 +6460,14 @@ void RegisterInternalCalls() {
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_GetDirectionalShadowPlanningSettings", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_GetDirectionalShadowPlanningSettings));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSettings", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_SetDirectionalShadowPlanningSettings));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_CameraRenderRequestContext_ClearDirectionalShadow", reinterpret_cast<const void*>(&InternalCall_Rendering_CameraRenderRequestContext_ClearDirectionalShadow));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetRendererIndex));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_GetIsConfigured", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_GetIsConfigured));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultSceneSetup", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultSceneSetup));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultEnvironment", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultEnvironment));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_UseDefaultGlobalShaderKeywords));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearEnvironment", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_ClearEnvironment));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_ClearGlobalShaderKeywords));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_RenderSceneSetupContext_ClearSceneSetup", reinterpret_cast<const void*>(&InternalCall_Rendering_RenderSceneSetupContext_ClearSceneSetup));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow", reinterpret_cast<const void*>(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetHasPlannedMainDirectionalShadow));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetRendererIndex", reinterpret_cast<const void*>(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetRendererIndex));
mono_add_internal_call("XCEngine.InternalCalls::Rendering_DirectionalShadowExecutionContext_GetIsConfigured", reinterpret_cast<const void*>(&InternalCall_Rendering_DirectionalShadowExecutionContext_GetIsConfigured));
@@ -6396,6 +6532,10 @@ void MonoScriptRuntime::Shutdown() {
GetManagedScriptableRenderContextNextHandle() = 1;
GetManagedCameraRenderRequestContextRegistry().clear();
GetManagedCameraRenderRequestContextNextHandle() = 1;
GetManagedRenderSceneSetupContextRegistry().clear();
GetManagedRenderSceneSetupContextNextHandle() = 1;
GetManagedDirectionalShadowExecutionContextRegistry().clear();
GetManagedDirectionalShadowExecutionContextNextHandle() = 1;
GetManagedScriptableRenderPipelinePlanningContextRegistry().clear();
GetManagedScriptableRenderPipelinePlanningContextNextHandle() = 1;
ClearManagedInstances();
@@ -6415,12 +6555,14 @@ void MonoScriptRuntime::Shutdown() {
m_scriptableRenderPipelineClass = nullptr;
m_scriptableRenderContextClass = nullptr;
m_cameraRenderRequestContextClass = nullptr;
m_renderSceneSetupContextClass = nullptr;
m_directionalShadowExecutionContextClass = nullptr;
m_scriptableRenderPipelinePlanningContextClass = nullptr;
m_serializeFieldAttributeClass = nullptr;
m_gameObjectConstructor = nullptr;
m_scriptableRenderContextConstructor = nullptr;
m_cameraRenderRequestContextConstructor = nullptr;
m_renderSceneSetupContextConstructor = nullptr;
m_directionalShadowExecutionContextConstructor = nullptr;
m_scriptableRenderPipelinePlanningContextConstructor = nullptr;
m_managedGameObjectUUIDField = nullptr;
@@ -7216,6 +7358,27 @@ bool MonoScriptRuntime::DiscoverScriptClasses() {
return false;
}
m_renderSceneSetupContextClass = mono_class_from_name(
m_coreImage,
kManagedRenderingNamespace,
"RenderSceneSetupContext");
if (!m_renderSceneSetupContextClass) {
SetError(
"Failed to locate the managed RenderSceneSetupContext type.");
return false;
}
m_renderSceneSetupContextConstructor =
mono_class_get_method_from_name(
m_renderSceneSetupContextClass,
".ctor",
1);
if (!m_renderSceneSetupContextConstructor) {
SetError(
"Failed to locate the managed RenderSceneSetupContext constructor.");
return false;
}
m_directionalShadowExecutionContextClass = mono_class_from_name(
m_coreImage,
kManagedRenderingNamespace,
@@ -7853,6 +8016,46 @@ MonoScriptRuntime::CreateManagedCameraRenderRequestContext(
return contextObject;
}
MonoObject*
MonoScriptRuntime::CreateManagedRenderSceneSetupContext(
uint64_t nativeHandle) {
if (!m_initialized ||
nativeHandle == 0 ||
m_renderSceneSetupContextClass == nullptr ||
m_renderSceneSetupContextConstructor == nullptr) {
return nullptr;
}
SetCurrentDomain();
MonoObject* const contextObject =
mono_object_new(
m_appDomain,
m_renderSceneSetupContextClass);
if (contextObject == nullptr) {
SetError(
"Mono failed to allocate a managed RenderSceneSetupContext.");
return nullptr;
}
void* args[1];
uint64_t nativeHandleArgument = nativeHandle;
args[0] = &nativeHandleArgument;
MonoObject* exception = nullptr;
mono_runtime_invoke(
m_renderSceneSetupContextConstructor,
contextObject,
args,
&exception);
if (exception != nullptr) {
RecordException(exception);
return nullptr;
}
return contextObject;
}
MonoObject*
MonoScriptRuntime::CreateManagedDirectionalShadowExecutionContext(
uint64_t nativeHandle) {