Struct rin::gl::SharedBufferStorage

pub struct SharedBufferStorage<T> { /* fields omitted */ }

Wrapper around a BufferStorage with internal reference counting

Useful for example when the same buffer or ranges of the same buffer are to be used in different VAOs

Implementations

impl<T> SharedBufferStorage<T> where
    T: 'static, 

pub fn update(&mut self, data: &[T])

pub fn with_map_read<F>(&self, flags: MapReadFlags, f: F) -> Result<(), Error> where
    F: FnMut(&[T]), 

pub unsafe fn map_write<F>(
    &mut self,
    flags: MapWriteFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&mut [T]), 

pub fn map_read_write<F>(
    &mut self,
    flags: MapReadWriteFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&mut [T]), 

pub fn copy_to<U, B>(&self, dst: &mut B) where
    B: BufferRange<U> + WithBackendMut, 

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

pub fn bytes(&self) -> usize

pub fn capacity_bytes(&self) -> usize

pub fn id(&self) -> u32

pub fn stride(&self) -> usize

pub fn range<R>(
    &self,
    range: R
) -> Range<T, SharedBufferStorage<T>, SharedBufferStorage<T>> where
    R: InputRange, 

pub fn range_mut<R>(
    &mut self,
    range: R
) -> Range<T, SharedBufferStorage<T>, SharedBufferStorage<T>> where
    R: InputRange, 

Get a mutable range from the buffer

Useful to do operations on portions of the buffer

Panics if the range is out of bounds

pub fn is_persistant(&self) -> bool

On creation the storage was passed the GL_MAP_PERSISTENT_BIT

The client may request that the server read from or write to the buffer while it is mapped. The client’s pointer to the data store remains valid so long as the data store is mapped, even during execution of drawing or dispatch commands.

If the storage is not persistent, calls to persistent_map_* will fail

pub fn is_read_map(&self) -> bool

On creation the storage was passed the GL_MAP_READ_BIT

The data store may be mapped by the client for read access and a pointer in the client’s address space obtained that may be read from.

If the storage is not read map, calls to any read map will fail

pub fn is_write_map(&self) -> bool

On creation the storage was passed the GL_MAP_WRITE_BIT

The data store may be mapped by the client for write access and a pointer in the client’s address space obtained that may be written through.

If the storage is not read write, calls to any write map will fail

pub fn is_dynamic_storage(&self) -> bool

On creation the storage was passed the GL_DYNAMIC_STORAGE_BIT

The contents of the data store may be updated after creation through calls to update (glSubBufferData). If this bit is not set, the buffer content may not be directly updated by the client. The data argument may be used to specify the initial content of the buffer’s data store regardless of the presence of the GL_DYNAMIC_STORAGE_BIT. Regardless of the presence of this bit, buffers may always be updated with server-side calls such as copy (glCopyBufferSubData) and clear (glClearBufferSubData).

pub fn is_coherent(&self) -> bool

On creation the storage was passed the gL_MAP_COHERENT_BIT

Shared access to buffers that are simultaneously mapped for client access and are used by the server will be coherent, so long as that mapping is performed using glMapBufferRange. That is, data written to the store by either the client or server will be immediately visible to the other with no further action taken by the application. In particular,

• If GL_MAP_COHERENT_BIT is not set and the client performs a write followed by a call to the glMemoryBarrier command with the GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT set, then in subsequent commands the server will see the writes.

• If GL_MAP_COHERENT_BIT is set and the client performs a write, then in subsequent commands the server will see the writes.

• If GL_MAP_COHERENT_BIT is not set and the server performs a write, the application must call glMemoryBarrier with the GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT set and then call glFenceSync with GL_SYNC_GPU_COMMANDS_COMPLETE (or glFinish). Then the CPU will see the writes after the sync is complete.

