Unity Personal Edition and Native Plugins

I decided to post the question about Native Plugins here in the General Discussion forum. I could not find an appropriate forum discussing Native Platforms.

Can I, when using Unity Personal Edition 2021.2.7, use Native Plugins?

Thanks

 

All editions have the same feature set. Personal, Plus, Pro. The difference is ability to shut down splash screen and some extra services. So, yes, you should be able to. It is in the docs.

https://docs.unity3d.com/2021.1/Documentation/Manual/NativePlugins.html

 

Thanks for the quick reply....

Although I did not explicitly asked the question, what forum would be best to discuss Native Plugins?

 

There's no dedicated forum for them. So, General SUpport or Scripting (because you need to write glue code) would PROBABLY be the best.

 

I always love these hints I get from Unity... Like function signatures for P/Invoke... The specific platform is MacOS but my ignorance on Frameworks and Bundles is right there on the bottom with the cherry pits.

I am also a windows and Linux user... With that said, I would prefer the path of least resistance in setting-up a Native Plugin. The reason for the plugin is to incorporate C++ Large Math Library for the simulations. I thought at one time that Personal Unity did not allow for Native Plugins!?

I was looking online for clean template like code and discovered that C# software that uses generics... I only found one but the code is incomplete.... https://github.com/HadiSalehWeb/LinearAlgebraSharp... The code is clean, once uploaded into unity and for days now trying to learn ADVANCED Csharp idiosyncrasies with frustrations...

So my programming skills in Csharp although lacking, I was thinking of using a C++ Plugin for my work while using Unity...

Thanks for the input...

 

So, IF I have very very large library (OOP) with classes having properties and methods instead of functions, then how is that exported? At the same time, just export what is needed and nothing more?

The compiler macro (define) _MSC_VER stands for exactly what IDE?

I really appreciate the help...

Again Thanks

Addendum:
I am little confused as to where Unity is going with IL2CPP (Intermediate Language To C++) assuming that Intermediate Language is C# generic based software, Android and MS Phone and WHY the push to Native Plugins? The confusion comes with 2022.1 version and a complete NOT SO descriptive entailing procedures for using Native Plugins for OOP C++ Libraries.. It's hard at times to predict Unity's future and I am wondering if tutorials for this push in this direction whether Unity Learn and tutorials are forthcoming???

IL2CPP Overview

The IL2CPP (Intermediate Language To C++) scripting backend
is an alternative to the Mono backend. IL2CPP provides better support for applications across a wider range of platforms. The IL2CPP backend converts MSIL (Microsoft Intermediate Language) code (for example, C# code in scripts) into C++ code, then uses the C++ code to create a native binary file (for example, .exe, .apk, or .xap) for your chosen platform.

 

That was before Unity 5.

The best idea is to use C# libraries, if available.

Interfacing with C++ code from C# can be difficult, and you can't use things like C++ templates.
You can, howver, easily interface with C-style APIs. You'll still need to write a lot of glue code.

C++ does not have properties and interfacing with OOP C++ code from C# is not easy.
https://stackoverflow.com/questions/315051/using-a-class-defined-in-a-c-dll-in-c-sharp-code

So you'd need to design a set of function to interact with that large C++ library. T hat's why using C# library, when available, is a good idea - less hassle.

 

Lost in Unity Space... OK

Unless I can find a sophisticated AI code converter FROM Template C++ to Generic C#, then I have to learn ADVANCED Csharp idiosyncrasies....

Thanks I Love Challenges.

Many in the industry would narrow the modern Programming languages down by encapsulating it into a singularity called abstraction.

 

I'm not sure if it is advanced or not, but it is not beginner. Interfacing with C++ requires some familiarity with C++. You'll also need to design functions used by C# in a specific way. As you cannot call C++ class directly from C#. You also need solid understanding of t he way things are laid out in memory.

Passing something like a struct to C++ side would require you to write a C# equivalent of the same struct, possibly with extra attributes that define memory layout of it in memory. This is what I call "writing glue code" and it is very tedious.

The related reading kinda starts here:
https://docs.microsoft.com/en-us/dotnet/standard/native-interop/type-marshaling

There's also a VERY annoying gotcha that C# Marshalling/Interop API was designed for interfacing with Win32 API calls, and as a result C# bool turns into a 32-bit DWORD by default, while C++ wants bool to be one byte.

 

What I meant by Lost in Unity Space is the obvious. Of course many in their own dogmatic world is about control. The goal is the quick hand performing the illusive tricks that Unity has to offer.... Come on, as Serena Williams yells out, get with the GAME.

 

What @Tautvydas-Zilys meant was that you have to make C-style wrapper functions that calls the C++ methods, and then in a C# class, you make an extern method that mirrors the C functions. Here is an example:

C++:

Code (cpp):

1. extern "C" void* class_A_new()
2. {
3.     return new A();
4. }
5.  
6. extern "C" void class_A_dealloc(void* handle)
7. {
8.     delete handle;
9. }
10.  
11. extern "C" void class_A_foo(void* handle)
12. {
13.     A* instance = static_cast<A*>(handle);
14.     instance->foo();
15. }
16.  
17. class A
18. {
19. public:
20.     void foo()
21.     {
22.           // Do stuff.
23.     }
24. }

C#:

Code (CSharp):

1. using System;
2. using System.Runtime.InteropServices;
3.  
4. class A
5. {
6.     private IntPtr nativeHandle;
7.  
8.     public A()
9.     {
10.         nativeHandle = class_A_new();
11.     }
12.  
13.     ~A()
14.     {
15.         class_A_delete(nativeHandle);
16.     }
17.  
18.     public void Foo()
19.     {
20.         class_A_foo(nativeHandle);
21.     }
22.  
23.     [DllImport("YOUR LIBRARY NAME HERE")]
24.     private static extern IntPtr class_A_new();
25.  
26.     [DllImport("YOUR LIBRARY NAME HERE")]
27.     private static extern void class_A_delete(IntPtr handle);
28.  
29.     [DllImport("YOUR LIBRARY NAME HERE")]
30.     private static extern void class_A_foo(IntPtr handle);
31. }

Now before anyone else say anything, I know that for native resources I should conform the C# class to IDisposable. I'm trying to go for the easiest example.

 

You completely lost me here.

 

Yes, that's the rough idea. Lots of glue code.

First you write the class in C++, then you write a wrapper for it in C++, then you write its doppelganger in C#, and if the class uses struct, you write duplicates for those in C# as well, and ensure they marshal properly.

It is a fairly tedious thing to do.

 

If the library is C++, you can potentially use SWIG (http://www.swig.org/) to generate C# wrappers, but it is a bit of work to set up.

 

When I had a similar problem at developing a C++ dll I sort of emulated the association of instances by using an ID on unity side and list (vector) of instances on the C++ list.
Whenever a new instance was needed, the C++ method created it, added a reference to it, to the vector and then returned its index in that vector to Unity.

Then every further call that would affect a specific instance has the instance id as its first parameter.
The C++ side just looks up the right field in the vector to get the reference to the required instance to affect.

Not a system suited for a high frequency of instance creation and destruction, but it's fairly solid and without a very high performance impact.

That you need a form of wrapper is annoying but that's unfortunately almost always the case when combining completely different programming languages. Therefore ideally when designing DLLs for Unity, try to make the DLL part as autonomous as possible. Have few calls from Unity and not interact with it all the time.