| 1 |
use crate::{ |
| 2 |
device::DeviceError, |
| 3 |
pipeline::{CreateComputePipelineError, CreateShaderModuleError}, |
| 4 |
}; |
| 5 |
use alloc::boxed::Box; |
| 6 |
use thiserror::Error; |
| 7 |
|
| 8 |
mod dispatch; |
| 9 |
mod draw; |
| 10 |
mod utils; |
| 11 |
|
| 12 |
pub(crate) use dispatch::Dispatch; |
| 13 |
pub(crate) use draw::{Draw, DrawBatcher, DrawResources}; |
| 14 |
|
| 15 |
#[derive(Clone, Debug, Error)] |
| 16 |
#[non_exhaustive] |
| 17 |
enum CreateIndirectValidationPipelineError { |
| 18 |
#[error(transparent)] |
| 19 |
DeviceError(#[from] DeviceError), |
| 20 |
#[error(transparent)] |
| 21 |
ShaderModule(#[from] CreateShaderModuleError), |
| 22 |
#[error(transparent)] |
| 23 |
ComputePipeline(#[from] CreateComputePipelineError), |
| 24 |
} |
| 25 |
|
| 26 |
pub(crate) struct IndirectValidation { |
| 27 |
pub(crate) dispatch: Dispatch, |
| 28 |
pub(crate) draw: Draw, |
| 29 |
} |
| 30 |
|
| 31 |
impl IndirectValidation { |
| 32 |
pub(crate) fn new( |
| 33 |
device: &dyn hal::DynDevice, |
| 34 |
required_limits: &wgt::Limits, |
| 35 |
required_features: &wgt::Features, |
| 36 |
backend: wgt::Backend, |
| 37 |
) -> Result<Self, DeviceError> { |
| 38 |
let dispatch = match Dispatch::new(device, required_limits) { |
| 39 |
Ok(dispatch) => dispatch, |
| 40 |
Err(e) => { |
| 41 |
log::error!("indirect-validation error: {e:?}"); |
| 42 |
return Err(DeviceError::Lost); |
| 43 |
} |
| 44 |
}; |
| 45 |
let draw = match Draw::new(device, required_features, backend) { |
| 46 |
Ok(draw) => draw, |
| 47 |
Err(e) => { |
| 48 |
log::error!("indirect-draw-validation error: {e:?}"); |
| 49 |
return Err(DeviceError::Lost); |
| 50 |
} |
| 51 |
}; |
| 52 |
Ok(Self { dispatch, draw }) |
| 53 |
} |
| 54 |
|
| 55 |
pub(crate) fn dispose(self, device: &dyn hal::DynDevice) { |
| 56 |
let Self { dispatch, draw } = self; |
| 57 |
|
| 58 |
dispatch.dispose(device); |
| 59 |
draw.dispose(device); |
| 60 |
} |
| 61 |
} |
| 62 |
|
| 63 |
#[derive(Debug)] |
| 64 |
pub(crate) struct BindGroups { |
| 65 |
pub(crate) dispatch: Box<dyn hal::DynBindGroup>, |
| 66 |
draw: Box<dyn hal::DynBindGroup>, |
| 67 |
} |
| 68 |
|
| 69 |
impl BindGroups { |
| 70 |
/// `Ok(None)` will only be returned if `buffer_size` is `0`. |
| 71 |
pub(crate) fn new( |
| 72 |
indirect_validation: &IndirectValidation, |
| 73 |
device: &crate::device::Device, |
| 74 |
buffer_size: u64, |
| 75 |
buffer: &dyn hal::DynBuffer, |
| 76 |
) -> Result<Option<Self>, DeviceError> { |
| 77 |
let dispatch = indirect_validation.dispatch.create_src_bind_group( |
| 78 |
device.raw(), |
| 79 |
&device.limits, |
| 80 |
buffer_size, |
| 81 |
buffer, |
| 82 |
)?; |
| 83 |
let draw = indirect_validation.draw.create_src_bind_group( |
| 84 |
device.raw(), |
| 85 |
&device.adapter.limits(), |
| 86 |
buffer_size, |
| 87 |
buffer, |
| 88 |
)?; |
| 89 |
|
| 90 |
match (dispatch, draw) { |
| 91 |
(None, None) => Ok(None), |
| 92 |
(None, Some(_)) => unreachable!(), |
| 93 |
(Some(_), None) => unreachable!(), |
| 94 |
(Some(dispatch), Some(draw)) => Ok(Some(Self { dispatch, draw })), |
| 95 |
} |
| 96 |
} |
| 97 |
|
| 98 |
pub(crate) fn dispose(self, device: &dyn hal::DynDevice) { |
| 99 |
let Self { dispatch, draw } = self; |
| 100 |
|
| 101 |
unsafe { |
| 102 |
device.destroy_bind_group(dispatch); |
| 103 |
device.destroy_bind_group(draw); |
| 104 |
} |
| 105 |
} |
| 106 |
} |