github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

[rs] Update wgpu with the error model changes

Browse Source
This commit is contained in:
Dzmitry Malyshau
2020-07-31 23:36:07 -04:00
parent d846081d36
commit 6832ad1513
10 changed files with 91 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
wgpu/Cargo.toml
View File

@@ -27,14 +27,14 @@ vulkan-portability = ["wgc/gfx-backend-vulkan"]
package = "wgpu-core"
version = "0.5"
git = "https://github.com/gfx-rs/wgpu"
rev = "b35209398823e95d71cce718fd98fa54ce43271d"
rev = "78546f410da6c3d48152c8b7d2cf3799babf956b"
features = ["raw-window-handle"]
[dependencies.wgt]
package = "wgpu-types"
version = "0.5"
git = "https://github.com/gfx-rs/wgpu"
rev = "b35209398823e95d71cce718fd98fa54ce43271d"
rev = "78546f410da6c3d48152c8b7d2cf3799babf956b"
[dependencies]
arrayvec = "0.5"

32
wgpu/examples/boids/main.rs
View File

@@ -51,13 +51,11 @@ impl framework::Example for Example {
0.005, // rule3Scale
]
.to_vec();
let sim_param_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Simulation Parameter Buffer"),
contents: bytemuck::cast_slice(&sim_param_data),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
}
);
let sim_param_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Simulation Parameter Buffer"),
contents: bytemuck::cast_slice(&sim_param_data),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
});
// create compute bind layout group and compute pipeline layout
@@ -163,13 +161,11 @@ impl framework::Example for Example {
// buffer for the three 2d triangle vertices of each instance
let vertex_buffer_data = [-0.01f32, -0.02, 0.01, -0.02, 0.00, 0.02];
let vertices_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::bytes_of(&vertex_buffer_data),
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
}
);
let vertices_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::bytes_of(&vertex_buffer_data),
usage: wgpu::BufferUsage::VERTEX | wgpu::BufferUsage::COPY_DST,
});
// buffer for all particles data of type [(posx,posy,velx,vely),...]
@@ -188,15 +184,15 @@ impl framework::Example for Example {
let mut particle_buffers = Vec::<wgpu::Buffer>::new();
let mut particle_bind_groups = Vec::<wgpu::BindGroup>::new();
for i in 0..2 {
particle_buffers.push(device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
particle_buffers.push(
device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some(&format!("Particle Buffer {}", i)),
contents: bytemuck::cast_slice(&initial_particle_data),
usage: wgpu::BufferUsage::VERTEX
| wgpu::BufferUsage::STORAGE
| wgpu::BufferUsage::COPY_DST,
}
));
}),
);
}
// create two bind groups, one for each buffer as the src

36
wgpu/examples/cube/main.rs
View File

@@ -125,21 +125,17 @@ impl framework::Example for Example {
let vertex_size = mem::size_of::<Vertex>();
let (vertex_data, index_data) = create_vertices();
let vertex_buf = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
}
);
let vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
});
let index_buf = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(&index_data),
usage: wgpu::BufferUsage::INDEX,
}
);
let index_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(&index_data),
usage: wgpu::BufferUsage::INDEX,
});
// Create pipeline layout
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
@@ -219,13 +215,11 @@ impl framework::Example for Example {
});
let mx_total = Self::generate_matrix(sc_desc.width as f32 / sc_desc.height as f32);
let mx_ref: &[f32; 16] = mx_total.as_ref();
let uniform_buf = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Uniform Buffer"),
contents: bytemuck::cast_slice(mx_ref),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
}
);
let uniform_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Uniform Buffer"),
contents: bytemuck::cast_slice(mx_ref),
usage: wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
});
// Create bind group
let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {

14
wgpu/examples/hello-compute/main.rs
View File

@@ -53,13 +53,13 @@ async fn execute_gpu(numbers: Vec<u32>) -> Vec<u32> {
mapped_at_creation: false,
});
let storage_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Storage Buffer"),
contents: bytemuck::cast_slice(&numbers),
usage: wgpu::BufferUsage::STORAGE | wgpu::BufferUsage::COPY_DST | wgpu::BufferUsage::COPY_SRC,
}
);
let storage_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Storage Buffer"),
contents: bytemuck::cast_slice(&numbers),
usage: wgpu::BufferUsage::STORAGE
| wgpu::BufferUsage::COPY_DST
| wgpu::BufferUsage::COPY_SRC,
});
let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
label: None,

12
wgpu/examples/msaa-line/main.rs
View File

