bevy_render/render_resource/
uniform_buffer.rs

1use core::{marker::PhantomData, num::NonZero};
2
3use crate::{
4    render_resource::Buffer,
5    renderer::{RenderDevice, RenderQueue},
6};
7use encase::{
8    internal::{AlignmentValue, BufferMut, WriteInto},
9    DynamicUniformBuffer as DynamicUniformBufferWrapper, ShaderType,
10    UniformBuffer as UniformBufferWrapper,
11};
12use wgpu::{
13    util::BufferInitDescriptor, BindingResource, BufferBinding, BufferDescriptor, BufferUsages,
14};
15
16use super::IntoBinding;
17
18/// Stores data to be transferred to the GPU and made accessible to shaders as a uniform buffer.
19///
20/// Uniform buffers are available to shaders on a read-only basis. Uniform buffers are commonly used to make available to shaders
21/// parameters that are constant during shader execution, and are best used for data that is relatively small in size as they are
22/// only guaranteed to support up to 16kB per binding.
23///
24/// The contained data is stored in system RAM. [`write_buffer`](UniformBuffer::write_buffer) queues
25/// copying of the data from system RAM to VRAM. Data in uniform buffers must follow [std140 alignment/padding requirements],
26/// which is automatically enforced by this structure. Per the WGPU spec, uniform buffers cannot store runtime-sized array
27/// (vectors), or structures with fields that are vectors.
28///
29/// Other options for storing GPU-accessible data are:
30/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
31/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
32/// * [`DynamicUniformBuffer`]
33/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
34/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
35/// * [`BufferVec`](crate::render_resource::BufferVec)
36/// * [`Texture`](crate::render_resource::Texture)
37///
38/// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
39pub struct UniformBuffer<T: ShaderType> {
40    value: T,
41    scratch: UniformBufferWrapper<Vec<u8>>,
42    buffer: Option<Buffer>,
43    label: Option<String>,
44    changed: bool,
45    buffer_usage: BufferUsages,
46}
47
48impl<T: ShaderType> From<T> for UniformBuffer<T> {
49    fn from(value: T) -> Self {
50        Self {
51            value,
52            scratch: UniformBufferWrapper::new(Vec::new()),
53            buffer: None,
54            label: None,
55            changed: false,
56            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
57        }
58    }
59}
60
61impl<T: ShaderType + Default> Default for UniformBuffer<T> {
62    fn default() -> Self {
63        Self {
64            value: T::default(),
65            scratch: UniformBufferWrapper::new(Vec::new()),
66            buffer: None,
67            label: None,
68            changed: false,
69            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
70        }
71    }
72}
73
74impl<T: ShaderType + WriteInto> UniformBuffer<T> {
75    #[inline]
76    pub fn buffer(&self) -> Option<&Buffer> {
77        self.buffer.as_ref()
78    }
79
80    #[inline]
81    pub fn binding(&self) -> Option<BindingResource> {
82        Some(BindingResource::Buffer(
83            self.buffer()?.as_entire_buffer_binding(),
84        ))
85    }
86
87    /// Set the data the buffer stores.
88    pub fn set(&mut self, value: T) {
89        self.value = value;
90    }
91
92    pub fn get(&self) -> &T {
93        &self.value
94    }
95
96    pub fn get_mut(&mut self) -> &mut T {
97        &mut self.value
98    }
99
100    pub fn set_label(&mut self, label: Option<&str>) {
101        let label = label.map(str::to_string);
102
103        if label != self.label {
104            self.changed = true;
105        }
106
107        self.label = label;
108    }
109
110    pub fn get_label(&self) -> Option<&str> {
111        self.label.as_deref()
112    }
113
114    /// Add more [`BufferUsages`] to the buffer.
115    ///
116    /// This method only allows addition of flags to the default usage flags.
117    ///
118    /// The default values for buffer usage are `BufferUsages::COPY_DST` and `BufferUsages::UNIFORM`.
119    pub fn add_usages(&mut self, usage: BufferUsages) {
120        self.buffer_usage |= usage;
121        self.changed = true;
122    }
123
124    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
125    /// and the provided [`RenderQueue`], if a GPU-side backing buffer already exists.
126    ///
127    /// If a GPU-side buffer does not already exist for this data, such a buffer is initialized with currently
128    /// available data.
129    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
130        self.scratch.write(&self.value).unwrap();
131
132        if self.changed || self.buffer.is_none() {
133            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
134                label: self.label.as_deref(),
135                usage: self.buffer_usage,
136                contents: self.scratch.as_ref(),
137            }));
138            self.changed = false;
139        } else if let Some(buffer) = &self.buffer {
140            queue.write_buffer(buffer, 0, self.scratch.as_ref());
141        }
142    }
143}
144
145impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a UniformBuffer<T> {
146    #[inline]
147    fn into_binding(self) -> BindingResource<'a> {
148        self.buffer()
149            .expect("Failed to get buffer")
150            .as_entire_buffer_binding()
151            .into_binding()
152    }
153}
154
155/// Stores data to be transferred to the GPU and made accessible to shaders as a dynamic uniform buffer.
156///
157/// Dynamic uniform buffers are available to shaders on a read-only basis. Dynamic uniform buffers are commonly used to make
158/// available to shaders runtime-sized arrays of parameters that are otherwise constant during shader execution, and are best
159/// suited to data that is relatively small in size as they are only guaranteed to support up to 16kB per binding.
160///
161/// The contained data is stored in system RAM. [`write_buffer`](DynamicUniformBuffer::write_buffer) queues
162/// copying of the data from system RAM to VRAM. Data in uniform buffers must follow [std140 alignment/padding requirements],
163/// which is automatically enforced by this structure. Per the WGPU spec, uniform buffers cannot store runtime-sized array
164/// (vectors), or structures with fields that are vectors.
165///
166/// Other options for storing GPU-accessible data are:
167/// * [`StorageBuffer`](crate::render_resource::StorageBuffer)
168/// * [`DynamicStorageBuffer`](crate::render_resource::DynamicStorageBuffer)
169/// * [`UniformBuffer`]
170/// * [`DynamicUniformBuffer`]
171/// * [`GpuArrayBuffer`](crate::render_resource::GpuArrayBuffer)
172/// * [`RawBufferVec`](crate::render_resource::RawBufferVec)
173/// * [`BufferVec`](crate::render_resource::BufferVec)
174/// * [`Texture`](crate::render_resource::Texture)
175///
176/// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
177pub struct DynamicUniformBuffer<T: ShaderType> {
178    scratch: DynamicUniformBufferWrapper<Vec<u8>>,
179    buffer: Option<Buffer>,
180    label: Option<String>,
181    changed: bool,
182    buffer_usage: BufferUsages,
183    _marker: PhantomData<fn() -> T>,
184}
185
186impl<T: ShaderType> Default for DynamicUniformBuffer<T> {
187    fn default() -> Self {
188        Self {
189            scratch: DynamicUniformBufferWrapper::new(Vec::new()),
190            buffer: None,
191            label: None,
192            changed: false,
193            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
194            _marker: PhantomData,
195        }
196    }
197}
198
199impl<T: ShaderType + WriteInto> DynamicUniformBuffer<T> {
200    pub fn new_with_alignment(alignment: u64) -> Self {
201        Self {
202            scratch: DynamicUniformBufferWrapper::new_with_alignment(Vec::new(), alignment),
203            buffer: None,
204            label: None,
205            changed: false,
206            buffer_usage: BufferUsages::COPY_DST | BufferUsages::UNIFORM,
207            _marker: PhantomData,
208        }
209    }
210
211    #[inline]
212    pub fn buffer(&self) -> Option<&Buffer> {
213        self.buffer.as_ref()
214    }
215
216    #[inline]
217    pub fn binding(&self) -> Option<BindingResource> {
218        Some(BindingResource::Buffer(BufferBinding {
219            buffer: self.buffer()?,
220            offset: 0,
221            size: Some(T::min_size()),
222        }))
223    }
224
225    #[inline]
226    pub fn is_empty(&self) -> bool {
227        self.scratch.as_ref().is_empty()
228    }
229
230    /// Push data into the `DynamicUniformBuffer`'s internal vector (residing on system RAM).
231    #[inline]
232    pub fn push(&mut self, value: &T) -> u32 {
233        self.scratch.write(value).unwrap() as u32
234    }
235
236    pub fn set_label(&mut self, label: Option<&str>) {
237        let label = label.map(str::to_string);
238
239        if label != self.label {
240            self.changed = true;
241        }
242
243        self.label = label;
244    }
245
246    pub fn get_label(&self) -> Option<&str> {
247        self.label.as_deref()
248    }
249
250    /// Add more [`BufferUsages`] to the buffer.
251    ///
252    /// This method only allows addition of flags to the default usage flags.
253    ///
254    /// The default values for buffer usage are `BufferUsages::COPY_DST` and `BufferUsages::UNIFORM`.
255    pub fn add_usages(&mut self, usage: BufferUsages) {
256        self.buffer_usage |= usage;
257        self.changed = true;
258    }
259
260    /// Creates a writer that can be used to directly write elements into the target buffer.
261    ///
262    /// This method uses less memory and performs fewer memory copies using over [`push`] and [`write_buffer`].
263    ///
264    /// `max_count` *must* be greater than or equal to the number of elements that are to be written to the buffer, or
265    /// the writer will panic while writing.  Dropping the writer will schedule the buffer write into the provided
266    /// [`RenderQueue`].
267    ///
268    /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
269    /// allocated does not have enough capacity to hold `max_count` elements, a new GPU-side buffer is created.
270    ///
271    /// Returns `None` if there is no allocated GPU-side buffer, and `max_count` is 0.
272    ///
273    /// [`push`]: Self::push
274    /// [`write_buffer`]: Self::write_buffer
275    #[inline]
276    pub fn get_writer<'a>(
277        &'a mut self,
278        max_count: usize,
279        device: &RenderDevice,
280        queue: &'a RenderQueue,
281    ) -> Option<DynamicUniformBufferWriter<'a, T>> {
282        let alignment = if cfg!(feature = "ios_simulator") {
283            // On iOS simulator on silicon macs, metal validation check that the host OS alignment
284            // is respected, but the device reports the correct value for iOS, which is smaller.
285            // Use the larger value.
286            // See https://github.com/bevyengine/bevy/pull/10178 - remove if it's not needed anymore.
287            AlignmentValue::new(256)
288        } else {
289            AlignmentValue::new(device.limits().min_uniform_buffer_offset_alignment as u64)
290        };
291
292        let mut capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
293        let size = alignment
294            .round_up(T::min_size().get())
295            .checked_mul(max_count as u64)
296            .unwrap();
297
298        if capacity < size || (self.changed && size > 0) {
299            let buffer = device.create_buffer(&BufferDescriptor {
300                label: self.label.as_deref(),
301                usage: self.buffer_usage,
302                size,
303                mapped_at_creation: false,
304            });
305            capacity = buffer.size();
306            self.buffer = Some(buffer);
307            self.changed = false;
308        }
309
310        if let Some(buffer) = self.buffer.as_deref() {
311            let buffer_view = queue
312                .write_buffer_with(buffer, 0, NonZero::<u64>::new(buffer.size())?)
313                .unwrap();
314            Some(DynamicUniformBufferWriter {
315                buffer: encase::DynamicUniformBuffer::new_with_alignment(
316                    QueueWriteBufferViewWrapper {
317                        capacity: capacity as usize,
318                        buffer_view,
319                    },
320                    alignment.get(),
321                ),
322                _marker: PhantomData,
323            })
324        } else {
325            None
326        }
327    }
328
329    /// Queues writing of data from system RAM to VRAM using the [`RenderDevice`]
330    /// and the provided [`RenderQueue`].
331    ///
332    /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
333    /// allocated does not have enough capacity, a new GPU-side buffer is created.
334    #[inline]
335    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
336        let capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
337        let size = self.scratch.as_ref().len() as u64;
338
339        if capacity < size || (self.changed && size > 0) {
340            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
341                label: self.label.as_deref(),
342                usage: self.buffer_usage,
343                contents: self.scratch.as_ref(),
344            }));
345            self.changed = false;
346        } else if let Some(buffer) = &self.buffer {
347            queue.write_buffer(buffer, 0, self.scratch.as_ref());
348        }
349    }
350
351    #[inline]
352    pub fn clear(&mut self) {
353        self.scratch.as_mut().clear();
354        self.scratch.set_offset(0);
355    }
356}
357
358/// A writer that can be used to directly write elements into the target buffer.
359///
360/// For more information, see [`DynamicUniformBuffer::get_writer`].
361pub struct DynamicUniformBufferWriter<'a, T> {
362    buffer: encase::DynamicUniformBuffer<QueueWriteBufferViewWrapper<'a>>,
363    _marker: PhantomData<fn() -> T>,
364}
365
366impl<'a, T: ShaderType + WriteInto> DynamicUniformBufferWriter<'a, T> {
367    pub fn write(&mut self, value: &T) -> u32 {
368        self.buffer.write(value).unwrap() as u32
369    }
370}
371
372/// A wrapper to work around the orphan rule so that [`wgpu::QueueWriteBufferView`] can  implement
373/// [`BufferMut`].
374struct QueueWriteBufferViewWrapper<'a> {
375    buffer_view: wgpu::QueueWriteBufferView<'a>,
376    // Must be kept separately and cannot be retrieved from buffer_view, as the read-only access will
377    // invoke a panic.
378    capacity: usize,
379}
380
381impl<'a> BufferMut for QueueWriteBufferViewWrapper<'a> {
382    #[inline]
383    fn capacity(&self) -> usize {
384        self.capacity
385    }
386
387    #[inline]
388    fn write<const N: usize>(&mut self, offset: usize, val: &[u8; N]) {
389        self.buffer_view.write(offset, val);
390    }
391
392    #[inline]
393    fn write_slice(&mut self, offset: usize, val: &[u8]) {
394        self.buffer_view.write_slice(offset, val);
395    }
396}
397
398impl<'a, T: ShaderType + WriteInto> IntoBinding<'a> for &'a DynamicUniformBuffer<T> {
399    #[inline]
400    fn into_binding(self) -> BindingResource<'a> {
401        self.binding().unwrap()
402    }
403}
bevy_render/render_resource/uniform_buffer.rs

bevy_render/render_resource/
uniform_buffer.rs
