Add managed render pipeline selection bridge

engine/src/Scripting/Mono/MonoScriptRuntime.cpp

@@ -8,6 +8,7 @@
 #include "Components/TransformComponent.h"
 #include "Debug/Logger.h"
 #include "Input/InputManager.h"
+#include "Rendering/Pipelines/ManagedScriptableRenderPipelineAsset.h"
 #include "Scene/Scene.h"
 #include "Scripting/ScriptComponent.h"
 #include "Scripting/ScriptEngine.h"
@@ -92,6 +93,16 @@ std::string SafeString(const char* value) {
     return value ? std::string(value) : std::string();
 }
 
+std::string TrimAssemblyName(const std::string& assemblyName) {
+    constexpr const char* kDllSuffix = ".dll";
+    if (assemblyName.size() >= 4u &&
+        assemblyName.substr(assemblyName.size() - 4u) == kDllSuffix) {
+        return assemblyName.substr(0u, assemblyName.size() - 4u);
+    }
+
+    return assemblyName;
+}
+
 bool IsMonoClassOrSubclass(MonoClass* monoClass, MonoClass* potentialBaseClass) {
     if (!monoClass || !potentialBaseClass) {
         return false;
@@ -1522,6 +1533,47 @@ void InternalCall_MeshRenderer_SetRenderLayer(uint64_t gameObjectUUID, int32_t v
     component->SetRenderLayer(static_cast<uint32_t>(std::max(value, 0)));
 }
 
+void InternalCall_Rendering_SetRenderPipelineAssetType(MonoReflectionType* assetType) {
+    if (assetType == nullptr) {
+        Rendering::Pipelines::ClearManagedRenderPipelineAssetDescriptor();
+        return;
+    }
+
+    MonoType* monoType = mono_reflection_type_get_type(assetType);
+    MonoClass* monoClass =
+        monoType != nullptr ? mono_class_from_mono_type(monoType) : nullptr;
+    if (monoClass == nullptr) {
+        Rendering::Pipelines::ClearManagedRenderPipelineAssetDescriptor();
+        return;
+    }
+
+    MonoImage* image = mono_class_get_image(monoClass);
+    Rendering::Pipelines::ManagedRenderPipelineAssetDescriptor descriptor = {};
+    descriptor.assemblyName =
+        TrimAssemblyName(SafeString(image != nullptr ? mono_image_get_name(image) : nullptr));
+    descriptor.namespaceName = SafeString(mono_class_get_namespace(monoClass));
+    descriptor.className = SafeString(mono_class_get_name(monoClass));
+    if (!descriptor.IsValid()) {
+        Rendering::Pipelines::ClearManagedRenderPipelineAssetDescriptor();
+        return;
+    }
+
+    Rendering::Pipelines::SetManagedRenderPipelineAssetDescriptor(descriptor);
+}
+
+MonoString* InternalCall_Rendering_GetRenderPipelineAssetTypeName() {
+    const Rendering::Pipelines::ManagedRenderPipelineAssetDescriptor descriptor =
+        Rendering::Pipelines::GetManagedRenderPipelineAssetDescriptor();
+    if (!descriptor.IsValid()) {
+        return mono_string_new(mono_domain_get(), "");
+    }
+
+    std::string assemblyQualifiedName = descriptor.GetFullName();
+    assemblyQualifiedName += ", ";
+    assemblyQualifiedName += descriptor.assemblyName;
+    return mono_string_new(mono_domain_get(), assemblyQualifiedName.c_str());
+}
+
 void RegisterInternalCalls() {
     if (GetInternalCallRegistrationState()) {
         return;
@@ -1629,6 +1681,8 @@ void RegisterInternalCalls() {
     mono_add_internal_call("XCEngine.InternalCalls::MeshRenderer_SetReceiveShadows", reinterpret_cast<const void*>(&InternalCall_MeshRenderer_SetReceiveShadows));
     mono_add_internal_call("XCEngine.InternalCalls::MeshRenderer_GetRenderLayer", reinterpret_cast<const void*>(&InternalCall_MeshRenderer_GetRenderLayer));
     mono_add_internal_call("XCEngine.InternalCalls::MeshRenderer_SetRenderLayer", reinterpret_cast<const void*>(&InternalCall_MeshRenderer_SetRenderLayer));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_SetRenderPipelineAssetType", reinterpret_cast<const void*>(&InternalCall_Rendering_SetRenderPipelineAssetType));
+    mono_add_internal_call("XCEngine.InternalCalls::Rendering_GetRenderPipelineAssetTypeName", reinterpret_cast<const void*>(&InternalCall_Rendering_GetRenderPipelineAssetTypeName));
 
     GetInternalCallRegistrationState() = true;
 }