Creates a new buffer according to BufferCreation specification.

Creates a buffer from a strict bytestring.

The principle is the same as in newBufferFromVector.

Creates a buffer from a list.

The principle is the same as in newBufferFromVector.

Creates a buffer from a storable vector.

This is a convenience function.

Buffer data type.

The frequency of access to a buffer.

These correspond to the OpenGL access frequency hints. You can look for them in the OpenGL specification or check this link:

https://www.opengl.org/wiki/GLAPI/glBufferData

The nature of access to a buffer.

These correspond to the OpenGL access nature hints. You can look for them in the OpenGL specification or check this link:

https://www.opengl.org/wiki/GLAPI/glBufferData

Describes a style of mapping.

Additional mapping flags.

This data describes how a buffer should behave and what operations can be done with it.

Accurate description can improve performance.

For forwards compatibility, it is recommended to use defaultBufferCreation and then set the fields you want to change.

The default buffer creation flags.

The default attempts to give you the most general (and possibly slowest) buffer. Both read and write access are allowed.

Default size is 0 which will make newBuffer fail if you don't set it.

Invalidates the contents of a buffer.

This is you saying: "I don't care what's in this buffer anymore. You can do whatever you want with it.".

The data may be gone or it may not be gone. Use this as a hint to the implementation that you will not use the _current_ contents of the buffer anymore.

This requires the OpenGL extension "GL_ARB_invalidate_subdata" but if this extension is not present, then this simply does nothing.

See https://www.opengl.org/wiki/Buffer_Object#Invalidation.

Explicitly flushes part of a buffer mapping.

The buffer must have been mapped with ExplicitFlush set. Furthermore, either OpenGL 3.0 or "GL_ARB_map_buffer_range" is required; however this function does nothing is neither of those are available.

Maps (part) of a buffer to system memory space.

The mapping is valid until the buffer is garbage collected (in which case the mapping is automatically unmapped) or when bufferUnmap is called on the buffer.

You can not have two mappings going on at the same time.

Same as bufferMap but allows more control over mapping.

 bufferMap = bufferMap2 mempty

Unmaps a buffer.

Does nothing if the buffer was not mapped.

It is possible that the mapping become corrupt during the time it was mapped. If there was corruption, BufferCorruption is thrown in this call.

Corruption means that the contents of the buffer are now undefined.

Copies bytes from one buffer to another.

This will use GL_ARB_copy_buffer extension if it is available (this became available in OpenGL 3.1).

The buffers must not be mapped; however this call can bypass the access flags set in newBuffer, if the above extension is available. That is, you can copy data even to a buffer that was set as not writable or copy from a buffer that was set as not readable.

When GL_ARB_copy_buffer is not available, this is implemented in terms of withMapping and is subject to mapping restrictions.

This is faster (when the required extensions are available) than mapping both buffers and then doing a memcpy() style copying in system memory because this call usually does not require a round-trip to the driver.

You can use the same buffer for both destination and source but the copying area may not overlap.

A convenience function over map/unmap that automatically unmaps the buffer when done (even in the case of exceptions).

The arguments to this function are the same as for bufferMap, except for extra action argument.

This calls bufferUnmap which means it can throw BufferCorruption when the action is done.

There is a rare case that can happen if your action throws an exception AND the unmapping throws an exception. Which exception is propagated upwards? If this happens, this call silences BufferCorruption exception and re-throws the user exception. This unfortunately means there is no way to know if the buffer was corrupted if you threw an exception inside the action.

Same as withMapping but with map flags.

See bufferMap2.

A convenience function to upload a storable vector to a buffer.

The buffer must be in an unmapped state and must be write-mappable.

Returns the size of the buffer, in bytes.

Returns the allowed mappings.

Exception that is thrown from bufferUnmap when buffer corruption is detected.

Corruption can happen due to external factors and is system-specific.