Trying to create VkFFT native plugin for Unity but it is crashing as soon as I hit the play button.

[anupkumar8245]

I am trying to implement the VkFFT for native plugin for Unity but unity is crashing as soon as I hit the play button for version1 of VkFFTPlugin.cpp or getting the error of [Native]: VkFFTAppend FAILED: 2004 for version2 of VkFFTPluing.cpp. The files are attached for reference. Can anybody help If you have tried this for Unity.

=============================VkFFTPlugin.cpp (v1)==============================
#include "IUnityInterface.h"
#include "IUnityGraphics.h"
#include "IUnityGraphicsVulkan.h"
#include <vulkan/vulkan.h>
#include
#include
#include // For hex printing

#define VKFFT_BACKEND 0
#include "vkFFT/vkFFT.h"

// --- GLOBALS ---
static IUnityInterfaces* s_UnityInterfaces = nullptr;
static IUnityGraphics* s_Graphics = nullptr;
static IUnityGraphicsVulkan* s_GraphicsVulkan = nullptr;

static VkFFTApplication app = {};
static bool isInitialized = false;

// Handles
static VkDevice g_Device = VK_NULL_HANDLE;
static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE;
static VkQueue g_Queue = VK_NULL_HANDLE;
static VkCommandPool g_CommandPool = VK_NULL_HANDLE;
static VkFence g_Fence = VK_NULL_HANDLE;

static VkBuffer inputBuffer = VK_NULL_HANDLE;
static VkBuffer outputBuffer = VK_NULL_HANDLE;
static size_t bufferSize = 0;

// Debugging
typedef void (DebugCallback)(const char message);
static DebugCallback s_DebugLog = nullptr;

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API RegisterDebugCallback(DebugCallback callback) {
s_DebugLog = callback;
}

void LogToUnity(const std::string& msg) {
if (s_DebugLog) s_DebugLog(msg.c_str());
}

// Helper to print pointer address
template
std::string Hex(T val) {
std::stringstream ss;
ss << std::hex << (uint64_t)val;
return "0x" + ss.str();
}

// --------------------------------------------------------------------------
// INIT
// --------------------------------------------------------------------------
void InitVkFFT() {
if (isInitialized || !s_GraphicsVulkan) return;

LogToUnity("--- Starting InitVkFFT ---");

UnityVulkanInstance unityInstance = s_GraphicsVulkan->Instance();

// 1. Capture Handles
g_Device = unityInstance.device;
g_PhysicalDevice = unityInstance.physicalDevice;
g_Queue = unityInstance.graphicsQueue;
uint32_t qIndex = unityInstance.queueFamilyIndex;

LogToUnity("Device: " + Hex(g_Device));
LogToUnity("Queue: " + Hex(g_Queue));
LogToUnity("QueueFamilyIndex: " + std::to_string(qIndex));

if (g_Device == VK_NULL_HANDLE) { LogToUnity("ERROR: Device is NULL"); return; }
if (g_Queue == VK_NULL_HANDLE) { LogToUnity("ERROR: Queue is NULL"); return; }

// 2. Create Command Pool
VkCommandPoolCreateInfo poolInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
poolInfo.queueFamilyIndex = qIndex;
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

VkResult poolRes = vkCreateCommandPool(g_Device, &poolInfo, nullptr, &g_CommandPool);
if (poolRes != VK_SUCCESS) {
    LogToUnity("ERROR: Failed to create Command Pool! VkResult: " + std::to_string(poolRes));
    return;
}
LogToUnity("CommandPool Created: " + Hex(g_CommandPool));

// 3. Create Fence
VkFenceCreateInfo fenceInfo = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
VkResult fenceRes = vkCreateFence(g_Device, &fenceInfo, nullptr, &g_Fence);
if (fenceRes != VK_SUCCESS) {
    LogToUnity("ERROR: Failed to create Fence! VkResult: " + std::to_string(fenceRes));
    return;
}
LogToUnity("Fence Created: " + Hex(g_Fence));

// 4. Configure VkFFT (Use LOCAL variable to ensure clean state)
VkFFTConfiguration config = {};
config.FFTdim = 1;
config.size[0] = bufferSize / sizeof(float) / 2;

// Pass Pointers
config.device = &g_Device;
config.physicalDevice = &g_PhysicalDevice;
config.queue = &g_Queue;
config.commandPool = &g_CommandPool;
config.fence = &g_Fence;

config.isInputFormatted = false;
config.isOutputFormatted = false;
uint64_t bufferSizeBytes = bufferSize;
config.bufferSize = &bufferSizeBytes;

LogToUnity("Calling initializeVkFFT...");

// 5. Initialize
VkFFTResult res = initializeVkFFT(&app, config);

if (res == VKFFT_SUCCESS) {
    isInitialized = true;
    LogToUnity("SUCCESS: VkFFT Initialized!");
}
else {
    LogToUnity("FAILURE: VkFFT Init Error code: " + std::to_string((int)res));
    // Cleanup attempt
    if (g_Fence) vkDestroyFence(g_Device, g_Fence, nullptr);
    if (g_CommandPool) vkDestroyCommandPool(g_Device, g_CommandPool, nullptr);
    g_Fence = VK_NULL_HANDLE;
    g_CommandPool = VK_NULL_HANDLE;
}

}

