✨🚧 Support DX11 on textures by adding a copy (see #2 (comment))

Author: davidAlgis

InteropUnityCUDA/Assets/Actions/InteropHandlerSample.cs

@@ -127,21 +127,39 @@ protected override void InitializeActions()
                 Debug.LogError("Set particles drawer in inspector !");
                 return;
             }
+            InitSampleTexture();
+            // InitSampleTextureArray();
+            // InitSampleVertexBuffer();
 
-            CreateBuffer();
+        }
+
+        private void InitSampleTexture()
+        {
             CreateTexture();
-            CreateTextureArray();
             ActionUnitySampleTexture actionUnitySampleTexture = new ActionUnitySampleTexture(_renderTexture);
-            ActionUnitySampleVertexBuffer actionUnitySampleVertexBuffer = new ActionUnitySampleVertexBuffer(_computeBuffer, _sizeBuffer);
-            ActionUnitySampleTextureArray actionUnitySampleTextureArray = new ActionUnitySampleTextureArray(_renderTextureArray);
             RegisterActionUnity(actionUnitySampleTexture, _ActionTextureName);
-            RegisterActionUnity(actionUnitySampleVertexBuffer, _ActionVertexBufferName);
-            RegisterActionUnity(actionUnitySampleTextureArray, _ActionTextureArrayName);
             CallFunctionStartInAction(_ActionTextureName);
-            CallFunctionStartInAction(_ActionVertexBufferName);
+            
+        }
+
+        private void InitSampleTextureArray()
+        {
+            CreateTextureArray();
+            ActionUnitySampleTextureArray actionUnitySampleTextureArray = new ActionUnitySampleTextureArray(_renderTextureArray);
+            RegisterActionUnity(actionUnitySampleTextureArray, _ActionTextureArrayName);
             CallFunctionStartInAction(_ActionTextureArrayName);
+            
         }
 
+        private void InitSampleVertexBuffer()
+        {
+            CreateBuffer();
+            ActionUnitySampleVertexBuffer actionUnitySampleVertexBuffer = new ActionUnitySampleVertexBuffer(_computeBuffer, _sizeBuffer);
+            RegisterActionUnity(actionUnitySampleVertexBuffer, _ActionVertexBufferName);
+            CallFunctionStartInAction(_ActionVertexBufferName);
+            
+        }
+        
         public void Update()
         {
             UpdateInteropHandler();
@@ -153,18 +171,18 @@ public void Update()
         protected override void UpdateActions()
         {
             base.UpdateActions();
-            CallFunctionUpdateInAction(_ActionTextureArrayName);
+            // CallFunctionUpdateInAction(_ActionTextureArrayName);
             CallFunctionUpdateInAction(_ActionTextureName);
-            CallFunctionUpdateInAction(_ActionVertexBufferName);
-            Graphics.CopyTexture(_renderTextureArray,0,_renderTextureForDisplay0,0);
-            Graphics.CopyTexture(_renderTextureArray,1,_renderTextureForDisplay1,0);
-            _rawImageTextureArray0.texture = _renderTextureForDisplay0;
-            _rawImageTextureArray1.texture = _renderTextureForDisplay1;
+            // CallFunctionUpdateInAction(_ActionVertexBufferName);
+            // Graphics.CopyTexture(_renderTextureArray,0,_renderTextureForDisplay0,0);
+            // Graphics.CopyTexture(_renderTextureArray,1,_renderTextureForDisplay1,0);
+            // _rawImageTextureArray0.texture = _renderTextureForDisplay0;
+            // _rawImageTextureArray1.texture = _renderTextureForDisplay1;
         }
 
         public void OnDestroy()
         {
-            OnDestroyInteropHandler();
+            // OnDestroyInteropHandler();
         }
 
         /// <summary>
@@ -173,9 +191,9 @@ public void OnDestroy()
         protected override void OnDestroyActions()
         {
             base.OnDestroyActions();
-            CallFunctionOnDestroyInAction(_ActionTextureArrayName);
             CallFunctionOnDestroyInAction(_ActionTextureName);
-            CallFunctionOnDestroyInAction(_ActionVertexBufferName);
+            // CallFunctionOnDestroyInAction(_ActionTextureArrayName);
+            // CallFunctionOnDestroyInAction(_ActionVertexBufferName);
         }
     }
 

