[rs] Update wgpu and use write_buffer in the examples

This commit is contained in:
Dzmitry Malyshau authored and Dzmitry Malyshau committed 2020-05-14 10:12:47 -04:00
1 parent fe904b0706
commit c548050b47
11 files changed
+113 -157

No files matched your search

+2 -2
View File
@@ -28,14 +28,14 @@ vulkan = ["wgc/gfx-backend-vulkan"]
package = "wgpu-core"
version = "0.5"
git = "https://github.com/gfx-rs/wgpu"
rev = "4c448c3fc583da6d22c62c7e92bbb74b53863357"
rev = "a7200bb8658e7b7bb972ee46a81f423209fb7659"
features = ["raw-window-handle"]
[dependencies.wgt]
package = "wgpu-types"
version = "0.5"
git = "https://github.com/gfx-rs/wgpu"
rev = "4c448c3fc583da6d22c62c7e92bbb74b53863357"
rev = "a7200bb8658e7b7bb972ee46a81f423209fb7659"
[dependencies]
arrayvec = "0.5"
+4 -2
View File
@@ -249,8 +249,9 @@ impl framework::Example for Example {
&mut self,
_sc_desc: &wgpu::SwapChainDescriptor,
_device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer> {
None
_queue: &wgpu::Queue,
) {
//empty
}
/// render is called each frame, dispatching compute groups proportional
@@ -259,6 +260,7 @@ impl framework::Example for Example {
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
_queue: &wgpu::Queue,
) -> wgpu::CommandBuffer {
// create render pass descriptor
let render_pass_descriptor = wgpu::RenderPassDescriptor {
+5 -10
View File
@@ -314,24 +314,19 @@ impl framework::Example for Example {
fn resize(
&mut self,
sc_desc: &wgpu::SwapChainDescriptor,
device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer> {
_device: &wgpu::Device,
queue: &wgpu::Queue,
) {
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 temp_buf = device
.create_buffer_with_data(bytemuck::cast_slice(mx_ref), wgpu::BufferUsage::COPY_SRC);
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
encoder.copy_buffer_to_buffer(&temp_buf, 0, &self.uniform_buf, 0, 64);
Some(encoder.finish())
queue.write_buffer(bytemuck::cast_slice(mx_ref), &self.uniform_buf, 0);
}
fn render(
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
_queue: &wgpu::Queue,
) -> wgpu::CommandBuffer {
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+6 -7
View File
@@ -38,12 +38,14 @@ pub trait Example: 'static + Sized {
&mut self,
sc_desc: &wgpu::SwapChainDescriptor,
device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer>;
queue: &wgpu::Queue,
);
fn update(&mut self, event: WindowEvent);
fn render(
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> wgpu::CommandBuffer;
}
@@ -76,7 +78,7 @@ async fn run_async<E: Example>(event_loop: EventLoop<()>, window: Window) {
},
limits: wgpu::Limits::default(),
},
None,
Some(std::path::Path::new("trace")),
)
.await
.unwrap();
@@ -140,10 +142,7 @@ async fn run_async<E: Example>(event_loop: EventLoop<()>, window: Window) {
sc_desc.width = size.width;
sc_desc.height = size.height;
swap_chain = device.create_swap_chain(&surface, &sc_desc);
let command_buf = example.resize(&sc_desc, &device);
if command_buf.is_some() {
queue.submit(command_buf);
}
example.resize(&sc_desc, &device, &queue);
}
event::Event::WindowEvent { event, .. } => match event {
WindowEvent::KeyboardInput {
@@ -166,7 +165,7 @@ async fn run_async<E: Example>(event_loop: EventLoop<()>, window: Window) {
let frame = swap_chain
.get_next_texture()
.expect("Timeout when acquiring next swap chain texture");
let command_buf = example.render(&frame, &device);
let command_buf = example.render(&frame, &device, &queue);
queue.submit(Some(command_buf));
}
_ => {}
+5 -10
View File
@@ -398,24 +398,19 @@ impl framework::Example for Example {
fn resize(
&mut self,
sc_desc: &wgpu::SwapChainDescriptor,
device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer> {
_device: &wgpu::Device,
queue: &wgpu::Queue,
) {
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 temp_buf = device
.create_buffer_with_data(bytemuck::cast_slice(mx_ref), wgpu::BufferUsage::COPY_SRC);
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
encoder.copy_buffer_to_buffer(&temp_buf, 0, &self.uniform_buf, 0, 64);
Some(encoder.finish())
queue.write_buffer(bytemuck::cast_slice(mx_ref), &self.uniform_buf, 0);
}
fn render(
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
_queue: &wgpu::Queue,
) -> wgpu::CommandBuffer {
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+3 -2
View File
@@ -208,17 +208,18 @@ impl framework::Example for Example {
&mut self,
sc_desc: &wgpu::SwapChainDescriptor,
device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer> {
_queue: &wgpu::Queue,
) {
self.sc_desc = sc_desc.clone();
self.multisampled_framebuffer =
Example::create_multisampled_framebuffer(device, sc_desc, self.sample_count);
None
}
fn render(
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
_queue: &wgpu::Queue,
) -> wgpu::CommandBuffer {
if self.rebuild_pipeline {
self.pipeline = Example::create_pipeline(
+35 -78
View File
@@ -668,18 +668,16 @@ impl framework::Example for Example {
&mut self,
sc_desc: &wgpu::SwapChainDescriptor,
device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer> {
let command_buf = {
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 temp_buf = device
.create_buffer_with_data(bytemuck::cast_slice(mx_ref), wgpu::BufferUsage::COPY_SRC);
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
encoder.copy_buffer_to_buffer(&temp_buf, 0, &self.forward_pass.uniform_buf, 0, 64);
encoder.finish()
};
queue: &wgpu::Queue,
) {
// update view-projection matrix
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();
queue.write_buffer(
bytemuck::cast_slice(mx_ref),
&self.forward_pass.uniform_buf,
0,
);
let depth_texture = device.create_texture(&wgpu::TextureDescriptor {
size: wgpu::Extent3d {
@@ -695,87 +693,46 @@ impl framework::Example for Example {
label: None,
});
self.forward_depth = depth_texture.create_default_view();
Some(command_buf)
}
fn render(
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> wgpu::CommandBuffer {
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
{
let size = mem::size_of::<EntityUniforms>();
let mut temp_buf_data = device.create_buffer_mapped(&wgpu::BufferDescriptor {
size: (self.entities.len() * size) as u64,
usage: wgpu::BufferUsage::COPY_SRC,
label: None,
});
// FIXME: Align and use `LayoutVerified`
for (entity, slot) in self
.entities
.iter_mut()
.zip(temp_buf_data.data().chunks_exact_mut(size))
{
if entity.rotation_speed != 0.0 {
let rotation =
cgmath::Matrix4::from_angle_x(cgmath::Deg(entity.rotation_speed));
entity.mx_world = entity.mx_world * rotation;
}
slot.copy_from_slice(bytemuck::bytes_of(&EntityUniforms {
model: entity.mx_world.into(),
color: [
entity.color.r as f32,
entity.color.g as f32,
entity.color.b as f32,
entity.color.a as f32,
],
}));
}
let temp_buf = temp_buf_data.finish();
for (i, entity) in self.entities.iter().enumerate() {
encoder.copy_buffer_to_buffer(
&temp_buf,
(i * size) as wgpu::BufferAddress,
&entity.uniform_buf,
0,
size as wgpu::BufferAddress,
);
// update uniforms
for entity in self.entities.iter_mut() {
if entity.rotation_speed != 0.0 {
let rotation = cgmath::Matrix4::from_angle_x(cgmath::Deg(entity.rotation_speed));
entity.mx_world = entity.mx_world * rotation;
}
let data = EntityUniforms {
model: entity.mx_world.into(),
color: [
entity.color.r as f32,
entity.color.g as f32,
entity.color.b as f32,
entity.color.a as f32,
],
};
queue.write_buffer(bytemuck::bytes_of(&data), &entity.uniform_buf, 0);
}
if self.lights_are_dirty {
self.lights_are_dirty = false;
let size = mem::size_of::<LightRaw>();
let total_size = size * self.lights.len();
let mut temp_buf_data = device.create_buffer_mapped(&wgpu::BufferDescriptor {
size: total_size as u64,
usage: wgpu::BufferUsage::COPY_SRC,
label: None,
});
// FIXME: Align and use `LayoutVerified`
for (light, slot) in self
.lights
.iter()
.zip(temp_buf_data.data().chunks_exact_mut(size))
{
slot.copy_from_slice(bytemuck::bytes_of(&light.to_raw()));
for (i, light) in self.lights.iter().enumerate() {
queue.write_buffer(
bytemuck::bytes_of(&light.to_raw()),
&self.light_uniform_buf,
(i * mem::size_of::<LightRaw>()) as wgpu::BufferAddress,
);
}
encoder.copy_buffer_to_buffer(
&temp_buf_data.finish(),
0,
&self.light_uniform_buf,
0,
total_size as wgpu::BufferAddress,
);
}
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
for (i, light) in self.lights.iter().enumerate() {
// The light uniform buffer already has the projection,
// let's just copy it over to the shadow uniform buffer.
+21 -46
View File
@@ -6,6 +6,13 @@ const SKYBOX_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
type Uniform = cgmath::Matrix4<f32>;
type Uniforms = [Uniform; 2];
fn raw_uniforms(uniforms: &Uniforms) -> [f32; 16 * 2] {
let mut raw = [0f32; 16 * 2];
raw[..16].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&uniforms[0])[..]);
raw[16..].copy_from_slice(&AsRef::<[f32; 16]>::as_ref(&uniforms[1])[..]);
raw
}
pub struct Skybox {
aspect: f32,
pipeline: wgpu::RenderPipeline,
@@ -27,27 +34,6 @@ impl Skybox {
}
}
fn buffer_from_uniforms(
device: &wgpu::Device,
uniforms: &Uniforms,
usage: wgpu::BufferUsage,
) -> wgpu::Buffer {
let mut uniform_buf = device.create_buffer_mapped(&wgpu::BufferDescriptor {
size: std::mem::size_of::<Uniforms>() as u64,
usage,
label: None,
});
// FIXME: Align and use `LayoutVerified`
for (u, slot) in uniforms.iter().zip(
uniform_buf
.data()
.chunks_exact_mut(std::mem::size_of::<Uniform>()),
) {
slot.copy_from_slice(bytemuck::cast_slice(AsRef::<[[f32; 4]; 4]>::as_ref(u)));
}
uniform_buf.finish()
}
impl framework::Example for Skybox {
fn init(
sc_desc: &wgpu::SwapChainDescriptor,
@@ -91,9 +77,8 @@ impl framework::Example for Skybox {
let aspect = sc_desc.width as f32 / sc_desc.height as f32;
let uniforms = Self::generate_uniforms(aspect);
let uniform_buf = buffer_from_uniforms(
&device,
&uniforms,
let uniform_buf = device.create_buffer_with_data(
bytemuck::cast_slice(&raw_uniforms(&uniforms)),
wgpu::BufferUsage::UNIFORM | wgpu::BufferUsage::COPY_DST,
);
@@ -265,45 +250,35 @@ impl framework::Example for Skybox {
fn resize(
&mut self,
sc_desc: &wgpu::SwapChainDescriptor,
device: &wgpu::Device,
) -> Option<wgpu::CommandBuffer> {
_device: &wgpu::Device,
queue: &wgpu::Queue,
) {
self.aspect = sc_desc.width as f32 / sc_desc.height as f32;
let uniforms = Skybox::generate_uniforms(self.aspect);
let mx_total = uniforms[0] * uniforms[1];
let mx_ref: &[f32; 16] = mx_total.as_ref();
let temp_buf = device
.create_buffer_with_data(bytemuck::cast_slice(mx_ref), wgpu::BufferUsage::COPY_SRC);
let mut init_encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
init_encoder.copy_buffer_to_buffer(&temp_buf, 0, &self.uniform_buf, 0, 64);
self.uniforms = uniforms;
Some(init_encoder.finish())
queue.write_buffer(bytemuck::cast_slice(mx_ref), &self.uniform_buf, 0);
}
fn render(
&mut self,
frame: &wgpu::SwapChainOutput,
device: &wgpu::Device,
queue: &wgpu::Queue,
) -> wgpu::CommandBuffer {
let mut init_encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
// update rotation
let rotation = cgmath::Matrix4::<f32>::from_angle_x(cgmath::Deg(0.25));
self.uniforms[1] = self.uniforms[1] * rotation;
let uniform_buf_size = std::mem::size_of::<Uniforms>();
let temp_buf = buffer_from_uniforms(&device, &self.uniforms, wgpu::BufferUsage::COPY_SRC);
init_encoder.copy_buffer_to_buffer(
&temp_buf,
0,
queue.write_buffer(
bytemuck::cast_slice(&raw_uniforms(&self.uniforms)),
&self.uniform_buf,
0,
uniform_buf_size as wgpu::BufferAddress,
);
let mut encoder =
device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
{
let mut rpass = init_encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
attachment: &frame.view,
resolve_target: None,
@@ -323,7 +298,7 @@ impl framework::Example for Skybox {
rpass.set_bind_group(0, &self.bind_group, &[]);
rpass.draw(0..3 as u32, 0..1);
}
init_encoder.finish()
encoder.finish()
}
}
+10
View File
@@ -876,6 +876,16 @@ impl crate::Context for Context {
gfx_select!(*encoder => self.command_encoder_finish(*encoder, &desc))
}
fn queue_write_buffer(
&self,
queue: &Self::QueueId,
data: &[u8],
buffer: &Self::BufferId,
offset: wgt::BufferAddress,
) {
gfx_select!(*queue => self.queue_write_buffer(*queue, data, *buffer, offset))
}
fn queue_submit<I: Iterator<Item = Self::CommandBufferId>>(
&self,
queue: &Self::QueueId,
+10
View File
@@ -1320,6 +1320,16 @@ impl crate::Context for Context {
Sendable(encoder.finish_with_descriptor(&mapped_desc))
}
fn queue_write_buffer(
&self,
_queue: &Self::QueueId,
_data: &[u8],
_buffer: &Self::BufferId,
_offset: wgt::BufferAddress,
) {
unimplemented!()
}
fn queue_submit<I: Iterator<Item = Self::CommandBufferId>>(
&self,
queue: &Self::QueueId,
+12
View File
@@ -288,6 +288,13 @@ trait Context: Sized {
pass: &mut Self::RenderPassId,
);
fn encoder_finish(&self, encoder: &Self::CommandEncoderId) -> Self::CommandBufferId;
fn queue_write_buffer(
&self,
queue: &Self::QueueId,
data: &[u8],
buffer: &Self::BufferId,
offset: BufferAddress,
);
fn queue_submit<I: Iterator<Item = Self::CommandBufferId>>(
&self,
queue: &Self::QueueId,
@@ -1582,6 +1589,11 @@ impl<'a> Drop for ComputePass<'a> {
}
impl Queue {
/// Schedule a data write into `buffer` starting at `offset`.
pub fn write_buffer(&self, data: &[u8], buffer: &Buffer, offset: BufferAddress) {
Context::queue_write_buffer(&*self.context, &self.id, data, &buffer.id, offset)
}
/// Submits a series of finished command buffers for execution.
pub fn submit<I: IntoIterator<Item = CommandBuffer>>(&self, command_buffers: I) {
Context::queue_submit(