// --------------------------------------------------------------------------
// RENDER LOOP
// --------------------------------------------------------------------------
static void UNITY_INTERFACE_API OnRenderEvent(int eventID)
{
if (!s_GraphicsVulkan) return;

if (eventID == 1) {
    if (!isInitialized) InitVkFFT();

    if (isInitialized) {
        UnityVulkanRecordingState recordingState;
        // Access: Don't Care (Just gives us the current buffer)
        if (s_GraphicsVulkan->CommandRecordingState(&recordingState, kUnityVulkanGraphicsQueueAccess_DontCare)) {

            VkCommandBuffer cmd = recordingState.commandBuffer;

            // ---------------------------------------------------------
            // STEP A: INPUT BARRIER
            // Wait for Unity to finish Transferring (SetData) before we Read
            // ---------------------------------------------------------
            VkBufferMemoryBarrier inputBarrier = {};
            inputBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
            inputBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
            inputBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
            inputBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            inputBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            inputBarrier.buffer = (VkBuffer)inputBuffer;
            inputBarrier.offset = 0;
            inputBarrier.size = VK_WHOLE_SIZE;

            vkCmdPipelineBarrier(cmd,
                VK_PIPELINE_STAGE_TRANSFER_BIT,
                VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                0, 0, nullptr, 1, &inputBarrier, 0, nullptr);

            // ---------------------------------------------------------
            // STEP B: EXECUTE YOUR FFT
            // ---------------------------------------------------------
            VkFFTLaunchParams launchParams = {};
            launchParams.inputBuffer = &inputBuffer;
            launchParams.outputBuffer = &outputBuffer;
            launchParams.commandBuffer = &cmd;

            // CHANGE: 0 = Forward FFT (Time -> Freq), 1 = Inverse FFT
            // Since you want to see the Frequencies of your Sine Wave, use 0 (Forward).
            int direction = 0;

            VkFFTResult r = VkFFTAppend(&app, direction, &launchParams);

            if (r != VKFFT_SUCCESS) {

                LogToUnity("VkFFTAppend FAILED: " + std::to_string((int)r));

            }

            // ---------------------------------------------------------
            // STEP C: OUTPUT BARRIER
            // Wait for FFT to finish Writing before Unity Reads (Transfer)
            // ---------------------------------------------------------
            VkBufferMemoryBarrier outputBarrier = {};
            outputBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
            outputBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
            outputBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
            outputBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            outputBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            outputBarrier.buffer = (VkBuffer)outputBuffer;
            outputBarrier.offset = 0;
            outputBarrier.size = VK_WHOLE_SIZE;

            vkCmdPipelineBarrier(cmd,
                VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                VK_PIPELINE_STAGE_TRANSFER_BIT,
                0, 0, nullptr, 1, &outputBarrier, 0, nullptr);
        }
    }
}

}

// --------------------------------------------------------------------------
// UNLOAD
// --------------------------------------------------------------------------
extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginUnload()
{
if (isInitialized) {
deleteVkFFT(&app);
isInitialized = false;
}
if (g_Fence) vkDestroyFence(g_Device, g_Fence, nullptr);
if (g_CommandPool) vkDestroyCommandPool(g_Device, g_CommandPool, nullptr);
}

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginLoad(IUnityInterfaces* unityInterfaces) {
s_UnityInterfaces = unityInterfaces;
s_Graphics = s_UnityInterfaces->Get();
s_GraphicsVulkan = s_UnityInterfaces->Get();
}

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API SetBuffers(void* inputPtr, void* outputPtr, int size) {
inputBuffer = (VkBuffer)inputPtr;
outputBuffer = (VkBuffer)outputPtr;
bufferSize = size;
// Reset if size changes
if (isInitialized) {
deleteVkFFT(&app);
isInitialized = false;
// Note: We don't destroy the Pool/Fence here, we reuse them.
}
}