Plugin/PluginInteropUnityCUDA/include/Texture/texture.h

@@ -31,6 +31,34 @@ class Texture
     /// </summary>
     UNITY_INTERFACE_EXPORT virtual void unRegisterTextureInCUDA() = 0;
 
+
+    /// <summary>
+    /// For some API (DX11) CUDA cannot edit the texture created by Unity
+    /// therefore, we have to create a new texture that will used as a buffer
+    /// between the unity texture and the surface object that is modify by CUDA
+    /// For these API, this function will copy the content of the unity texture
+    /// to this buffer, for the other API. It'll do nothing.
+    /// If Unity texture has been modify in Unity, you have to do the copy before
+    /// reading it in CUDA. It's not necessary if you only write into the texture 
+    /// in CUDA, or if the texture has not been modify in Unity.
+    /// Tips : not necessary for write only in CUDA or read only in Unity
+    /// </summary>
+    UNITY_INTERFACE_EXPORT virtual void copyUnityTextureToAPITexture() = 0;
+
+
+    /// <summary>
+    /// For some API (DX11) CUDA cannot edit the texture created by Unity
+    /// therefore, we have to create a new texture that will used as a buffer
+    /// between the unity texture and the surface object that is modify by CUDA
+    /// For these API, this function will copy the content of the buffer texture
+    /// to the unity texture, for the other API. It'll do nothing.
+    /// If API texture has been modify by, you have to do the copy before
+    /// reading it in Unity. It's not necessary if you only read into the texture 
+    /// in CUDA, or if the texture is only write only in Unity.
+    /// Tips : not necessary for read only in CUDA or write only in Unity
+    /// </summary>
+    UNITY_INTERFACE_EXPORT virtual void copyAPITextureToUnityTexture() = 0;
+
     /// <summary>
     /// Map a cuda array to the graphics resources and wrap it into a surface
     /// object of cuda

Plugin/PluginInteropUnityCUDA/include/Texture/texture_D3D11.h

@@ -1,23 +1,42 @@
 #pragma once
-// Direct3D 11 implementation of Texture API
 #include "texture.h"
 
-
 #if SUPPORT_D3D11
 
-#include <d3d11.h>
+#include "renderAPI_D3D11.h"
+#include <assert.h>
 #include <cuda_d3d11_interop.h>
 #include "IUnityGraphicsD3D11.h"
-#include <assert.h>
+#include "d3d11.h"
 
+/// <summary>
+/// This class handles interoperability for texture from Unity to CUDA, with
+/// dx11 graphics API. With dx11 interoperability work differently, texture
+/// created in Unity, cannot be directly registered in CUDA, therefore we need
+/// to create another texture
+/// (_texBufferInterop) that will be used as a buffer. We will copy the content
+/// of the texture created in Unity and then we will registered this new texture
+/// in CUDA see issue #2 on github for more details
+/// </summary>
 class Texture_D3D11 : public Texture
 {
-public:
-	Texture_D3D11(void* textureHandle, int textureWidth, int textureHeight, int textureDepth);
-	~Texture_D3D11();
-	virtual void registerTextureInCUDA();
-	virtual void unRegisterTextureInCUDA();
+    public:
+    Texture_D3D11(void *textureHandle, int textureWidth, int textureHeight,
+                  int textureDepth, RenderAPI *renderAPI);
+    ~Texture_D3D11();
+    virtual void registerTextureInCUDA();
+    virtual void unRegisterTextureInCUDA();
+
+    protected:
+    virtual void copyUnityTextureToAPITexture();
+    virtual void copyAPITextureToUnityTexture();
+
+    private:
+    int copyUnityTextureToBuffer();
 
+    ID3D11Texture2D *_texBufferInterop{};
+    ID3D11Texture2D *_texUnityDX11{};
+    RenderAPI_D3D11 *_renderAPI;
 };
 
 #endif

Plugin/PluginInteropUnityCUDA/include/Texture/texture_OpenGLCoreES.h

@@ -17,7 +17,9 @@ class Texture_OpenGLCoreES : public Texture
 	~Texture_OpenGLCoreES();
 	virtual void registerTextureInCUDA();
 	virtual void unRegisterTextureInCUDA();
