FAIR WARNING: I've never written C# before this, so the code may not be great.
------------------
In my spare time I have been working on porting the REAPER C/C++ API to common languages. I plan to publish translations and working examples in most common languages, including Java/Kotlin, Swift, and others.
Please let me know if there's a language you'd like to have native access from.
I've managed to port it so far to D and C#.
Though nobody writes D, so I have yet to publish my D translation.
Instructions:- Clone https://github.com/GavinRay97/reaper-native
- Install .NET 6 SDK from https://dotnet.microsoft.com/download/dotnet/6.0
- Run "dotnet build" from inside of "reaper-native/dotnet"
- Copy files from "reaper-native/dotnet/bin/Debug/net6.0/win-x64" to "REAPER/UserPlugins"
- Start REAPER, see console message which was fired by C# calling a C/C++ method
What this is:
A starter project which can successfully compile a functioning shared library that works as a REAPER native extension and has access to the C API.
I have translated the definitions of all +800 functions from C, to C#'s unmanaged function pointer syntax.
IE, the following C code:
PHP Code:
void (*ShowConsoleMsg)(const char* msg);
Can be called like this in C#:
PHP Code:
// NativeTypeName is just for documentation
[NativeTypeName("void (*)(const char *)")]
public delegate* unmanaged[Cdecl]<sbyte*, void> ShowConsoleMsg;
Additionally, I've taken care of "loading in" the function pointers at the start of the plugin for you. The C header does this for you with the
REAPERAPI_IMPLEMENT macro, but since we're not in C-land, we've no such niceties.
This works via reflection and calculating struct offsets.
Many thanks to "Zombie" from the C# Discord server "#low-level" channel for help here.
After all this, that means you can write a native REAPER extension in .NET with just:
PHP Code:
public static unsafe class MyReaperPlugin
{
[UnmanagedCallersOnly(EntryPoint = "ReaperPluginEntry")]
public static int ReaperPluginEntry(IntPtr hInstance, [DNNE.C99Type("struct reaper_plugin_info_t*")] reaper_plugin_info_t* rec)
{
try
{
// Initialize
reaper_plugin_functions reaper = new reaper_plugin_functions();
reaper.Initialize(rec);
// Hello World
IntPtr msgPtr = Marshal.StringToHGlobalAnsi("Hello From C#");
try
{
reaper.ShowConsoleMsg((sbyte*)msgPtr);
}
finally
{
Marshal.FreeHGlobal(msgPtr);
}
return 1;
}
// Handle exception
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
return 0;
}
}
}
================================================== ===========
Long explanation that probably nobody cares about:
.NET these days allows you to:
- Compile native binaries/libraries and export a C ABI
- Export a C ABI from a managed (non-native) assembly, in the form of static/shared lib
- See this recent article for more interesting native/C(++) interop stuff:
The tl;dr of it, is that we can write something like this:
PHP Code:
[UnmanagedCallersOnly(EntryPoint = "add")]
public static int Add(int a, int b)
{
return a + b;
}
And then have a native artifact which exports this:
PHP Code:
DLL_EXPORT int add(int a, int b);
The REAPER native API expects an export name called "ReaperPluginEntry", that it will call with arguments:
PHP Code:
struct reaper_plugin_info_t
{
int caller_version;
void* hwnd_main;
int (*Register)(const char* name, void* infostruct);
void* (*GetFunc)(const char* name);
};
int ReaperPluginEntry(HINSTANCE, reaper_plugin_info_t* rec);
Knowing this, and knowing that we can export C calling-convention functions from .NET, then we can write a C# library which exports the same thing:
PHP Code:
public static unsafe class MyReaperPlugin
{
private const string ReaperPluginInfoStructString = @"
struct reaper_plugin_info_t
{
int caller_version;
void* hwnd_main;
int (*Register)(const char* name, void* infostruct);
void* (*GetFunc)(const char* name);
};
";
public unsafe partial struct reaper_plugin_info_t
{
public int caller_version;
public IntPtr hwnd_main;
[NativeTypeName("int (*)(const char *, void *)")]
public delegate* unmanaged[Cdecl]<sbyte*, void*, int> Register;
[NativeTypeName("void *(*)(const char *)")]
public delegate* unmanaged[Cdecl]<sbyte*, void*> GetFunc;
}
[UnmanagedCallersOnly(EntryPoint = "ReaperPluginEntry")]
[DNNE.C99DeclCode(ReaperPluginInfoStructString)]
public static int ReaperPluginEntry(IntPtr hInstance, [DNNE.C99Type("struct reaper_plugin_info_t*")] reaper_plugin_info_t* rec)
{
try
{
// &ShowConsoleMsg = (ShowConsoleMsg)rec->GetFunc("ShowConsoleMsg")
IntPtr fnNamePtr = Marshal.StringToHGlobalAnsi("ShowConsoleMsg");
delegate* unmanaged[Cdecl]<sbyte*, void> ShowConsoleMsg;
try
{
void* fnPtr = rec->GetFunc((sbyte*)fnNamePtr);
ShowConsoleMessage = (unmanaged[Cdecl]<sbyte*, void>) fnPtr;
}
finally
{
Marshal.FreeHGlobal(fnNamePtr);
}
// reaper.ShowConsoleMessage("Hello World")
IntPtr msgPtr = Marshal.StringToHGlobalAnsi("Hello From C#");
try
{
ShowConsoleMsg((sbyte*)msgPtr);
}
finally
{
Marshal.FreeHGlobal(msgPtr);
}
return 1;
}
// Handle exception
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
return 0;
}
}
}
If we take a look at the compiled library exports, you'll see our entrypoint listed, and there's no more magic to it than that:
ReaperSharp - Build native REAPER extensions in C#/VB instead of C++
Linear Mode
