public StreamBuffer(string name, BufferTarget target, int size, BufferStorageFlags flags = BufferStorageFlags.MapWriteBit, BufferAccessMask mask = (BufferAccessMask)0, int bufferingLevel = 3)
{
Size = size;
TotalBytesPerFrame += size;
_bufferingLevel = bufferingLevel;
_fences = new FenceSync[bufferingLevel];
_handle = GL.GenBuffer();
GL.BindBuffer(target, _handle);
GL.BufferStorage(target, new IntPtr(size * bufferingLevel), IntPtr.Zero,
(BufferStorageFlags)flags | BufferStorageFlags.MapPersistentBit);
Glob.Utils.SetObjectLabel(ObjectLabelIdentifier.Buffer, _handle, name);
var accessFlags = (BufferAccessMask)0;
if (flags.HasFlag(BufferStorageFlags.MapWriteBit))
{
accessFlags = accessFlags | BufferAccessMask.MapWriteBit;
}
if (flags.HasFlag(BufferStorageFlags.MapReadBit))
{
accessFlags = accessFlags | BufferAccessMask.MapReadBit;
}
_bufferPointer = GL.MapBufferRange(target, IntPtr.Zero, new IntPtr(size * bufferingLevel),
accessFlags | mask | BufferAccessMask.MapPersistentBit);
}
public BufferObject(T[] data, BufferStorageFlags storageFlags = BufferStorageFlags.DynamicStorageBit)
{
GL.CreateBuffers(1, out id);
_dataSize = Marshal.SizeOf <T>();
_bufferSize = _dataSize * data.Length;
GL.NamedBufferStorage(id, _bufferSize, data, storageFlags);
}
void CreateVBOs()
{
var totalLength = (sizeof(uint) * indicesVboData.Length)
+ (Marshal.SizeOf(typeof(Vector3)) * positionVboData.Length);
var buffers = new int[1];
// ARB_direct_state_access
// Allows buffer objects to be initialised without binding them
GL.CreateBuffers(1, buffers);
{
var error = GL.GetError();
if (error != ErrorCode.NoError)
{
Console.WriteLine("GL.CreateBuffers " + error);
}
}
mRender_VBO_position = buffers[0];
BufferStorageFlags flags = BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit;
GL.NamedBufferStorage(mRender_VBO_position, totalLength, IntPtr.Zero, flags);
{
var error = GL.GetError();
if (error != ErrorCode.NoError)
{
Console.WriteLine("GL.NamedBufferStorage " + error);
}
}
}
public void Create <T_DATA>()
{
int data_size = Marshal.SizeOf(default(T_DATA));
GL.CreateBuffers(1, out this._ppbo);
BufferStorageFlags storage = BufferStorageFlags.MapReadBit | BufferStorageFlags.MapPersistentBit;
GL.NamedBufferStorage(this._ppbo, data_size, IntPtr.Zero, storage);
}
private void load(BufferStorageFlags storage_flags, int index, int size)
{
// Create Uniform Buffer
GL.GenBuffers(1, out _buffer_id);
GL.BindBuffer(BufferTarget.UniformBuffer, _buffer_id);
GL.BufferStorage(BufferTarget.UniformBuffer, size, (IntPtr)null, storage_flags);
GL.BindBuffer(BufferTarget.UniformBuffer, 0);
//Bind uniform buffer to binding index since the block size is set and ubo is created
GL.BindBufferBase(BufferRangeTarget.UniformBuffer, index, _buffer_id);
}
public PersistentBufferObject(BufferUsageHint hint, UInt32 size)
: base(BufferTarget.ArrayBuffer, hint)
{
mySize = size;
bind();
BufferStorageFlags flags = BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit;
GL.BufferStorage(BufferTarget.ArrayBuffer, new IntPtr(size), IntPtr.Zero, flags);
BufferAccessMask flags2 = BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit | BufferAccessMask.MapCoherentBit;
myPtr = GL.MapBufferRange(BufferTarget.ArrayBuffer, IntPtr.Zero, new IntPtr(size), flags2);
unbind();
}
public static BufferObject CreateBuffer(int size, IntPtr data, BufferStorageFlags flags)
{
BufferObject b = new BufferObject();
b.Bind(BufferTarget.CopyWriteBuffer);
b.immutable |= IMMUTABLE;
if ((flags & BufferStorageFlags.DynamicStorageBit) == 0)
{
b.immutable |= NOT_DYNAMIC;
}
GL.NamedBufferStorage(b.ID, size, data, flags);
return(b);
}
public static BufferObject CreateBuffer <T>(T[] data, BufferStorageFlags flags) where T : struct
{
BufferObject b = new BufferObject();
b.Bind(BufferTarget.CopyWriteBuffer);
b.immutable |= IMMUTABLE;
if ((flags & BufferStorageFlags.DynamicStorageBit) == 0)
{
b.immutable |= NOT_DYNAMIC;
}
GL.NamedBufferStorage(b.ID, data.Length * Marshal.SizeOf(typeof(T)), data, flags);
return(b);
}
/// <summary>
/// Construct a new buffer
/// </summary>
/// <param name="handle"></param>
/// <param name="name"></param>
/// <param name="size"></param>
/// <param name="flags"></param>
/// <param name="data"></param>
private Buffer(
int handle, string name, IntPtr size, BufferStorageFlags flags = BufferStorageFlags.None, IntPtr data = default
)
{
GL.BindBuffer(BufferTarget.ArrayBuffer, handle);
GL.BufferStorage(BufferTarget.ArrayBuffer, size, data, flags);
if (State.VersionIsAtLeast(4, 3))
{
GL.ObjectLabel(ObjectLabelIdentifier.Buffer, handle, name.Length, name);
}
Handle = new GLHandle(handle);
Name = name;
}
void CreateVBOs()
{
// positionVboHandle = GL.GenBuffer();
// GL.BindBuffer(BufferTarget.ArrayBuffer, positionVboHandle);
var totalLength = (sizeof(uint) * indicesVboData.Length)
+ (Marshal.SizeOf(typeof(Vector3)) * positionVboData.Length);
var buffers = new int[1];
// ARB_direct_state_access
// Allows buffer objects to be initialised without binding them
GL.CreateBuffers(1, buffers);
{
var error = GL.GetError();
//Debug.WriteLineIf (error != ErrorCode.NoError, "GL.CreateBuffers " + error);
}
positionVboHandle = buffers [0];
BufferStorageFlags flags = BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit;
GL.NamedBufferStorage(positionVboHandle, totalLength, IntPtr.Zero, flags);
{
var error = GL.GetError();
//Debug.WriteLineIf (error != ErrorCode.NoError, "GL.NamedBufferStorage " + error);
}
// GL.BufferData<Vector3>(BufferTarget.ArrayBuffer,
// new IntPtr(positionVboData.Length * Vector3.SizeInBytes),
// positionVboData, BufferUsageHint.StaticDraw);
// normalVboHandle = GL.GenBuffer();
// GL.BindBuffer(BufferTarget.ArrayBuffer, normalVboHandle);
// GL.BufferData<Vector3>(BufferTarget.ArrayBuffer,
// new IntPtr(positionVboData.Length * Vector3.SizeInBytes),
// positionVboData, BufferUsageHint.StaticDraw);
// eboHandle = GL.GenBuffer();
// GL.BindBuffer(BufferTarget.ElementArrayBuffer, positionVboHandle);
// GL.BufferData(BufferTarget.ElementArrayBuffer,
// new IntPtr(sizeof(uint) * indicesVboData.Length),
// indicesVboData, BufferUsageHint.StaticDraw);
// GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
// GL.BindBuffer(BufferTarget.ElementArrayBuffer, 0);
}
public UniformBuffer(BufferStorageFlags storage_flags, int index, EngineHelper.size[] ubo_stack)
{
// Calculate total UBO byte size based on ubo_stack items
_ubo_stack = ubo_stack;
_ubo_stack_offets = new int[ubo_stack.Length];
int size = 0;
for (int i = 0; i < ubo_stack.Length; i++)
{
_ubo_stack_offets[i] = size;
size += (int)ubo_stack[i];
}
load(storage_flags, index, size);
}
public UniformBuffer(BufferStorageFlags storage_flags, int index, EngineHelper.size ubo_item_size, int length)
{
// Calculate total UBO byte size based on ubo_stack items
_ubo_stack = new EngineHelper.size[length];
_ubo_stack_offets = new int[length];
int size = (int)ubo_item_size * length;
int size_increment = 0;
for (int i = 0; i < length; i++)
{
_ubo_stack[i] = ubo_item_size;
_ubo_stack_offets[i] = size_increment;
size_increment += (int)ubo_item_size;
}
load(storage_flags, index, size);
}
protected unsafe void Allocate <T>(T[] data,
BufferUsageHint bufferUsageHint,
bool immutable = true,
BufferStorageFlags extraFlags = BufferStorageFlags.None)
where T : unmanaged
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
SizeInBytes = data.Length * sizeof(T);
Count = data.Length;
IsImmutable = immutable;
InitializeBuffer(data, bufferUsageHint, extraFlags);
}
void CreateMappableBuffer()
{
// int localBuffer = GL.GenBuffer ();
// GL.BindBuffer( BufferTarget.ElementArrayBuffer, localBuffer);
//
var indices = new ushort[] { 0, 1, 2, 1, 2, 3 };
//
// var bufferSize = (IntPtr)(indices.Length * sizeof(ushort));
// GL.BufferData (BufferTarget.ElementArrayBuffer, bufferSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
// GL.Arb.BufferStorage(
//
// IntPtr VideoMemoryIntPtr = GL.Ext.MapNamedBufferRange(localBuffer, IntPtr.Zero, bufferSize, BufferAccessMask.MapWriteBit);
// GL.Ext.UnmapNamedBuffer(localBuffer);
//
// GL.DeleteBuffer (localBuffer);
var buffers = new int[1];
// ARB_direct_state_access
// Allows buffer objects to be initialised without binding them
GL.CreateBuffers(1, buffers);
var targetType = BufferTarget.ElementArrayBuffer;
//GL.BindBuffer (targetType, buffers[0]);
var bufferSize = (indices.Length * sizeof(ushort));
BufferStorageFlags flags = BufferStorageFlags.MapCoherentBit;
GL.NamedBufferStorage(buffers[0], bufferSize, IntPtr.Zero, BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit);
var error = GL.GetError();
Debug.WriteLineIf(error != ErrorCode.NoError, "NamedBufferStorage " + error);
BufferAccessMask rangeFlags = BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit | BufferAccessMask.MapCoherentBit;
IntPtr Handle = GL.MapNamedBufferRange(buffers[0], IntPtr.Zero, bufferSize, rangeFlags);
error = GL.GetError();
Debug.WriteLineIf(error != ErrorCode.NoError, "MapNamedBufferRange " + error);
var result = GL.Ext.UnmapNamedBuffer(buffers[0]);
error = GL.GetError();
Debug.WriteLineIf(error != ErrorCode.NoError, "UnmapNamedBuffer " + error);
GL.DeleteBuffer(buffers[0]);
}
public static unsafe VertexBuffer Create <T>(RenderContext renderContext,
int capacity,
BufferUsageHint bufferUsageHint,
bool immutable,
BufferStorageFlags flags = BufferStorageFlags.None)
where T : unmanaged
{
if (renderContext == null)
{
throw new ArgumentNullException(nameof(renderContext));
}
var vbo = new VertexBuffer(renderContext, VertexTypeInfo.Get <T>());
vbo.Allocate <T>(capacity * sizeof(T), bufferUsageHint, immutable, flags);
return(vbo);
}
public GraphicsBuffer(
BufferTarget target,
BufferStorageFlags storageFlags =
BufferStorageFlags.MapReadBit | BufferStorageFlags.MapWriteBit | BufferStorageFlags.DynamicStorageBit |
BufferStorageFlags.MapCoherentBit | BufferStorageFlags.MapPersistentBit,
BufferAccessMask accessMask =
BufferAccessMask.MapReadBit | BufferAccessMask.MapWriteBit |
BufferAccessMask.MapCoherentBit | BufferAccessMask.MapPersistentBit)
{
Target = target;
StorageFlags = storageFlags;
AccessMask = accessMask;
Cursor = 0;
Length = DefaultLength;
Allocate();
}
public GLDeviceMemory(MgMemoryAllocateInfo pAllocateInfo, IGLErrorHandler errHandler)
{
mErrHandler = errHandler;
mBufferType = (GLMemoryBufferType)pAllocateInfo.MemoryTypeIndex;
mIsHostCached = (mBufferType == GLMemoryBufferType.INDIRECT || mBufferType == GLMemoryBufferType.IMAGE);
if (pAllocateInfo.AllocationSize > (ulong)int.MaxValue)
{
throw new ArgumentOutOfRangeException("pAllocateInfo.AllocationSize > int.MaxValue");
}
mBufferSize = (int)pAllocateInfo.AllocationSize;
if (mBufferType != GLMemoryBufferType.IMAGE)
{
mBufferTarget = GetBufferTarget(mBufferType);
}
if (mIsHostCached || pAllocateInfo.MemoryTypeIndex == (uint)GLMemoryBufferType.IMAGE)
{
mHandle = Marshal.AllocHGlobal(mBufferSize);
}
else
{
if (mBufferTarget.HasValue)
{
var buffers = new uint[1];
// ARB_direct_state_access
// Allows buffer objects to be initialised without binding them
GL.CreateBuffers(1, buffers);
mErrHandler.LogGLError("GL.CreateBuffers");
mBufferId = buffers[0];
// TODO : update flags based on buffer request
BufferStorageFlags flags = BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit;
GL.NamedBufferStorage(mBufferId, mBufferSize, IntPtr.Zero, flags);
mErrHandler.LogGLError("GL.NamedBufferStorage");
// BufferAccessMask rangeFlags = BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit | BufferAccessMask.MapCoherentBit;
// Handle = GL.MapNamedBufferRange (buffers[0], (IntPtr)0, BufferSize, rangeFlags);
}
}
}
protected unsafe void Allocate <T>(int sizeInBytes,
BufferUsageHint bufferUsageHint,
bool immutable = true,
BufferStorageFlags extraFlags = BufferStorageFlags.None)
where T : unmanaged
{
SizeInBytes = sizeInBytes;
IsImmutable = immutable;
float capacity = sizeInBytes / (float)sizeof(T);
if (!(Math.Abs(capacity - (int)capacity) < float.Epsilon))
{
throw new ArgumentOutOfRangeException(nameof(sizeInBytes));
}
Count = (int)capacity;
InitializeBuffer <T>(null, bufferUsageHint, extraFlags);
}
private void InitializeBuffer <T>(T[] data,
BufferUsageHint bufferUsageHint,
BufferStorageFlags storageFlags)
where T : unmanaged
{
if (GLInfo.HasDirectStateAccess)
{
if (IsImmutable && GLInfo.HasBufferStorage)
{
GL.NamedBufferStorage(Handle,
SizeInBytes,
data,
BufferUsageToStorageFlags(bufferUsageHint) | storageFlags);
}
else
{
GL.NamedBufferData(Handle, SizeInBytes, data, bufferUsageHint);
}
}
else
{
Bind(ParentContext);
if (IsImmutable && GLInfo.HasBufferStorage)
{
GL.BufferStorage(BufferTarget,
SizeInBytes,
data,
BufferUsageToStorageFlags(bufferUsageHint) | storageFlags);
}
else
{
GL.BufferData(BufferTarget,
SizeInBytes,
data,
bufferUsageHint);
}
}
}
public UniformBuffer(BufferStorageFlags storage_flags, int index, EngineHelper.size[] ubo_sub_stack, int length)
{
// Calculate total UBO byte size based on ubo_stack items
int stack_length = ubo_sub_stack.Length * length;
_ubo_stack = new EngineHelper.size[stack_length];
_ubo_stack_offets = new int[stack_length];
int size = 0;
for (int i = 0; i < length; i++)
{
for (int j = 0; j < ubo_sub_stack.Length; j++)
{
int stack_index = i * ubo_sub_stack.Length + j;
_ubo_stack[stack_index] = ubo_sub_stack[j];
_ubo_stack_offets[stack_index] = size;
size += (int)ubo_sub_stack[j];
}
}
load(storage_flags, index, size);
}
/// <summary>
/// Generate an empty buffer
/// </summary>
/// <param name="name"></param>
/// <param name="length"></param>
/// <param name="flags"></param>
/// <param name="data"></param>
/// <returns>The new buffer</returns>
public static unsafe Buffer <T> Create(
string name, long length, BufferStorageFlags flags = BufferStorageFlags.None, IntPtr data = default
)
{
return(new Buffer <T>(GL.GenBuffer(), name, (IntPtr)(TypeInfo <T> .TypeSize * length), flags, data));
}
//ARB_buffer_storage
/// <summary>
/// Allocates immutable storage for buffer bound to specified target.
/// </summary>
/// <param name="target">Target containging a buffer to allocate immutable storage for.s</param>
/// <param name="size">Size in bytes of allocates storage.</param>
/// <param name="data">Data to upload to buffer or zero to just allocate.</param>
/// <param name="flags">Buffer Allocation Flags.</param>
public static void BufferStorage(BufferTarget target, IntPtr size, IntPtr data, BufferStorageFlags flags)
{
Delegates.glBufferStorage(target, size, data, flags);
}
/// <summary>
/// Creates an OpenGL buffer object with immutable storage using GL.BufferStorage
/// Note: changes buffer binding of the "target" BufferTarget parameter.
/// </summary>
/// <param name="target">BufferTarget for the new buffer</param>
/// <param name="length">Size of the new buffer in bytes</param>
/// <param name="contents">Data that will be copied to the new buffer</param>
/// <param name="flags">BufferStorageFlags for the new buffer</param>
/// <param name="name">Debug label of the new buffer</param>
/// <returns>Handle of the new buffer</returns>
public static int CreateBuffer <T>(BufferTarget target, IntPtr length, T[] contents, BufferStorageFlags flags,
string name)
where T : struct
{
int buffer = GL.GenBuffer();
GL.BindBuffer(target, buffer);
GL.BufferStorage(target, length, contents, flags);
SetObjectLabel(ObjectLabelIdentifier.Buffer, buffer, name);
GL.BindBuffer(target, 0);
return(buffer);
}
//ARB_buffer_storage
/// <summary>
/// Allocates a buffer with immutable storage.
/// </summary>
/// <param name="buffer">Buffer id to allocate storage for.</param>
/// <param name="size">Size in bytes of buffer.</param>
/// <param name="data">Pointer to the data to upload or null.</param>
/// <param name="flags">Buffer Allocation Flags.</param>
public static void NamedBufferStorageEXT(uint buffer, long size, IntPtr data, BufferStorageFlags flags)
{
Delegates.glNamedBufferStorageEXT(buffer, (IntPtr)size, data, flags);
}
//ARB_buffer_storage
/// <summary>
/// Allocates immutable storage for buffer bound to specified target.
/// </summary>
/// <param name="target">Target containging a buffer to allocate immutable storage for.s</param>
/// <param name="size">Size in bytes of allocates storage.</param>
/// <param name="data">Data to upload to buffer or zero to just allocate.</param>
/// <param name="flags">Buffer Allocation Flags.</param>
public static void BufferStorage(BufferTarget target, IntPtr size, IntPtr data, BufferStorageFlags flags)
{
Delegates.glBufferStorage(target, size, data, flags);
}
public void storage(IntPtr size, IntPtr data, BufferStorageFlags flags)
{
GL.BufferStorage(_target, size, data, flags);
}
//ARB_buffer_storage
/// <summary>
/// Allocates a buffer with immutable storage.
/// </summary>
/// <param name="buffer">Buffer id to allocate storage for.</param>
/// <param name="size">Size in bytes of buffer.</param>
/// <param name="data">Pointer to the data to upload or null.</param>
/// <param name="flags">Buffer Allocation Flags.</param>
public static void NamedBufferStorageEXT(uint buffer, long size, IntPtr data, BufferStorageFlags flags)
{
Delegates.glNamedBufferStorageEXT(buffer, (IntPtr)size, data, flags);
}
