agpu 0.1.2

Abstract GPU Project
Documentation 
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

mod builder;
pub use builder::*;

mod binding;
pub use binding::*;

mod view;
use futures::executor::block_on;
pub use view::*;

mod vertex_layout;
pub use vertex_layout::*;

use crate::Gpu;
use std::ops::Deref;

/// * Probably best used as `RefCell<Buffer>`
pub struct Buffer {
    pub(crate) gpu: Gpu,
    pub(crate) label: String,
    pub(crate) inner: wgpu::Buffer,
    pub(crate) usages: wgpu::BufferUsages,
    pub size: u64,
}
/// Allows you to use this as a reference to the inner `wgpu::Buffer`
impl Deref for Buffer {
    type Target = wgpu::Buffer;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}
impl Buffer {
    /// # Errors
    /// Errors according to [`wgpu::BufferAsyncError`]
    pub fn download_immediately(
        &self,
    ) -> Result<wgpu::util::DownloadBuffer, wgpu::BufferAsyncError> {
        let fut = wgpu::util::DownloadBuffer::read_buffer(
            &self.gpu.device,
            &self.gpu.queue,
            &self.inner.slice(..),
        );
        self.gpu.poll(wgpu::Maintain::Wait);
        block_on(fut)
    }

    pub fn size(&self) -> usize {
        self.size as usize
    }

    // Writes the data to the buffer
    // Resizes the buffer if the data is larger than the current buffer size
    pub fn write<T>(&mut self, data: &[T])
    where
        T: bytemuck::Pod,
    {
        let data = bytemuck::cast_slice(data);

        self.resize_if_smaller(data.len() as u64, true);
        self.write_impl(0, data);
    }

    /// Writes to the buffer at the given byte offset
    pub fn write_at<T>(&mut self, offset: u64, data: &[T])
    where
        T: bytemuck::Pod,
    {
        let data = bytemuck::cast_slice(data);
        self.resize_if_smaller(offset + data.len() as u64, true);
        self.write_impl(offset, data);
    }

    /// Convenince function for writing at an index of the buffer
    /// (multiple of the data size)
    pub fn write_index<T>(&mut self, index: u64, data: &[T])
    where
        T: bytemuck::Pod,
    {
        let offset = index * std::mem::size_of::<T>() as u64;
        self.write_at(offset, data);
    }

    // Writes the data to the buffer
    // Will panic if the data is larger than the current buffer size
    pub fn write_unchecked<T>(&self, data: &[T])
    where
        T: bytemuck::Pod,
    {
        let data = bytemuck::cast_slice(data);
        self.write_impl(0, data);
    }

    /// Writes to the buffer at the given byte offset
    pub fn write_at_unchecked<T>(&mut self, offset: u64, data: &[T])
    where
        T: bytemuck::Pod,
    {
        let data = bytemuck::cast_slice(data);
        self.write_impl(offset, data);
    }

    /// Convenince function for writing at an index of the buffer
    /// (multiple of the data size)
    pub fn write_index_unchecked<T>(&mut self, index: u64, data: &[T])
    where
        T: bytemuck::Pod,
    {
        let offset = index * std::mem::size_of::<T>() as u64;
        self.write_at_unchecked(offset, data);
    }

    fn write_impl(&self, offset: u64, data: &[u8]) {
        self.gpu.queue.write_buffer(&self.inner, offset, data);
    }

    // If the buffer is too small, resize it
    fn resize_if_smaller(&mut self, size: u64, copy: bool) -> bool {
        if self.size >= size {
            return false;
        }
        self.resize_impl(size, copy);
        true
    }

    /// Resizes the buffer (does not check if the buffer is bigger)
    /// Currently the encoder is immediately submitted which may cause a
    /// performance hit
    fn resize_impl(&mut self, size: u64, copy: bool) {
        if copy {
            self.usages |= wgpu::BufferUsages::COPY_DST
        };
        // Create the new buffer
        let new_buffer = self.gpu.device.create_buffer(&wgpu::BufferDescriptor {
            label: Some(&self.label),
            size,
            usage: self.usages,
            mapped_at_creation: false,
        });
        if copy {
            // Copy the contents of the old buffer to the new buffer
            let mut encoder = self
                .gpu
                .create_command_encoder("agpu::Buffer::resize_impl() command encoder");
            self.copy_to(&mut encoder, &new_buffer);
            self.gpu.queue.submit([encoder.finish()]);
        };
        // Destroy the old buffer
        self.inner.destroy();
        // Update the inner buffer
        self.inner = new_buffer;
        // Update the size
        self.size = size;
    }

    pub fn resize(&mut self, size: u64) {
        self.resize_impl(size, true);
    }

    pub fn copy_to(&self, encoder: &mut wgpu::CommandEncoder, target: &wgpu::Buffer) {
        encoder.copy_buffer_to_buffer(&self.inner, 0, target, 0, self.size);
    }
}