mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-20 22:41:07 +01:00
Restore the buffer size changes
This commit is contained in:
1 parent
03f1b535ca
commit
27e7408f16
26 files changed
+422
-244
No files matched your search
@@ -95,8 +95,39 @@ impl WebGpuError for CreateBindGroupLayoutError {
|
||||
}
|
||||
}
|
||||
|
||||
//TODO: refactor this to move out `enum BindingError`.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
#[non_exhaustive]
|
||||
pub enum BindingError {
|
||||
#[error(transparent)]
|
||||
DestroyedResource(#[from] DestroyedResourceError),
|
||||
#[error("Buffer {buffer}: Binding with size {binding_size} at offset {offset} would overflow buffer size of {buffer_size}")]
|
||||
BindingRangeTooLarge {
|
||||
buffer: ResourceErrorIdent,
|
||||
offset: wgt::BufferAddress,
|
||||
binding_size: u64,
|
||||
buffer_size: u64,
|
||||
},
|
||||
#[error("Buffer {buffer}: Binding offset {offset} is greater than buffer size {buffer_size}")]
|
||||
BindingOffsetTooLarge {
|
||||
buffer: ResourceErrorIdent,
|
||||
offset: wgt::BufferAddress,
|
||||
buffer_size: u64,
|
||||
},
|
||||
}
|
||||
|
||||
impl WebGpuError for BindingError {
|
||||
fn webgpu_error_type(&self) -> ErrorType {
|
||||
match self {
|
||||
Self::DestroyedResource(e) => e.webgpu_error_type(),
|
||||
Self::BindingRangeTooLarge { .. } | Self::BindingOffsetTooLarge { .. } => {
|
||||
ErrorType::Validation
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: there may be additional variants here that can be extracted into
|
||||
// `BindingError`.
|
||||
#[derive(Clone, Debug, Error)]
|
||||
#[non_exhaustive]
|
||||
pub enum CreateBindGroupError {
|
||||
@@ -104,6 +135,8 @@ pub enum CreateBindGroupError {
|
||||
Device(#[from] DeviceError),
|
||||
#[error(transparent)]
|
||||
DestroyedResource(#[from] DestroyedResourceError),
|
||||
#[error(transparent)]
|
||||
BindingError(#[from] BindingError),
|
||||
#[error(
|
||||
"Binding count declared with at most {expected} items, but {actual} items were provided"
|
||||
)]
|
||||
@@ -114,12 +147,6 @@ pub enum CreateBindGroupError {
|
||||
BindingArrayLengthMismatch { actual: usize, expected: usize },
|
||||
#[error("Array binding provided zero elements")]
|
||||
BindingArrayZeroLength,
|
||||
#[error("The bound range {range:?} of {buffer} overflows its size ({size})")]
|
||||
BindingRangeTooLarge {
|
||||
buffer: ResourceErrorIdent,
|
||||
range: Range<wgt::BufferAddress>,
|
||||
size: u64,
|
||||
},
|
||||
#[error("Binding size {actual} of {buffer} is less than minimum {min}")]
|
||||
BindingSizeTooSmall {
|
||||
buffer: ResourceErrorIdent,
|
||||
@@ -234,6 +261,7 @@ impl WebGpuError for CreateBindGroupError {
|
||||
let e: &dyn WebGpuError = match self {
|
||||
Self::Device(e) => e,
|
||||
Self::DestroyedResource(e) => e,
|
||||
Self::BindingError(e) => e,
|
||||
Self::MissingBufferUsage(e) => e,
|
||||
Self::MissingTextureUsage(e) => e,
|
||||
Self::ResourceUsageCompatibility(e) => e,
|
||||
@@ -241,7 +269,6 @@ impl WebGpuError for CreateBindGroupError {
|
||||
Self::BindingArrayPartialLengthMismatch { .. }
|
||||
| Self::BindingArrayLengthMismatch { .. }
|
||||
| Self::BindingArrayZeroLength
|
||||
| Self::BindingRangeTooLarge { .. }
|
||||
| Self::BindingSizeTooSmall { .. }
|
||||
| Self::BindingsNumMismatch { .. }
|
||||
| Self::BindingZeroSize(_)
|
||||
|
||||
@@ -93,6 +93,7 @@ use core::{
|
||||
use arrayvec::ArrayVec;
|
||||
use thiserror::Error;
|
||||
|
||||
use wgpu_hal::ShouldBeNonZeroExt;
|
||||
use wgt::error::{ErrorType, WebGpuError};
|
||||
|
||||
use crate::{
|
||||
@@ -504,7 +505,7 @@ impl RenderBundleEncoder {
|
||||
buffer_id,
|
||||
index_format,
|
||||
offset,
|
||||
size,
|
||||
size: size.map(NonZeroU64::get),
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -602,13 +603,14 @@ fn set_pipeline(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// This function is duplicative of `render::set_index_buffer`.
|
||||
fn set_index_buffer(
|
||||
state: &mut State,
|
||||
buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
|
||||
buffer_id: id::Id<id::markers::Buffer>,
|
||||
index_format: wgt::IndexFormat,
|
||||
offset: u64,
|
||||
size: Option<NonZeroU64>,
|
||||
size: Option<wgt::BufferSizeOrZero>,
|
||||
) -> Result<(), RenderBundleErrorInner> {
|
||||
let buffer = buffer_guard.get(buffer_id).get()?;
|
||||
|
||||
@@ -620,28 +622,27 @@ fn set_index_buffer(
|
||||
buffer.same_device(&state.device)?;
|
||||
buffer.check_usage(wgt::BufferUsages::INDEX)?;
|
||||
|
||||
let end = match size {
|
||||
Some(s) => offset + s.get(),
|
||||
None => buffer.size,
|
||||
};
|
||||
let end = buffer.resolve_binding_size(offset, size)?;
|
||||
|
||||
state
|
||||
.buffer_memory_init_actions
|
||||
.extend(buffer.initialization_status.read().create_action(
|
||||
&buffer,
|
||||
offset..end,
|
||||
offset..end.get(),
|
||||
MemoryInitKind::NeedsInitializedMemory,
|
||||
));
|
||||
state.set_index_buffer(buffer, index_format, offset..end);
|
||||
state.set_index_buffer(buffer, index_format, offset..end.get());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// This function is duplicative of `render::set_vertex_buffer`.
|
||||
fn set_vertex_buffer(
|
||||
state: &mut State,
|
||||
buffer_guard: &crate::storage::Storage<Fallible<Buffer>>,
|
||||
slot: u32,
|
||||
buffer_id: id::Id<id::markers::Buffer>,
|
||||
offset: u64,
|
||||
size: Option<NonZeroU64>,
|
||||
size: Option<wgt::BufferSizeOrZero>,
|
||||
) -> Result<(), RenderBundleErrorInner> {
|
||||
let max_vertex_buffers = state.device.limits.max_vertex_buffers;
|
||||
if slot >= max_vertex_buffers {
|
||||
@@ -662,18 +663,16 @@ fn set_vertex_buffer(
|
||||
buffer.same_device(&state.device)?;
|
||||
buffer.check_usage(wgt::BufferUsages::VERTEX)?;
|
||||
|
||||
let end = match size {
|
||||
Some(s) => offset + s.get(),
|
||||
None => buffer.size,
|
||||
};
|
||||
let end = buffer.resolve_binding_size(offset, size)?;
|
||||
|
||||
state
|
||||
.buffer_memory_init_actions
|
||||
.extend(buffer.initialization_status.read().create_action(
|
||||
&buffer,
|
||||
offset..end,
|
||||
offset..end.get(),
|
||||
MemoryInitKind::NeedsInitializedMemory,
|
||||
));
|
||||
state.vertex[slot as usize] = Some(VertexState::new(buffer, offset..end));
|
||||
state.vertex[slot as usize] = Some(VertexState::new(buffer, offset..end.get()));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -965,10 +964,14 @@ impl RenderBundle {
|
||||
size,
|
||||
} => {
|
||||
let buffer = buffer.try_raw(snatch_guard)?;
|
||||
let bb = hal::BufferBinding {
|
||||
buffer,
|
||||
offset: *offset,
|
||||
size: *size,
|
||||
let bb = unsafe {
|
||||
// SAFETY: The binding size was checked against the buffer size
|
||||
// in `set_index_buffer` and again in `IndexState::flush`.
|
||||
hal::BufferBinding::new_unchecked(
|
||||
buffer,
|
||||
*offset,
|
||||
size.expect("size was resolved in `RenderBundleEncoder::finish`"),
|
||||
)
|
||||
};
|
||||
unsafe { raw.set_index_buffer(bb, *index_format) };
|
||||
}
|
||||
@@ -979,10 +982,14 @@ impl RenderBundle {
|
||||
size,
|
||||
} => {
|
||||
let buffer = buffer.try_raw(snatch_guard)?;
|
||||
let bb = hal::BufferBinding {
|
||||
buffer,
|
||||
offset: *offset,
|
||||
size: *size,
|
||||
let bb = unsafe {
|
||||
// SAFETY: The binding size was checked against the buffer size
|
||||
// in `set_vertex_buffer` and again in `VertexState::flush`.
|
||||
hal::BufferBinding::new_unchecked(
|
||||
buffer,
|
||||
*offset,
|
||||
size.expect("size was resolved in `RenderBundleEncoder::finish`"),
|
||||
)
|
||||
};
|
||||
unsafe { raw.set_vertex_buffer(*slot, bb) };
|
||||
}
|
||||
@@ -1131,6 +1138,9 @@ crate::impl_trackable!(RenderBundle);
|
||||
/// [`RenderBundleEncoder::finish`] records the currently set index buffer here,
|
||||
/// and calls [`State::flush_index`] before any indexed draw command to produce
|
||||
/// a `SetIndexBuffer` command if one is necessary.
|
||||
///
|
||||
/// Binding ranges must be validated against the size of the buffer before
|
||||
/// being stored in `IndexState`.
|
||||
#[derive(Debug)]
|
||||
struct IndexState {
|
||||
buffer: Arc<Buffer>,
|
||||
@@ -1152,13 +1162,21 @@ impl IndexState {
|
||||
/// Generate a `SetIndexBuffer` command to prepare for an indexed draw
|
||||
/// command, if needed.
|
||||
fn flush(&mut self) -> Option<ArcRenderCommand> {
|
||||
// This was all checked before, but let's check again just in case.
|
||||
let binding_size = self
|
||||
.range
|
||||
.end
|
||||
.checked_sub(self.range.start)
|
||||
.filter(|_| self.range.end <= self.buffer.size)
|
||||
.expect("index range must be contained in buffer");
|
||||
|
||||
if self.is_dirty {
|
||||
self.is_dirty = false;
|
||||
Some(ArcRenderCommand::SetIndexBuffer {
|
||||
buffer: self.buffer.clone(),
|
||||
index_format: self.format,
|
||||
offset: self.range.start,
|
||||
size: wgt::BufferSize::new(self.range.end - self.range.start),
|
||||
size: Some(binding_size),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
@@ -1174,6 +1192,9 @@ impl IndexState {
|
||||
/// calls this type's [`flush`] method just before any draw command to
|
||||
/// produce a `SetVertexBuffer` commands if one is necessary.
|
||||
///
|
||||
/// Binding ranges must be validated against the size of the buffer before
|
||||
/// being stored in `VertexState`.
|
||||
///
|
||||
/// [`flush`]: IndexState::flush
|
||||
#[derive(Debug)]
|
||||
struct VertexState {
|
||||
@@ -1183,6 +1204,9 @@ struct VertexState {
|
||||
}
|
||||
|
||||
impl VertexState {
|
||||
/// Create a new `VertexState`.
|
||||
///
|
||||
/// The `range` must be contained within `buffer`.
|
||||
fn new(buffer: Arc<Buffer>, range: Range<wgt::BufferAddress>) -> Self {
|
||||
Self {
|
||||
buffer,
|
||||
@@ -1195,13 +1219,20 @@ impl VertexState {
|
||||
///
|
||||
/// `slot` is the index of the vertex buffer slot that `self` tracks.
|
||||
fn flush(&mut self, slot: u32) -> Option<ArcRenderCommand> {
|
||||
let binding_size = self
|
||||
.range
|
||||
.end
|
||||
.checked_sub(self.range.start)
|
||||
.filter(|_| self.range.end <= self.buffer.size)
|
||||
.expect("vertex range must be contained in buffer");
|
||||
|
||||
if self.is_dirty {
|
||||
self.is_dirty = false;
|
||||
Some(ArcRenderCommand::SetVertexBuffer {
|
||||
slot,
|
||||
buffer: self.buffer.clone(),
|
||||
offset: self.range.start,
|
||||
size: wgt::BufferSize::new(self.range.end - self.range.start),
|
||||
size: Some(binding_size),
|
||||
})
|
||||
} else {
|
||||
None
|
||||
@@ -1565,7 +1596,7 @@ where
|
||||
pub mod bundle_ffi {
|
||||
use super::{RenderBundleEncoder, RenderCommand};
|
||||
use crate::{id, RawString};
|
||||
use core::{convert::TryInto, slice};
|
||||
use core::{convert::TryInto, num::NonZeroU64, slice};
|
||||
use wgt::{BufferAddress, BufferSize, DynamicOffset, IndexFormat};
|
||||
|
||||
/// # Safety
|
||||
@@ -1624,7 +1655,7 @@ pub mod bundle_ffi {
|
||||
slot,
|
||||
buffer_id,
|
||||
offset,
|
||||
size,
|
||||
size: size.map(NonZeroU64::get),
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@ use wgt::error::{ErrorType, WebGpuError};
|
||||
use super::bind::BinderError;
|
||||
use crate::command::pass;
|
||||
use crate::{
|
||||
binding_model::{LateMinBufferBindingSizeMismatch, PushConstantUploadError},
|
||||
binding_model::{BindingError, LateMinBufferBindingSizeMismatch, PushConstantUploadError},
|
||||
resource::{
|
||||
DestroyedResourceError, MissingBufferUsageError, MissingTextureUsageError,
|
||||
ResourceErrorIdent,
|
||||
@@ -89,6 +89,8 @@ pub enum RenderCommandError {
|
||||
MissingTextureUsage(#[from] MissingTextureUsageError),
|
||||
#[error(transparent)]
|
||||
PushConstants(#[from] PushConstantUploadError),
|
||||
#[error(transparent)]
|
||||
BindingError(#[from] BindingError),
|
||||
#[error("Viewport size {{ w: {w}, h: {h} }} greater than device's requested `max_texture_dimension_2d` limit {max}, or less than zero")]
|
||||
InvalidViewportRectSize { w: f32, h: f32, max: u32 },
|
||||
#[error("Viewport has invalid rect {rect:?} for device's requested `max_texture_dimension_2d` limit; Origin less than -2 * `max_texture_dimension_2d` ({min}), or rect extends past 2 * `max_texture_dimension_2d` - 1 ({max})")]
|
||||
@@ -110,6 +112,7 @@ impl WebGpuError for RenderCommandError {
|
||||
Self::MissingBufferUsage(e) => e,
|
||||
Self::MissingTextureUsage(e) => e,
|
||||
Self::PushConstants(e) => e,
|
||||
Self::BindingError(e) => e,
|
||||
|
||||
Self::BindGroupIndexOutOfRange { .. }
|
||||
| Self::VertexBufferIndexOutOfRange { .. }
|
||||
|
||||
@@ -1,12 +1,17 @@
|
||||
use alloc::{borrow::Cow, sync::Arc, vec::Vec};
|
||||
use core::{fmt, num::NonZeroU32, ops::Range, str};
|
||||
use core::{
|
||||
fmt,
|
||||
num::{NonZeroU32, NonZeroU64},
|
||||
str,
|
||||
};
|
||||
use hal::ShouldBeNonZeroExt;
|
||||
|
||||
use arrayvec::ArrayVec;
|
||||
use thiserror::Error;
|
||||
use wgt::{
|
||||
error::{ErrorType, WebGpuError},
|
||||
BufferAddress, BufferSize, BufferUsages, Color, DynamicOffset, IndexFormat, ShaderStages,
|
||||
TextureSelector, TextureUsages, TextureViewDimension, VertexStepMode,
|
||||
BufferAddress, BufferSize, BufferSizeOrZero, BufferUsages, Color, DynamicOffset, IndexFormat,
|
||||
ShaderStages, TextureSelector, TextureUsages, TextureViewDimension, VertexStepMode,
|
||||
};
|
||||
|
||||
use crate::command::{
|
||||
@@ -357,13 +362,17 @@ struct IndexState {
|
||||
}
|
||||
|
||||
impl IndexState {
|
||||
fn update_buffer(&mut self, range: Range<BufferAddress>, format: IndexFormat) {
|
||||
fn update_buffer<B: hal::DynBuffer + ?Sized>(
|
||||
&mut self,
|
||||
binding: &hal::BufferBinding<'_, B>,
|
||||
format: IndexFormat,
|
||||
) {
|
||||
self.buffer_format = Some(format);
|
||||
let shift = match format {
|
||||
IndexFormat::Uint16 => 1,
|
||||
IndexFormat::Uint32 => 2,
|
||||
};
|
||||
self.limit = (range.end - range.start) >> shift;
|
||||
self.limit = binding.size.get() >> shift;
|
||||
}
|
||||
|
||||
fn reset(&mut self) {
|
||||
@@ -2323,13 +2332,14 @@ fn set_pipeline(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// This function is duplicative of `bundle::set_index_buffer`.
|
||||
fn set_index_buffer(
|
||||
state: &mut State,
|
||||
cmd_buf: &Arc<CommandBuffer>,
|
||||
buffer: Arc<crate::resource::Buffer>,
|
||||
index_format: IndexFormat,
|
||||
offset: u64,
|
||||
size: Option<BufferSize>,
|
||||
size: Option<BufferSizeOrZero>,
|
||||
) -> Result<(), RenderPassErrorInner> {
|
||||
api_log!("RenderPass::set_index_buffer {}", buffer.error_ident());
|
||||
|
||||
@@ -2342,40 +2352,34 @@ fn set_index_buffer(
|
||||
buffer.same_device_as(cmd_buf.as_ref())?;
|
||||
|
||||
buffer.check_usage(BufferUsages::INDEX)?;
|
||||
let buf_raw = buffer.try_raw(state.general.snatch_guard)?;
|
||||
|
||||
let end = match size {
|
||||
Some(s) => offset + s.get(),
|
||||
None => buffer.size,
|
||||
};
|
||||
state.index.update_buffer(offset..end, index_format);
|
||||
let binding = buffer
|
||||
.binding(offset, size, state.general.snatch_guard)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
state.index.update_buffer(&binding, index_format);
|
||||
|
||||
state.general.buffer_memory_init_actions.extend(
|
||||
buffer.initialization_status.read().create_action(
|
||||
&buffer,
|
||||
offset..end,
|
||||
offset..(offset + binding.size.get()),
|
||||
MemoryInitKind::NeedsInitializedMemory,
|
||||
),
|
||||
);
|
||||
|
||||
let bb = hal::BufferBinding {
|
||||
buffer: buf_raw,
|
||||
offset,
|
||||
size,
|
||||
};
|
||||
unsafe {
|
||||
hal::DynCommandEncoder::set_index_buffer(state.general.raw_encoder, bb, index_format);
|
||||
hal::DynCommandEncoder::set_index_buffer(state.general.raw_encoder, binding, index_format);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// This function is duplicative of `render::set_vertex_buffer`.
|
||||
fn set_vertex_buffer(
|
||||
state: &mut State,
|
||||
cmd_buf: &Arc<CommandBuffer>,
|
||||
slot: u32,
|
||||
buffer: Arc<crate::resource::Buffer>,
|
||||
offset: u64,
|
||||
size: Option<BufferSize>,
|
||||
size: Option<BufferSizeOrZero>,
|
||||
) -> Result<(), RenderPassErrorInner> {
|
||||
api_log!(
|
||||
"RenderPass::set_vertex_buffer {slot} {}",
|
||||
@@ -2400,30 +2404,22 @@ fn set_vertex_buffer(
|
||||
}
|
||||
|
||||
buffer.check_usage(BufferUsages::VERTEX)?;
|
||||
let buf_raw = buffer.try_raw(state.general.snatch_guard)?;
|
||||
|
||||
//TODO: where are we checking that the offset is in bound?
|
||||
let buffer_size = match size {
|
||||
Some(s) => s.get(),
|
||||
None => buffer.size - offset,
|
||||
};
|
||||
state.vertex.buffer_sizes[slot as usize] = Some(buffer_size);
|
||||
let binding = buffer
|
||||
.binding(offset, size, state.general.snatch_guard)
|
||||
.map_err(RenderCommandError::from)?;
|
||||
state.vertex.buffer_sizes[slot as usize] = Some(binding.size.get());
|
||||
|
||||
state.general.buffer_memory_init_actions.extend(
|
||||
buffer.initialization_status.read().create_action(
|
||||
&buffer,
|
||||
offset..(offset + buffer_size),
|
||||
offset..(offset + binding.size.get()),
|
||||
MemoryInitKind::NeedsInitializedMemory,
|
||||
),
|
||||
);
|
||||
|
||||
let bb = hal::BufferBinding {
|
||||
buffer: buf_raw,
|
||||
offset,
|
||||
size,
|
||||
};
|
||||
unsafe {
|
||||
hal::DynCommandEncoder::set_vertex_buffer(state.general.raw_encoder, slot, bb);
|
||||
hal::DynCommandEncoder::set_vertex_buffer(state.general.raw_encoder, slot, binding);
|
||||
}
|
||||
if let Some(pipeline) = state.pipeline.as_ref() {
|
||||
state.vertex.update_limits(&pipeline.vertex_steps);
|
||||
@@ -3094,7 +3090,7 @@ impl Global {
|
||||
buffer: pass_try!(base, scope, self.resolve_render_pass_buffer_id(buffer_id)),
|
||||
index_format,
|
||||
offset,
|
||||
size,
|
||||
size: size.map(NonZeroU64::get),
|
||||
});
|
||||
|
||||
Ok(())
|
||||
@@ -3115,7 +3111,7 @@ impl Global {
|
||||
slot,
|
||||
buffer: pass_try!(base, scope, self.resolve_render_pass_buffer_id(buffer_id)),
|
||||
offset,
|
||||
size,
|
||||
size: size.map(NonZeroU64::get),
|
||||
});
|
||||
|
||||
Ok(())
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
use alloc::sync::Arc;
|
||||
|
||||
use wgt::{BufferAddress, BufferSize, Color};
|
||||
use wgt::{BufferAddress, BufferSizeOrZero, Color};
|
||||
|
||||
use super::{Rect, RenderBundle};
|
||||
use crate::{
|
||||
@@ -24,13 +24,13 @@ pub enum RenderCommand {
|
||||
buffer_id: id::BufferId,
|
||||
index_format: wgt::IndexFormat,
|
||||
offset: BufferAddress,
|
||||
size: Option<BufferSize>,
|
||||
size: Option<BufferSizeOrZero>,
|
||||
},
|
||||
SetVertexBuffer {
|
||||
slot: u32,
|
||||
buffer_id: id::BufferId,
|
||||
offset: BufferAddress,
|
||||
size: Option<BufferSize>,
|
||||
size: Option<BufferSizeOrZero>,
|
||||
},
|
||||
SetBlendConstant(Color),
|
||||
SetStencilReference(u32),
|
||||
@@ -392,6 +392,17 @@ impl RenderCommand {
|
||||
}
|
||||
|
||||
/// Equivalent to `RenderCommand` with the Ids resolved into resource Arcs.
|
||||
///
|
||||
/// In a render pass, commands are stored in this format between when they are
|
||||
/// added to the pass, and when the pass is `end()`ed and the commands are
|
||||
/// replayed to the HAL encoder. Validation occurs when the pass is ended, which
|
||||
/// means that parameters stored in an `ArcRenderCommand` for a pass operation
|
||||
/// have generally not been validated.
|
||||
///
|
||||
/// In a render bundle, commands are stored in this format between when the bundle
|
||||
/// is `finish()`ed and when the bundle is executed. Validation occurs when the
|
||||
/// bundle is finished, which means that parameters stored in an `ArcRenderCommand`
|
||||
/// for a render bundle operation must have been validated.
|
||||
#[doc(hidden)]
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum ArcRenderCommand {
|
||||
@@ -405,13 +416,20 @@ pub enum ArcRenderCommand {
|
||||
buffer: Arc<Buffer>,
|
||||
index_format: wgt::IndexFormat,
|
||||
offset: BufferAddress,
|
||||
size: Option<BufferSize>,
|
||||
|
||||
// For a render pass, this reflects the argument passed by the
|
||||
// application, which may be `None`. For a finished render bundle, this
|
||||
// reflects the validated size of the binding, and will be populated
|
||||
// even in the case that the application omitted the size.
|
||||
size: Option<BufferSizeOrZero>,
|
||||
},
|
||||
SetVertexBuffer {
|
||||
slot: u32,
|
||||
buffer: Arc<Buffer>,
|
||||
offset: BufferAddress,
|
||||
size: Option<BufferSize>,
|
||||
|
||||
// See comment in `SetIndexBuffer`.
|
||||
size: Option<BufferSizeOrZero>,
|
||||
},
|
||||
SetBlendConstant(Color),
|
||||
SetStencilReference(u32),
|
||||
|
||||
@@ -385,6 +385,7 @@ impl Global {
|
||||
/// - `hal_buffer` must be created from `device_id` corresponding raw handle.
|
||||
/// - `hal_buffer` must be created respecting `desc`
|
||||
/// - `hal_buffer` must be initialized
|
||||
/// - `hal_buffer` must not have zero size.
|
||||
pub unsafe fn create_buffer_from_hal<A: HalApi>(
|
||||
&self,
|
||||
hal_buffer: A::Buffer,
|
||||
@@ -406,7 +407,7 @@ impl Global {
|
||||
trace.add(trace::Action::CreateBuffer(fid.id(), desc.clone()));
|
||||
}
|
||||
|
||||
let (buffer, err) = device.create_buffer_from_hal(Box::new(hal_buffer), desc);
|
||||
let (buffer, err) = unsafe { device.create_buffer_from_hal(Box::new(hal_buffer), desc) };
|
||||
|
||||
let id = fid.assign(buffer);
|
||||
api_log!("Device::create_buffer -> {id:?}");
|
||||
|
||||
@@ -8,9 +8,10 @@ use alloc::{
|
||||
use core::{
|
||||
fmt,
|
||||
mem::{self, ManuallyDrop},
|
||||
num::NonZeroU32,
|
||||
num::{NonZeroU32, NonZeroU64},
|
||||
sync::atomic::{AtomicBool, Ordering},
|
||||
};
|
||||
use hal::ShouldBeNonZeroExt;
|
||||
|
||||
use arrayvec::ArrayVec;
|
||||
use bitflags::Flags;
|
||||
@@ -702,7 +703,8 @@ impl Device {
|
||||
let buffer = unsafe { self.raw().create_buffer(&hal_desc) }
|
||||
.map_err(|e| self.handle_hal_error_with_nonfatal_oom(e))?;
|
||||
|
||||
let timestamp_normalization_bind_group = Snatchable::new(
|
||||
let timestamp_normalization_bind_group = Snatchable::new(unsafe {
|
||||
// SAFETY: The size passed here must not overflow the buffer.
|
||||
self.timestamp_normalizer
|
||||
.get()
|
||||
.unwrap()
|
||||
@@ -710,10 +712,10 @@ impl Device {
|
||||
self,
|
||||
&*buffer,
|
||||
desc.label.as_deref(),
|
||||
desc.size,
|
||||
wgt::BufferSize::new(hal_desc.size).unwrap(),
|
||||
desc.usage,
|
||||
)?,
|
||||
);
|
||||
)
|
||||
}?);
|
||||
|
||||
let indirect_validation_bind_groups =
|
||||
self.create_indirect_validation_bind_groups(buffer.as_ref(), desc.size, desc.usage)?;
|
||||
@@ -809,28 +811,36 @@ impl Device {
|
||||
Ok(texture)
|
||||
}
|
||||
|
||||
pub(crate) fn create_buffer_from_hal(
|
||||
/// # Safety
|
||||
///
|
||||
/// - `hal_buffer` must have been created on this device.
|
||||
/// - `hal_buffer` must have been created respecting `desc` (in particular, the size).
|
||||
/// - `hal_buffer` must be initialized.
|
||||
/// - `hal_buffer` must not have zero size.
|
||||
pub(crate) unsafe fn create_buffer_from_hal(
|
||||
self: &Arc<Self>,
|
||||
hal_buffer: Box<dyn hal::DynBuffer>,
|
||||
desc: &resource::BufferDescriptor,
|
||||
) -> (Fallible<Buffer>, Option<resource::CreateBufferError>) {
|
||||
let timestamp_normalization_bind_group = match self
|
||||
.timestamp_normalizer
|
||||
.get()
|
||||
.unwrap()
|
||||
.create_normalization_bind_group(
|
||||
self,
|
||||
&*hal_buffer,
|
||||
desc.label.as_deref(),
|
||||
desc.size,
|
||||
desc.usage,
|
||||
) {
|
||||
Ok(bg) => Snatchable::new(bg),
|
||||
Err(e) => {
|
||||
return (
|
||||
Fallible::Invalid(Arc::new(desc.label.to_string())),
|
||||
Some(e.into()),
|
||||
)
|
||||
let timestamp_normalization_bind_group = unsafe {
|
||||
match self
|
||||
.timestamp_normalizer
|
||||
.get()
|
||||
.unwrap()
|
||||
.create_normalization_bind_group(
|
||||
self,
|
||||
&*hal_buffer,
|
||||
desc.label.as_deref(),
|
||||
wgt::BufferSize::new(desc.size).unwrap(),
|
||||
desc.usage,
|
||||
) {
|
||||
Ok(bg) => Snatchable::new(bg),
|
||||
Err(e) => {
|
||||
return (
|
||||
Fallible::Invalid(Arc::new(desc.label.to_string())),
|
||||
Some(e.into()),
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
@@ -2187,31 +2197,9 @@ impl Device {
|
||||
buffer.same_device(self)?;
|
||||
|
||||
buffer.check_usage(pub_usage)?;
|
||||
let raw_buffer = buffer.try_raw(snatch_guard)?;
|
||||
|
||||
let (bind_size, bind_end) = match bb.size {
|
||||
Some(size) => {
|
||||
let end = bb.offset + size.get();
|
||||
if end > buffer.size {
|
||||
return Err(Error::BindingRangeTooLarge {
|
||||
buffer: buffer.error_ident(),
|
||||
range: bb.offset..end,
|
||||
size: buffer.size,
|
||||
});
|
||||
}
|
||||
(size.get(), end)
|
||||
}
|
||||
None => {
|
||||
if buffer.size < bb.offset {
|
||||
return Err(Error::BindingRangeTooLarge {
|
||||
buffer: buffer.error_ident(),
|
||||
range: bb.offset..bb.offset,
|
||||
size: buffer.size,
|
||||
});
|
||||
}
|
||||
(buffer.size - bb.offset, buffer.size)
|
||||
}
|
||||
};
|
||||
let bb = buffer.binding(bb.offset, bb.size.map(NonZeroU64::get), snatch_guard)?;
|
||||
let bind_size = bb.size.get();
|
||||
|
||||
if bind_size > range_limit as u64 {
|
||||
return Err(Error::BufferRangeTooLarge {
|
||||
@@ -2226,8 +2214,8 @@ impl Device {
|
||||
dynamic_binding_info.push(binding_model::BindGroupDynamicBindingData {
|
||||
binding_idx: binding,
|
||||
buffer_size: buffer.size,
|
||||
binding_range: bb.offset..bind_end,
|
||||
maximum_dynamic_offset: buffer.size - bind_end,
|
||||
binding_range: bb.offset..bb.offset + bind_size,
|
||||
maximum_dynamic_offset: buffer.size - bb.offset - bind_size,
|
||||
binding_type: binding_ty,
|
||||
});
|
||||
}
|
||||
@@ -2265,11 +2253,7 @@ impl Device {
|
||||
MemoryInitKind::NeedsInitializedMemory,
|
||||
));
|
||||
|
||||
Ok(hal::BufferBinding {
|
||||
buffer: raw_buffer,
|
||||
offset: bb.offset,
|
||||
size: bb.size,
|
||||
})
|
||||
Ok(bb)
|
||||
}
|
||||
|
||||
fn create_sampler_binding<'a>(
|
||||
|
||||
@@ -232,10 +232,9 @@ impl Dispatch {
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
}],
|
||||
buffers: &[hal::BufferBinding {
|
||||
buffer: dst_buffer.as_ref(),
|
||||
offset: 0,
|
||||
size: Some(DST_BUFFER_SIZE),
|
||||
buffers: &[unsafe {
|
||||
// SAFETY: We just created the buffer with this size.
|
||||
hal::BufferBinding::new_unchecked(dst_buffer.as_ref(), 0, DST_BUFFER_SIZE)
|
||||
}],
|
||||
samplers: &[],
|
||||
textures: &[],
|
||||
@@ -278,10 +277,9 @@ impl Dispatch {
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
}],
|
||||
buffers: &[hal::BufferBinding {
|
||||
buffer,
|
||||
offset: 0,
|
||||
size: Some(binding_size),
|
||||
buffers: &[unsafe {
|
||||
// SAFETY: We calculated the binding size to fit within the buffer.
|
||||
hal::BufferBinding::new_unchecked(buffer, 0, binding_size)
|
||||
}],
|
||||
samplers: &[],
|
||||
textures: &[],
|
||||
|
||||
@@ -135,10 +135,9 @@ impl Draw {
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
}],
|
||||
buffers: &[hal::BufferBinding {
|
||||
buffer,
|
||||
offset: 0,
|
||||
size: Some(binding_size),
|
||||
buffers: &[unsafe {
|
||||
// SAFETY: We calculated the binding size to fit within the buffer.
|
||||
hal::BufferBinding::new_unchecked(buffer, 0, binding_size)
|
||||
}],
|
||||
samplers: &[],
|
||||
textures: &[],
|
||||
@@ -684,10 +683,9 @@ fn create_buffer_and_bind_group(
|
||||
resource_index: 0,
|
||||
count: 1,
|
||||
}],
|
||||
buffers: &[hal::BufferBinding {
|
||||
buffer: buffer.as_ref(),
|
||||
offset: 0,
|
||||
size: Some(BUFFER_SIZE),
|
||||
buffers: &[unsafe {
|
||||
// SAFETY: We just created the buffer with this size.
|
||||
hal::BufferBinding::new_unchecked(buffer.as_ref(), 0, BUFFER_SIZE)
|
||||
}],
|
||||
samplers: &[],
|
||||
textures: &[],
|
||||
|
||||
@@ -17,7 +17,7 @@ use wgt::{
|
||||
#[cfg(feature = "trace")]
|
||||
use crate::device::trace;
|
||||
use crate::{
|
||||
binding_model::BindGroup,
|
||||
binding_model::{BindGroup, BindingError},
|
||||
device::{
|
||||
queue, resource::DeferredDestroy, BufferMapPendingClosure, Device, DeviceError,
|
||||
DeviceMismatch, HostMap, MissingDownlevelFlags, MissingFeatures,
|
||||
@@ -494,6 +494,81 @@ impl Buffer {
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve the size of a binding for buffer with `offset` and `size`.
|
||||
///
|
||||
/// If `size` is `None`, then the remainder of the buffer starting from
|
||||
/// `offset` is used.
|
||||
///
|
||||
/// If the binding would overflow the buffer, then an error is returned.
|
||||
///
|
||||
/// Zero-size bindings are permitted here for historical reasons. Although
|
||||
/// zero-size bindings are permitted by WebGPU, they are not permitted by
|
||||
/// some backends. See [`Buffer::binding`] and
|
||||
/// [#3170](https://github.com/gfx-rs/wgpu/issues/3170).
|
||||
pub fn resolve_binding_size(
|
||||
&self,
|
||||
offset: wgt::BufferAddress,
|
||||
binding_size: Option<wgt::BufferSizeOrZero>,
|
||||
) -> Result<wgt::BufferSizeOrZero, BindingError> {
|
||||
let buffer_size = self.size;
|
||||
|
||||
match binding_size {
|
||||
Some(binding_size) => match offset.checked_add(binding_size) {
|
||||
Some(end) if end <= buffer_size => Ok(binding_size),
|
||||
_ => Err(BindingError::BindingRangeTooLarge {
|
||||
buffer: self.error_ident(),
|
||||
offset,
|
||||
binding_size,
|
||||
buffer_size,
|
||||
}),
|
||||
},
|
||||
None => {
|
||||
buffer_size
|
||||
.checked_sub(offset)
|
||||
.ok_or_else(|| BindingError::BindingOffsetTooLarge {
|
||||
buffer: self.error_ident(),
|
||||
offset,
|
||||
buffer_size,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new [`hal::BufferBinding`] for the buffer with `offset` and
|
||||
/// `size`.
|
||||
///
|
||||
/// If `size` is `None`, then the remainder of the buffer starting from
|
||||
/// `offset` is used.
|
||||
///
|
||||
/// If the binding would overflow the buffer, then an error is returned.
|
||||
///
|
||||
/// Zero-size bindings are permitted here for historical reasons. Although
|
||||
/// zero-size bindings are permitted by WebGPU, they are not permitted by
|
||||
/// some backends. Previous documentation for `hal::BufferBinding`
|
||||
/// disallowed zero-size bindings, but this restriction was not honored
|
||||
/// elsewhere in the code. Zero-size bindings need to be quashed or remapped
|
||||
/// to a non-zero size, either universally in wgpu-core, or in specific
|
||||
/// backends that do not support them. See
|
||||
/// [#3170](https://github.com/gfx-rs/wgpu/issues/3170).
|
||||
pub fn binding<'a>(
|
||||
&'a self,
|
||||
offset: wgt::BufferAddress,
|
||||
binding_size: Option<wgt::BufferSizeOrZero>,
|
||||
snatch_guard: &'a SnatchGuard,
|
||||
) -> Result<hal::BufferBinding<'a, dyn hal::DynBuffer>, BindingError> {
|
||||
let buf_raw = self.try_raw(snatch_guard)?;
|
||||
let resolved_size = self.resolve_binding_size(offset, binding_size)?;
|
||||
unsafe {
|
||||
// SAFETY: The offset and size passed to hal::BufferBinding::new_unchecked must
|
||||
// define a binding contained within the buffer.
|
||||
Ok(hal::BufferBinding::new_unchecked(
|
||||
buf_raw,
|
||||
offset,
|
||||
resolved_size,
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the mapping callback in case of error so that the callback can be fired outside
|
||||
/// of the locks that are held in this function.
|
||||
pub(crate) fn map_async(
|
||||
|
||||
@@ -242,12 +242,16 @@ impl TimestampNormalizer {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn create_normalization_bind_group(
|
||||
/// Create a bind group for normalizing timestamps in `buffer`.
|
||||
///
|
||||
/// This function is unsafe because it does not know that `buffer_size` is
|
||||
/// the true size of the buffer.
|
||||
pub unsafe fn create_normalization_bind_group(
|
||||
&self,
|
||||
device: &Device,
|
||||
buffer: &dyn hal::DynBuffer,
|
||||
buffer_label: Option<&str>,
|
||||
buffer_size: u64,
|
||||
buffer_size: wgt::BufferSize,
|
||||
buffer_usages: wgt::BufferUsages,
|
||||
) -> Result<TimestampNormalizationBindGroup, DeviceError> {
|
||||
unsafe {
|
||||
@@ -263,7 +267,7 @@ impl TimestampNormalizer {
|
||||
// at once to normalize the timestamps, we can't use it. We force the buffer to fail
|
||||
// to allocate. The lowest max binding size is 128MB, and query sets must be small
|
||||
// (no more than 4096), so this should never be hit in practice by sane programs.
|
||||
if buffer_size > device.adapter.limits().max_storage_buffer_binding_size as u64 {
|
||||
if buffer_size.get() > device.adapter.limits().max_storage_buffer_binding_size as u64 {
|
||||
return Err(DeviceError::OutOfMemory);
|
||||
}
|
||||
|
||||
@@ -282,11 +286,7 @@ impl TimestampNormalizer {
|
||||
.create_bind_group(&hal::BindGroupDescriptor {
|
||||
label: Some(label),
|
||||
layout: &*state.temporary_bind_group_layout,
|
||||
buffers: &[hal::BufferBinding {
|
||||
buffer,
|
||||
offset: 0,
|
||||
size: None,
|
||||
}],
|
||||
buffers: &[hal::BufferBinding::new_unchecked(buffer, 0, buffer_size)],
|
||||
samplers: &[],
|
||||
textures: &[],
|
||||
acceleration_structures: &[],
|
||||
|
||||
@@ -445,10 +445,9 @@ impl<A: hal::Api> Example<A> {
|
||||
let texture_view = unsafe { device.create_texture_view(&texture, &view_desc).unwrap() };
|
||||
|
||||
let global_group = {
|
||||
let global_buffer_binding = hal::BufferBinding {
|
||||
buffer: &global_buffer,
|
||||
offset: 0,
|
||||
size: None,
|
||||
let global_buffer_binding = unsafe {
|
||||
// SAFETY: This is the same size that was specified for buffer creation.
|
||||
hal::BufferBinding::new_unchecked(&global_buffer, 0, global_buffer_desc.size)
|
||||
};
|
||||
let texture_binding = hal::TextureBinding {
|
||||
view: &texture_view,
|
||||
@@ -483,10 +482,13 @@ impl<A: hal::Api> Example<A> {
|
||||
};
|
||||
|
||||
let local_group = {
|
||||
let local_buffer_binding = hal::BufferBinding {
|
||||
buffer: &local_buffer,
|
||||
offset: 0,
|
||||
size: wgpu_types::BufferSize::new(size_of::<Locals>() as _),
|
||||
let local_buffer_binding = unsafe {
|
||||
// SAFETY: The size must fit within the buffer.
|
||||
hal::BufferBinding::new_unchecked(
|
||||
&local_buffer,
|
||||
0,
|
||||
wgpu_types::BufferSize::new(size_of::<Locals>() as _).unwrap(),
|
||||
)
|
||||
};
|
||||
let local_group_desc = hal::BindGroupDescriptor {
|
||||
label: Some("local"),
|
||||
|
||||
@@ -603,10 +603,13 @@ impl<A: hal::Api> Example<A> {
|
||||
let texture_view = unsafe { device.create_texture_view(&texture, &view_desc).unwrap() };
|
||||
|
||||
let bind_group = {
|
||||
let buffer_binding = hal::BufferBinding {
|
||||
buffer: &uniform_buffer,
|
||||
offset: 0,
|
||||
size: None,
|
||||
let buffer_binding = unsafe {
|
||||
// SAFETY: The size matches the buffer allocation.
|
||||
hal::BufferBinding::new_unchecked(
|
||||
&uniform_buffer,
|
||||
0,
|
||||
wgpu_types::BufferSize::new_unchecked(uniforms_size as u64),
|
||||
)
|
||||
};
|
||||
let texture_binding = hal::TextureBinding {
|
||||
view: &texture_view,
|
||||
|
||||
@@ -1136,7 +1136,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
|
||||
) {
|
||||
let ibv = Direct3D12::D3D12_INDEX_BUFFER_VIEW {
|
||||
BufferLocation: binding.resolve_address(),
|
||||
SizeInBytes: binding.resolve_size() as u32,
|
||||
SizeInBytes: binding.size.try_into().unwrap(),
|
||||
Format: auxil::dxgi::conv::map_index_format(format),
|
||||
};
|
||||
|
||||
@@ -1149,7 +1149,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
|
||||
) {
|
||||
let vb = &mut self.pass.vertex_buffers[index as usize];
|
||||
vb.BufferLocation = binding.resolve_address();
|
||||
vb.SizeInBytes = binding.resolve_size() as u32;
|
||||
vb.SizeInBytes = binding.size.try_into().unwrap();
|
||||
self.pass.dirty_vertex_buffers |= 1 << index;
|
||||
}
|
||||
|
||||
|
||||
@@ -1442,7 +1442,7 @@ impl crate::Device for super::Device {
|
||||
let end = start + entry.count as usize;
|
||||
for data in &desc.buffers[start..end] {
|
||||
let gpu_address = data.resolve_address();
|
||||
let mut size = data.resolve_size() as u32;
|
||||
let mut size = data.size.try_into().unwrap();
|
||||
|
||||
if has_dynamic_offset {
|
||||
match ty {
|
||||
|
||||
@@ -865,13 +865,6 @@ unsafe impl Sync for Buffer {}
|
||||
impl crate::DynBuffer for Buffer {}
|
||||
|
||||
impl crate::BufferBinding<'_, Buffer> {
|
||||
fn resolve_size(&self) -> wgt::BufferAddress {
|
||||
match self.size {
|
||||
Some(size) => size.get(),
|
||||
None => self.buffer.size - self.offset,
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Return GPU handle directly?
|
||||
fn resolve_address(&self) -> wgt::BufferAddress {
|
||||
(unsafe { self.buffer.resource.GetGPUVirtualAddress() }) + self.offset
|
||||
|
||||
@@ -534,7 +534,6 @@ impl crate::Device for super::Device {
|
||||
return Ok(super::Buffer {
|
||||
raw: None,
|
||||
target,
|
||||
size: desc.size,
|
||||
map_flags: 0,
|
||||
data: Some(Arc::new(MaybeMutex::new(vec![0; desc.size as usize]))),
|
||||
offset_of_current_mapping: Arc::new(MaybeMutex::new(0)),
|
||||
@@ -634,7 +633,6 @@ impl crate::Device for super::Device {
|
||||
Ok(super::Buffer {
|
||||
raw,
|
||||
target,
|
||||
size: desc.size,
|
||||
map_flags,
|
||||
data,
|
||||
offset_of_current_mapping: Arc::new(MaybeMutex::new(0)),
|
||||
@@ -1263,13 +1261,11 @@ impl crate::Device for super::Device {
|
||||
let binding = match layout.ty {
|
||||
wgt::BindingType::Buffer { .. } => {
|
||||
let bb = &desc.buffers[entry.resource_index as usize];
|
||||
assert!(bb.size != 0, "zero-size bindings are not supported");
|
||||
super::RawBinding::Buffer {
|
||||
raw: bb.buffer.raw.unwrap(),
|
||||
offset: bb.offset as i32,
|
||||
size: match bb.size {
|
||||
Some(s) => s.get() as i32,
|
||||
None => (bb.buffer.size - bb.offset) as i32,
|
||||
},
|
||||
offset: bb.offset.try_into().unwrap(),
|
||||
size: bb.size.try_into().unwrap(),
|
||||
}
|
||||
}
|
||||
wgt::BindingType::Sampler { .. } => {
|
||||
|
||||
@@ -342,7 +342,6 @@ impl Drop for Queue {
|
||||
pub struct Buffer {
|
||||
raw: Option<glow::Buffer>,
|
||||
target: BindTarget,
|
||||
size: wgt::BufferAddress,
|
||||
map_flags: u32,
|
||||
data: Option<Arc<MaybeMutex<Vec<u8>>>>,
|
||||
offset_of_current_mapping: Arc<MaybeMutex<wgt::BufferAddress>>,
|
||||
|
||||
+83
-19
@@ -297,7 +297,7 @@ use core::{
|
||||
borrow::Borrow,
|
||||
error::Error,
|
||||
fmt,
|
||||
num::NonZeroU32,
|
||||
num::{NonZeroU32, NonZeroU64},
|
||||
ops::{Range, RangeInclusive},
|
||||
ptr::NonNull,
|
||||
};
|
||||
@@ -1968,11 +1968,18 @@ pub struct PipelineLayoutDescriptor<'a, B: DynBindGroupLayout + ?Sized> {
|
||||
///
|
||||
/// [`BindGroup`]: Api::BindGroup
|
||||
///
|
||||
/// ## Construction
|
||||
///
|
||||
/// The recommended way to construct a `BufferBinding` is using the `binding`
|
||||
/// method on a wgpu-core `Buffer`, which will validate the binding size
|
||||
/// against the buffer size. An unsafe `new_unchecked` constructor is also
|
||||
/// provided for cases where direct construction is necessary.
|
||||
///
|
||||
/// ## Accessible region
|
||||
///
|
||||
/// `wgpu_hal` guarantees that shaders compiled with
|
||||
/// [`ShaderModuleDescriptor::runtime_checks`] set to `true` cannot read or
|
||||
/// write data via this binding outside the *accessible region* of [`buffer`]:
|
||||
/// write data via this binding outside the *accessible region* of a buffer:
|
||||
///
|
||||
/// - The accessible region starts at [`offset`].
|
||||
///
|
||||
@@ -1992,39 +1999,47 @@ pub struct PipelineLayoutDescriptor<'a, B: DynBindGroupLayout + ?Sized> {
|
||||
/// parts of which buffers shaders might observe. This optimization is only
|
||||
/// sound if shader access is bounds-checked.
|
||||
///
|
||||
/// [`buffer`]: BufferBinding::buffer
|
||||
/// ## Zero-length bindings
|
||||
///
|
||||
/// Some back ends cannot tolerate zero-length regions; for example, see
|
||||
/// [VUID-VkDescriptorBufferInfo-offset-00340][340] and
|
||||
/// [VUID-VkDescriptorBufferInfo-range-00341][341], or the
|
||||
/// documentation for GLES's [glBindBufferRange][bbr]. This documentation
|
||||
/// previously stated that a `BufferBinding` must have `offset` strictly less
|
||||
/// than the size of the buffer, but this restriction was not honored elsewhere
|
||||
/// in the code, so has been removed. However, it remains the case that
|
||||
/// some backends do not support zero-length bindings, so additional
|
||||
/// logic is needed somewhere to handle this properly. See
|
||||
/// [#3170](https://github.com/gfx-rs/wgpu/issues/3170).
|
||||
///
|
||||
/// [`offset`]: BufferBinding::offset
|
||||
/// [`size`]: BufferBinding::size
|
||||
/// [`Storage`]: wgt::BufferBindingType::Storage
|
||||
/// [`Uniform`]: wgt::BufferBindingType::Uniform
|
||||
/// [340]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-offset-00340
|
||||
/// [341]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00341
|
||||
/// [bbr]: https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glBindBufferRange.xhtml
|
||||
/// [woob]: https://gpuweb.github.io/gpuweb/wgsl/#out-of-bounds-access-sec
|
||||
#[derive(Debug)]
|
||||
pub struct BufferBinding<'a, B: DynBuffer + ?Sized> {
|
||||
/// The buffer being bound.
|
||||
pub buffer: &'a B,
|
||||
///
|
||||
/// This is not fully `pub` to prevent direct construction of
|
||||
/// `BufferBinding`s, while still allowing public read access to the `offset`
|
||||
/// and `size` properties.
|
||||
pub(crate) buffer: &'a B,
|
||||
|
||||
/// The offset at which the bound region starts.
|
||||
///
|
||||
/// This must be less than the size of the buffer. Some back ends
|
||||
/// cannot tolerate zero-length regions; for example, see
|
||||
/// [VUID-VkDescriptorBufferInfo-offset-00340][340] and
|
||||
/// [VUID-VkDescriptorBufferInfo-range-00341][341], or the
|
||||
/// documentation for GLES's [glBindBufferRange][bbr].
|
||||
///
|
||||
/// [340]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-offset-00340
|
||||
/// [341]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-VkDescriptorBufferInfo-range-00341
|
||||
/// [bbr]: https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glBindBufferRange.xhtml
|
||||
/// This must be less or equal to the size of the buffer.
|
||||
pub offset: wgt::BufferAddress,
|
||||
|
||||
/// The size of the region bound, in bytes.
|
||||
///
|
||||
/// If `None`, the region extends from `offset` to the end of the
|
||||
/// buffer. Given the restrictions on `offset`, this means that
|
||||
/// the size is always greater than zero.
|
||||
pub size: Option<wgt::BufferSize>,
|
||||
pub size: wgt::BufferSizeOrZero,
|
||||
}
|
||||
|
||||
impl<'a, T: DynBuffer + ?Sized> Clone for BufferBinding<'a, T> {
|
||||
// We must implement this manually because `B` is not necessarily `Clone`.
|
||||
impl<B: DynBuffer + ?Sized> Clone for BufferBinding<'_, B> {
|
||||
fn clone(&self) -> Self {
|
||||
BufferBinding {
|
||||
buffer: self.buffer,
|
||||
@@ -2034,6 +2049,55 @@ impl<'a, T: DynBuffer + ?Sized> Clone for BufferBinding<'a, T> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Temporary convenience trait to let us call `.get()` on `u64`s in code that
|
||||
/// really wants to be using `NonZeroU64`.
|
||||
/// TODO(<https://github.com/gfx-rs/wgpu/issues/3170>): remove this
|
||||
pub trait ShouldBeNonZeroExt {
|
||||
fn get(&self) -> u64;
|
||||
}
|
||||
|
||||
impl ShouldBeNonZeroExt for NonZeroU64 {
|
||||
fn get(&self) -> u64 {
|
||||
NonZeroU64::get(*self)
|
||||
}
|
||||
}
|
||||
|
||||
impl ShouldBeNonZeroExt for u64 {
|
||||
fn get(&self) -> u64 {
|
||||
*self
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, B: DynBuffer + ?Sized> BufferBinding<'a, B> {
|
||||
/// Construct a `BufferBinding` with the given contents.
|
||||
///
|
||||
/// When possible, use the `binding` method on a wgpu-core `Buffer` instead
|
||||
/// of this method. `Buffer::binding` validates the size of the binding
|
||||
/// against the size of the buffer.
|
||||
///
|
||||
/// It is more difficult to provide a validating constructor here, due to
|
||||
/// not having direct access to the size of a `DynBuffer`.
|
||||
///
|
||||
/// SAFETY: The caller is responsible for ensuring that a binding of `size`
|
||||
/// bytes starting at `offset` is contained within the buffer.
|
||||
///
|
||||
/// The `S` type parameter is a temporary convenience to allow callers to
|
||||
/// pass either a `u64` or a `NonZeroU64`. When the zero-size binding issue
|
||||
/// is resolved, the argument should just match the type of the member.
|
||||
/// TODO(<https://github.com/gfx-rs/wgpu/issues/3170>): remove the parameter
|
||||
pub unsafe fn new_unchecked<S: Into<wgt::BufferSizeOrZero>>(
|
||||
buffer: &'a B,
|
||||
offset: wgt::BufferAddress,
|
||||
size: S,
|
||||
) -> Self {
|
||||
Self {
|
||||
buffer,
|
||||
offset,
|
||||
size: size.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct TextureBinding<'a, T: DynTextureView + ?Sized> {
|
||||
pub view: &'a T,
|
||||
|
||||
@@ -4,7 +4,7 @@ use alloc::{
|
||||
borrow::{Cow, ToOwned as _},
|
||||
vec::Vec,
|
||||
};
|
||||
use core::ops::Range;
|
||||
use core::{num::NonZeroU64, ops::Range};
|
||||
use metal::{
|
||||
MTLIndexType, MTLLoadAction, MTLPrimitiveType, MTLScissorRect, MTLSize, MTLStoreAction,
|
||||
MTLViewport, MTLVisibilityResultMode, NSRange,
|
||||
@@ -977,15 +977,11 @@ impl crate::CommandEncoder for super::CommandEncoder {
|
||||
let encoder = self.state.render.as_ref().unwrap();
|
||||
encoder.set_vertex_buffer(buffer_index, Some(&binding.buffer.raw), binding.offset);
|
||||
|
||||
let buffer_size = binding.resolve_size();
|
||||
if buffer_size > 0 {
|
||||
self.state.vertex_buffer_size_map.insert(
|
||||
buffer_index,
|
||||
core::num::NonZeroU64::new(buffer_size).unwrap(),
|
||||
);
|
||||
} else {
|
||||
self.state.vertex_buffer_size_map.remove(&buffer_index);
|
||||
}
|
||||
// https://github.com/gfx-rs/wgpu/issues/3170
|
||||
let size =
|
||||
NonZeroU64::new(binding.size).expect("zero-size vertex buffers are not supported");
|
||||
|
||||
self.state.vertex_buffer_size_map.insert(buffer_index, size);
|
||||
|
||||
if let Some((index, sizes)) = self
|
||||
.state
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
use alloc::{borrow::ToOwned as _, sync::Arc, vec::Vec};
|
||||
use core::{ptr::NonNull, sync::atomic};
|
||||
use core::{num::NonZeroU64, ptr::NonNull, sync::atomic};
|
||||
use std::{thread, time};
|
||||
|
||||
use parking_lot::Mutex;
|
||||
@@ -340,10 +340,6 @@ impl super::Device {
|
||||
}
|
||||
}
|
||||
|
||||
pub unsafe fn buffer_from_raw(raw: metal::Buffer, size: wgt::BufferAddress) -> super::Buffer {
|
||||
super::Buffer { raw, size }
|
||||
}
|
||||
|
||||
pub fn raw_device(&self) -> &Mutex<metal::Device> {
|
||||
&self.shared.device
|
||||
}
|
||||
@@ -373,10 +369,7 @@ impl crate::Device for super::Device {
|
||||
raw.set_label(label);
|
||||
}
|
||||
self.counters.buffers.add(1);
|
||||
Ok(super::Buffer {
|
||||
raw,
|
||||
size: desc.size,
|
||||
})
|
||||
Ok(super::Buffer { raw })
|
||||
})
|
||||
}
|
||||
unsafe fn destroy_buffer(&self, _buffer: super::Buffer) {
|
||||
@@ -935,14 +928,12 @@ impl crate::Device for super::Device {
|
||||
let end = start + 1;
|
||||
bg.buffers
|
||||
.extend(desc.buffers[start..end].iter().map(|source| {
|
||||
// Given the restrictions on `BufferBinding::offset`,
|
||||
// this should never be `None`.
|
||||
let remaining_size = wgt::BufferSize::new(
|
||||
source.buffer.size - source.offset,
|
||||
);
|
||||
// https://github.com/gfx-rs/wgpu/issues/3170
|
||||
let source_size = NonZeroU64::new(source.size)
|
||||
.expect("zero-size bindings are not supported");
|
||||
let binding_size = match ty {
|
||||
wgt::BufferBindingType::Storage { .. } => {
|
||||
source.size.or(remaining_size)
|
||||
Some(source_size)
|
||||
}
|
||||
_ => None,
|
||||
};
|
||||
|
||||
@@ -502,7 +502,6 @@ impl crate::Queue for Queue {
|
||||
#[derive(Debug)]
|
||||
pub struct Buffer {
|
||||
raw: metal::Buffer,
|
||||
size: wgt::BufferAddress,
|
||||
}
|
||||
|
||||
unsafe impl Send for Buffer {}
|
||||
@@ -516,15 +515,6 @@ impl Buffer {
|
||||
}
|
||||
}
|
||||
|
||||
impl crate::BufferBinding<'_, Buffer> {
|
||||
fn resolve_size(&self) -> wgt::BufferAddress {
|
||||
match self.size {
|
||||
Some(size) => size.get(),
|
||||
None => self.buffer.size - self.offset,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Texture {
|
||||
raw: metal::Texture,
|
||||
|
||||
@@ -1804,12 +1804,12 @@ impl crate::Device for super::Device {
|
||||
(buffer_infos, local_buffer_infos) =
|
||||
buffer_infos.extend(desc.buffers[start as usize..end as usize].iter().map(
|
||||
|binding| {
|
||||
// https://github.com/gfx-rs/wgpu/issues/3170
|
||||
assert!(binding.size != 0, "zero-size bindings are not supported");
|
||||
vk::DescriptorBufferInfo::default()
|
||||
.buffer(binding.buffer.raw)
|
||||
.offset(binding.offset)
|
||||
.range(
|
||||
binding.size.map_or(vk::WHOLE_SIZE, wgt::BufferSize::get),
|
||||
)
|
||||
.range(binding.size)
|
||||
},
|
||||
));
|
||||
write.buffer_info(local_buffer_infos)
|
||||
|
||||
@@ -61,6 +61,12 @@ pub type BufferAddress = u64;
|
||||
/// [`BufferSlice`]: ../wgpu/struct.BufferSlice.html
|
||||
pub type BufferSize = core::num::NonZeroU64;
|
||||
|
||||
/// Integral type used for buffer sizes that may be zero.
|
||||
///
|
||||
/// Although the wgpu Rust API disallows zero-size `BufferSlice` and wgpu-hal
|
||||
/// disallows zero-size bindings, WebGPU permits zero-size buffers and bindings.
|
||||
pub type BufferSizeOrZero = u64;
|
||||
|
||||
/// Integral type used for binding locations in shaders.
|
||||
///
|
||||
/// Used in [`VertexAttribute`]s and errors.
|
||||
|
||||
@@ -324,6 +324,7 @@ impl Device {
|
||||
/// - `hal_buffer` must be created from this device internal handle
|
||||
/// - `hal_buffer` must be created respecting `desc`
|
||||
/// - `hal_buffer` must be initialized
|
||||
/// - `hal_buffer` must not have zero size
|
||||
#[cfg(wgpu_core)]
|
||||
#[must_use]
|
||||
pub unsafe fn create_buffer_from_hal<A: wgc::hal_api::HalApi>(
|
||||
|
||||
@@ -166,6 +166,12 @@ impl ContextWgpuCore {
|
||||
}
|
||||
}
|
||||
|
||||
/// # Safety
|
||||
///
|
||||
/// - `hal_buffer` must be created from `device`.
|
||||
/// - `hal_buffer` must be created respecting `desc`
|
||||
/// - `hal_buffer` must be initialized
|
||||
/// - `hal_buffer` must not have zero size.
|
||||
pub unsafe fn create_buffer_from_hal<A: wgc::hal_api::HalApi>(
|
||||
&self,
|
||||
hal_buffer: A::Buffer,
|
||||
|
||||
Reference in new issue
Block a user