Luma: Add managed resources

Source/Core/Core.vcxproj

@@ -608,13 +608,15 @@
   <ItemGroup>
     <ClInclude Include="dlss\DLSS.h" />
     <ClInclude Include="fsr\FSR.h" />
+    <ClInclude Include="includes\callbacks.h" />
     <ClInclude Include="includes\cbuffers.h" />
     <ClInclude Include="includes\com_ptr.h" />
     <ClInclude Include="includes\debug.h" />
     <ClInclude Include="includes\game.h" />
     <ClInclude Include="includes\globals.h" />
     <ClInclude Include="includes\hash.h" />
     <ClInclude Include="includes\instance_data.h" />
+    <ClInclude Include="includes\managed_resources.h" />
     <ClInclude Include="includes\overlay_log.h" />
     <ClInclude Include="includes\math.h" />
     <ClInclude Include="includes\matrix.h" />

Source/Core/Core.vcxproj.filters

@@ -105,5 +105,11 @@
     <ClInclude Include="includes\overlay_log.h">
       <Filter>Includes</Filter>
     </ClInclude>
+    <ClInclude Include="includes\callbacks.h">
+      <Filter>Includes</Filter>
+    </ClInclude>
+    <ClInclude Include="includes\managed_resources.h">
+      <Filter>Includes</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Source/Core/core.hpp

@@ -1,39 +1,39 @@
 #pragma once
 
 // "_DEBUG" might already be defined in debug?
 // Setting it to 0 causes the compiler to still assume it as defined and that thus we are in debug mode (don't change this manually).
 #ifndef NDEBUG
 #define _DEBUG 1
 #endif // !NDEBUG
 
 // Enable when you are developing shaders or code (not debugging, there's "NDEBUG" for that).
 // This brings out the development tools, allowing you to trace draw calls and a lot more stuff.
 #ifndef DEVELOPMENT
 #define DEVELOPMENT 0
 #endif // DEVELOPMENT
 // Enable when you are testing shaders or code (e.g. to dump the shaders, logging warnings, etc etc).
 // This is not mutually exclusive with "DEVELOPMENT", but it should be a sub-set of it.
 // If neither of these are true, then we are in "shipping" mode, with code meant to be used by the final user.
 #ifndef TEST
 #define TEST 0
 #endif // TEST
 
 #define LOG_VERBOSE ((DEVELOPMENT || TEST) && 0)
 
 // Disables loading the ReShade Addon code (useful to test the mod without any ReShade dependencies (e.g. optionally "Prey"))
 #define DISABLE_RESHADE 0
 
 #pragma comment(lib, "Gdi32.lib") // For "SetDeviceGammaRamp"
 #pragma comment(lib, "dxguid.lib")
 #pragma comment(lib, "Dxva2.lib")   // For "SetMonitorBrightness"
 
 #define _USE_MATH_DEFINES
 
 #ifdef _WIN32
 #define ImTextureID ImU64
 #endif
 
 #include <d3d11.h>
 #include <d3d11_4.h>
 #include <dxgi.h>
 #include <dxgi1_6.h>
@@ -42,12 +42,12 @@
 
 #include <cstdio>
 #include <filesystem>
 #include <fstream>
 #include <shared_mutex>
 #include <string>
 #include <map>
 #include <unordered_map>
 #include <unordered_set>
 #include <set>
 #include <vector>
 #include <semaphore>
@@ -2570,6 +2570,12 @@
       }
 #endif // ENABLE_SR
 
+      // Execute all Luma callbacks.
+      for (const auto& callback : LumaCallbacks::on_destroy_device)
+      {
+          callback.second();
+      }
+
       device->destroy_private_data<DeviceData>();
    }
 
@@ -2959,6 +2965,12 @@
          // TODO: put code to track all recently created resources and late upgraded them if the size/aspect ratio now matches the swapchain (some games resize the swapchain after resources, so in that case we should handle indirect upgrades like this)
       }
 
+      // Execute all Luma callbacks.
+      for (const auto& callback : LumaCallbacks::on_init_swapchain)
+      {
+          callback.second();
+      }
+
       game->OnInitSwapchain(swapchain);
    }
 

Source/Core/includes/callbacks.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <vector>
+#include <functional>
+
+// struct cause maybe we want to make some members private in future
+// 
+// So far std::unoredered_map may be the best solution for this.
+// std::unordered_set could be better, but it won't work with std::function.
+// std::vector could be too much manual management for the user (developer)?
+//
+// Signal user that callback was executed?
+struct LumaCallbacks final
+{
+    // Executed after swapchain resize and after swapchain creation.
+    static inline std::unordered_map<uint32_t, std::function<void()>> on_init_swapchain;
+
+    // Executed before device is destroyed.
+    static inline std::unordered_map<uint32_t, std::function<void()>> on_destroy_device;
+};

Source/Core/includes/instance_data.h

