I am trying to pass an array from struct

from C ++ to Unity script in C #. When I use the code in production, the size of the array will vary greatly, so I really need to pass an array of unknown length.

My smart idea was to store the array on the heap and pass a reference to that array to Unity. I found StackOverflow posts on how to do this. But then Unity complains that the link is null.

Here is a portion of my C ++ code:

extern "C" struct S; // Not currently used.

struct S {
  int i;
  float f;
};

extern "C" bool helloWorld(S ** a, int * i);

S * s;

bool helloWorld(S ** a, int * i) {
  s = new S[4];
  for (int j = 0; j < 4; j++) {
    s[j].i = j;           // Fill in placeholder
    s[j].f = (float) j;   // data for now.
  }
  *a = s; // I don't know if this works.
  *i = 4; // Works.
  return true;
}

      

        
        
        
      

    

I tried this with int

instead struct

and it worked.

Now my C # code:

[StructLayout(LayoutKind.Sequential),Serializable]
public struct S {
  int i;
  float f;
};

void Start() {
  IntPtr ptrNativeData = IntPtr.Zero;
  int itemsLength = 0;

  bool success = helloWorld(ref ptrNativeData, ref itemsLength);
  if (!success) {
    return;
  }

  S[] SArray = new S[itemsLength];  // Where the final data will be stored.
  IntPtr[] SPointers = new IntPtr[itemsLength];

  Debug.Log("Length: " + itemsLength); // Works!
  Marshal.Copy(ptrNativeData, SPointers, 0, itemsLength); // Seems not to work.

  for (int i = 0; i < itemsLength; i++) {
    Debug.Log("Pointer: " + SPointers[i]); // SPointers[0] prints 0.
    Marshal.PtrToStructure(SPointers[i], SArray[i]); // Crashes here. Boom.
  }
}

[DllImport("TestUnity")]
private static extern bool helloWorld(ref IntPtr ptrResultVerts,
    ref int resultVertLength);

      

        
        
        
      

    

The statement Marshal.PtrToStructure

states that the SPointers [i] argument is null. I checked with the Debug.Log command and indeed it looks like null: it prints as 0.

But I've tried something similar with an array before int

and it worked. I'm not sure about this: is this my problem in C ++ or C #? Am I not transmitting correct information or am I not processing correct information in the wrong way?

Solution 1

This was the first solution I came up with mostly on my own. The second solution is better.

Thanks completely to Alex Skalozub, I figured it out. One level of pointer directionality is abstracted during sorting. So my C ++ code contains:

S ** s; // Not a pointer to Ss, but a pointer to pointers to Ss.

bool helloWorld(S *** a, int * i) { // Pass a triple pointer.
  s = new S * [4]; // Create array of pointers.
  for (int j = 0; j < 4; j++) {
    s[j] = new S; // Actually create each object.
    s[j]->i = j;
    s[j]->f = (float) j;
  }
  *a = s;
  *i = 4;
  return true;
}

      

        
        
        
      

    

And my C # code contains:

for (int i = 0; i < itemsLength; i++) {
  Debug.Log("Pointer: " + SPointers[i]);
  SArray[i] = (S) Marshal.PtrToStructure(SPointers[i], typeof(S));
}

      

        
        
        
      

    

And this! All data has been transferred.

Now this leaves me with a memory management problem: every single object created in C ++ code must be freed . I know about this, and I will take care of it further.

Solution 2

See verified answer. Alex's answer is much better as it uses much less unnecessary pointers. I used more pointers because I just figured out how to use them in C #.