@@ -162,13 +162,11 @@ impl framework::Example for Example {
});
}
let vertex_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
}
);
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
});
let vertex_count = vertex_data.len() as u32;
let bundle = Example::create_bundle(

24
wgpu/examples/texture-arrays/main.rs
View File

@@ -123,22 +123,18 @@ impl framework::Example for Example {
let vertex_size = std::mem::size_of::<Vertex>();
let vertex_data = create_vertices();
let vertex_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
}
);
let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Vertex Buffer"),
contents: bytemuck::cast_slice(&vertex_data),
usage: wgpu::BufferUsage::VERTEX,
});
let index_data = create_indices();
let index_buffer = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(&index_data),
usage: wgpu::BufferUsage::INDEX,
}
);
let index_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Index Buffer"),
contents: bytemuck::cast_slice(&index_data),
usage: wgpu::BufferUsage::INDEX,
});
let red_texture_data = create_texture_data(Color::RED);
let green_texture_data = create_texture_data(Color::GREEN);

24
wgpu/examples/water/main.rs
View File

@@ -338,21 +338,17 @@ impl framework::Example for Example {
let terrain_vertices = terrain.make_buffer_data();
// Create the buffers on the GPU to hold the data.
let water_vertex_buf = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Water vertices"),
contents: bytemuck::cast_slice(&water_vertices),
usage: wgpu::BufferUsage::VERTEX,
}
);
let water_vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Water vertices"),
contents: bytemuck::cast_slice(&water_vertices),
usage: wgpu::BufferUsage::VERTEX,
});
let terrain_vertex_buf = device.create_buffer_init(
&wgpu::util::BufferInitDescriptor {
label: Some("Terrain vertices"),
contents: bytemuck::cast_slice(&terrain_vertices),
usage: wgpu::BufferUsage::VERTEX,
}
);
let terrain_vertex_buf = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Terrain vertices"),
contents: bytemuck::cast_slice(&terrain_vertices),
usage: wgpu::BufferUsage::VERTEX,
});
// Create the bind group layout. This is what our uniforms will look like.
let water_bind_group_layout =

53
wgpu/src/backend/direct.rs
View File

