♻️🚧 Split Render API source files in header+source files.

For RenderAPI DX11 I add methods to create and copy texture see #2

Author: davidAlgis

Plugin/PluginInteropUnityCUDA/include/renderAPI.h renamed to Plugin/PluginInteropUnityCUDA/include/RenderAPI/renderAPI.h

@@ -0,0 +1,49 @@
+#pragma once
+#include "renderAPI.h"
+#include "framework.h"
+#include "log.h"
+// Direct3D 11 implementation of RenderAPI.
+
+#if SUPPORT_D3D11
+
+#include "d3d11.h"
+#include "IUnityGraphicsD3D11.h"
+#include <assert.h>
+
+class RenderAPI_D3D11 : public RenderAPI
+{
+    public:
+    RenderAPI_D3D11();
+    virtual ~RenderAPI_D3D11();
+    virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type,
+                                    IUnityInterfaces *interfaces);
+    
+
+
+    /// <summary>
+    /// Create a 2D texture with the given paramaters
+    /// return -1, if device has not been set, -2 if dx11
+    /// failed to create the texture, else 0
+    /// </summary>
+    int createTexture2D(int textureWidth, int textureHeight, int textureDepth,
+                                     ID3D11Texture2D **textureHandle);
+
+    /// <summary>
+    /// Copy the content of texture 2D src to texture 2D dest
+    /// This method is UNSAFE, because for efficiency reason it 
+    /// doesn't check if src and dest textures are compatible
+    /// Therefore, make sure to have compatible textures. See
+    /// https://learn.microsoft.com/en-us/windows/win32/api/d3d11/nf-d3d11-id3d11devicecontext-copyresource 
+    /// for more details
+    /// </summary>
+    void copyTextures2D(ID3D11Texture2D* dest, ID3D11Texture2D* src);
+    
+
+    private:
+    ID3D11Device *_device;
+    ID3D11DeviceContext* _context{};
+};
+
+RenderAPI *CreateRenderAPI_D3D11();
+
+#endif // #if SUPPORT_D3D11

Plugin/PluginInteropUnityCUDA/include/RenderAPI/renderAPI_D3D11.h

@@ -0,0 +1,40 @@
+#pragma once
+#include "framework.h"
+#include "renderAPI.h"
+
+#include <cmath>
+
+// Direct3D 12 implementation of RenderAPI.
+
+#if SUPPORT_D3D12
+
+#include <assert.h>
+#include <d3d12.h>
+#include "IUnityGraphicsD3D12.h"
+
+class RenderAPI_D3D12 : public RenderAPI
+{
+    public:
+    RenderAPI_D3D12();
+    virtual ~RenderAPI_D3D12();
+
+    virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type,
+                                    IUnityInterfaces *interfaces);
+
+    private:
+    void CreateResources();
+    void ReleaseResources();
+
+    private:
+    IUnityGraphicsD3D12v2 *s_D3D12;
+    ID3D12CommandAllocator *s_D3D12CmdAlloc;
+    ID3D12GraphicsCommandList *s_D3D12CmdList;
+    UINT64 s_D3D12FenceValue = 0;
+    HANDLE s_D3D12Event = NULL;
+};
+
+RenderAPI *CreateRenderAPI_D3D12();
+
+const UINT kNodeMask = 0;
+
+#endif // #if SUPPORT_D3D12

Plugin/PluginInteropUnityCUDA/include/RenderAPI/renderAPI_D3D12.h

@@ -0,0 +1,31 @@
+#pragma once
+#include "openGL_include.h"
+#include "renderAPI.h"
+#include "framework.h"
+
+// OpenGL Core profile (desktop) or OpenGL ES (mobile) implementation of RenderAPI.
+// Supports several flavors: Core, ES2, ES3
+
+
+#if SUPPORT_OPENGL_UNIFIED
+
+class RenderAPI_OpenGLCoreES : public RenderAPI
+{
+public:
+	RenderAPI_OpenGLCoreES(UnityGfxRenderer apiType);
+	virtual ~RenderAPI_OpenGLCoreES();
+
+
+	virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces);
+private:
+	void CreateResources();
+
+private:
+	UnityGfxRenderer m_APIType;
+};
+
+
+RenderAPI* CreateRenderAPI_OpenGLCoreES(UnityGfxRenderer apiType);
+
+
+#endif // #if SUPPORT_OPENGL_UNIFIED

