♻️ Update texture and buffer and add a function to simplify dimension grid calculation

Author: davidAlgis

Plugin/PluginInteropUnityCUDA/include/Buffer/vertexBuffer_OpenGLCoreES.h

@@ -10,9 +10,9 @@ class VertexBuffer_OpenGLCoreES : public VertexBuffer
 public:
 	VertexBuffer_OpenGLCoreES(void* bufferHandle, int size);
 	~VertexBuffer_OpenGLCoreES();
-	virtual void registerBufferInCUDA();
-	virtual void unRegisterBufferInCUDA();
-	virtual int SetTextureFromBuffer(Texture& texture);
+	void registerBufferInCUDA() override;
+	void unRegisterBufferInCUDA() override;
+	int SetTextureFromBuffer(Texture& texture) const override;
 
 };
 

Plugin/PluginInteropUnityCUDA/include/cudaInclude.h

@@ -14,3 +14,75 @@ inline void gpuAssert(cudaError_t code, const char* file, int line)
         Log::log().debugLogError(buffer);
     }
 }
+
+
+ /// <summary>
+/// Get thedim grid to use for a dispatch, from a multiple of
+/// dim block that are used by the kernel, and the number of
+/// calculation that has to be done.
+/// </summary>
+/// <param name="dimBlock">Number of threads per block
+/// </param> 
+/// <param name="numCalculation">Number of calculation
+/// to do on kernel (eg. if we make calculation on a 1024x1024 texture, and
+/// we only want to compute a value on the first 528x528 pixels , then
+/// numCalculation = 528,528,1)
+/// </param> 
+/// <param name="getUp">If true will get the
+/// upper multiple of dimBlock, else will get the lower multiple. By
+/// default its true.
+/// </param> 
+/// <param name="mustDoAllCalculation">if true
+/// imply that dimBlock must be multiple of numCalculation
+/// </param>
+/// <returns>The dim of grid to use in dispatch</returns>
+inline dim3 calculateDimGrid(dim3 dimBlock, dim3 numCalculation, bool getUp = true,
+                     bool mustDoAllCalculation = false)
+{
+    int addFactor = getUp ? 1 : 0;
+    float invDimBlockX = 1.0f / dimBlock.x;
+    float invDimBlockY = 1.0f / dimBlock.y;
+    float invDimBlockZ = 1.0f / dimBlock.z;
+
+    if (mustDoAllCalculation)
+    {
+        if (numCalculation.x % dimBlock.x != 0 ||
+            numCalculation.y % dimBlock.y != 0 ||
+            numCalculation.z % dimBlock.z != 0)
+        {
+            Log::log().debugLogError(
+                "Number of threads per block (" + std::to_string(dimBlock.x) +
+                ", " + std::to_string(dimBlock.y) + ", " +
+                std::to_string(dimBlock.z) +
+                ")"
+                " is not a multiple of (" +
+                std::to_string(numCalculation.x) + ", " +
+                std::to_string(numCalculation.y) + ", " +
+                std::to_string(numCalculation.z) +
+                ")"
+                ", therefore the compute shader will not compute on all data.");
+        }
+    }
+
+    unsigned int multipleDimBlockX =
+        dimBlock.x * ((int)(numCalculation.x * invDimBlockX) + addFactor);
+    unsigned int dimGridX = multipleDimBlockX / dimBlock.x;
+
+    unsigned int multipleDimBlockY =
+        dimBlock.y * ((int)(numCalculation.y * invDimBlockY) + addFactor);
+    unsigned int dimGridY = multipleDimBlockY / dimBlock.y;
+
+    unsigned int multipleDimBlockZ =
+        dimBlock.z * ((int)(numCalculation.z * invDimBlockZ) + addFactor);
+    unsigned int dimGridZ = multipleDimBlockZ / dimBlock.z;
+
+    if (dimGridX < 1 || dimGridY < 1 || dimGridZ <1)
+    {
+        Log::log().debugLogError(
+            "Threads group size " + std::to_string(dimGridX) +
+            std::to_string(dimGridY) + std::to_string(dimGridZ) +
+            " must be above zero.");
+    }
+
+    return dim3{dimGridX, dimGridY, dimGridZ};
+}

Plugin/PluginInteropUnityCUDA/src/Buffer/vertexBuffer_OpenGLCoreES.cpp

@@ -32,21 +32,22 @@ void VertexBuffer_OpenGLCoreES::registerBufferInCUDA()
 	CUDA_CHECK(cudaGraphicsGLRegisterBuffer(&_pGraphicsResource, glBuffer, cudaGraphicsRegisterFlagsNone));
 }
 
-int VertexBuffer_OpenGLCoreES::SetTextureFromBuffer(Texture& texture) 
+int VertexBuffer_OpenGLCoreES::SetTextureFromBuffer(Texture& texture) const 
 {
-	//TODO: add some check on type
-	if (texture.getHeight() * texture.getWidth() != _size) 
-	{
-		Log::log().debugLogError("Cannot create a texture from a buffer which has a different size");
-		return -1;
-	}
-
-	// Select the appropriate buffer
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, (GLuint)_bufferHandle);
-	// Select the appropriate texture
-	glBindTexture(GL_TEXTURE_2D, (GLuint)texture.getNativeTexturePtr());
-
-	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture.getWidth(), texture.getHeight(), GL_BGRA, GL_UNSIGNED_BYTE, NULL);
+	return 0;
+	////TODO: add some check on type
+	//if (texture.getHeight() * texture.getWidth() != _size) 
+	//{
+	//	Log::log().debugLogError("Cannot create a texture from a buffer which has a different size");
+	//	return -1;
+	//}
+
+	//// Select the appropriate buffer
+	//glBindBuffer(GL_PIXEL_UNPACK_BUFFER, (GLuint)_bufferHandle);
+	//// Select the appropriate texture
+	//glBindTexture(GL_TEXTURE_2D, (GLuint)texture.getNativeTexturePtr());
+
+	//glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture.getWidth(), texture.getHeight(), GL_BGRA, GL_UNSIGNED_BYTE, NULL);
 }
 
 void VertexBuffer_OpenGLCoreES::unRegisterBufferInCUDA()

Plugin/PluginInteropUnityCUDA/src/Texture/texture.cpp

@@ -12,8 +12,15 @@ Texture::Texture(void* textureHandle, int textureWidth, int textureHeight, int t
     // set a default size of grid and block to avoid calculating it each time
     // TODO : update this for texture depth
     _dimBlock = { 8, 8, 1 };
-    _dimGrid = { (textureWidth + _dimBlock.x - 1) / _dimBlock.x,
+    _dimGrid = calculateDimGrid(_dimBlock, {textureWidth, textureHeight, 1});
+    dim3 dimGrid = { (textureWidth + _dimBlock.x - 1) / _dimBlock.x,
         (textureHeight + _dimBlock.y - 1) / _dimBlock.y, 1};
+    Log::log().debugLog("(" + std::to_string(dimGrid.x) + ", " +
+                        std::to_string(dimGrid.y) + ", " +
+                        std::to_string(dimGrid.z) + ")");
+    Log::log().debugLog("(" + std::to_string(_dimGrid.x) + ", " +
+                        std::to_string(_dimGrid.y) + ", " +
+                        std::to_string(_dimGrid.z) + ")");
     _pGraphicsResource = nullptr;
 }