unsafe public byte *ReadPtr <T>() where T : struct
{
byte *cur = m_CurrentPtr;
int size = UnsafeUtility.SizeOf <T>();
Advance(size);
m_LastPtr = cur;
return(cur);
}
// Fills the int array with offsets of specified type's fields, starting from specified index and updating the index after each write into array.
internal unsafe static void FillFieldOffsetsArray(Type typeContainingFields, List <KeyValuePair <string, bool> > fieldNamesAndAccess, int *fieldOffsets, ref int fieldIndex)
{
foreach (KeyValuePair <string, bool> fieldInfo in fieldNamesAndAccess)
{
if (fieldInfo.Value)
{
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeContainingFields.GetField(fieldInfo.Key));
}
else
{
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeContainingFields.GetField(fieldInfo.Key, BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
}
fieldIndex++;
}
}
// Fills the specified array (given as pointer and length) with offsets of this struct's fields that need to be in sync with plugin struct fields.
public unsafe static int FillFieldOffsetsArray(int startFrom, int *fieldOffsets, int fieldOffsetsLength)
{
const int myFieldCount = 3;
if (startFrom + myFieldCount > fieldOffsetsLength)
{
throw new ArgumentException($"{nameof(fieldOffsets)} (length {fieldOffsetsLength}) is not big enough for all {myFieldCount} fields of this struct (starting from {startFrom})!");
}
int fieldIndex = startFrom;
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeof(HpIntArray).GetField("Data"));
fieldIndex++;
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeof(HpIntArray).GetField("m_Size", BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
fieldIndex++;
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeof(HpIntArray).GetField("m_Flags", BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
fieldIndex++;
Assert.AreEqual(myFieldCount, fieldIndex - startFrom);
return(fieldIndex);
}
// There's more fields of in-place array here, but we don't care about them
#pragma warning restore CS0649, CS0169
// Fills the specified array (given as pointer and length) with offsets of this struct's fields that need to be in sync with plugin struct fields.
public unsafe static int FillFieldOffsetsArray(int startFrom, int *fieldOffsets, int fieldOffsetsLength)
{
// List of (field name, isPublic) pairs
List <KeyValuePair <string, bool> > fieldNamesAndAccess = new List <KeyValuePair <string, bool> >()
{
new KeyValuePair <string, bool>("m_Allocator", false),
new KeyValuePair <string, bool>("m_NumTotalElements", false),
new KeyValuePair <string, bool>("m_PartiallyFreed", false),
new KeyValuePair <string, bool>("m_IsLocked", false)
};
// We need to account for m_Data* separately
int myFieldCount = fieldNamesAndAccess.Count + 1;
if (startFrom + myFieldCount > fieldOffsetsLength)
{
throw new ArgumentException($"{nameof(fieldOffsets)} (length {fieldOffsetsLength}) is not big enough for all {myFieldCount} fields of this struct (starting from {startFrom})!");
}
int fieldIndex = startFrom;
UnsafeEx.FillFieldOffsetsArray(typeof(HpBlockStream), fieldNamesAndAccess, fieldOffsets, ref fieldIndex);
if (BuildPlatformUtil.is32Bit())
{
// 32bit
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeof(HpBlockStream).GetField("m_Data32Bit", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
}
else
{
// 64bit
fieldOffsets[fieldIndex] = UnsafeUtility.GetFieldOffset(typeof(HpBlockStream).GetField("m_Data64Bit", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
}
fieldIndex++;
Assert.AreEqual(myFieldCount, fieldIndex - startFrom);
return(fieldIndex);
}
// Returns the memory offset (in bytes) between the specified pointer and referenced object
internal unsafe static int CalculateOffset <T>(void *value, ref T baseValue)
where T : struct
{
return((int)((byte *)value - (byte *)UnsafeUtility.AddressOf(ref baseValue)));
}
