public void Set(BufferHandle destination, int offset, int size, uint value)
{
_destination = destination;
_offset = offset;
_size = size;
_value = value;
}
/// <summary>
/// Gets the handle of a buffer large enough to hold the data that will be written to <paramref name="offset"/>.
/// </summary>
/// <param name="renderer">Host renderer</param>
/// <param name="offset">Offset where the data will be written</param>
/// <returns>Buffer handle</returns>
private BufferHandle GetInlineIndexBuffer(IRenderer renderer, int offset)
{
// Calculate a reasonable size for the buffer that can fit all the data,
// and that also won't require frequent resizes if we need to push more data.
int size = BitUtils.AlignUp(offset + 0x10, 0x200);
if (_inlineIndexBuffer == BufferHandle.Null)
{
_inlineIndexBuffer = renderer.CreateBuffer(size);
_inlineIndexBufferSize = size;
}
else if (_inlineIndexBufferSize < size)
{
BufferHandle oldBuffer = _inlineIndexBuffer;
int oldSize = _inlineIndexBufferSize;
_inlineIndexBuffer = renderer.CreateBuffer(size);
_inlineIndexBufferSize = size;
renderer.Pipeline.CopyBuffer(oldBuffer, _inlineIndexBuffer, 0, 0, oldSize);
renderer.DeleteBuffer(oldBuffer);
}
return(_inlineIndexBuffer);
}
public BufferHandle Retain(bool pin = false)
{
BufferHandle bufferHandle;
if (pin)
{
if (_owner != null)
{
bufferHandle = _owner.Pin(_index);
}
else
{
var handle = GCHandle.Alloc(_array, GCHandleType.Pinned);
unsafe
{
var pointer = OwnedBuffer <T> .Add((void *)handle.AddrOfPinnedObject(), _index);
bufferHandle = new BufferHandle(null, pointer, handle);
}
}
}
else
{
if (_owner != null)
{
_owner.Retain();
}
bufferHandle = new BufferHandle(_owner);
}
return(bufferHandle);
}
internal void UnassignBuffer(BufferHandle threadedHandle)
{
lock (_bufferMap)
{
_bufferMap.Remove(threadedHandle);
}
}
public void ClearBuffer(BufferHandle destination, int offset, int size, uint value)
{
EndRenderPass();
var dst = Gd.BufferManager.GetBuffer(CommandBuffer, destination, true).Get(Cbs, offset, size).Value;
BufferHolder.InsertBufferBarrier(
Gd,
Cbs.CommandBuffer,
dst,
BufferHolder.DefaultAccessFlags,
AccessFlags.AccessTransferWriteBit,
PipelineStageFlags.PipelineStageAllCommandsBit,
PipelineStageFlags.PipelineStageTransferBit,
offset,
size);
Gd.Api.CmdFillBuffer(CommandBuffer, dst, (ulong)offset, (ulong)size, value);
BufferHolder.InsertBufferBarrier(
Gd,
Cbs.CommandBuffer,
dst,
AccessFlags.AccessTransferWriteBit,
BufferHolder.DefaultAccessFlags,
PipelineStageFlags.PipelineStageTransferBit,
PipelineStageFlags.PipelineStageAllCommandsBit,
offset,
size);
}
public BufferHandle Retain(bool pin = false)
{
BufferHandle bufferHandle;
if (pin)
{
if (_index < 0)
{
bufferHandle = Unsafe.As <OwnedBuffer <T> >(_arrayOrOwnedBuffer).Pin();
}
else
{
var handle = GCHandle.Alloc(Unsafe.As <T[]>(_arrayOrOwnedBuffer), GCHandleType.Pinned);
unsafe
{
void *pointer = Unsafe.Add <T>((void *)handle.AddrOfPinnedObject(), _index);
bufferHandle = new BufferHandle(null, pointer, handle);
}
}
}
else
{
if (_index < 0)
{
Unsafe.As <OwnedBuffer <T> >(_arrayOrOwnedBuffer).Retain();
bufferHandle = new BufferHandle(Unsafe.As <OwnedBuffer <T> >(_arrayOrOwnedBuffer));
}
else
{
bufferHandle = new BufferHandle(null);
}
}
return(bufferHandle);
}
public void SetData(BufferHandle handle, int offset, ReadOnlySpan <byte> data, CommandBufferScoped?cbs, Action endRenderPass)
{
if (TryGetBuffer(handle, out var holder))
{
holder.SetData(offset, data, cbs, endRenderPass);
}
}
public void Set(BufferHandle buffer, int offset, int size, TableRef <ResultBox <PinnedSpan <byte> > > result)
{
_buffer = buffer;
_offset = offset;
_size = size;
_result = result;
}
public void ClearBuffer(BufferHandle destination, int offset, int size, uint value)
{
EndRenderPass();
var dst = Gd.BufferManager.GetBuffer(CommandBuffer, destination, true).Get(Cbs, offset, size).Value;
Gd.Api.CmdFillBuffer(CommandBuffer, dst, (ulong)offset, (ulong)size, value);
}
public void Initialize()
{
_supportBuffer = Buffer.Create(SupportBuffer.RequiredSize);
GL.BindBufferBase(BufferRangeTarget.UniformBuffer, 0, Unsafe.As <BufferHandle, int>(ref _supportBuffer));
SetSupportBufferData <Vector4 <int> >(SupportBuffer.FragmentIsBgraOffset, _fpIsBgra, SupportBuffer.FragmentIsBgraCount);
SetSupportBufferData <Vector4 <float> >(SupportBuffer.FragmentRenderScaleOffset, _renderScale, SupportBuffer.RenderScaleMaxCount);
}
public void Delete(BufferHandle handle)
{
if (TryGetBuffer(handle, out var holder))
{
holder.Dispose();
_buffers.Remove((int)Unsafe.As <BufferHandle, ulong>(ref handle));
}
}
public void Set(BufferHandle source, BufferHandle destination, int srcOffset, int dstOffset, int size)
{
_source = source;
_destination = destination;
_srcOffset = srcOffset;
_dstOffset = dstOffset;
_size = size;
}
public void Delete(BufferHandle handle)
{
if (TryGetBuffer(handle, out var holder))
{
holder.Dispose();
// _buffers.Remove(handle);
}
}
public void CopyBuffer(BufferHandle source, BufferHandle destination, int srcOffset, int dstOffset, int size)
{
EndRenderPass();
var src = Gd.BufferManager.GetBuffer(CommandBuffer, source, false);
var dst = Gd.BufferManager.GetBuffer(CommandBuffer, destination, true);
BufferHolder.Copy(Gd, Cbs, src, dst, srcOffset, dstOffset, size);
}
public VertexArray()
{
Handle = GL.GenVertexArray();
_vertexAttribs = new VertexAttribDescriptor[Constants.MaxVertexAttribs];
_vertexBuffers = new VertexBufferDescriptor[Constants.MaxVertexBuffers];
_tempIndexBuffer = Buffer.Create();
}
public Auto <DisposableBufferView> CreateView(BufferHandle handle, VkFormat format, int offset, int size)
{
if (TryGetBuffer(handle, out var holder))
{
return(holder.CreateView(format, offset, size));
}
return(null);
}
private void DisposeBufferHandle()
{
if (BufferHandle == null)
{
throw new NullReferenceException("BufferHandle in Utilities\\DirectBitmap is NULL");
}
BufferHandle.Free();
BufferHandle = default;
}
public Auto <DisposableBuffer> GetBuffer(CommandBuffer commandBuffer, BufferHandle handle, bool isWrite)
{
if (TryGetBuffer(handle, out var holder))
{
return(holder.GetBuffer(commandBuffer, isWrite));
}
return(null);
}
public Auto <DisposableBuffer> GetBufferI8ToI16(CommandBufferScoped cbs, BufferHandle handle, int offset, int size)
{
if (TryGetBuffer(handle, out var holder))
{
return(holder.GetBufferI8ToI16(cbs, offset, size));
}
return(null);
}
public ReadOnlySpan <byte> GetData(BufferHandle handle, int offset, int size)
{
if (TryGetBuffer(handle, out var holder))
{
return(holder.GetData(offset, size));
}
return(ReadOnlySpan <byte> .Empty);
}
public static byte[] GetData(BufferHandle buffer, int offset, int size)
{
GL.BindBuffer(BufferTarget.CopyReadBuffer, buffer.ToInt32());
byte[] data = new byte[size];
GL.GetBufferSubData(BufferTarget.CopyReadBuffer, (IntPtr)offset, size, data);
return(data);
}
public void RacyAccess()
{
for (int k = 0; k < 1000; k++)
{
var owners = new OwnedBuffer <byte> [128];
var memories = new Buffer <byte> [owners.Length];
var reserves = new BufferHandle[owners.Length];
var disposeSuccesses = new bool[owners.Length];
var reserveSuccesses = new bool[owners.Length];
for (int i = 0; i < owners.Length; i++)
{
var array = new byte[1024];
owners[i] = array;
memories[i] = owners[i].Buffer;
}
var dispose_task = Task.Run(() => {
for (int i = 0; i < owners.Length; i++)
{
try
{
owners[i].Dispose();
disposeSuccesses[i] = true;
}
catch (InvalidOperationException)
{
disposeSuccesses[i] = false;
}
}
});
var reserve_task = Task.Run(() => {
for (int i = owners.Length - 1; i >= 0; i--)
{
try
{
reserves[i] = memories[i].Retain();
reserveSuccesses[i] = true;
}
catch (ObjectDisposedException)
{
reserveSuccesses[i] = false;
}
}
});
Task.WaitAll(reserve_task, dispose_task);
for (int i = 0; i < owners.Length; i++)
{
Assert.False(disposeSuccesses[i] && reserveSuccesses[i]);
}
}
}
private unsafe LibuvFunctions.uv_buf_t OnAlloc(UvStreamHandle handle, int suggestedSize)
{
Debug.Assert(_currentWritableBuffer == null);
var currentWritableBuffer = Input.Alloc(MinAllocBufferSize);
_currentWritableBuffer = currentWritableBuffer;
_bufferHandle = currentWritableBuffer.Buffer.Retain(true);
return(handle.Libuv.buf_init((IntPtr)_bufferHandle.PinnedPointer, currentWritableBuffer.Buffer.Length));
}
/// <inheritdoc cref="IDisposable" />
public void Dispose()
{
Graphics.Dispose();
Graphics = default;
Bitmap.Dispose();
Bitmap = default;
BufferHandle.Free();
BufferHandle = default;
}
public static void SetData(BufferHandle buffer, int offset, ReadOnlySpan <byte> data)
{
GL.BindBuffer(BufferTarget.CopyWriteBuffer, buffer.ToInt32());
unsafe
{
fixed(byte *ptr = data)
{
GL.BufferSubData(BufferTarget.CopyWriteBuffer, (IntPtr)offset, data.Length, (IntPtr)ptr);
}
}
}
public static void Copy(BufferHandle source, BufferHandle destination, int srcOffset, int dstOffset, int size)
{
GL.BindBuffer(BufferTarget.CopyReadBuffer, source.ToInt32());
GL.BindBuffer(BufferTarget.CopyWriteBuffer, destination.ToInt32());
GL.CopyBufferSubData(
BufferTarget.CopyReadBuffer,
BufferTarget.CopyWriteBuffer,
(IntPtr)srcOffset,
(IntPtr)dstOffset,
(IntPtr)size);
}
private unsafe Uv.uv_buf_t OnAlloc(UvStreamHandle handle, int status)
{
var inputBuffer = _input.Writer.Alloc(2048);
_inputBuffer = inputBuffer;
var pinnedHandle = inputBuffer.Buffer.Pin();
_inputBufferPin = pinnedHandle;
return(handle.Libuv.buf_init((IntPtr)pinnedHandle.PinnedPointer, inputBuffer.Buffer.Length));
}
internal BufferHandle CreateBufferHandle()
{
ulong handle64 = Interlocked.Increment(ref _bufferHandle);
BufferHandle threadedHandle = Unsafe.As <ulong, BufferHandle>(ref handle64);
lock (_inFlight)
{
_inFlight.Add(threadedHandle);
}
return(threadedHandle);
}
private bool TryGetBuffer(BufferHandle handle, out BufferHolder holder)
{
int index = (int)Unsafe.As <BufferHandle, ulong>(ref handle) - 1;
if ((uint)index < _buffers.Count)
{
holder = _buffers[index];
return(true);
}
holder = default;
return(false);
}
internal void AssignBuffer(BufferHandle threadedHandle, BufferHandle realHandle)
{
lock (_bufferMap)
{
_bufferMap[threadedHandle] = realHandle;
}
lock (_inFlight)
{
_inFlight.Remove(threadedHandle);
}
_inFlightChanged.Set();
}