@@ -24,7 +24,7 @@ pub struct Context(wgc::hub::Global<wgc::hub::IdentityManagerFactory>);
impl Context {
pub fn adapter_get_info(&self, id: wgc::id::AdapterId) -> wgc::instance::AdapterInfo {
let global = &self.0;
wgc::gfx_select!(id => global.adapter_get_info(id))
wgc::gfx_select!(id => global.adapter_get_info(id)).unwrap_pretty()
}
pub fn enumerate_adapters(&self, backends: wgt::BackendBit) -> Vec<wgc::id::AdapterId> {
@@ -47,13 +47,11 @@ impl Context {
}),
};
crate::Surface {
id: self.0.surfaces.register_identity(
PhantomData,
surface,
&mut wgc::hub::Token::root(),
),
}
let id = self.0.surfaces.process_id(PhantomData);
self.0
.surfaces
.register(id, surface, &mut wgc::hub::Token::root());
crate::Surface { id }
}
}
@@ -536,14 +534,14 @@ impl crate::Context for Context {
&self,
options: &crate::RequestAdapterOptions,
) -> Self::RequestAdapterFuture {
let id = self.0.pick_adapter(
let id = self.0.request_adapter(
&wgc::instance::RequestAdapterOptions {
power_preference: options.power_preference,
compatible_surface: options.compatible_surface.map(|surface| surface.id),
},
wgc::instance::AdapterInputs::Mask(wgt::BackendBit::all(), |_| PhantomData),
);
ready(id)
ready(id.ok())
}
fn adapter_request_device(
@@ -562,22 +560,22 @@ impl crate::Context for Context {
fn adapter_features(&self, adapter: &Self::AdapterId) -> Features {
let global = &self.0;
wgc::gfx_select!(*adapter => global.adapter_features(*adapter))
wgc::gfx_select!(*adapter => global.adapter_features(*adapter)).unwrap_pretty()
}
fn adapter_limits(&self, adapter: &Self::AdapterId) -> Limits {
let global = &self.0;
wgc::gfx_select!(*adapter => global.adapter_limits(*adapter))
wgc::gfx_select!(*adapter => global.adapter_limits(*adapter)).unwrap_pretty()
}
fn device_features(&self, device: &Self::DeviceId) -> Features {
let global = &self.0;
wgc::gfx_select!(*device => global.device_features(*device))
wgc::gfx_select!(*device => global.device_features(*device)).unwrap_pretty()
}
fn device_limits(&self, device: &Self::DeviceId) -> Limits {
let global = &self.0;
wgc::gfx_select!(*device => global.device_limits(*device))
wgc::gfx_select!(*device => global.device_limits(*device)).unwrap_pretty()
}
fn device_create_swap_chain(
@@ -858,7 +856,7 @@ impl crate::Context for Context {
#[cfg(feature = "metal-auto-capture")]
{
let global = &self.0;
wgc::gfx_select!(*device => global.device_destroy(*device));
wgc::gfx_select!(*device => global.device_drop(*device));
}
}
@@ -993,52 +991,51 @@ impl crate::Context for Context {
fn texture_drop(&self, texture: &Self::TextureId) {
let global = &self.0;
wgc::gfx_select!(*texture => global.texture_destroy(*texture))
wgc::gfx_select!(*texture => global.texture_drop(*texture))
}
fn texture_view_drop(&self, texture_view: &Self::TextureViewId) {
let global = &self.0;
wgc::gfx_select!(*texture_view => global.texture_view_destroy(*texture_view))
.unwrap_pretty()
wgc::gfx_select!(*texture_view => global.texture_view_drop(*texture_view)).unwrap_pretty()
}
fn sampler_drop(&self, sampler: &Self::SamplerId) {
let global = &self.0;
wgc::gfx_select!(*sampler => global.sampler_destroy(*sampler))
wgc::gfx_select!(*sampler => global.sampler_drop(*sampler))
}
fn buffer_drop(&self, buffer: &Self::BufferId) {
let global = &self.0;
wgc::gfx_select!(*buffer => global.buffer_destroy(*buffer, false))
wgc::gfx_select!(*buffer => global.buffer_drop(*buffer, false))
}
fn bind_group_drop(&self, bind_group: &Self::BindGroupId) {
let global = &self.0;
wgc::gfx_select!(*bind_group => global.bind_group_destroy(*bind_group))
wgc::gfx_select!(*bind_group => global.bind_group_drop(*bind_group))
}
fn bind_group_layout_drop(&self, bind_group_layout: &Self::BindGroupLayoutId) {
let global = &self.0;
wgc::gfx_select!(*bind_group_layout => global.bind_group_layout_destroy(*bind_group_layout))
wgc::gfx_select!(*bind_group_layout => global.bind_group_layout_drop(*bind_group_layout))
}
fn pipeline_layout_drop(&self, pipeline_layout: &Self::PipelineLayoutId) {
let global = &self.0;
wgc::gfx_select!(*pipeline_layout => global.pipeline_layout_destroy(*pipeline_layout))
wgc::gfx_select!(*pipeline_layout => global.pipeline_layout_drop(*pipeline_layout))
}
fn shader_module_drop(&self, shader_module: &Self::ShaderModuleId) {
let global = &self.0;
wgc::gfx_select!(*shader_module => global.shader_module_destroy(*shader_module))
wgc::gfx_select!(*shader_module => global.shader_module_drop(*shader_module))
}
fn command_buffer_drop(&self, command_buffer: &Self::CommandBufferId) {
let global = &self.0;
wgc::gfx_select!(*command_buffer => global.command_buffer_destroy(*command_buffer))
wgc::gfx_select!(*command_buffer => global.command_buffer_drop(*command_buffer))
}
fn render_bundle_drop(&self, render_bundle: &Self::RenderBundleId) {
let global = &self.0;
wgc::gfx_select!(*render_bundle => global.render_bundle_destroy(*render_bundle))
wgc::gfx_select!(*render_bundle => global.render_bundle_drop(*render_bundle))
}
fn compute_pipeline_drop(&self, pipeline: &Self::ComputePipelineId) {
let global = &self.0;
wgc::gfx_select!(*pipeline => global.compute_pipeline_destroy(*pipeline))
wgc::gfx_select!(*pipeline => global.compute_pipeline_drop(*pipeline))
}
fn render_pipeline_drop(&self, pipeline: &Self::RenderPipelineId) {
let global = &self.0;
wgc::gfx_select!(*pipeline => global.render_pipeline_destroy(*pipeline))
wgc::gfx_select!(*pipeline => global.render_pipeline_drop(*pipeline))
}
fn command_encoder_copy_buffer_to_buffer(

6
wgpu/src/util/belt.rs
View File

@@ -122,13 +122,13 @@ impl StagingBelt {
&mut self.encoder,
device.create_command_encoder(&CommandEncoderDescriptor::default()),
)
.finish()
.finish()
}
/// Recall all of the closed buffers back for re-usal.
///
/// This has to be called after the command buffer produced by `flush` is submitted!
pub fn recall(&mut self) -> impl Future<Output=()> + Send {
pub fn recall(&mut self) -> impl Future<Output = ()> + Send {
while let Ok(mut chunk) = self.receiver.try_recv() {
chunk.offset = 0;
self.free_chunks.push(chunk);
@@ -143,6 +143,6 @@ impl StagingBelt {
.map_async(MapMode::Write)
.inspect(move |_| sender.send(chunk).unwrap())
}))
.map(|_| ())
.map(|_| ())
}
}

1
wgpu/src/util/mod.rs
View File

@@ -107,4 +107,3 @@ pub struct BufferInitDescriptor<'a> {
/// will panic.
pub usage: crate::BufferUsage,
}