Plugin/PluginInteropUnityCUDA/include/RenderAPI/renderAPI_OpenGLCoreES.h

@@ -30,22 +30,6 @@ RenderAPI* CreateRenderAPI(UnityGfxRenderer apiType)
 	}
 #	endif // if SUPPORT_OPENGL_UNIFIED
 
-#	if SUPPORT_METAL
-	if (apiType == kUnityGfxRendererMetal)
-	{
-		extern RenderAPI* CreateRenderAPI_Metal();
-		return CreateRenderAPI_Metal();
-	}
-#	endif // if SUPPORT_METAL
-
-#	if SUPPORT_VULKAN
-	if (apiType == kUnityGfxRendererVulkan)
-	{
-		extern RenderAPI* CreateRenderAPI_Vulkan();
-		return CreateRenderAPI_Vulkan();
-	}
-#	endif // if SUPPORT_VULKAN
-
 	// Unknown or unsupported graphics API
 	return NULL;
 }

Plugin/PluginInteropUnityCUDA/src/RenderAPI/renderAPI.cpp

@@ -1,55 +1,80 @@
-#include "framework.h"
-#include "renderAPI.h"
-#include "log.h"
-// Direct3D 11 implementation of RenderAPI.
+#include "RenderAPI_D3D11.h"
 
 #if SUPPORT_D3D11
 
-#include <assert.h>
-#include <d3d11.h>
-#include "IUnityGraphicsD3D11.h"
-
-class RenderAPI_D3D11 : public RenderAPI
+RenderAPI *CreateRenderAPI_D3D11()
 {
-    public:
-    RenderAPI_D3D11();
-    virtual ~RenderAPI_D3D11()
-    {
-    }
+    return new RenderAPI_D3D11();
+}
 
-    virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type,
-                                    IUnityInterfaces *interfaces);
+RenderAPI_D3D11::RenderAPI_D3D11() : _device(NULL)
+{
+}
 
-    private:
-    ID3D11Device *m_Device;
-};
+RenderAPI_D3D11::~RenderAPI_D3D11()
+{
+}
 
-RenderAPI *CreateRenderAPI_D3D11()
+int RenderAPI_D3D11::createTexture2D(int textureWidth, int textureHeight,
+                                     int textureDepth,
+                                     ID3D11Texture2D **textureHandle)
 {
-    return new RenderAPI_D3D11();
+    D3D11_TEXTURE2D_DESC texDesc;
+    ZeroMemory(&texDesc, sizeof(texDesc));
+    texDesc.Width = textureWidth;
+    texDesc.Height = textureHeight;
+    texDesc.MipLevels = 1;
+    texDesc.ArraySize = textureDepth;
+    texDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
+    texDesc.SampleDesc.Count = 1;
+    texDesc.Usage = D3D11_USAGE_DEFAULT;
+    texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+    texDesc.CPUAccessFlags = 0;
+    texDesc.MiscFlags = 0;
+
+    if (_device == NULL)
+    {
+        Log::log().debugLogError(
+            "m_Device has not been initialized in RenderAPI_D3D11, please make "
+            "sure event kUnityGfxDeviceEventInitialize has been called "
+            "before.");
+        return -1;
+    }
+
+    HRESULT hr = _device->CreateTexture2D(&texDesc, nullptr, textureHandle);
+    if (FAILED(hr))
+    {
+        Log::log().debugLogError("Error " + std::to_string(hr) +
+                                 " when creating Texture in DX11.");
+        return -2;
+    }
+    return 0;
 }
 
-RenderAPI_D3D11::RenderAPI_D3D11() : m_Device(NULL)
+void RenderAPI_D3D11::copyTextures2D(ID3D11Texture2D *dest,
+                                     ID3D11Texture2D *src)
 {
+    _device->GetImmediateContext(&_context);
+    _context->CopyResource(dest, src);
 }
 