• If GL_MAP_COHERENT_BIT is set and the server does a write, the app must call FenceSync with GL_SYNC_GPU_COMMANDS_COMPLETE (or glFinish). Then the CPU will see the writes after the sync is complete.

pub fn map_persistent_read(
    &self,
    flags: MapReadFlags
) -> Result<MapPersistentRead<T, &SharedBufferStorage<T>>, Error>

Persistently maps a buffer object’s data store

If the storage wasn’t created as pesistent this call will fail

Persistent maps can be send and shared with other threads but need to be dropped from the same thread they were created from. The destructor will panic otherwise.

A common pattern to do this is to return the map as the return value of a thread and receive it by explicitly joining the thread using it’s join handle from the original thread.

see glMapBuffer with GL_MAP_PERSISTENT_BIT

pub fn into_map_persistent_read(
    self,
    flags: MapReadFlags
) -> Result<MapPersistentRead<T, SharedBufferStorage<T>>, Error>

pub fn map_persistent_write(
    &self,
    flags: MapWriteFlags
) -> Result<MapPersistentWrite<T, &SharedBufferStorage<T>>, Error>

Persistently maps a buffer object’s data store

If the storage wasn’t created as pesistent this call will fail

Persistent maps can be send and shared with other threads but need to be dropped from the same thread they were created from. The destructor will panic otherwise.

A common pattern to do this is to return the map as the return value of a thread and receive it by explicitly joining the thread using it’s join handle from the original thread.

see glMapBuffer with GL_MAP_PERSISTENT_BIT

pub fn into_map_persistent_write(
    self,
    flags: MapWriteFlags
) -> Result<MapPersistentWrite<T, SharedBufferStorage<T>>, Error>

pub fn map_persistent_read_write(
    &self,
    flags: MapReadWriteFlags
) -> Result<MapPersistentReadWrite<T, &SharedBufferStorage<T>>, Error>

Persistently maps a buffer object’s data store

If the storage wasn’t created as pesistent this call will fail

Persistent maps can be send and shared with other threads but need to be dropped from the same thread they were created from. The destructor will panic otherwise.

A common pattern to do this is to return the map as the return value of a thread and receive it by explicitly joining the thread using it’s join handle from the original thread.

see glMapBuffer with GL_MAP_PERSISTENT_BIT

pub fn into_map_persistent_read_write(
    self,
    flags: MapReadWriteFlags
) -> Result<MapPersistentReadWrite<T, SharedBufferStorage<T>>, Error>

impl SharedBufferStorage<u8>

pub fn cast<T>(self) -> SharedBufferStorage<T>

Trait Implementations

impl<'_, T> BufferRange<T> for &'_ SharedBufferStorage<T> where
    T: 'static, 

pub fn start(&self) -> usize

pub fn end(&self) -> usize

pub fn into_range<R>(
    self,
    range: R
) -> Range<T, &'_ SharedBufferStorage<T>, &'_ SharedBufferStorage<T>> where
    R: InputRange,
    &'_ SharedBufferStorage<T>: Sized, 

impl<T> BufferRange<T> for SharedBufferStorage<T> where
    T: 'static, 

pub fn start(&self) -> usize

pub fn end(&self) -> usize

pub fn into_range<R>(
    self,
    range: R
) -> Range<T, SharedBufferStorage<T>, SharedBufferStorage<T>> where
    R: InputRange,
    SharedBufferStorage<T>: Sized, 

impl<T> BufferRangeMut<T> for SharedBufferStorage<T> where
    T: 'static, 

pub fn update(&mut self, data: &[T])

impl<T> Cast<T> for SharedBufferStorage<u8> where
    T: 'static, 

type CastTo = SharedBufferStorage<T>

pub fn cast(self) -> SharedBufferStorage<T>

impl<T> Clone for SharedBufferStorage<T>

pub fn clone(&self) -> SharedBufferStorage<T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for SharedBufferStorage<T> where
    T: Debug, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> From<BufferStorage<T>> for SharedBufferStorage<T> where
    T: 'static, 