extern "C" UnityRenderingEvent UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API GetRenderEventFunc() {
return OnRenderEvent;
}
extern "C" __declspec(dllexport) int TestFunction() { return 999; }

====================================VkFFTPlugin.cpp (v2)==============================
#include "IUnityInterface.h"
#include "IUnityGraphics.h"
#include "IUnityGraphicsVulkan.h"
#include <vulkan/vulkan.h>
#include
#include
#include // For hex printing

#define VKFFT_BACKEND 0
#include "vkFFT/vkFFT.h"

// --- GLOBALS ---
static IUnityInterfaces* s_UnityInterfaces = nullptr;
static IUnityGraphics* s_Graphics = nullptr;
static IUnityGraphicsVulkan* s_GraphicsVulkan = nullptr;

static VkFFTApplication app = {};
static bool isInitialized = false;

// Handles
static VkDevice g_Device = VK_NULL_HANDLE;
static VkPhysicalDevice g_PhysicalDevice = VK_NULL_HANDLE;
static VkQueue g_Queue = VK_NULL_HANDLE;
static VkCommandPool g_CommandPool = VK_NULL_HANDLE;
static VkFence g_Fence = VK_NULL_HANDLE;

static VkBuffer inputBuffer = VK_NULL_HANDLE;
static VkBuffer outputBuffer = VK_NULL_HANDLE;
static size_t bufferSize = 0;

// Debugging
typedef void (DebugCallback)(const char message);
static DebugCallback s_DebugLog = nullptr;

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API RegisterDebugCallback(DebugCallback callback) {
s_DebugLog = callback;
}

void LogToUnity(const std::string& msg) {
if (s_DebugLog) s_DebugLog(msg.c_str());
}

// Helper to print pointer address
template
std::string Hex(T val) {
std::stringstream ss;
ss << std::hex << (uint64_t)val;
return "0x" + ss.str();
}