-
+protected:
+	virtual void copyUnityTextureToAPITexture();
+	virtual void copyAPITextureToUnityTexture();
 };
 
 #endif

Plugin/PluginInteropUnityCUDA/include/factory.h

@@ -1,13 +1,17 @@
 #pragma once
-class VertexBuffer;
-class Texture;
+#include "texture_OpenGLCoreES.h"
+#include "vertex_buffer_OpenGLCoreES.h"
+#include "texture_D3D11.h"
+#include "vertex_buffer_D3D11.h"
+#include "renderAPI.h"
+
 
 /// <summary>
 /// Simple factory template to create some vertex buffer or texture in function of API type 
 /// </summary>
 namespace Factory
 {
-	VertexBuffer* createBuffer(void* bufferHandle, int size, UnityGfxRenderer apiType);
-	Texture* createTexture(void* textureHandle, int textureWidth, int textureHeight, int textureDepth, UnityGfxRenderer apiType);
+	VertexBuffer* createBuffer(void* bufferHandle, int size, UnityGfxRenderer apiType, RenderAPI* renderAPI);
+	Texture* createTexture(void* textureHandle, int textureWidth, int textureHeight, int textureDepth, UnityGfxRenderer apiType, RenderAPI* renderAPI);
 }
 

Plugin/PluginInteropUnityCUDA/src/Texture/texture_D3D11.cpp

@@ -4,40 +4,73 @@
 #if SUPPORT_D3D11
 
 Texture_D3D11::Texture_D3D11(void *textureHandle, int textureWidth,
-                             int textureHeight, int textureDepth)
+                             int textureHeight, int textureDepth,
+                             RenderAPI *renderAPI)
     : Texture(textureHandle, textureWidth, textureHeight, textureDepth)
 {
+
+    // we need the render api associated to dx11, because we need device to
+    // initialize texture
+    _renderAPI = (RenderAPI_D3D11 *)renderAPI;
 }
 
 Texture_D3D11::~Texture_D3D11()
 {
+    _texBufferInterop->Release();
     CUDA_CHECK(cudaGetLastError());
 };
 
 /// <summary>
 /// Has to be call after the first issue plugin event
 /// see. https://docs.unity3d.com/ScriptReference/GL.IssuePluginEvent.html
-/// register a graphics resources defined from the texture openGL
+/// register a graphics resources defined from the texture dx11
 /// </summary>
 void Texture_D3D11::registerTextureInCUDA()
 {
 
-    Log::log().debugLog("try register");
-    ID3D11Texture2D *d3dtex = (ID3D11Texture2D *)_textureHandle;
-    assert(d3dtex);
-    // ID3D11DeviceContext* ctx = NULL;
-	// m_Device->GetImmediateContext(&ctx);
-    // ID3D11Resource* tex = (ID3D11Resource*)(_textureHandle);
-    // HRESULT result = tex->GetDevice()->GetDeviceRemovedReason();
+    // This method initialize the buffer textures that will be registered in
+    // CUDA This method will use m_device attributes in RenderAPI_D3D11, make
+    // sure it has been well initialized.
+    int retCodeCreate = _renderAPI->createTexture2D(
+        _textureWidth, _textureHeight, _textureDepth, &_texBufferInterop);
+    // we initialize
+    if (retCodeCreate < 0)
+    {
+        Log::log().debugLogError("Could not initialize texture on DX11 for "
+                                 "copy. Interoperability has failed.");
+    }
+
+
+    // we cast it here, to make it only once.
+    _texUnityDX11 = (ID3D11Texture2D *)_textureHandle;
+    // assert(_texBufferInterop);
+    // D3D11_TEXTURE2D_DESC texDesc;
+    // _texBufferInterop->GetDesc(&texDesc);
+
+    // DXGI_FORMAT format = texDesc.Format;
+    // Log::log().debugLog(std::to_string(format));
+
+    // CUDA_CHECK(cudaGetLastError());
     // register the texture to cuda : it initialize the _pGraphicsResource
     CUDA_CHECK(cudaGraphicsD3D11RegisterResource(
-        &_pGraphicsResource, d3dtex, cudaGraphicsRegisterFlagsWriteDiscard));
-    Log::log().debugLog("register");
+        &_pGraphicsResource, _texBufferInterop, cudaGraphicsRegisterFlagsNone));
+    CUDA_CHECK(cudaGetLastError());
 }
 
 void Texture_D3D11::unRegisterTextureInCUDA()
 {
+
     CUDA_CHECK(cudaGraphicsUnregisterResource(_pGraphicsResource));
 }
 