pub fn from(buffer: BufferStorage<T>) -> SharedBufferStorage<T>

Performs the conversion.

impl InternalCreation<SharedBufferStorage<u8>> for Allocator<SharedBufferStorage<u8>>

pub fn create<C>(
    gl: &C,
    initial_size: usize,
    flags: u32,
    _target: u32
) -> Result<SharedBufferStorage<u8>, Error> where
    C: CreationContext, 

impl<T> MapPersistent<T> for SharedBufferStorage<T> where
    T: 'static, 

pub fn map_persistent_read(
    &self,
    flags: MapReadFlags
) -> Result<MapPersistentRead<T, &SharedBufferStorage<T>>, Error>

pub fn into_map_persistent_read(
    self,
    flags: MapReadFlags
) -> Result<MapPersistentRead<T, SharedBufferStorage<T>>, Error> where
    SharedBufferStorage<T>: Sized, 

impl<T> MapPersistentMut<T> for SharedBufferStorage<T> where
    T: 'static, 

pub fn map_persistent_write(
    &self,
    flags: MapWriteFlags
) -> Result<MapPersistentWrite<T, &SharedBufferStorage<T>>, Error>

pub fn map_persistent_read_write(
    &self,
    flags: MapReadWriteFlags
) -> Result<MapPersistentReadWrite<T, &SharedBufferStorage<T>>, Error>

pub fn into_map_persistent_write(
    self,
    flags: MapWriteFlags
) -> Result<MapPersistentWrite<T, SharedBufferStorage<T>>, Error>

pub fn into_map_persistent_read_write(
    self,
    flags: MapReadWriteFlags
) -> Result<MapPersistentReadWrite<T, SharedBufferStorage<T>>, Error>

impl<T> MapPersistentRange<T> for SharedBufferStorage<T> where
    T: 'static, 

pub unsafe fn unsafe_map_range_persistent_read(
    &self,
    range: Option<Range<usize>>,
    flags: MapReadFlags
) -> Result<&'static [T], Error>

pub fn map_range_persistent_read(
    &self,
    offset: usize,
    length: usize,
    flags: MapReadFlags
) -> Result<MapPersistentRead<T, &SharedBufferStorage<T>>, Error>

pub fn into_map_range_persistent_read(
    self,
    offset: usize,
    length: usize,
    flags: MapReadFlags
) -> Result<MapPersistentRead<T, SharedBufferStorage<T>>, Error> where
    SharedBufferStorage<T>: Sized, 

impl<T> MapPersistentRangeMut<T> for SharedBufferStorage<T> where
    T: 'static, 

pub unsafe fn unsafe_map_range_persistent_write(
    &self,
    range: Option<Range<usize>>,
    flags: MapWriteFlags
) -> Result<&'static mut [T], Error>

pub unsafe fn unsafe_map_range_persistent_read_write(
    &self,
    range: Option<Range<usize>>,
    flags: MapReadWriteFlags
) -> Result<&'static mut [T], Error>

pub fn map_range_persistent_write(
    &self,
    offset: usize,
    length: usize,
    flags: MapWriteFlags
) -> Result<MapPersistentWrite<T, &SharedBufferStorage<T>>, Error>

pub fn map_range_persistent_read_write(
    &self,
    offset: usize,
    length: usize,
    flags: MapReadWriteFlags
) -> Result<MapPersistentReadWrite<T, &SharedBufferStorage<T>>, Error>

pub fn into_map_range_persistent_write(
    self,
    offset: usize,
    length: usize,
    flags: MapWriteFlags
) -> Result<MapPersistentWrite<T, SharedBufferStorage<T>>, Error>

pub fn into_map_range_persistent_read_write(
    self,
    offset: usize,
    length: usize,
    flags: MapReadWriteFlags
) -> Result<MapPersistentReadWrite<T, SharedBufferStorage<T>>, Error>