+
 void RenderAPI_D3D11::ProcessDeviceEvent(UnityGfxDeviceEventType type,
                                          IUnityInterfaces *interfaces)
 {
     switch (type)
     {
     case kUnityGfxDeviceEventInitialize: {
-    	Log::log().debugLog("init dx11");
         IUnityGraphicsD3D11 *d3d = interfaces->Get<IUnityGraphicsD3D11>();
-        m_Device = d3d->GetDevice();
-
-        ID3D11DeviceContext *ctx = NULL;
-        m_Device->GetImmediateContext(&ctx);
-    	Log::log().debugLog("end dx11");
+        _device = d3d->GetDevice();
         break;
     }
     case kUnityGfxDeviceEventShutdown:
         break;
+    case kUnityGfxDeviceEventBeforeReset:
+        break;
+    case kUnityGfxDeviceEventAfterReset:
+        break;
     }
 }
 

Plugin/PluginInteropUnityCUDA/src/RenderAPI/renderAPI_D3D11.cpp

@@ -1,47 +1,13 @@
-#include "renderAPI.h"
-#include "framework.h"
-
-#include <cmath>
-
-// Direct3D 12 implementation of RenderAPI.
-
+#include "renderAPI_D3D12.h"
 
 #if SUPPORT_D3D12
 
-#include <assert.h>
-#include <d3d12.h>
-#include "IUnityGraphicsD3D12.h"
-
-
-class RenderAPI_D3D12 : public RenderAPI
-{
-public:
-	RenderAPI_D3D12();
-	virtual ~RenderAPI_D3D12() { }
-
-	virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces);
-
-private:
-	void CreateResources();
-	void ReleaseResources();
-
-private:
-	IUnityGraphicsD3D12v2* s_D3D12;
-	ID3D12CommandAllocator* s_D3D12CmdAlloc;
-	ID3D12GraphicsCommandList* s_D3D12CmdList;
-	UINT64 s_D3D12FenceValue = 0;
-	HANDLE s_D3D12Event = NULL;
-};
-
-
 RenderAPI* CreateRenderAPI_D3D12()
 {
 	return new RenderAPI_D3D12();
 }
 
 
-const UINT kNodeMask = 0;
-
 
 RenderAPI_D3D12::RenderAPI_D3D12()
 	: s_D3D12(NULL)
@@ -52,6 +18,10 @@ RenderAPI_D3D12::RenderAPI_D3D12()
 {
 }
 
+RenderAPI_D3D12::~RenderAPI_D3D12()
+{
+	
+}
 
 void RenderAPI_D3D12::CreateResources()
 {
@@ -92,7 +62,10 @@ void RenderAPI_D3D12::ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInt
 	case kUnityGfxDeviceEventShutdown:
 		ReleaseResources();
 		break;
-	}
+    case kUnityGfxDeviceEventBeforeReset:
+    case kUnityGfxDeviceEventAfterReset:
+        break;
+    }
 }
 
 #endif // #if SUPPORT_D3D12

Plugin/PluginInteropUnityCUDA/src/RenderAPI/renderAPI_D3D12.cpp

@@ -1,28 +1,7 @@
-#include "openGL_include.h"
-#include "renderAPI.h"
-#include "framework.h"
-
-// OpenGL Core profile (desktop) or OpenGL ES (mobile) implementation of RenderAPI.
-// Supports several flavors: Core, ES2, ES3
-
+#include "renderAPI_OpenGLCoreES.h"
 
 #if SUPPORT_OPENGL_UNIFIED
 
-class RenderAPI_OpenGLCoreES : public RenderAPI
-{
-public:
-	RenderAPI_OpenGLCoreES(UnityGfxRenderer apiType);
-	virtual ~RenderAPI_OpenGLCoreES() { }
-
-	virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces);
-private:
-	void CreateResources();
-
-private:
-	UnityGfxRenderer m_APIType;
-};
-
-
 RenderAPI* CreateRenderAPI_OpenGLCoreES(UnityGfxRenderer apiType)
 {
 	return new RenderAPI_OpenGLCoreES(apiType);
@@ -37,12 +16,15 @@ void RenderAPI_OpenGLCoreES::CreateResources()
 
 
 
-
 RenderAPI_OpenGLCoreES::RenderAPI_OpenGLCoreES(UnityGfxRenderer apiType)
 	: m_APIType(apiType)
 {
 }
 
+RenderAPI_OpenGLCoreES::~RenderAPI_OpenGLCoreES()
+{
+
+}
 
 void RenderAPI_OpenGLCoreES::ProcessDeviceEvent(UnityGfxDeviceEventType type, IUnityInterfaces* interfaces)
 {