+void Texture_D3D11::copyUnityTextureToAPITexture()
+{
+    _renderAPI->copyTextures2D(_texBufferInterop, _texUnityDX11);
+}
+
+void Texture_D3D11::copyAPITextureToUnityTexture()
+{
+    _renderAPI->copyTextures2D(_texUnityDX11, _texBufferInterop);
+}
+
 #endif // #if SUPPORT_D3D11

Plugin/PluginInteropUnityCUDA/src/Texture/texture_OpenGLCoreES.cpp

@@ -3,39 +3,54 @@
 
 #if SUPPORT_OPENGL_UNIFIED
 
-
-Texture_OpenGLCoreES::Texture_OpenGLCoreES(void* textureHandle, int textureWidth, int textureHeight, int textureDepth)
-	: Texture(textureHandle, textureWidth, textureHeight, textureDepth)
-{}
+Texture_OpenGLCoreES::Texture_OpenGLCoreES(void *textureHandle,
+                                           int textureWidth, int textureHeight,
+                                           int textureDepth)
+    : Texture(textureHandle, textureWidth, textureHeight, textureDepth)
+{
+}
 
 Texture_OpenGLCoreES::~Texture_OpenGLCoreES()
 {
-	GL_CHECK();
-	CUDA_CHECK(cudaGetLastError());
+    GL_CHECK();
+    CUDA_CHECK(cudaGetLastError());
 };
 
 /// <summary>
-/// Has to be call after the first issue plugin event 
-/// see. https://docs.unity3d.com/ScriptReference/GL.IssuePluginEvent.html 
+/// Has to be call after the first issue plugin event
+/// see. https://docs.unity3d.com/ScriptReference/GL.IssuePluginEvent.html
 /// register a graphics resources defined from the texture openGL
 /// </summary>
 void Texture_OpenGLCoreES::registerTextureInCUDA()
 {
-	// if depth is < 2 it's a texture2D, else it's a texture2DArray
-	GLenum target = _textureDepth < 2 ? GL_TEXTURE_2D : GL_TEXTURE_3D;
-
-	// cast the pointer on the texture of unity to gluint
-	GLuint gltex = (GLuint)(size_t)(_textureHandle);
-	//glBindTexture(target, gltex);
-	GL_CHECK();
-	// register the texture to cuda : it initialize the _pGraphicsResource
-	CUDA_CHECK(cudaGraphicsGLRegisterImage(&_pGraphicsResource, gltex, target, cudaGraphicsRegisterFlagsWriteDiscard));
+    // if depth is < 2 it's a texture2D, else it's a texture2DArray
+    GLenum target = _textureDepth < 2 ? GL_TEXTURE_2D : GL_TEXTURE_3D;
+
+    // cast the pointer on the texture of unity to gluint
+    GLuint gltex = (GLuint)(size_t)(_textureHandle);
+    // glBindTexture(target, gltex);
+    GL_CHECK();
+    // register the texture to cuda : it initialize the _pGraphicsResource
+    CUDA_CHECK(
+        cudaGraphicsGLRegisterImage(&_pGraphicsResource, gltex, target,
+                                    cudaGraphicsRegisterFlagsWriteDiscard));
 }
 
-
 void Texture_OpenGLCoreES::unRegisterTextureInCUDA()
 {
-	CUDA_CHECK(cudaGraphicsUnregisterResource(_pGraphicsResource));
+    CUDA_CHECK(cudaGraphicsUnregisterResource(_pGraphicsResource));
+}
+
+void Texture_OpenGLCoreES::copyUnityTextureToAPITexture()
+{
+    
+}
+
+void Texture_OpenGLCoreES::copyAPITextureToUnityTexture()
+{
+    
 }
 
+
+
 #endif // #if SUPPORT_OPENGL_UNIFIED