impl<T> PartialEq<SharedBufferStorage<T>> for SharedBufferStorage<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &SharedBufferStorage<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &SharedBufferStorage<T>) -> bool

This method tests for !=.

impl<T> TypedBuffer<T> for SharedBufferStorage<T> where
    T: 'static, 

pub fn id(&self) -> u32

OpenGL id

pub fn len(&self) -> usize

Number of elements on the last update

pub fn capacity(&self) -> usize

Allocated capacity of the buffer in number of elements

pub fn with_map_read<F>(&self, flags: MapReadFlags, f: F) -> Result<(), Error> where
    F: FnMut(&[T]), 

Maps a buffer object’s data store

pub fn copy_to<U, B>(&self, dst: &mut B) where
    B: BufferRange<U> + WithBackendMut, 

Copy one buffer into another

pub unsafe fn unmap(&self)

pub fn is_empty(&self) -> bool

pub fn bytes(&self) -> usize

Total bytes on the last update

pub fn capacity_bytes(&self) -> usize

Total capcacity of the buffer in bytes

pub fn stride(&self) -> usize

Stride of the buffer type

impl<'_, T> TypedBuffer<T> for &'_ SharedBufferStorage<T> where
    T: 'static, 

pub fn id(&self) -> u32

OpenGL id

pub fn len(&self) -> usize

Number of elements on the last update

pub fn capacity(&self) -> usize

Allocated capacity of the buffer in number of elements

pub fn with_map_read<F>(&self, flags: MapReadFlags, f: F) -> Result<(), Error> where
    F: FnMut(&[T]), 

Maps a buffer object’s data store

pub fn copy_to<U, B>(&self, dst: &mut B) where
    B: BufferRange<U> + WithBackendMut, 

Copy one buffer into another

pub unsafe fn unmap(&self)

pub fn is_empty(&self) -> bool

pub fn bytes(&self) -> usize

Total bytes on the last update

pub fn capacity_bytes(&self) -> usize

Total capcacity of the buffer in bytes

pub fn stride(&self) -> usize

Stride of the buffer type

impl<'a, T> TypedBufferMut<T> for SharedBufferStorage<T> where
    T: 'static, 

pub unsafe fn with_map_write<F>(
    &mut self,
    flags: MapWriteFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&mut [T]), 

Maps a buffer object’s data store

pub fn with_map_read_write<F>(
    &mut self,
    flags: MapReadWriteFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&mut [T]), 

Maps a buffer object’s data store

impl<T> WithBackend for SharedBufferStorage<T>

pub fn with_backend<F, R>(&self, f: F) -> R where
    F: FnMut(&dyn Backend) -> R, 

impl<T> WithBackendMut for SharedBufferStorage<T>

pub fn with_backend_mut<F, R>(&mut self, f: F) -> R where
    F: FnMut(&mut dyn Backend) -> R, 

impl<T> WithMapRange<T> for SharedBufferStorage<T> where
    T: 'static, 

pub fn with_map_range_read<F>(
    &self,
    offset: usize,
    length: usize,
    flags: MapReadFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&[T]), 

impl<T> WithMapRangeMut<T> for SharedBufferStorage<T> where
    T: 'static, 

pub unsafe fn with_map_range_write<F>(
    &mut self,
    offset: usize,
    length: usize,
    flags: MapWriteFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&mut [T]), 

pub fn with_map_range_read_write<F>(
    &mut self,
    offset: usize,
    length: usize,
    flags: MapReadWriteFlags,
    f: F
) -> Result<(), Error> where
    F: FnMut(&mut [T]), 

impl<T> BufferExt<T> for SharedBufferStorage<T> where
    T: 'static, 

impl<T> Eq for SharedBufferStorage<T> where
    T: Eq, 

impl<T> StructuralEq for SharedBufferStorage<T>

impl<T> StructuralPartialEq for SharedBufferStorage<T>