// --------------------------------------------------------------------------
// INIT
// --------------------------------------------------------------------------
void InitVkFFT() {
if (isInitialized || !s_GraphicsVulkan) return;

LogToUnity("--- Starting InitVkFFT ---");

UnityVulkanInstance unityInstance = s_GraphicsVulkan->Instance();

// 1. Capture Handles
g_Device = unityInstance.device;
g_PhysicalDevice = unityInstance.physicalDevice;
g_Queue = unityInstance.graphicsQueue;
uint32_t qIndex = unityInstance.queueFamilyIndex;

LogToUnity("Device: " + Hex(g_Device));
LogToUnity("Queue: " + Hex(g_Queue));
LogToUnity("QueueFamilyIndex: " + std::to_string(qIndex));

if (g_Device == VK_NULL_HANDLE) { LogToUnity("ERROR: Device is NULL"); return; }
if (g_Queue == VK_NULL_HANDLE) { LogToUnity("ERROR: Queue is NULL"); return; }

// 2. Create Command Pool
VkCommandPoolCreateInfo poolInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
poolInfo.queueFamilyIndex = qIndex;
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

VkResult poolRes = vkCreateCommandPool(g_Device, &poolInfo, nullptr, &g_CommandPool);
if (poolRes != VK_SUCCESS) {
    LogToUnity("ERROR: Failed to create Command Pool! VkResult: " + std::to_string(poolRes));
    return;
}
LogToUnity("CommandPool Created: " + Hex(g_CommandPool));

// 3. Create Fence
VkFenceCreateInfo fenceInfo = { VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
VkResult fenceRes = vkCreateFence(g_Device, &fenceInfo, nullptr, &g_Fence);
if (fenceRes != VK_SUCCESS) {
    LogToUnity("ERROR: Failed to create Fence! VkResult: " + std::to_string(fenceRes));
    return;
}
LogToUnity("Fence Created: " + Hex(g_Fence));

// 4. Configure VkFFT (Use LOCAL variable to ensure clean state)
VkFFTConfiguration config = {};
config.FFTdim = 1;
config.size[0] = bufferSize / sizeof(float) / 2;

// Pass Pointers
config.device = &g_Device;
config.physicalDevice = &g_PhysicalDevice;
config.queue = &g_Queue;
config.commandPool = &g_CommandPool;
config.fence = &g_Fence;

config.inputBuffer = &inputBuffer;
config.buffer = &outputBuffer;

config.isInputFormatted = 1;
//config.isOutputFormatted = 1;
// Buffer sizes (required for Vulkan)
uint64_t inputSize = bufferSize;
uint64_t outputSize = bufferSize;
config.inputBufferSize = &inputSize;
config.bufferSize = &outputSize;

config.performR2C = 0;  // We're doing C2C


LogToUnity("Calling initializeVkFFT...");

// 5. Initialize
VkFFTResult res = initializeVkFFT(&app, config);

if (res == VKFFT_SUCCESS) {
    isInitialized = true;
    LogToUnity("SUCCESS: VkFFT Initialized!");
}
else {
    LogToUnity("FAILURE: VkFFT Init Error code: " + std::to_string((int)res));
    // Cleanup attempt
    if (g_Fence) vkDestroyFence(g_Device, g_Fence, nullptr);
    if (g_CommandPool) vkDestroyCommandPool(g_Device, g_CommandPool, nullptr);
    g_Fence = VK_NULL_HANDLE;
    g_CommandPool = VK_NULL_HANDLE;
}

}

// --------------------------------------------------------------------------
// RENDER LOOP
// --------------------------------------------------------------------------
static void UNITY_INTERFACE_API OnRenderEvent(int eventID)
{
if (!s_GraphicsVulkan) return;

if (eventID == 1) {
    if (!isInitialized) InitVkFFT();

    if (isInitialized) {
        UnityVulkanRecordingState recordingState;
        // Access: Don't Care (Just gives us the current buffer)
        if (s_GraphicsVulkan->CommandRecordingState(&recordingState, kUnityVulkanGraphicsQueueAccess_DontCare)) {

            VkCommandBuffer cmd = recordingState.commandBuffer;

            // ---------------------------------------------------------
            // STEP A: INPUT BARRIER
            // Wait for Unity to finish Transferring (SetData) before we Read
            // ---------------------------------------------------------
            VkBufferMemoryBarrier inputBarrier = {};
            inputBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
            inputBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
            inputBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
            inputBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            inputBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            inputBarrier.buffer = (VkBuffer)inputBuffer;
            inputBarrier.offset = 0;
            inputBarrier.size = VK_WHOLE_SIZE;

            vkCmdPipelineBarrier(cmd,
                VK_PIPELINE_STAGE_TRANSFER_BIT,
                VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                0, 0, nullptr, 1, &inputBarrier, 0, nullptr);

            // ---------------------------------------------------------
            // STEP B: EXECUTE YOUR FFT
            // ---------------------------------------------------------
            VkFFTLaunchParams launchParams = {};
            launchParams.inputBuffer = &inputBuffer;
            launchParams.outputBuffer = &outputBuffer;
            launchParams.commandBuffer = &cmd;

            // CHANGE: 0 = Forward FFT (Time -> Freq), 1 = Inverse FFT
            // Since you want to see the Frequencies of your Sine Wave, use 0 (Forward).
            int direction = 0;

            VkFFTResult r = VkFFTAppend(&app, direction, &launchParams);

            if (r != VKFFT_SUCCESS) {

                LogToUnity("VkFFTAppend FAILED: " + std::to_string((int)r));

            }

            // ---------------------------------------------------------
            // STEP C: OUTPUT BARRIER
            // Wait for FFT to finish Writing before Unity Reads (Transfer)
            // ---------------------------------------------------------
            VkBufferMemoryBarrier outputBarrier = {};
            outputBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
            outputBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
            outputBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
            outputBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            outputBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            outputBarrier.buffer = (VkBuffer)outputBuffer;
            outputBarrier.offset = 0;
            outputBarrier.size = VK_WHOLE_SIZE;

            vkCmdPipelineBarrier(cmd,
                VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                VK_PIPELINE_STAGE_TRANSFER_BIT,
                0, 0, nullptr, 1, &outputBarrier, 0, nullptr);
        }
    }
}

}

// --------------------------------------------------------------------------
// UNLOAD
// --------------------------------------------------------------------------
extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginUnload()
{
if (isInitialized) {
deleteVkFFT(&app);
isInitialized = false;
}
if (g_Fence) vkDestroyFence(g_Device, g_Fence, nullptr);
if (g_CommandPool) vkDestroyCommandPool(g_Device, g_CommandPool, nullptr);
}

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API UnityPluginLoad(IUnityInterfaces* unityInterfaces) {
s_UnityInterfaces = unityInterfaces;
s_Graphics = s_UnityInterfaces->Get();
s_GraphicsVulkan = s_UnityInterfaces->Get();
}

extern "C" void UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API SetBuffers(void* inputPtr, void* outputPtr, int size) {
inputBuffer = (VkBuffer)inputPtr;
outputBuffer = (VkBuffer)outputPtr;
bufferSize = size;
// Reset if size changes
if (isInitialized) {
deleteVkFFT(&app);
isInitialized = false;
// Note: We don't destroy the Pool/Fence here, we reuse them.
}
}

extern "C" UnityRenderingEvent UNITY_INTERFACE_EXPORT UNITY_INTERFACE_API GetRenderEventFunc() {
return OnRenderEvent;
}
extern "C" __declspec(dllexport) int TestFunction() { return 996; }

===================================CMakeLists.txt======================================
cmake_minimum_required(VERSION 3.10)
project(VkFFTPlugin)

1. Setup Vulkan SDK

if(NOT DEFINED ENV{VULKAN_SDK})
message(FATAL_ERROR "VULKAN_SDK environment variable is not set.")
endif()

file(TO_CMAKE_PATH "$ENV{VULKAN_SDK}" VULKAN_SDK_PATH)
message(STATUS "Using Vulkan SDK at: ${VULKAN_SDK_PATH}")

2. Setup Source

set(SOURCES src/VkFFTPlugin.cpp)

add_library(VkFFTPlugin SHARED ${SOURCES})

3. Include Directories

target_include_directories(VkFFTPlugin PRIVATE
${VULKAN_SDK_PATH}/Include #Vulkan API
${CMAKE_SOURCE_DIR}/include # For vkFFT/vkFFT.h, VkFFT headers
${CMAKE_SOURCE_DIR}/include/Unity # Unity native plugin headers
$ENV{VULKAN_SDK}/Include/glslang/Include
)

4. Link Directories (Where the .lib files are)

target_link_directories(VkFFTPlugin PRIVATE ${VULKAN_SDK_PATH}/Lib)

5. Link Libraries (MANUAL FORCE LINK), required because: VkFFT compile shaders at runtime, Needs SPIRV optimizer and validator

The order matters!

target_link_libraries(VkFFTPlugin PRIVATE
vulkan-1
glslang
MachineIndependent
GenericCodeGen
SPIRV
SPIRV-Tools # <-- Added
SPIRV-Tools-opt # <-- Added
)

6. Definitions

target_compile_definitions(VkFFTPlugin PRIVATE
WIN32
VK_USE_PLATFORM_WIN32_KHR
)

7. Auto-Copy to Unity, This makes Unity instantly see: Updated dll, No Manual Copying

add_custom_command(TARGET VkFFTPlugin POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
$<TARGET_FILE:VkFFTPlugin>
"${CMAKE_SOURCE_DIR}/../UnityProject/Assets/Plugins/x86_64/$<TARGET_FILE_NAME:VkFFTPlugin>"
)

==================================VkFFT.cs (Unity C# code)=================================
using UnityEngine;
using System;
using System.Runtime.InteropServices;
using UnityEngine.Rendering;

public class VkFFT : MonoBehaviour
{
//// 1. Import functions from your DLL
//[DllImport("VkFFTPlugin")]
//private static extern void SetBuffers(IntPtr input, IntPtr output, int size);

//[DllImport("VkFFTPlugin")]
//private static extern IntPtr GetRenderEventFunc();

[DllImport("VkFFTPlugin", CallingConvention = CallingConvention.Cdecl)]
static extern void SetBuffers(IntPtr input, IntPtr output, int size);

[DllImport("VkFFTPlugin", CallingConvention = CallingConvention.Cdecl)]
static extern IntPtr GetRenderEventFunc();

[DllImport("VkFFTPlugin")]
static extern int TestFunction();

// Debug Callback definition
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate void DebugCallback(string message);

[DllImport("VkFFTPlugin", CallingConvention = CallingConvention.Cdecl)]
private static extern void RegisterDebugCallback(DebugCallback callback);

// Keep reference to prevent GC
private static DebugCallback debugCallbackDelegate;

void Awake()
{ // Use Awake to register early
    debugCallbackDelegate = new DebugCallback(DebugMethod);
    RegisterDebugCallback(debugCallbackDelegate);
}

// Static method to handle logs
[AOT.MonoPInvokeCallback(typeof(DebugCallback))]
private static void DebugMethod(string message)
{
    Debug.Log($"[Native]: {message}");
}


// 2. Constants
private const int FFT_SIZE = 1024; // Must match your C++ logic if hardcoded, or pass it down
private ComputeBuffer inputBuffer;
private ComputeBuffer outputBuffer;

void Start()
{
    Debug.Log("Native test: " + TestFunction());
    // A. Allocate GPU Memory
    // Size * 2 because FFT uses Complex numbers (Real, Imaginary)
    // Stride is 4 bytes (sizeof float)
    // Use ComputeBufferType.Structured to ensure VK_BUFFER_USAGE_STORAGE_BUFFER_BIT is set
    inputBuffer = new ComputeBuffer(FFT_SIZE * 2, sizeof(float), ComputeBufferType.Structured);
    outputBuffer = new ComputeBuffer(FFT_SIZE * 2, sizeof(float), ComputeBufferType.Structured);

    // B. Generate Test Data (Sine Wave at 10Hz)
    float[] data = new float[FFT_SIZE * 2];
    for (int i = 0; i < FFT_SIZE; i++)
    {
        float t = (float)i / FFT_SIZE;
        // Real part: sin(2 * pi * 50 * t) -> We expect a spike at bin 50
        data[i * 2] = Mathf.Sin(2 * Mathf.PI * 50 * t);
        // Imaginary part: 0
        data[i * 2 + 1] = 0;
    }

    // Upload data to GPU
    inputBuffer.SetData(data);

    // C. Pass Native Pointers to C++
    // When using Vulkan, GetNativeBufferPtr() returns the VkBuffer handle
    SetBuffers(inputBuffer.GetNativeBufferPtr(), outputBuffer.GetNativeBufferPtr(), FFT_SIZE * sizeof(float) * 2);


}

void Update()
{
    // 3. Execute FFT on the GPU
    // This queues the C++ function to run on the Render Thread
    GL.IssuePluginEvent(GetRenderEventFunc(), 1);

    // FORCE GPU to finish everything before continuing (STALLS CPU)
    // If this makes the data appear, your issue is definitely the C++ Barrier.
    // Note: You can't easily force a Fence wait on Unity's internal queue from C#, 
    // so this test relies on Unity flushing its buffer.
    GL.Flush();

    // 4. Verify Results (Optional Debugging)
    // We use AsyncGPUReadback to avoid freezing the game
    if (Time.frameCount % 60 == 0) // Check once per second
    {
        AsyncGPUReadback.Request(outputBuffer, OnCompleteReadback);//Safely copies GPU → CPU without stalling.
    }
}

void OnCompleteReadback(AsyncGPUReadbackRequest request)
{
    if (request.hasError) return;

    var data = request.GetData<float>();

    // Check bin 50 (where we put the sine wave)
    // FFT magnitude = sqrt(real^2 + imag^2)
    float real = data[50 * 2];
    float imag = data[50 * 2 + 1];
    float magnitude = Mathf.Sqrt(real * real + imag * imag);

    //Debug.Log($"FFT Result at Bin 50: {magnitude} (Expected ~512 for N=1024)");

    for (int i = 45; i <= 55; i++)
    {
        float r = data[i * 2];
        float im = data[i * 2 + 1];
        Debug.Log($"Bin {i}: {Mathf.Sqrt(r * r + im * im)}");
    }
}

void OnDestroy()
{
    // 5. Cleanup
    inputBuffer?.Release();
    outputBuffer?.Release();
}

}

[DTolm]

Hello,

I think the issue is that in your launchParams you need to specify the buffer field with a pointer to your main working buffer. The isInputFormatted option enables initial reading from the inputBuffer and isOutputFormatted enables final writing to the outputBuffer, but the main work happens in the buffer. Hope this solves the issue.

Best regards,
Dmitrii