[core] Do not use IDs as default types in BindingResource and BufferBinding

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
sagudev authored and Teodor Tanasoaia committed 2026-08-11 14:04:27 +02:00
1 parent 1d683f8b53
commit 9bd70d113f
5 files changed
+55 -58

No files matched your search

+13 -15
View File
@@ -718,8 +718,8 @@ impl Player {
let resource = match entry.resource {
BindingResource::Buffer(buffer_binding) => {
let buffer = self.resolve_buffer_id(buffer_binding.buffer);
wgc::binding_model::ResolvedBindingResource::Buffer(
wgc::binding_model::ResolvedBufferBinding {
wgc::binding_model::BindingResource::Buffer(
wgc::binding_model::BufferBinding {
buffer,
offset: buffer_binding.offset,
size: buffer_binding.size,
@@ -732,20 +732,20 @@ impl Player {
.into_iter()
.map(|bb| {
let buffer = self.resolve_buffer_id(bb.buffer);
wgc::binding_model::ResolvedBufferBinding {
wgc::binding_model::BufferBinding {
buffer,
offset: bb.offset,
size: bb.size,
}
})
.collect();
wgc::binding_model::ResolvedBindingResource::BufferArray(Cow::Owned(
wgc::binding_model::BindingResource::BufferArray(Cow::Owned(
resolved_buffers,
))
}
BindingResource::Sampler(sampler_id) => {
let sampler = self.resolve_sampler_id(sampler_id);
wgc::binding_model::ResolvedBindingResource::Sampler(sampler)
wgc::binding_model::BindingResource::Sampler(sampler)
}
BindingResource::SamplerArray(sampler_ids) => {
let resolved_samplers: Vec<_> = sampler_ids
@@ -753,13 +753,13 @@ impl Player {
.into_iter()
.map(|id| self.resolve_sampler_id(id))
.collect();
wgc::binding_model::ResolvedBindingResource::SamplerArray(Cow::Owned(
wgc::binding_model::BindingResource::SamplerArray(Cow::Owned(
resolved_samplers,
))
}
BindingResource::TextureView(texture_view_id) => {
let texture_view = self.resolve_texture_view_id(texture_view_id);
wgc::binding_model::ResolvedBindingResource::TextureView(texture_view)
wgc::binding_model::BindingResource::TextureView(texture_view)
}
BindingResource::TextureViewArray(texture_view_ids) => {
let resolved_views: Vec<_> = texture_view_ids
@@ -767,13 +767,13 @@ impl Player {
.into_iter()
.map(|id| self.resolve_texture_view_id(id))
.collect();
wgc::binding_model::ResolvedBindingResource::TextureViewArray(Cow::Owned(
wgc::binding_model::BindingResource::TextureViewArray(Cow::Owned(
resolved_views,
))
}
BindingResource::AccelerationStructure(tlas_id) => {
let tlas = self.resolve_tlas_id(tlas_id);
wgc::binding_model::ResolvedBindingResource::AccelerationStructure(tlas)
wgc::binding_model::BindingResource::AccelerationStructure(tlas)
}
BindingResource::AccelerationStructureArray(tlas_ids) => {
let resolved_tlas: Vec<_> = tlas_ids
@@ -781,16 +781,14 @@ impl Player {
.into_iter()
.map(|id| self.resolve_tlas_id(id))
.collect();
wgc::binding_model::ResolvedBindingResource::AccelerationStructureArray(
Cow::Owned(resolved_tlas),
)
wgc::binding_model::BindingResource::AccelerationStructureArray(Cow::Owned(
resolved_tlas,
))
}
BindingResource::ExternalTexture(external_texture_id) => {
let external_texture =
self.resolve_external_texture_id(external_texture_id);
wgc::binding_model::ResolvedBindingResource::ExternalTexture(
external_texture,
)
wgc::binding_model::BindingResource::ExternalTexture(external_texture)
}
};
+6 -18
View File
@@ -20,7 +20,6 @@ use wgt::error::{ErrorType, WebGpuError};
use crate::{
api_log,
device::{bgl, Device, DeviceError, MissingDownlevelFlags, MissingFeatures},
id::{BufferId, ExternalTextureId, SamplerId, TextureViewId, TlasId},
init_tracker::{BufferInitTrackerAction, TextureInitTrackerAction},
pipeline::{ComputePipeline, RenderPipeline},
resource::{
@@ -1107,7 +1106,7 @@ crate::impl_storage_item!(PipelineLayout);
#[repr(C)]
#[derive(Clone, Debug, Hash, Eq, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct BufferBinding<B = BufferId> {
pub struct BufferBinding<B = Arc<Buffer>> {
pub buffer: B,
pub offset: wgt::BufferAddress,
@@ -1121,19 +1120,17 @@ pub struct BufferBinding<B = BufferId> {
pub size: Option<wgt::BufferAddress>,
}
pub type ResolvedBufferBinding = BufferBinding<Arc<Buffer>>;
// Note: Duplicated in `wgpu-rs` as `BindingResource`
// They're different enough that it doesn't make sense to share a common type
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BindingResource<
'a,
B = BufferId,
S = SamplerId,
TV = TextureViewId,
TLAS = TlasId,
ET = ExternalTextureId,
B = Arc<Buffer>,
S = Arc<Sampler>,
TV = Arc<TextureView>,
TLAS = Arc<Tlas>,
ET = Arc<ExternalTexture>,
> where
[BufferBinding<B>]: ToOwned,
[S]: ToOwned,
@@ -1171,15 +1168,6 @@ pub enum BindingResource<
ExternalTexture(ET),
}
pub type ResolvedBindingResource<'a> = BindingResource<
'a,
Arc<Buffer>,
Arc<Sampler>,
Arc<TextureView>,
Arc<Tlas>,
Arc<ExternalTexture>,
>;
#[derive(Clone, Debug, Error)]
#[non_exhaustive]
pub enum BindError {
+24 -13
View File
@@ -4,9 +4,7 @@ use core::ptr::NonNull;
#[cfg(feature = "trace")]
use crate::device::trace;
use crate::{
binding_model::{
self, BindingResource, BufferBinding, ResolvedBindingResource, ResolvedBufferBinding,
},
binding_model::{self},
command,
device::{life::WaitIdleError, DeviceError, DeviceLostClosure},
global::Global,
@@ -46,6 +44,17 @@ pub type BindGroupEntry<'a> = binding_model::BindGroupEntry<
id::ExternalTextureId,
>;
pub type BufferBinding = binding_model::BufferBinding<id::BufferId>;
pub type BindingResource<'a> = binding_model::BindingResource<
'a,
id::BufferId,
id::SamplerId,
id::TextureViewId,
id::TlasId,
id::ExternalTextureId,
>;
impl Global {
pub fn adapter_is_surface_supported(
&self,
@@ -531,7 +540,7 @@ impl Global {
) -> binding_model::BindGroupEntry<'a> {
let resolve_buffer = |bb: &BufferBinding| {
let buffer = buffer_storage.get(bb.buffer);
ResolvedBufferBinding {
binding_model::BufferBinding {
buffer,
offset: bb.offset,
size: bb.size,
@@ -544,35 +553,37 @@ impl Global {
|id: &id::ExternalTextureId| external_texture_storage.get(*id);
let resource = match e.resource {
BindingResource::Buffer(ref buffer) => {
ResolvedBindingResource::Buffer(resolve_buffer(buffer))
binding_model::BindingResource::Buffer(resolve_buffer(buffer))
}
BindingResource::BufferArray(ref buffers) => {
let buffers = buffers.iter().map(resolve_buffer).collect::<Vec<_>>();
ResolvedBindingResource::BufferArray(Cow::Owned(buffers))
binding_model::BindingResource::BufferArray(Cow::Owned(buffers))
}
BindingResource::Sampler(ref sampler) => {
ResolvedBindingResource::Sampler(resolve_sampler(sampler))
binding_model::BindingResource::Sampler(resolve_sampler(sampler))
}
BindingResource::SamplerArray(ref samplers) => {
let samplers = samplers.iter().map(resolve_sampler).collect::<Vec<_>>();
ResolvedBindingResource::SamplerArray(Cow::Owned(samplers))
binding_model::BindingResource::SamplerArray(Cow::Owned(samplers))
}
BindingResource::TextureView(ref view) => {
ResolvedBindingResource::TextureView(resolve_view(view))
binding_model::BindingResource::TextureView(resolve_view(view))
}
BindingResource::TextureViewArray(ref views) => {
let views = views.iter().map(resolve_view).collect::<Vec<_>>();
ResolvedBindingResource::TextureViewArray(Cow::Owned(views))
binding_model::BindingResource::TextureViewArray(Cow::Owned(views))
}
BindingResource::AccelerationStructure(ref tlas) => {
ResolvedBindingResource::AccelerationStructure(resolve_tlas(tlas))
binding_model::BindingResource::AccelerationStructure(resolve_tlas(tlas))
}
BindingResource::AccelerationStructureArray(ref tlas_array) => {
let tlas_array = tlas_array.iter().map(resolve_tlas).collect::<Vec<_>>();
ResolvedBindingResource::AccelerationStructureArray(Cow::Owned(tlas_array))
binding_model::BindingResource::AccelerationStructureArray(Cow::Owned(
tlas_array,
))
}
BindingResource::ExternalTexture(ref et) => {
ResolvedBindingResource::ExternalTexture(resolve_external_texture(et))
binding_model::BindingResource::ExternalTexture(resolve_external_texture(et))
}
};
binding_model::BindGroupEntry {
+2 -2
View File
@@ -3190,7 +3190,7 @@ impl Device {
fn create_buffer_binding<'a>(
&self,
bb: &'a binding_model::ResolvedBufferBinding,
bb: &'a binding_model::BufferBinding,
binding: u32,
decl: &wgt::BindGroupLayoutEntry,
buffer_init_actions: &mut Vec<BufferInitTrackerAction>,
@@ -3621,7 +3621,7 @@ impl Device {
self: &Arc<Self>,
desc: &binding_model::BindGroupDescriptor,
) -> Result<Arc<BindGroup>, CreateBindGroupError> {
use crate::binding_model::{CreateBindGroupError as Error, ResolvedBindingResource as Br};
use crate::binding_model::{BindingResource as Br, CreateBindGroupError as Error};
self.check_is_valid()?;
+10 -10
View File
@@ -677,7 +677,7 @@ impl<'a> IntoTrace for &'_ crate::binding_model::BindGroupDescriptor<'a> {
fn into_trace(self) -> Self::Output {
use crate::binding_model::{
BindGroupEntry, BindingResource, BufferBinding, ResolvedBindingResource,
BindGroupEntry, BindingResource, BufferBinding,
};
TraceBindGroupDescriptor {
label: self.label.clone(),
@@ -687,14 +687,14 @@ impl<'a> IntoTrace for &'_ crate::binding_model::BindGroupDescriptor<'a> {
.iter()
.map(|entry| {
let resource = match &entry.resource {
ResolvedBindingResource::Buffer(buffer_binding) => {
BindingResource::Buffer(buffer_binding) => {
BindingResource::Buffer(BufferBinding {
buffer: buffer_binding.buffer.to_trace(),
offset: buffer_binding.offset,
size: buffer_binding.size,
})
}
ResolvedBindingResource::BufferArray(buffer_bindings) => {
BindingResource::BufferArray(buffer_bindings) => {
let resolved_buffers: Vec<_> = buffer_bindings
.iter()
.map(|bb| BufferBinding {
@@ -705,31 +705,31 @@ impl<'a> IntoTrace for &'_ crate::binding_model::BindGroupDescriptor<'a> {
.collect();
BindingResource::BufferArray(Cow::Owned(resolved_buffers))
}
ResolvedBindingResource::Sampler(sampler_id) => {
BindingResource::Sampler(sampler_id) => {
BindingResource::Sampler(sampler_id.to_trace())
}
ResolvedBindingResource::SamplerArray(sampler_ids) => {
BindingResource::SamplerArray(sampler_ids) => {
let resolved: Vec<_> =
sampler_ids.iter().map(|id| id.to_trace()).collect();
BindingResource::SamplerArray(Cow::Owned(resolved))
}
ResolvedBindingResource::TextureView(texture_view_id) => {
BindingResource::TextureView(texture_view_id) => {
BindingResource::TextureView(texture_view_id.to_trace())
}
ResolvedBindingResource::TextureViewArray(texture_view_ids) => {
BindingResource::TextureViewArray(texture_view_ids) => {
let resolved: Vec<_> =
texture_view_ids.iter().map(|id| id.to_trace()).collect();
BindingResource::TextureViewArray(Cow::Owned(resolved))
}
ResolvedBindingResource::AccelerationStructure(tlas_id) => {
BindingResource::AccelerationStructure(tlas_id) => {
BindingResource::AccelerationStructure(tlas_id.to_trace())
}
ResolvedBindingResource::AccelerationStructureArray(tlas_ids) => {
BindingResource::AccelerationStructureArray(tlas_ids) => {
let resolved: Vec<_> =
tlas_ids.iter().map(|id| id.to_trace()).collect();
BindingResource::AccelerationStructureArray(Cow::Owned(resolved))
}
ResolvedBindingResource::ExternalTexture(external_texture_id) => {
BindingResource::ExternalTexture(external_texture_id) => {
BindingResource::ExternalTexture(external_texture_id.to_trace())
}
};