public unsafe static void Main()
{
ExampleStruct ex = new ExampleStruct();
byte * addr = (byte *)&ex;
Console.WriteLine("Size: {0}", sizeof(ExampleStruct));
Console.WriteLine("b1 Offset: {0}", &ex.b1 - addr);
Console.WriteLine("b2 Offset: {0}", &ex.b2 - addr);
Console.WriteLine("i3 Offset: {0}", (byte *)&ex.i3 - addr);
}
public void BasicUploads()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[1024];
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = i
}
}
;
Setup(initialData);
var structSize = UnsafeUtility.SizeOf <ExampleStruct>();
var totalSize = structSize * initialData.Length;
var tsu = uploader.Begin(totalSize, totalSize, initialData.Length);
tsu.AddUpload(new ExampleStruct {
someData = 7
}, 4);
uploader.EndAndCommit(tsu);
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
Assert.AreEqual(0, resultingData[0].someData);
Assert.AreEqual(7, resultingData[1].someData);
Assert.AreEqual(2, resultingData[2].someData);
tsu = uploader.Begin(structSize, structSize, 1);
tsu.AddUpload(new ExampleStruct {
someData = 13
}, 8);
uploader.EndAndCommit(tsu);
buffer.GetData(resultingData);
Assert.AreEqual(0, resultingData[0].someData);
Assert.AreEqual(7, resultingData[1].someData);
Assert.AreEqual(13, resultingData[2].someData);
Assert.AreEqual(3, resultingData[3].someData);
Teardown();
}
public void SmallUpload()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[64];
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = 0
};
}
var buffer = new ComputeBuffer(initialData.Length, UnsafeUtility.SizeOf <ExampleStruct>());
buffer.SetData(initialData);
var uploader = new SparseUploader(buffer);
{
var tsu = uploader.Begin(UnsafeUtility.SizeOf <ExampleStruct>() * initialData.Length, initialData.Length);
for (int i = 0; i < initialData.Length; ++i)
{
tsu.AddUpload(new ExampleStruct {
someData = i
}, i * 4);
}
uploader.EndAndCommit(tsu);
}
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
for (int i = 0; i < resultingData.Length; ++i)
{
Assert.AreEqual(i, resultingData[i].someData);
}
uploader.Dispose();
buffer.Dispose();
}
public void SmallUpload()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[64];
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = 0
}
}
;
Setup(initialData);
var structSize = UnsafeUtility.SizeOf <ExampleStruct>();
var totalSize = structSize * initialData.Length;
var tsu = uploader.Begin(totalSize, structSize, initialData.Length);
for (int i = 0; i < initialData.Length; ++i)
{
tsu.AddUpload(new ExampleStruct {
someData = i
}, i * 4);
}
uploader.EndAndCommit(tsu);
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
for (int i = 0; i < resultingData.Length; ++i)
{
Assert.AreEqual(i, resultingData[i].someData);
}
Teardown();
}
public void UploadFromJobs()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[4 * 1024];
var stride = UnsafeUtility.SizeOf <ExampleStruct>();
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = 0
};
}
var buffer = new ComputeBuffer(initialData.Length, stride);
buffer.SetData(initialData);
var uploader = new SparseUploader(buffer);
var job = new UploadJob();
job.uploader = uploader.Begin(initialData.Length * stride, initialData.Length);
job.Schedule(initialData.Length, 64).Complete();
uploader.EndAndCommit(job.uploader);
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
for (int i = 0; i < resultingData.Length; ++i)
{
Assert.AreEqual(i, resultingData[i].someData);
}
uploader.Dispose();
buffer.Dispose();
}
public void ToNativeStruct_Returns_Correct_Values_In_Custom_Struct()
{
XmlRpcStruct str = new XmlRpcStruct(new Struct()
{
{ "Field1", new XmlRpcInteger(3425) },
{ "Field2", new XmlRpcDouble(325.235) },
{ "Field3", new XmlRpcString("Test String") },
{ "Field4", new XmlRpcBoolean(true) },
{ "Field5", new XmlRpcBoolean(false) },
{ "Field6", new XmlRpcBase64(Base64.FromBase64String("VGVzdCBTdHJpbmc=")) },
{ "Field7", new XmlRpcDateTime(DateTime.Parse("2021-04-06T16:36:44.1557489+02:00").ToUniversalTime()) },
{ "Field8", new XmlRpcArray(new XmlRpcBaseType[] {
new XmlRpcInteger(1),
new XmlRpcInteger(2),
new XmlRpcInteger(3)
}) },
{ "Field9", new XmlRpcStruct(new Struct()
{
{ "Field1", new XmlRpcInteger(1) },
{ "Field2", new XmlRpcInteger(2) },
{ "Field3", new XmlRpcInteger(3) }
}) },
});
ExampleStruct result = (ExampleStruct)XmlRpcTypes.ToNativeStruct <ExampleStruct>(str);
Base64 field6Expected = Base64.FromBase64String("VGVzdCBTdHJpbmc=");
DateTime field7Expected = DateTime.Parse("2021-04-06T16:36:44.1557489+02:00").ToUniversalTime();
Assert.NotNull(result);
Assert.Equal(3425, result.Field1);
Assert.Equal(325.235, result.Field2);
Assert.Equal("Test String", result.Field3);
Assert.True(result.Field4);
Assert.False(result.Field5);
Assert.Equal(field6Expected, result.Field6);
Assert.Equal(field7Expected, result.Field7);
Assert.Equal(new int[] { 1, 2, 3 }, result.Field8);
Assert.NotNull(result.Field9);
Assert.Equal(1, result.Field9.Field1);
Assert.Equal(2, result.Field9.Field2);
Assert.Equal(3, result.Field9.Field3);
}
public void ClassGetDefault()
{
object result;
object expect;
result = Energy.Base.Class.GetDefault(typeof(DateTime));
expect = DateTime.MinValue;
Assert.AreEqual(expect, result);
result = Energy.Base.Class.GetDefault <DateTime>();
Assert.AreEqual(expect, result);
result = Energy.Base.Class.GetDefault(typeof(ExampleStruct));
expect = new ExampleStruct()
{
Value = null
};
Assert.AreEqual(expect, result);
result = Energy.Base.Class.GetDefault <ExampleStruct>();
Assert.AreEqual(expect, result);
}
public void RewriteConstructor()
{
var info = typeof(ExampleClass).GetConstructor(new[] { typeof(int) });
var context = new ShimContext();
var rewrite = ILRewriter.ILRewriter.Rewrite(info, context);
var exampleClass = new ExampleClass(2);
rewrite.Invoke(null, new object[] { exampleClass, 3, context });
Assert.Equal(3, exampleClass.Factor);
info = typeof(ExampleStruct).GetConstructor(new[] { typeof(int) });
rewrite = ILRewriter.ILRewriter.Rewrite(info, new ShimContext());
var dele = (ExampleStructConstructor)rewrite.CreateDelegate(typeof(ExampleStructConstructor));
var exampleStruct = new ExampleStruct(2);
dele(ref exampleStruct, 3, context);
Assert.Equal(3, exampleStruct.Factor);
}
public void ReplaceBuffer()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[64];
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = i
}
}
;
Setup(initialData);
var newBuffer = new ComputeBuffer(initialData.Length * 2, UnsafeUtility.SizeOf <ExampleStruct>());
uploader.ReplaceBuffer(newBuffer, true);
buffer.Dispose();
buffer = newBuffer;
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
for (int i = 0; i < resultingData.Length; ++i)
{
Assert.AreEqual(i, resultingData[i].someData);
}
Teardown();
}
public unsafe void BigUploads()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[4 * 1024];
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = i
}
}
;
Setup(initialData);
var newData = new ExampleStruct[312];
for (int i = 0; i < newData.Length; ++i)
{
newData[i] = new ExampleStruct {
someData = i + 3000
}
}
;
var newData2 = new ExampleStruct[316];
for (int i = 0; i < newData2.Length; ++i)
{
newData2[i] = new ExampleStruct {
someData = i + 4000
}
}
;
var structSize = UnsafeUtility.SizeOf <ExampleStruct>();
var totalSize = structSize * (newData.Length + newData2.Length);
var tsu = uploader.Begin(totalSize, totalSize, initialData.Length);
fixed(void *ptr = newData)
tsu.AddUpload(ptr, newData.Length * 4, 512 * 4);
fixed(void *ptr2 = newData2)
tsu.AddUpload(ptr2, newData2.Length * 4, 1136 * 4);
uploader.EndAndCommit(tsu);
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
for (int i = 0; i < resultingData.Length; ++i)
{
if (i < 512)
{
Assert.AreEqual(i, resultingData[i].someData);
}
else if (i < 824)
{
Assert.AreEqual(i - 512 + 3000, resultingData[i].someData);
}
else if (i < 1136)
{
Assert.AreEqual(i, resultingData[i].someData);
}
else if (i < 1452)
{
Assert.AreEqual(i - 1136 + 4000, resultingData[i].someData);
}
else
{
Assert.AreEqual(i, resultingData[i].someData);
}
}
Teardown();
}
private static extern int AcceptStruct(ref ExampleStruct s);
// Test functions
private void Awake()
{
// return int
print(ReturnInt());
// accept string
bool r1 = AcceptStr("BAR");
bool r2 = AcceptStr("FOO");
print("r1=" + r1);
print("r2=" + r2);
// accept byte array, uses marshalling to pass array back and forth
byte[] arr1 = { 0, 0, 0 };
AcceptArray1(arr1, arr1.Length);
for (int i = 0; i < arr1.Length; i++)
{
print("arr" + i + "=" + arr1[i]);
}
// accept byte array, passes no-copy raw memory pointer
byte[] arr2 = { 0, 0, 0 };
GCHandle h = GCHandle.Alloc(arr2, GCHandleType.Pinned);
AcceptArray2(h.AddrOfPinnedObject(), arr2.Length);
for (int i = 0; i < arr2.Length; i++)
{
print("arr" + i + "=" + arr2[i]);
}
h.Free();
// return dynamically allocated string
string s1 = ReturnDynamicStr();
print("s1=" + s1);
// return constant string
string s2 = Marshal.PtrToStringAnsi(ReturnConstStr());
print("s2=" + s2);
// return dynamically allocated byte array
int arraySize = 0;
IntPtr dataPtr = ReturnDynamicByteArray(ref arraySize);
byte[] data = new byte[arraySize];
Marshal.Copy(dataPtr, data, 0, arraySize);
Marshal.FreeCoTaskMem(dataPtr); // deallocate unmanaged memory
print("data[" + arraySize + "] = [" + data[0] + ", " + data[1] + ", " + data[2] + ",...]");
// return dynamically allocated string array
arraySize = 0;
dataPtr = ReturnDynamicStrArray(ref arraySize);
String[] strArray = MarshalStringArray(dataPtr, arraySize);
print("strArray[" + arraySize + "] = [" + String.Join(",", strArray) + "]");
// string array as parameter
dataPtr = MarshalStringArray(new String[] { "foo1", "foo2", "foo3" });
int len = AcceptStrArray(dataPtr, arraySize);
print("len=" + len);
CleanUpNativeStrArray(dataPtr, arraySize);
//strArray = MarshalStringArray(dataPtr, 3);
// Structure as parameter
ExampleStruct s = new ExampleStruct
{
val1 = 9999,
array1 = new UInt32[3],
array2 = new UInt32[10]
};
s.array1[0] = 1;
s.array1[1] = 2;
s.array1[2] = 3;
s.array2len = 5;
s.array2[0] = 10;
s.array2[1] = 11;
s.array2[2] = 12;
s.array2[3] = 13;
s.array2[4] = 14;
s.str1 = "Cat is a feline";
len = AcceptStruct(ref s);
print("s.val1=" + s.val1 + " len=" + len);
// return struct
ExamplePoint p = ReturnStruct();
// Marshal array of point objects
arraySize = 0;
dataPtr = ReturnArrayOfPoints(ref arraySize);
ExamplePoint[] pointArr = new ExamplePoint[arraySize];
// memory layout
// |float|float|float|float|float|float|float|float|float|float..
// | ExamplePoint0 | ExamplePoint1 | ExamplePoint2 |
int offset = 0;
int pointSize = Marshal.SizeOf(typeof(ExamplePoint));
for (int i = 0; i < arraySize; i++)
{
pointArr[i] = (ExamplePoint)Marshal.PtrToStructure(new IntPtr(dataPtr.ToInt32() + offset), typeof(ExamplePoint));
offset += pointSize;
}
print("pointArr[" + arraySize + "]=[" + pointArr[0] + ", " + pointArr[1] + ",...]");
Marshal.FreeCoTaskMem(dataPtr);
print("Done!");
}
public void BigUploads()
{
if (!SystemInfo.supportsComputeShaders)
{
Assert.Ignore("Skipped due to platform/computer not supporting compute shaders");
return;
}
var initialData = new ExampleStruct[4 * 1024];
for (int i = 0; i < initialData.Length; ++i)
{
initialData[i] = new ExampleStruct {
someData = i
};
}
var buffer = new ComputeBuffer(initialData.Length, UnsafeUtility.SizeOf <ExampleStruct>());
buffer.SetData(initialData);
var uploader = new SparseUploader(buffer);
var newData = new ExampleStruct[312];
for (int i = 0; i < newData.Length; ++i)
{
newData[i] = new ExampleStruct {
someData = i + 3000
};
}
var newData2 = new ExampleStruct[316];
for (int i = 0; i < newData2.Length; ++i)
{
newData2[i] = new ExampleStruct {
someData = i + 4000
};
}
var tsu = uploader.Begin(UnsafeUtility.SizeOf <ExampleStruct>() * (newData.Length + newData2.Length), 2);
unsafe
{
fixed(void *ptr = newData)
{
tsu.AddUpload(ptr, newData.Length * 4, 512 * 4);
}
fixed(void *ptr2 = newData2)
{
tsu.AddUpload(ptr2, newData2.Length * 4, 1136 * 4);
}
}
uploader.EndAndCommit(tsu);
var resultingData = new ExampleStruct[initialData.Length];
buffer.GetData(resultingData);
for (int i = 0; i < resultingData.Length; ++i)
{
if (i < 512)
{
Assert.AreEqual(i, resultingData[i].someData);
}
else if (i < 824)
{
Assert.AreEqual(i - 512 + 3000, resultingData[i].someData);
}
else if (i < 1136)
{
Assert.AreEqual(i, resultingData[i].someData);
}
else if (i < 1452)
{
Assert.AreEqual(i - 1136 + 4000, resultingData[i].someData);
}
else
{
Assert.AreEqual(i, resultingData[i].someData);
}
}
uploader.Dispose();
buffer.Dispose();
}
