public void FreeAll()
{
if (m_AllBuffers != null)
{
UnsafeUtility.Free(m_AllBuffers, Allocator.Persistent);
m_AllBuffers = null;
}
m_DynamicUpdateBuffers = new DoubleBuffers();
m_FixedUpdateBuffers = new DoubleBuffers();
#if UNITY_EDITOR
m_EditorUpdateBuffers = new DoubleBuffers();
#endif
s_CurrentBuffers = new DoubleBuffers();
if (s_DefaultStateBuffer == defaultStateBuffer)
{
s_DefaultStateBuffer = null;
}
defaultStateBuffer = null;
if (s_NoiseMaskBuffer == noiseMaskBuffer)
{
s_NoiseMaskBuffer = null;
}
noiseMaskBuffer = null;
totalSize = 0;
sizePerBuffer = 0;
}
public unsafe void FreeAll()
{
if (m_AllBuffers != IntPtr.Zero)
{
UnsafeUtility.Free(m_AllBuffers.ToPointer(), Allocator.Persistent);
m_AllBuffers = IntPtr.Zero;
}
m_DynamicUpdateBuffers = new DoubleBuffers();
m_FixedUpdateBuffers = new DoubleBuffers();
#if UNITY_EDITOR
m_EditorUpdateBuffers = new DoubleBuffers();
#endif
s_CurrentBuffers = new DoubleBuffers();
if (s_DefaultStateBuffer == defaultStateBuffer)
{
s_DefaultStateBuffer = IntPtr.Zero;
}
defaultStateBuffer = IntPtr.Zero;
if (s_NoiseBitmaskBuffer == noiseBitmaskBuffer)
{
s_NoiseBitmaskBuffer = IntPtr.Zero;
}
noiseBitmaskBuffer = IntPtr.Zero;
totalSize = 0;
sizePerBuffer = 0;
}
// Switch the current set of buffers used by the system.
public void SwitchTo(InputUpdateType update)
{
switch (update)
{
case InputUpdateType.Dynamic:
s_CurrentBuffers = m_DynamicUpdateBuffers;
break;
case InputUpdateType.Fixed:
s_CurrentBuffers = m_FixedUpdateBuffers;
break;
case InputUpdateType.BeforeRender:
if (m_DynamicUpdateBuffers.valid)
{
s_CurrentBuffers = m_DynamicUpdateBuffers;
}
else
{
s_CurrentBuffers = m_FixedUpdateBuffers;
}
break;
#if UNITY_EDITOR
case InputUpdateType.Editor:
s_CurrentBuffers = m_EditorUpdateBuffers;
break;
#endif
}
}
// Allocates all buffers to serve the given updates and comes up with a spot
// for the state block of each device. Returns the new state blocks for the
// devices (it will *NOT* install them on the devices).
public unsafe uint[] AllocateAll(InputUpdateType updateMask, InputDevice[] devices)
{
uint[] newDeviceOffsets = null;
sizePerBuffer = ComputeSizeOfSingleBufferAndOffsetForEachDevice(devices, ref newDeviceOffsets);
if (sizePerBuffer == 0)
{
return(null);
}
sizePerBuffer = NumberHelpers.AlignToMultiple(sizePerBuffer, 4);
var isDynamicUpdateEnabled = (updateMask & InputUpdateType.Dynamic) == InputUpdateType.Dynamic;
var isFixedUpdateEnabled = (updateMask & InputUpdateType.Fixed) == InputUpdateType.Fixed;
// Determine how much memory we need.
var deviceCount = devices.Length;
var mappingTableSizePerBuffer = (uint)(deviceCount * sizeof(void *) * 2);
if (isDynamicUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
if (isFixedUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
// Before render doesn't have its own buffers.
#if UNITY_EDITOR
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
#endif
// Allocate.
m_AllBuffers = (IntPtr)UnsafeUtility.Malloc(totalSize, 4, Allocator.Persistent);
UnsafeUtility.MemClear(m_AllBuffers.ToPointer(), totalSize);
// Set up device to buffer mappings.
var ptr = m_AllBuffers;
if (isDynamicUpdateEnabled)
{
m_DynamicUpdateBuffers =
SetUpDeviceToBufferMappings(devices, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
}
if (isFixedUpdateEnabled)
{
m_FixedUpdateBuffers =
SetUpDeviceToBufferMappings(devices, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
}
#if UNITY_EDITOR
m_EditorUpdateBuffers =
SetUpDeviceToBufferMappings(devices, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
#endif
return(newDeviceOffsets);
}
private static void MigrateDoubleBuffer(DoubleBuffers newBuffer, InputDevice[] devices, int deviceCount, DoubleBuffers oldBuffer)
{
// Nothing to migrate if we no longer keep a buffer of the corresponding type.
if (!newBuffer.valid)
{
return;
}
// We do the same if we don't had a corresponding buffer before.
if (!oldBuffer.valid)
{
return;
}
// Migrate every device that has allocated state blocks.
var newStateBlockOffset = 0u;
for (var i = 0; i < deviceCount; ++i)
{
var device = devices[i];
// Stop as soon as we're hitting a new device. Newly added devices *must* be *appended* to the
// array as otherwise our computing of offsets into the old buffer may be wrong.
// NOTE: This also means that device indices of
if (device.m_StateBlock.byteOffset == InputStateBlock.InvalidOffset)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
for (var n = i + 1; n < deviceCount; ++n)
{
Debug.Assert(devices[n].m_StateBlock.byteOffset == InputStateBlock.InvalidOffset,
"New devices must be appended to the array; found an old device coming in the array after a newly added device");
}
#endif
break;
}
var oldDeviceIndex = device.m_DeviceIndex;
var newDeviceIndex = i;
var numBytes = device.m_StateBlock.alignedSizeInBytes;
var oldFrontPtr = (byte *)oldBuffer.GetFrontBuffer(oldDeviceIndex) + (int)device.m_StateBlock.byteOffset; // m_StateBlock still refers to oldBuffer.
var oldBackPtr = (byte *)oldBuffer.GetBackBuffer(oldDeviceIndex) + (int)device.m_StateBlock.byteOffset;
var newFrontPtr = (byte *)newBuffer.GetFrontBuffer(newDeviceIndex) + (int)newStateBlockOffset;
var newBackPtr = (byte *)newBuffer.GetBackBuffer(newDeviceIndex) + (int)newStateBlockOffset;
// Copy state.
UnsafeUtility.MemCpy(newFrontPtr, oldFrontPtr, numBytes);
UnsafeUtility.MemCpy(newBackPtr, oldBackPtr, numBytes);
newStateBlockOffset = NextDeviceOffset(newStateBlockOffset, device);
}
}
private unsafe void MigrateDoubleBuffer(DoubleBuffers newBuffer, InputDevice[] devices, int deviceCount, uint[] newStateBlockOffsets, DoubleBuffers oldBuffer, int[] oldDeviceIndices)
{
// Nothing to migrate if we no longer keep a buffer of the corresponding type.
if (!newBuffer.valid)
{
return;
}
// We do the same if we don't had a corresponding buffer before.
if (!oldBuffer.valid)
{
return;
}
////TOOD: if we assume linear layouts of devices in 'devices' and assume that new devices are only added
//// at the end and only single devices can be removed, we can copy state buffers much more efficiently
//// in bulk rather than device-by-device
// Migrate every device that has allocated state blocks.
var newDeviceCount = deviceCount;
var oldDeviceCount = oldDeviceIndices != null ? oldDeviceIndices.Length : newDeviceCount;
for (var i = 0; i < newDeviceCount && i < oldDeviceCount; ++i)
{
var device = devices[i];
Debug.Assert(device.m_DeviceIndex == i);
// Skip device if it's a newly added device.
if (device.m_StateBlock.byteOffset == InputStateBlock.kInvalidOffset)
{
continue;
}
////FIXME: this is not protecting against devices that have changed their formats between domain reloads
var oldDeviceIndex = oldDeviceIndices != null ? oldDeviceIndices[i] : i;
var newDeviceIndex = i;
var numBytes = device.m_StateBlock.alignedSizeInBytes;
var oldFrontPtr = (byte *)oldBuffer.GetFrontBuffer(oldDeviceIndex).ToPointer() + (int)device.m_StateBlock.byteOffset;
var oldBackPtr = (byte *)oldBuffer.GetBackBuffer(oldDeviceIndex).ToPointer() + (int)device.m_StateBlock.byteOffset;
var newFrontPtr = (byte *)newBuffer.GetFrontBuffer(newDeviceIndex).ToPointer() + (int)newStateBlockOffsets[i];
var newBackPtr = (byte *)newBuffer.GetBackBuffer(newDeviceIndex).ToPointer() + (int)newStateBlockOffsets[i];
// Copy state.
UnsafeUtility.MemCpy(newFrontPtr, oldFrontPtr, numBytes);
UnsafeUtility.MemCpy(newBackPtr, oldBackPtr, numBytes);
}
}
public ShipDockComponentManager()
{
mComponent = default;
mIDMapper = new KeyValueList <int, int>();
mMapper = new IntegerMapper <IShipDockComponent>();
mDeletdComponents = new List <int>();
mUpdateByTicks = new List <IShipDockComponent>();
mUpdateByScene = new List <IShipDockComponent>();
mQueueUpdateTime = new DoubleBuffers <int>();
mQueueUpdateEntitas = new DoubleBuffers <IShipDockEntitas>();
mQueueUpdateExecute = new DoubleBuffers <Action <int, IShipDockEntitas> >();
mQueueUpdateExecute.OnDequeue += OnQueueUpdateExecute;
}
// Allocates all buffers to serve the given updates and comes up with a spot
// for the state block of each device. Returns the new state blocks for the
// devices (it will *NOT* install them on the devices).
public uint[] AllocateAll(InputDevice[] devices, int deviceCount)
{
uint[] newDeviceOffsets = null;
sizePerBuffer = ComputeSizeOfSingleBufferAndOffsetForEachDevice(devices, deviceCount, ref newDeviceOffsets);
if (sizePerBuffer == 0)
{
return(null);
}
sizePerBuffer = sizePerBuffer.AlignToMultipleOf(4);
// Determine how much memory we need.
var mappingTableSizePerBuffer = (uint)(deviceCount * sizeof(void *) * 2);
totalSize = 0;
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
#if UNITY_EDITOR
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
#endif
// Plus 2 more buffers (1 for default states, and one for noise masks).
totalSize += sizePerBuffer * 2;
// Allocate.
m_AllBuffers = UnsafeUtility.Malloc(totalSize, 4, Allocator.Persistent);
UnsafeUtility.MemClear(m_AllBuffers, totalSize);
// Set up device to buffer mappings.
var ptr = (byte *)m_AllBuffers;
m_PlayerStateBuffers =
SetUpDeviceToBufferMappings(devices, deviceCount, ref ptr, sizePerBuffer,
mappingTableSizePerBuffer);
#if UNITY_EDITOR
m_EditorStateBuffers =
SetUpDeviceToBufferMappings(devices, deviceCount, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
#endif
// Default state and noise filter buffers go last.
defaultStateBuffer = ptr;
noiseMaskBuffer = ptr + sizePerBuffer;
return(newDeviceOffsets);
}
public unsafe void FreeAll()
{
if (m_AllBuffers != IntPtr.Zero)
{
UnsafeUtility.Free(m_AllBuffers.ToPointer(), Allocator.Persistent);
m_AllBuffers = IntPtr.Zero;
}
m_DynamicUpdateBuffers = new DoubleBuffers();
m_FixedUpdateBuffers = new DoubleBuffers();
#if UNITY_EDITOR
m_EditorUpdateBuffers = new DoubleBuffers();
#endif
s_CurrentBuffers = new DoubleBuffers();
}
private static DoubleBuffers SetUpDeviceToBufferMappings(int deviceCount, ref byte *bufferPtr, uint sizePerBuffer, uint mappingTableSizePerBuffer)
{
var front = bufferPtr;
var back = bufferPtr + sizePerBuffer;
var mappings = (void **)(bufferPtr + sizePerBuffer * 2); // Put mapping table at end.
bufferPtr += sizePerBuffer * 2 + mappingTableSizePerBuffer;
var buffers = new DoubleBuffers {
deviceToBufferMapping = mappings
};
for (var i = 0; i < deviceCount; ++i)
{
var deviceIndex = i;
buffers.SetFrontBuffer(deviceIndex, front);
buffers.SetBackBuffer(deviceIndex, back);
}
return(buffers);
}
private unsafe DoubleBuffers SetUpDeviceToBufferMappings(InputDevice[] devices, int deviceCount, ref IntPtr bufferPtr, uint sizePerBuffer, uint mappingTableSizePerBuffer)
{
var front = bufferPtr;
var back = new IntPtr(bufferPtr.ToInt64() + sizePerBuffer);
var mappings = (void **)new IntPtr(bufferPtr.ToInt64() + sizePerBuffer * 2).ToPointer(); // Put mapping table at end.
bufferPtr = new IntPtr(bufferPtr.ToInt64() + sizePerBuffer * 2 + mappingTableSizePerBuffer);
var buffers = new DoubleBuffers {
deviceToBufferMapping = mappings
};
for (var i = 0; i < deviceCount; ++i)
{
var deviceIndex = devices[i].m_DeviceIndex;
buffers.SetFrontBuffer(deviceIndex, front);
buffers.SetBackBuffer(deviceIndex, back);
}
return(buffers);
}
// Switch the current set of buffers used by the system.
public static void SwitchTo(InputStateBuffers buffers, InputUpdateType update)
{
s_CurrentBuffers = buffers.GetDoubleBuffersFor(update);
}
// Allocates all buffers to serve the given updates and comes up with a spot
// for the state block of each device. Returns the new state blocks for the
// devices (it will *NOT* install them on the devices).
public uint[] AllocateAll(InputUpdateType updateMask, InputDevice[] devices, int deviceCount)
{
uint[] newDeviceOffsets = null;
sizePerBuffer = ComputeSizeOfSingleBufferAndOffsetForEachDevice(devices, deviceCount, ref newDeviceOffsets);
if (sizePerBuffer == 0)
{
return(null);
}
sizePerBuffer = NumberHelpers.AlignToMultiple(sizePerBuffer, 4);
var isDynamicUpdateEnabled = (updateMask & InputUpdateType.Dynamic) != 0;
var isFixedUpdateEnabled = (updateMask & InputUpdateType.Fixed) != 0;
var isManualUpdateEnabled = (updateMask & InputUpdateType.Manual) != 0;
// Determine how much memory we need.
var mappingTableSizePerBuffer = (uint)(deviceCount * sizeof(void *) * 2);
if (isDynamicUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
if (isFixedUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
if (isManualUpdateEnabled)
{
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
}
// Before render doesn't have its own buffers.
#if UNITY_EDITOR
totalSize += sizePerBuffer * 2;
totalSize += mappingTableSizePerBuffer;
#endif
// Plus 2 more buffers (1 for default states, and one for noise filters).
totalSize += sizePerBuffer * 2;
// Allocate.
m_AllBuffers = UnsafeUtility.Malloc(totalSize, 4, Allocator.Persistent);
UnsafeUtility.MemClear(m_AllBuffers, totalSize);
// Set up device to buffer mappings.
var ptr = (byte *)m_AllBuffers;
if (isDynamicUpdateEnabled)
{
m_DynamicUpdateBuffers =
SetUpDeviceToBufferMappings(devices, deviceCount, ref ptr, sizePerBuffer,
mappingTableSizePerBuffer);
}
if (isFixedUpdateEnabled)
{
m_FixedUpdateBuffers =
SetUpDeviceToBufferMappings(devices, deviceCount, ref ptr, sizePerBuffer,
mappingTableSizePerBuffer);
}
if (isManualUpdateEnabled)
{
m_ManualUpdateBuffers =
SetUpDeviceToBufferMappings(devices, deviceCount, ref ptr, sizePerBuffer,
mappingTableSizePerBuffer);
}
#if UNITY_EDITOR
m_EditorUpdateBuffers =
SetUpDeviceToBufferMappings(devices, deviceCount, ref ptr, sizePerBuffer, mappingTableSizePerBuffer);
#endif
// Default state and noise filter buffers go last.
defaultStateBuffer = ptr;
noiseMaskBuffer = ptr + sizePerBuffer;
return(newDeviceOffsets);
}
public TicksLater() : base()
{
mDoubleBuffer = new DoubleBuffers <Action <int> >();
mDoubleBuffer.OnDequeue += OnTicksLater;
}