@@ -1,3 +1,3 @@
 #pragma once
 
 #include <algorithm>
@@ -16,6 +16,8 @@
 #include <utility>
 #include <vector>
 
+#include "managed_resources.h"
+
 // Forward declarations
 struct GameDeviceData;
 
@@ -90,7 +92,7 @@
       AppendCommandList,
       ResetCommmandList,
       FlushCommandList,
-		Custom, // Custom draw call for custom passes we added/replaced
+        Custom, // Custom draw call for custom passes we added/replaced
    };
 
    TraceDrawCallType type = TraceDrawCallType::Shader;
@@ -583,6 +585,8 @@
          buffers.push_back(luma_ui_data.get());
       return buffers;
    }
+
+   ManagedResources managed_resources;
 };
 
 struct __declspec(uuid("c5805458-2c02-4ebf-b139-38b85118d971")) SwapchainData
@@ -595,5 +599,5 @@
    std::vector<com_ptr<ID3D11RenderTargetView>> display_composition_rtvs;
 
    // Whether the original SDR (vanilla) swapchain was linear space (e.g. sRGB formats)
-	bool vanilla_was_linear_space = false;
+    bool vanilla_was_linear_space = false;
 };

Source/Core/includes/managed_resources.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <d3d11_4.h>
+#include <unordered_map>
+#include <vector>
+#include "com_ptr.h"
+
+struct ManagedResources
+{
+    // Key should be result of CompileTimeStringHash()!
+    // Example usage: shader_resource_views[CompileTimeStringHash("scene")] = srv_scene;
+    // Example usage: shader_resource_views["scene"_h] = srv_scene;
+    std::unordered_map<uint32_t, ComPtr<ID3D11ShaderResourceView>> shader_resource_views;
+    std::unordered_map<uint32_t, ComPtr<ID3D11RenderTargetView>> render_target_views;
+    std::unordered_map<uint32_t, ComPtr<ID3D11UnorderedAccessView>> unordered_access_views;
+    std::unordered_map<uint32_t, ComPtr<ID3D11DepthStencilView>> depth_stencil_views;
+    std::unordered_map<uint32_t, ComPtr<ID3D11Resource>> resources;
+    std::unordered_map<uint32_t, ComPtr<ID3D11Buffer>> buffers;
+    std::unordered_map<uint32_t, ComPtr<ID3D11Texture1D>> textures_1d;
+    std::unordered_map<uint32_t, ComPtr<ID3D11Texture2D>> textures_2d;
+    std::unordered_map<uint32_t, ComPtr<ID3D11Texture3D>> textures_3d;
+    std::unordered_map<uint32_t, ComPtr<ID3D11InputLayout>> input_layouts;
+    std::unordered_map<uint32_t, ComPtr<ID3D11RasterizerState>> rasterizers;
+    std::unordered_map<uint32_t, ComPtr<ID3D11SamplerState>> samplers;
+    std::unordered_map<uint32_t, ComPtr<ID3D11BlendState>> blends;
+    std::unordered_map<uint32_t, ComPtr<ID3D11DepthStencilState>> depth_stencils;
+    std::unordered_map<uint32_t, ComPtr<ID3D11VertexShader>> vertex_shaders;
+    std::unordered_map<uint32_t, ComPtr<ID3D11ComputeShader>> compute_shaders;
+    std::unordered_map<uint32_t, ComPtr<ID3D11PixelShader>> pixel_shaders;
+    std::unordered_map<uint32_t, ComPtr<ID3D11DomainShader>> domain_shaders;
+    std::unordered_map<uint32_t, ComPtr<ID3D11GeometryShader>> geometry_shaders;
+    std::unordered_map<uint32_t, ComPtr<ID3D11HullShader>> hull_shaders;
+};
+
+// TODO: Move this somewhere else.
+inline void ResetCOMArray(auto& array)
+{
+    for (auto*& ptr : array)
+    {
+        if (ptr)
+        {
+            ptr->Release();
+            ptr = nullptr;
+        }
+    }
+}

Source/Core/includes/math.h

@@ -1,3 +1,3 @@
 #pragma once
 
 // Needs to be defined before anybody else includes "cmath"
@@ -5,7 +5,7 @@
 #define _USE_MATH_DEFINES
 #endif
 
 #include <cmath>
 #include <array>
 #include <limits>
 #include <algorithm>
@@ -182,6 +182,13 @@
       return hash;
    }
 
+   // User-defined literal for CompileTimeStringHash.
+   // Usage: `"some_string"_h`, this is equivalent to `CompileTimeStringHash("some_string")`.
+   consteval uint32_t operator"" _h(const char* str, size_t len)
+   {
+	  return CompileTimeStringHash(str);
+   }
+
    uint32_t FindNextUniqueNumberInRange(uint32_t value, uint32_t min_value, uint32_t max_value, std::unordered_set<uint32_t> excluded_values)
    {
       assert(value >= min_value && value <= max_value);