1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108

use super::*;
use super::errors::*;

use raw::{clear_buffer_data, clear_buffer_sub_data, copy_named_buffer_sub_data, create_buffer,
          delete_buffer, named_buffer_storage, named_buffer_sub_data, BufferData, BufferId,
          BufferMap, BufferMutability};

#[derive(Debug)]
pub struct MutableBuffer {
    id: BufferId,
}

impl MutableBuffer {
    /// Creates new buffer and copies `data` to its memory on GPU
    ///
    /// # Errors
    /// - GL_OUT_OF_MEMORY - if the buffer cannot be created
    ///
    pub fn new<T>(data: &[T]) -> Result<MutableBuffer> {
        let id = create_buffer();

        unsafe {
            named_buffer_storage(id, BufferData::Data(data), BufferMutability::Mutable, None)
                .chain_err(|| ErrorKind::BufferCreationError)?;
        }

        Ok(MutableBuffer { id: id })
    }

    /// Creates new empty buffer
    ///
    /// # Errors
    /// - BufferCreationError(GL_OUT_OF_MEMORY) - if the buffer cannot be created
    ///
    pub fn new_empty(size: usize) -> Result<MutableBuffer> {
        let id = create_buffer();

        unsafe {
            named_buffer_storage::<u8, Option<BufferMap>>(
                id,
                BufferData::Empty(size),
                BufferMutability::Mutable,
                None,
            ).chain_err(|| ErrorKind::BufferCreationError)?;
        }

        Ok(MutableBuffer { id: id })
    }

    /// Replaces part of memory with `data`
    ///
    /// # Errors
    /// - BufferSetSubDataError(GL_INVALID_VALUE) - if size of `data` + offset > buffer size
    ///
    pub fn set_sub_data<T>(&mut self, data: &[T], offset: isize) -> Result<()> {
        unsafe {
            named_buffer_sub_data(self.id, offset, data)
                .chain_err(|| ErrorKind::BufferSetSubDataError)?;
        }

        Ok(())
    }

    pub fn clear_data(&mut self) -> Result<()> {
        unsafe {
            clear_buffer_data(self.id).chain_err(|| ErrorKind::BufferClearError)?;
        }

        Ok(())
    }

    pub fn clear_sub_data(&mut self, size: usize, offset: usize) -> Result<()> {
        unsafe {
            clear_buffer_sub_data(self.id, size, offset).chain_err(|| ErrorKind::BufferClearError)?;
        }

        Ok(())
    }

    pub fn copy_to(
        &mut self,
        other: &mut MutableBuffer,
        read_offset: usize,
        write_offset: usize,
        size: usize,
    ) -> Result<()> {
        unsafe {
            copy_named_buffer_sub_data(self.id, other.id, read_offset, write_offset, size)
                .chain_err(|| ErrorKind::BufferCopyError)?;
        }

        Ok(())
    }
}

impl Buffer for MutableBuffer {
    fn get_id(&self) -> BufferId {
        self.id
    }
}

impl Drop for MutableBuffer {
    fn drop(&mut self) {
        unsafe {
            delete_buffer(self.id);
        }
    }
}