public GLBuffer CreateBuffer(string bufferName, BufferTarget target)
{
this.Bind();
GLBuffer buffer = new GLBuffer(target);
this.arrays.Add(bufferName, buffer);
return buffer;
}
internal GLBuffer(int bufferHandle, BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, int size)
{
Handle = bufferHandle;
Target = bufferTarget;
UsageHint = bufferUsageHint;
Size = size;
}
public static int CreateBuffer(ushort[] data, BufferTarget target = BufferTarget.ArrayBuffer, BufferUsageHint hint = BufferUsageHint.StaticDraw)
{
var buffer = GenBuffer(target);
var size = data.Length * sizeof(ushort);
GL.BufferData(target, new IntPtr(size), data, hint);
return buffer;
}
public static int CreateBuffer(Vertex[] data, BufferTarget target = BufferTarget.ArrayBuffer, BufferUsageHint hint = BufferUsageHint.StaticDraw)
{
var buffer = GenBuffer(target);
var size = data.Length * Vertex.SizeInBytes;
GL.BufferData(target, new IntPtr(size), data, hint);
return buffer;
}
public static IBuffer Buffer(this IContextObjectFactory factory, BufferTarget creationTarget, int sizeInBytes, BufferUsageHint usageHint, Array initialData)
{
var handle = GCHandle.Alloc(initialData, GCHandleType.Pinned);
var result = factory.Buffer(creationTarget, sizeInBytes, usageHint, handle.AddrOfPinnedObject());
handle.Free();
return result;
}
public Buffer(BufferTarget type)
{
int temp;
GL.GenBuffers(1, out temp);
Id = temp;
Type = type;
}
public BufferObject(BufferTarget target)
{
this.target = target;
GL.GenBuffers(1, out glId);
GL.BindBuffer(target, glId);
}
public VertexBufferObject(VertexBufferType type, VertexBufferUsageHint hint)
{
GL.GenBuffers(1, out buffer_id);
buffer_target = (BufferTarget)type;
buffer_hint = (BufferUsageHint)hint;
}
public static void BindBuffer(BufferTarget target, int id)
{
if (target == BufferTarget.TransformFeedbackBuffer) throw new Exception("Incorrect Function Called, Use Overload for TransformFeedbackBuffers");
if (boundBuffers[target][0].Count == 0) boundBuffers[target][0].Push(0);
if (boundBuffers[target][0].Peek() != id || id == 0) GL.BindBuffer(target, id);
boundBuffers[target][0].Push(id);
}
internal GLVertexBuffer(BufferTarget target, VertexAttribPointerType glType, int stride, int size)
{
this.stride = stride;
this.size = size;
this.glType = glType;
this.target = target;
OGL.GenBuffers(1, out bufferId);
}
public static GLBuffer Allocate(BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, byte[] data)
{
int handle = GL.GenBuffer();
GL.BindBuffer(bufferTarget, handle);
GL.BufferData(bufferTarget, (IntPtr)data.Length, data, bufferUsageHint);
GL.BindBuffer(bufferTarget, 0);
return new GLBuffer(handle, bufferTarget, bufferUsageHint, data.Length);
}
public static GLBuffer Allocate(BufferTarget bufferTarget, BufferUsageHint bufferUsageHint, int size)
{
int handle = GL.GenBuffer();
GL.BindBuffer(bufferTarget, handle);
GL.BufferData(bufferTarget, (IntPtr)size, IntPtr.Zero, bufferUsageHint);
GL.BindBuffer(bufferTarget, 0);
return new GLBuffer(handle, bufferTarget, bufferUsageHint, size);
}
public GLBufferLockedBytes(GLBufferObject buffer, BufferTarget target, BufferAccess access, IntPtr pointer, int offset, int size)
{
fTarget = target;
fBuffer = buffer;
fOffset = offset;
fSize = size;
fAccess = access;
fLockingThread = Thread.CurrentThread;
fData = pointer;
}
internal void Resize(BufferTarget bufferTarget, int size)
{
if(!VBOexists(bufferTarget))
{
VBOobjects.Add(bufferTarget, new VBO(bufferTarget));
}
Bind();
VBOobjects[bufferTarget].Resize(size);
UnBind();
}
/// <summary>
/// Initializes a new instance of the <see cref="VBO"/> class.
/// </summary>
/// <param name="bufferTarget">Logical type of data in VBO</param>
/// <param name="bufferUsageHint">The buffer usage hint.</param>
/// <param name="size">The size.</param>
internal VBO(BufferTarget bufferTarget, BufferUsageHint bufferUsageHint = BufferUsageHint.DynamicDraw, int size = 0)
{
GL.GenBuffers(1, out _vbo);
_bufferTarget = bufferTarget;
GL.BindBuffer(_bufferTarget, _vbo);
GL.BufferData(_bufferTarget, new IntPtr(size), new IntPtr(0), bufferUsageHint);
GL.BindBuffer(_bufferTarget, 0);
_currentSize = size;
_bufferUsageHint = bufferUsageHint;
}
public MappingBuffer(BufferTarget bufferTarget, uint bufferObject, MapBufferAccess access)
{
// TODO: Complete member initialization
this.bufferTarget = bufferTarget;
this.bufferObject = bufferObject;
GL.BindBuffer(bufferTarget, bufferObject);
this.BufferPointer = GL.MapBuffer(bufferTarget, access);
}
/// <summary>
/// Changes stored data
/// </summary>
/// <param name="bufferTarget">The VBO type in VAO.</param>
/// <param name="dataBuffer">The vertex buffer.</param>
/// <param name="offset">Buffer offset </param>
/// <returns>True if data changes successful</returns>
internal bool ChangeData(BufferTarget bufferTarget, float[,] dataBuffer, int offset = 0)
{
if(!VBOexists(bufferTarget))
{
VBOobjects.Add(bufferTarget, new VBO(bufferTarget));
}
Bind();
bool result = VBOobjects[bufferTarget].ChangeDataInVBO(dataBuffer, offset);
UnBind();
return result;
}
public static void BindBuffer(BufferTarget bufferTarget, int bufferId)
{
if (boundBuffers.ContainsKey(bufferTarget) == false)
{
boundBuffers.Add(bufferTarget, bufferId);
GL.BindBuffer(bufferTarget, bufferId);
}
else if (boundBuffers[bufferTarget] != bufferId)
{
boundBuffers[bufferTarget] = bufferId;
GL.BindBuffer(bufferTarget, bufferId);
}
}
public Buffer(IContext context, BufferTarget target, int sizeInBytes, BufferUsageHint usage, IntPtr initialData)
{
this.context = context;
this.target = target;
this.sizeInBytes = sizeInBytes;
this.usage = usage;
uint handleProxy;
GL.GenBuffers(1, &handleProxy);
handle = handleProxy;
context.Bindings.Buffers.ByTarget(target).Set(this);
GL.BufferData((int)target, (IntPtr)sizeInBytes, initialData, (int)usage);
}
/// <summary>
/// Initializes a new instance of the <see cref="VAO"/> class.
/// </summary>
/// <param name="bufferTargets">The VBO data types.</param>
/// <param name="VBObufferUsageHint">The VBO buffer usage hint.</param>
/// <param name="VBOsize">The VBO size.</param>
public VAO(BufferTarget[] bufferTargets = null, BufferUsageHint VBObufferUsageHint = BufferUsageHint.DynamicDraw,
int VBOsize = 0)
{
GL.GenVertexArrays(1, out _vao);
GL.BindVertexArray(_vao);
if(bufferTargets != null)
{
foreach(var buffer in bufferTargets.Where(x => !VBOobjects.ContainsKey(x)))
{
VBOobjects.Add(buffer, new VBO(buffer, VBObufferUsageHint, VBOsize));
}
}
GL.BindVertexArray(0);
}
public GLBufferObject(GraphicsInterface gi, BufferTarget target, BufferUsage usage, IntPtr dataPtr, int size)
:base(gi)
{
fBufferTarget = target;
// Generate the buffer ID
gi.GenBufferID(out fBufferID);
// Bind the buffer so subsequent calls apply to that buffer
Bind();
if (size > 0)
AllocateStorage(dataPtr, size, usage);
Unbind();
}
public void Recreate(IntPtr dataPointer)
{
if ((ViewFlags & BufferFlags.VertexBuffer) == BufferFlags.VertexBuffer)
{
BufferTarget = BufferTarget.ArrayBuffer;
}
else if ((ViewFlags & BufferFlags.IndexBuffer) == BufferFlags.IndexBuffer)
{
BufferTarget = BufferTarget.ElementArrayBuffer;
}
else if ((ViewFlags & BufferFlags.UnorderedAccess) == BufferFlags.UnorderedAccess)
{
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
throw new NotSupportedException("GLES not support UnorderedAccess buffer");
#else
BufferTarget = BufferTarget.ShaderStorageBuffer;
#endif
}
else if ((ViewFlags & BufferFlags.ShaderResource) == BufferFlags.ShaderResource && GraphicsDevice.HasTextureBuffers)
{
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
Internal.Refactor.ThrowNotImplementedException();
#else
BufferTarget = BufferTarget.TextureBuffer;
#endif
}
if ((ViewFlags & BufferFlags.ConstantBuffer) == BufferFlags.ConstantBuffer)
{
BufferTarget = BufferTarget.UniformBuffer;
// Special case: ConstantBuffer are stored CPU side
StagingData = Marshal.AllocHGlobal(Description.SizeInBytes);
}
else if (Description.Usage == GraphicsResourceUsage.Dynamic)
{
#if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES
if (GraphicsDevice.IsOpenGLES2)
{
// OpenGL ES might not always support MapBuffer (TODO: Use MapBufferOES if available)
StagingData = Marshal.AllocHGlobal(Description.SizeInBytes);
}
#endif
}
Init(dataPointer);
}
public void Recreate(IntPtr dataPointer)
{
if ((ViewFlags & BufferFlags.VertexBuffer) == BufferFlags.VertexBuffer)
{
bufferTarget = BufferTarget.ArrayBuffer;
}
else if ((ViewFlags & BufferFlags.IndexBuffer) == BufferFlags.IndexBuffer)
{
bufferTarget = BufferTarget.ElementArrayBuffer;
}
else if ((ViewFlags & BufferFlags.UnorderedAccess) == BufferFlags.UnorderedAccess)
{
#if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES
throw new NotSupportedException("GLES not support UnorderedAccess buffer");
#else
bufferTarget = BufferTarget.ShaderStorageBuffer;
#endif
}
if ((ViewFlags & BufferFlags.ConstantBuffer) == BufferFlags.ConstantBuffer)
{
#if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES
// Special case: ConstantBuffer are faked with a byte array on OpenGL ES 2.0.
if (GraphicsDevice.IsOpenGLES2)
StagingData = Marshal.AllocHGlobal(Description.SizeInBytes);
else
#endif
{
bufferTarget = BufferTarget.UniformBuffer;
}
}
else if (Description.Usage == GraphicsResourceUsage.Dynamic)
{
#if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES
if (GraphicsDevice.IsOpenGLES2)
{
// OpenGL ES might not always support MapBuffer (TODO: Use MapBufferOES if available)
StagingData = Marshal.AllocHGlobal(Description.SizeInBytes);
}
#endif
}
Init(dataPointer);
}
public static void BufferData(BufferTarget target, int size, IntPtr data, BufferUsageHint usage)
{
#if USE_OPENGL
if (openGlHardwareAvailable)
{
if (glHasBufferObjects)
{
OpenTK.Graphics.OpenGL.GL.BufferData((OpenTK.Graphics.OpenGL.BufferTarget)target, (IntPtr)size, data, (OpenTK.Graphics.OpenGL.BufferUsageHint)usage);
}
else
{
byte[] dataCopy = new byte[size];
unsafe
{
for (int i = 0; i < size; i++)
{
dataCopy[i] = ((byte *)data)[i];
}
}
switch (target)
{
case BufferTarget.ArrayBuffer:
if (currentArrayBufferIndex == 0)
{
throw new Exception("You don't have a ArrayBuffer set.");
}
bufferData[currentArrayBufferIndex] = dataCopy;
break;
case BufferTarget.ElementArrayBuffer:
if (currentElementArrayBufferIndex == 0)
{
throw new Exception("You don't have an EllementArrayBuffer set.");
}
bufferData[currentElementArrayBufferIndex] = dataCopy;
break;
default:
throw new NotImplementedException();
}
}
}
#else
if (glHasBufferObjects)
{
OpenTK.Graphics.ES11.GL.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, data, (OpenTK.Graphics.ES11.All)usage);
}
else
{
byte[] dataCopy = new byte[size];
unsafe
{
for (int i = 0; i < size; i++)
{
dataCopy[i] = ((byte *)data)[i];
}
}
switch (target)
{
case BufferTarget.ArrayBuffer:
if (currentArrayBufferIndex == 0)
{
throw new Exception("You don't have a ArrayBuffer set.");
}
bufferData[currentArrayBufferIndex] = dataCopy;
break;
case BufferTarget.ElementArrayBuffer:
if (currentElementArrayBufferIndex == 0)
{
throw new Exception("You don't have an EllementArrayBuffer set.");
}
bufferData[currentElementArrayBufferIndex] = dataCopy;
break;
default:
throw new NotImplementedException();
}
}
#endif
}
public virtual void BindBuffer(BufferTarget bufferTarget, int id)
{
GL.BindBuffer(bufferTarget, id);
}
public static void BindBuffer(BufferTarget bufferTarget, int id)
{
Wrapper.BindBuffer(bufferTarget, id);
}
/// <summary>
/// Allocates memory for both buffer objects and initializes the first buffer with the given data.
/// The second buffer is left uninitialized.
/// </summary>
/// <param name="target">The BufferTarget to use when binding the buffers.</param>
/// <param name="data">The data to upload to the first buffer and allocate enough memory for in the second buffer.</param>
/// <param name="usageHint">The usage hint for both buffer objects.</param>
public void Init(BufferTarget target, T[] data, BufferUsageHint usageHint = BufferUsageHint.StaticDraw)
{
Ping.Init(target, data, usageHint);
Pong.Init(target, data.Length, usageHint);
}
/// <summary>
/// Allocates memory for both buffer objects without initializing it.
/// </summary>
/// <param name="target">The BufferTarget to use when binding the buffers.</param>
/// <param name="elementCount">The number of elements for each buffer to allocate memory for.</param>
/// <param name="usageHint">The usage hint for both buffer objects.</param>
public void Init(BufferTarget target, int elementCount, BufferUsageHint usageHint = BufferUsageHint.StaticDraw)
{
Ping.Init(target, elementCount, usageHint);
Pong.Init(target, elementCount, usageHint);
}
public Buffer(Clyde clyde, BufferTarget type, BufferUsageHint usage, Span <byte> initialize,
string name = null)
: this(clyde, type, usage, name)
{
Reallocate(initialize);
}
} // Тип VBO
public VBO(BufferTarget type = BufferTarget.ArrayBuffer)
{
Type = type;
AcquireHandle();
}
/// <summary>
/// 把客户端（CPU）上的当前Buffer Object映射到服务端（GPU）的内存上。
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public static bool UnmapBuffer(BufferTarget target)
{
return GetDelegateFor<glUnmapBuffer>()((uint)target);
}
public static void BindBuffer(BufferTarget target, int buffer)
{
#if USE_OPENGL
if (openGlHardwareAvailable)
{
if (glHasBufferObjects)
{
OpenTK.Graphics.OpenGL.GL.BindBuffer((OpenTK.Graphics.OpenGL.BufferTarget)target, buffer);
}
else
{
switch (target)
{
case BufferTarget.ArrayBuffer:
currentArrayBufferIndex = buffer;
break;
case BufferTarget.ElementArrayBuffer:
currentElementArrayBufferIndex = buffer;
break;
default:
throw new NotImplementedException();
}
}
}
#else
if (glHasBufferObjects)
{
OpenTK.Graphics.ES11.GL.BindBuffer((OpenTK.Graphics.ES11.All)target, buffer);
}
else
{
switch (target)
{
case BufferTarget.ArrayBuffer:
currentArrayBufferIndex = buffer;
break;
case BufferTarget.ElementArrayBuffer:
currentElementArrayBufferIndex = buffer;
break;
default:
throw new NotImplementedException();
}
}
#endif
}
/// <summary>
/// Overwrites part of the buffer with the given data at the given offset.
/// Writes all data available in data.
/// </summary>
/// <param name="bufferTarget">The BufferTarget to use when binding the buffer.</param>
/// <param name="data">The data to be transfered into the buffer.</param>
/// <param name="offset">The index to the first element of the buffer to be overwritten.</param>
public void SubData(BufferTarget bufferTarget, T[] data, int offset)
{
SubData(bufferTarget, data, offset, data.Length);
}
/// <summary>
/// Allocates buffer memory and uploads given data to it.
/// </summary>
/// <param name="bufferTarget">The BufferTarget to use when binding the buffer.</param>
/// <param name="data">The data to be transfered into the buffer.</param>
/// <param name="usageHint">The usage hint of the buffer object.</param>
public void Init(BufferTarget bufferTarget, T[] data, BufferUsageHint usageHint = BufferUsageHint.StaticDraw)
{
Init(bufferTarget, data.Length, data, usageHint);
ActiveElementCount = data.Length;
CurrentElementIndex = 0;
}
/// <summary>
/// Binds the vertex buffer object.
/// </summary>
/// <param name="target">The target.</param>
public void Bind(BufferTarget target = BufferTarget.ArrayBuffer)
{
GL.BindBuffer(target, this);
}
public IBuffer Buffer(BufferTarget creationTarget, int sizeInBytes, BufferUsageHint usage, IntPtr initialData = default(IntPtr))
{
return(new Buffer(context, creationTarget, sizeInBytes, usage, initialData));
}
public void Bind(BufferTarget t)
{
GL.BindBuffer(t, GLObject);
CurrentTarget = t;
}
/// <summary>
/// 把服务端（GPU）上的当前Buffer Object映射到客户端（CPU）的内存上。
/// </summary>
/// <param name="target"></param>
/// <param name="access"></param>
/// <returns></returns>
public static IntPtr MapBuffer(BufferTarget target, MapBufferAccess access)
{
return GetDelegateFor<glMapBuffer>()((uint)target, (uint)access);
}
public Buffer(Clyde clyde, BufferTarget type, BufferUsageHint usage, Span <T> initialize, string name = null)
: base(clyde, type, usage, MemoryMarshal.AsBytes(initialize), name)
{
}
public VertexBuffer(BufferTarget bufferTarget)
{
_target = bufferTarget;
_vbo = GL.GenBuffer();
}
/// <summary>
/// Creates a new instance of <see cref="GLBuffer"/>
/// </summary>
/// <param name="type">The type of the <see cref="GLBuffer"/></param>
public GLBuffer(BufferTarget type)
{
Target = type;
ObjectHandle = GL.GenBuffer();
}
/// <summary>
/// Checks, have we VBO with specified data or not
/// </summary>
/// <param name="bufferTarget">The VBO type.</param>
/// <returns>True, if we have VBO with specified data</returns>
internal bool VBOexists(BufferTarget bufferTarget)
{
return(VBOobjects.ContainsKey(bufferTarget));
}
public Buffer(Clyde clyde, BufferTarget type, BufferUsageHint usage, int size, string name = null)
: this(clyde, type, usage, name)
{
Reallocate(size);
}
public void set_buffer <T>(BufferTarget target, Buffer <T> buffer) where T : struct
{
GL.BindVertexArray(gl_handle);
GL.BindBuffer(target, buffer.gl_handle);
GL.BindVertexArray(NullHandle);
}
public static void BindBuffer(BufferTarget bufferTarget, uint buffer)
{
InvokeExtensionFunction <glBindBuffer>()((uint)bufferTarget, buffer);
}
public static void BindBuffer(BufferTarget target, int buffer)
{
Interop.Calli((int)target, buffer, BindBufferAddress);
}
/// <summary>
/// Uploads the vertex buffer to the GPU.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="usageHint">The usage hint.</param>
public void BufferData(
BufferTarget target = BufferTarget.ArrayBuffer,
BufferUsageHint usageHint = BufferUsageHint.StreamDraw)
{
GL.BufferData(target, (IntPtr)(VertexSize * Count), vertices, usageHint);
}
public static void BufferData(BufferTarget target, IntPtr size, IntPtr data, BufferUsage usage)
{
Interop.Calli((int)target, size, data, (int)usage, BufferDataAddress);
}
/// <summary>
/// Allocates buffer memory without initializing it.
/// </summary>
/// <param name="bufferTarget">The BufferTarget to use when binding the buffer.</param>
/// <param name="elementCount">The number of elements to allocate memory for.</param>
/// <param name="usageHint">The usage hint of the buffer object.</param>
public void Init(BufferTarget bufferTarget, int elementCount, BufferUsageHint usageHint = BufferUsageHint.StaticDraw)
{
Init(bufferTarget, elementCount, null, usageHint);
ActiveElementCount = 0;
CurrentElementIndex = 0;
}
public static void BufferSubData(BufferTarget target, IntPtr offset, IntPtr size, IntPtr data)
{
Interop.Calli((int)target, offset, size, data, BufferSubDataAddress);
}
/// <summary>
/// Clear the buffer to default values.
/// </summary>
/// <param name="bufferTarget">The BufferTarget to use when binding the buffer.</param>
public void Clear(BufferTarget bufferTarget)
{
SubData(bufferTarget, new T[ElementCount], 0, ElementCount);
}
public VAO(string bufferName, int bufferSize = 4, BufferTarget bufferTarget = BufferTarget.ShaderStorageBuffer) : base(bufferName, bufferSize, bufferTarget)
{
throw new NotImplementedException();
}
//ARB_copy_buffer
/// <summary>
/// Copies between two buffers from bound readbuffer to bound writebuffer.
/// Note that this doesn't have to be CopyReadBuffer or CopyWriteBuffer, it can be between ArrayBuffer and UniformBuffer.
/// </summary>
/// <param name="readOffset">Offset in bytes from start of buffer bound to readtarget</param>
/// <param name="writeOffset">Offset in bytes from start of buffer bound to writetarget.</param>
/// <param name="Size">Size in bytes to copy from read to write.</param>
/// <param name="readTarget">Buffer target to read from, doesn't have to be CopyReadBuffer</param>
/// <param name="writeTarget">Buffer target to write to, doesn't have to be CopyWriteBuffer</param>
public static void CopyBufferSubDataARB(long readOffset, long writeOffset, long Size, BufferTarget readTarget = BufferTarget.CopyReadBuffer, BufferTarget writeTarget = BufferTarget.CopyWriteBuffer)
{
Delegates.glCopyBufferSubdataARB(readTarget, writeTarget, (IntPtr)readOffset, (IntPtr)writeOffset, (IntPtr)Size);
}
public void Bind(BufferTarget target)
{
GL.BindBuffer(target, id);
}
public static void BufferData(BufferTarget target, int size, IntPtr data, BufferUsageHint usage)
{
#if USE_OPENGL
if (openGlHardwareAvailable)
{
if(glHasBufferObjects)
{
OpenTK.Graphics.OpenGL.GL.BufferData((OpenTK.Graphics.OpenGL.BufferTarget)target, (IntPtr)size, data, (OpenTK.Graphics.OpenGL.BufferUsageHint)usage);
}
else
{
byte[] dataCopy = new byte[size];
unsafe
{
for (int i = 0; i < size; i++)
{
dataCopy[i] = ((byte*)data)[i];
}
}
switch (target)
{
case BufferTarget.ArrayBuffer:
if(currentArrayBufferIndex == 0)
{
throw new Exception("You don't have a ArrayBuffer set.");
}
bufferData[currentArrayBufferIndex] = dataCopy;
break;
case BufferTarget.ElementArrayBuffer:
if(currentElementArrayBufferIndex == 0)
{
throw new Exception("You don't have an EllementArrayBuffer set.");
}
bufferData[currentElementArrayBufferIndex] = dataCopy;
break;
default:
throw new NotImplementedException();
}
}
}
#else
if (glHasBufferObjects)
{
OpenTK.Graphics.ES11.GL.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, data, (OpenTK.Graphics.ES11.All)usage);
}
else
{
byte[] dataCopy = new byte[size];
unsafe
{
for (int i = 0; i < size; i++)
{
dataCopy[i] = ((byte*)data)[i];
}
}
switch (target)
{
case BufferTarget.ArrayBuffer:
if (currentArrayBufferIndex == 0)
{
throw new Exception("You don't have a ArrayBuffer set.");
}
bufferData[currentArrayBufferIndex] = dataCopy;
break;
case BufferTarget.ElementArrayBuffer:
if (currentElementArrayBufferIndex == 0)
{
throw new Exception("You don't have an EllementArrayBuffer set.");
}
bufferData[currentElementArrayBufferIndex] = dataCopy;
break;
default:
throw new NotImplementedException();
}
}
#endif
}
public void BufferData(BufferTarget target, BufferUsageHint usage, Vector3[] vertices)
{
Bind(target);
GL.BufferData <Vector3>(target, new IntPtr(vertices.Length * Vector3.SizeInBytes), vertices, usage);
}
/// <summary>
/// 选择一个VBO作为当前VBO。
/// </summary>
/// <param name="target"></param>
/// <param name="id"></param>
public static void BindBuffer(BufferTarget target, uint id)
{
GL.BindBuffer((uint)target, id);
}
public StaticBuffer(int elementSize, T[] data, BufferTarget target) : base(elementSize, target)
{
Data = data;
}
/// <summary>
/// 设置当前VBO的数据。
/// </summary>
/// <param name="target"></param>
/// <param name="data"></param>
/// <param name="usage"></param>
public static void BufferData(BufferTarget target, UnmanagedArrayBase data, BufferUsage usage)
{
GetDelegateFor<glBufferData>()((uint)target, data.ByteLength, data.Header, (uint)usage);
}
protected VertexBuffer(int vertexBufferId, BufferTarget target) : this(vertexBufferId, ColoredTexturedVertex.Size)
{
Id = vertexBufferId;
Target = target;
}
