Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 05:30:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

update wgpu

Browse source
This commit is contained in:
Kunal Mohan 2020-08-16 12:35:38 +05:30
parent 216c13cdc4
commit 732efdacbd
5 changed files with 127 additions and 133 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Cargo.lock generated
View file

@ -6955,7 +6955,7 @@ dependencies = [
[[package]] [[package]]
name = "wgpu-core" name = "wgpu-core"
version = "0.5.0" version = "0.5.0"
source = "git+https://github.com/gfx-rs/wgpu#430b29d781200009ef02839e41136718ff62456a" source = "git+https://github.com/gfx-rs/wgpu#7e8b51b4286bd9452567eb1a56edb8e9b7c7f684"
dependencies = [ dependencies = [
"arrayvec 0.5.1", "arrayvec 0.5.1",
"bitflags", "bitflags",
@ -6982,7 +6982,7 @@ dependencies = [
[[package]] [[package]]
name = "wgpu-types" name = "wgpu-types"
version = "0.5.0" version = "0.5.0"
source = "git+https://github.com/gfx-rs/wgpu#430b29d781200009ef02839e41136718ff62456a" source = "git+https://github.com/gfx-rs/wgpu#7e8b51b4286bd9452567eb1a56edb8e9b7c7f684"
dependencies = [ dependencies = [
"bitflags", "bitflags",
"serde", "serde",

98
components/script/dom/gpudevice.rs
View file

@ -73,7 +73,7 @@ use std::collections::HashMap;
use std::ptr::NonNull; use std::ptr::NonNull;
use std::rc::Rc; use std::rc::Rc;
use webgpu::wgpu::{ use webgpu::wgpu::{
binding_model as wgpu_bind, command::RenderBundleEncoder, pipeline as wgpu_pipe, binding_model as wgpu_bind, command as wgpu_com, pipeline as wgpu_pipe, resource as wgpu_res,
}; };
use webgpu::{self, identity::WebGPUOpResult, wgt, ErrorScopeId, WebGPU, WebGPURequest}; use webgpu::{self, identity::WebGPUOpResult, wgt, ErrorScopeId, WebGPU, WebGPURequest};
@ -320,9 +320,14 @@ impl GPUDeviceMethods for GPUDevice {
/// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createbuffer /// https://gpuweb.github.io/gpuweb/#dom-gpudevice-createbuffer
fn CreateBuffer(&self, descriptor: &GPUBufferDescriptor) -> DomRoot<GPUBuffer> { fn CreateBuffer(&self, descriptor: &GPUBufferDescriptor) -> DomRoot<GPUBuffer> {
let desc = wgt::BufferUsage::from_bits(descriptor.usage).map(|usg| wgt::BufferDescriptor { let desc =
label: descriptor.parent.label.as_ref().map(|s| s.to_string()), wgt::BufferUsage::from_bits(descriptor.usage).map(|usg| wgpu_res::BufferDescriptor {
size: descriptor.size, label: descriptor
.parent
.label
.as_ref()
.map(|s| Cow::Owned(s.to_string())),
size: descriptor.size as wgt::BufferAddress,
usage: usg, usage: usg,
mapped_at_creation: descriptor.mappedAtCreation, mapped_at_creation: descriptor.mappedAtCreation,
}); });
@ -464,14 +469,19 @@ impl GPUDeviceMethods for GPUDevice {
}, },
}; };
wgt::BindGroupLayoutEntry::new(bind.binding, visibility, ty) wgt::BindGroupLayoutEntry {
binding: bind.binding,
visibility: visibility,
ty,
count: None,
}
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let scope_id = self.use_current_scope(); let scope_id = self.use_current_scope();
let desc = if valid { let desc = if valid {
Some(wgt::BindGroupLayoutDescriptor { Some(wgpu_bind::BindGroupLayoutDescriptor {
label: descriptor label: descriptor
.parent .parent
.label .label
@ -518,7 +528,12 @@ impl GPUDeviceMethods for GPUDevice {
&self, &self,
descriptor: &GPUPipelineLayoutDescriptor, descriptor: &GPUPipelineLayoutDescriptor,
) -> DomRoot<GPUPipelineLayout> { ) -> DomRoot<GPUPipelineLayout> {
let desc = wgt::PipelineLayoutDescriptor { let desc = wgpu_bind::PipelineLayoutDescriptor {
label: descriptor
.parent
.label
.as_ref()
.map(|s| Cow::Owned(s.to_string())),
bind_group_layouts: Cow::Owned( bind_group_layouts: Cow::Owned(
descriptor descriptor
.bindGroupLayouts .bindGroupLayouts
@ -673,7 +688,13 @@ impl GPUDeviceMethods for GPUDevice {
let scope_id = self.use_current_scope(); let scope_id = self.use_current_scope();
let desc = wgpu_pipe::ComputePipelineDescriptor { let desc = wgpu_pipe::ComputePipelineDescriptor {
layout: descriptor.parent.layout.id().0, label: descriptor
.parent
.parent
.label
.as_ref()
.map(|s| Cow::Owned(s.to_string())),
layout: Some(descriptor.parent.layout.id().0),
compute_stage: wgpu_pipe::ProgrammableStageDescriptor { compute_stage: wgpu_pipe::ProgrammableStageDescriptor {
module: descriptor.computeStage.module.id().0, module: descriptor.computeStage.module.id().0,
entry_point: Cow::Owned(descriptor.computeStage.entryPoint.to_string()), entry_point: Cow::Owned(descriptor.computeStage.entryPoint.to_string()),
@ -718,7 +739,11 @@ impl GPUDeviceMethods for GPUDevice {
WebGPURequest::CreateCommandEncoder { WebGPURequest::CreateCommandEncoder {
device_id: self.device.0, device_id: self.device.0,
command_encoder_id, command_encoder_id,
label: descriptor.parent.label.as_ref().map(|s| s.to_string()), label: descriptor
.parent
.label
.as_ref()
.map(|l| Cow::Owned(l.to_string())),
}, },
)) ))
.expect("Failed to create WebGPU command encoder"); .expect("Failed to create WebGPU command encoder");
@ -739,8 +764,12 @@ impl GPUDeviceMethods for GPUDevice {
fn CreateTexture(&self, descriptor: &GPUTextureDescriptor) -> DomRoot<GPUTexture> { fn CreateTexture(&self, descriptor: &GPUTextureDescriptor) -> DomRoot<GPUTexture> {
let size = convert_texture_size_to_dict(&descriptor.size); let size = convert_texture_size_to_dict(&descriptor.size);
let desc = let desc =
wgt::TextureUsage::from_bits(descriptor.usage).map(|usg| wgt::TextureDescriptor { wgt::TextureUsage::from_bits(descriptor.usage).map(|usg| wgpu_res::TextureDescriptor {
label: descriptor.parent.label.as_ref().map(|s| s.to_string()), label: descriptor
.parent
.label
.as_ref()
.map(|l| Cow::Owned(l.to_string())),
size: convert_texture_size_to_wgt(&size), size: convert_texture_size_to_wgt(&size),
mip_level_count: descriptor.mipLevelCount, mip_level_count: descriptor.mipLevelCount,
sample_count: descriptor.sampleCount, sample_count: descriptor.sampleCount,
@ -803,11 +832,17 @@ impl GPUDeviceMethods for GPUDevice {
.lock() .lock()
.create_sampler_id(self.device.0.backend()); .create_sampler_id(self.device.0.backend());
let compare_enable = descriptor.compare.is_some(); let compare_enable = descriptor.compare.is_some();
let desc = wgt::SamplerDescriptor { let desc = wgpu_res::SamplerDescriptor {
label: descriptor.parent.label.as_ref().map(|s| s.to_string()), label: descriptor
address_mode_u: convert_address_mode(descriptor.addressModeU), .parent
address_mode_v: convert_address_mode(descriptor.addressModeV), .label
address_mode_w: convert_address_mode(descriptor.addressModeW), .as_ref()
.map(|s| Cow::Owned(s.to_string())),
address_modes: [
convert_address_mode(descriptor.addressModeU),
convert_address_mode(descriptor.addressModeV),
convert_address_mode(descriptor.addressModeW),
],
mag_filter: convert_filter_mode(descriptor.magFilter), mag_filter: convert_filter_mode(descriptor.magFilter),
min_filter: convert_filter_mode(descriptor.minFilter), min_filter: convert_filter_mode(descriptor.minFilter),
mipmap_filter: convert_filter_mode(descriptor.mipmapFilter), mipmap_filter: convert_filter_mode(descriptor.mipmapFilter),
@ -872,7 +907,13 @@ impl GPUDeviceMethods for GPUDevice {
let desc = if valid { let desc = if valid {
Some(wgpu_pipe::RenderPipelineDescriptor { Some(wgpu_pipe::RenderPipelineDescriptor {
layout: descriptor.parent.layout.id().0, label: descriptor
.parent
.parent
.label
.as_ref()
.map(|s| Cow::Owned(s.to_string())),
layout: Some(descriptor.parent.layout.id().0),
vertex_stage: wgpu_pipe::ProgrammableStageDescriptor { vertex_stage: wgpu_pipe::ProgrammableStageDescriptor {
module: descriptor.vertexStage.module.id().0, module: descriptor.vertexStage.module.id().0,
entry_point: Cow::Owned(descriptor.vertexStage.entryPoint.to_string()), entry_point: Cow::Owned(descriptor.vertexStage.entryPoint.to_string()),
@ -911,23 +952,27 @@ impl GPUDeviceMethods for GPUDevice {
format: convert_texture_format(dss_desc.format), format: convert_texture_format(dss_desc.format),
depth_write_enabled: dss_desc.depthWriteEnabled, depth_write_enabled: dss_desc.depthWriteEnabled,
depth_compare: convert_compare_function(dss_desc.depthCompare), depth_compare: convert_compare_function(dss_desc.depthCompare),
stencil_front: wgt::StencilStateFaceDescriptor { stencil: wgt::StencilStateDescriptor {
front: wgt::StencilStateFaceDescriptor {
compare: convert_compare_function(dss_desc.stencilFront.compare), compare: convert_compare_function(dss_desc.stencilFront.compare),
fail_op: convert_stencil_op(dss_desc.stencilFront.failOp), fail_op: convert_stencil_op(dss_desc.stencilFront.failOp),
depth_fail_op: convert_stencil_op(dss_desc.stencilFront.depthFailOp), depth_fail_op: convert_stencil_op(
dss_desc.stencilFront.depthFailOp,
),
pass_op: convert_stencil_op(dss_desc.stencilFront.passOp), pass_op: convert_stencil_op(dss_desc.stencilFront.passOp),
}, },
stencil_back: wgt::StencilStateFaceDescriptor { back: wgt::StencilStateFaceDescriptor {
compare: convert_compare_function(dss_desc.stencilBack.compare), compare: convert_compare_function(dss_desc.stencilBack.compare),
fail_op: convert_stencil_op(dss_desc.stencilBack.failOp), fail_op: convert_stencil_op(dss_desc.stencilBack.failOp),
depth_fail_op: convert_stencil_op(dss_desc.stencilBack.depthFailOp), depth_fail_op: convert_stencil_op(dss_desc.stencilBack.depthFailOp),
pass_op: convert_stencil_op(dss_desc.stencilBack.passOp), pass_op: convert_stencil_op(dss_desc.stencilBack.passOp),
}, },
stencil_read_mask: dss_desc.stencilReadMask, read_mask: dss_desc.stencilReadMask,
stencil_write_mask: dss_desc.stencilWriteMask, write_mask: dss_desc.stencilWriteMask,
},
} }
}), }),
vertex_state: wgt::VertexStateDescriptor { vertex_state: wgpu_pipe::VertexStateDescriptor {
index_format: match vs_desc.indexFormat { index_format: match vs_desc.indexFormat {
GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16, GPUIndexFormat::Uint16 => wgt::IndexFormat::Uint16,
GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32, GPUIndexFormat::Uint32 => wgt::IndexFormat::Uint32,
@ -936,7 +981,7 @@ impl GPUDeviceMethods for GPUDevice {
vs_desc vs_desc
.vertexBuffers .vertexBuffers
.iter() .iter()
.map(|buffer| wgt::VertexBufferDescriptor { .map(|buffer| wgpu_pipe::VertexBufferDescriptor {
stride: buffer.arrayStride, stride: buffer.arrayStride,
step_mode: match buffer.stepMode { step_mode: match buffer.stepMode {
GPUInputStepMode::Vertex => wgt::InputStepMode::Vertex, GPUInputStepMode::Vertex => wgt::InputStepMode::Vertex,
@ -1002,7 +1047,7 @@ impl GPUDeviceMethods for GPUDevice {
&self, &self,
descriptor: &GPURenderBundleEncoderDescriptor, descriptor: &GPURenderBundleEncoderDescriptor,
) -> DomRoot<GPURenderBundleEncoder> { ) -> DomRoot<GPURenderBundleEncoder> {
let desc = wgt::RenderBundleEncoderDescriptor { let desc = wgpu_com::RenderBundleEncoderDescriptor {
label: descriptor label: descriptor
.parent .parent
.label .label
@ -1022,7 +1067,8 @@ impl GPUDeviceMethods for GPUDevice {
}; };
// Handle error gracefully // Handle error gracefully
let render_bundle_encoder = RenderBundleEncoder::new(&desc, self.device.0, None).unwrap(); let render_bundle_encoder =
wgpu_com::RenderBundleEncoder::new(&desc, self.device.0, None).unwrap();
GPURenderBundleEncoder::new( GPURenderBundleEncoder::new(
&self.global(), &self.global(),

7
components/script/dom/gpurenderbundleencoder.rs
View file

@ -15,6 +15,7 @@ use crate::dom::gpudevice::GPUDevice;
use crate::dom::gpurenderbundle::GPURenderBundle; use crate::dom::gpurenderbundle::GPURenderBundle;
use crate::dom::gpurenderpipeline::GPURenderPipeline; use crate::dom::gpurenderpipeline::GPURenderPipeline;
use dom_struct::dom_struct; use dom_struct::dom_struct;
use std::borrow::Cow;
use webgpu::{ use webgpu::{
wgpu::command::{bundle_ffi as wgpu_bundle, RenderBundleEncoder}, wgpu::command::{bundle_ffi as wgpu_bundle, RenderBundleEncoder},
wgt, WebGPU, WebGPURenderBundle, WebGPURequest, wgt, WebGPU, WebGPURenderBundle, WebGPURequest,
@ -184,7 +185,11 @@ impl GPURenderBundleEncoderMethods for GPURenderBundleEncoder {
/// https://gpuweb.github.io/gpuweb/#dom-gpurenderbundleencoder-finish /// https://gpuweb.github.io/gpuweb/#dom-gpurenderbundleencoder-finish
fn Finish(&self, descriptor: &GPURenderBundleDescriptor) -> DomRoot<GPURenderBundle> { fn Finish(&self, descriptor: &GPURenderBundleDescriptor) -> DomRoot<GPURenderBundle> {
let desc = wgt::RenderBundleDescriptor { let desc = wgt::RenderBundleDescriptor {
label: descriptor.parent.label.as_ref().map(|s| s.to_string()), label: descriptor
.parent
.label
.as_ref()
.map(|l| Cow::Owned(l.to_string())),
}; };
let encoder = self.render_bundle_encoder.borrow_mut().take().unwrap(); let encoder = self.render_bundle_encoder.borrow_mut().take().unwrap();
let render_bundle_id = self let render_bundle_id = self

33
components/script/dom/gputexture.rs
View file

@ -7,7 +7,7 @@ use crate::dom::bindings::codegen::Bindings::GPUTextureBinding::{
GPUExtent3DDict, GPUTextureDimension, GPUTextureFormat, GPUTextureMethods, GPUExtent3DDict, GPUTextureDimension, GPUTextureFormat, GPUTextureMethods,
}; };
use crate::dom::bindings::codegen::Bindings::GPUTextureViewBinding::{ use crate::dom::bindings::codegen::Bindings::GPUTextureViewBinding::{
GPUTextureAspect, GPUTextureViewDescriptor, GPUTextureViewDimension, GPUTextureAspect, GPUTextureViewDescriptor,
}; };
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector}; use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::root::{Dom, DomRoot}; use crate::dom::bindings::root::{Dom, DomRoot};
@ -16,10 +16,12 @@ use crate::dom::globalscope::GlobalScope;
use crate::dom::gpudevice::{convert_texture_format, convert_texture_view_dimension, GPUDevice}; use crate::dom::gpudevice::{convert_texture_format, convert_texture_view_dimension, GPUDevice};
use crate::dom::gputextureview::GPUTextureView; use crate::dom::gputextureview::GPUTextureView;
use dom_struct::dom_struct; use dom_struct::dom_struct;
use std::borrow::Cow;
use std::num::NonZeroU32; use std::num::NonZeroU32;
use std::string::String; use std::string::String;
use webgpu::{ use webgpu::{
identity::WebGPUOpResult, wgt, WebGPU, WebGPURequest, WebGPUTexture, WebGPUTextureView, identity::WebGPUOpResult, wgpu::resource, wgt, WebGPU, WebGPURequest, WebGPUTexture,
WebGPUTextureView,
}; };
#[dom_struct] #[dom_struct]
@ -123,23 +125,6 @@ impl GPUTextureMethods for GPUTexture {
/// https://gpuweb.github.io/gpuweb/#dom-gputexture-createview /// https://gpuweb.github.io/gpuweb/#dom-gputexture-createview
fn CreateView(&self, descriptor: &GPUTextureViewDescriptor) -> DomRoot<GPUTextureView> { fn CreateView(&self, descriptor: &GPUTextureViewDescriptor) -> DomRoot<GPUTextureView> {
let dimension = if let Some(d) = descriptor.dimension {
d
} else {
match self.dimension {
GPUTextureDimension::_1d => GPUTextureViewDimension::_1d,
GPUTextureDimension::_2d => {
if self.texture_size.depth > 1 && descriptor.arrayLayerCount.is_none() {
GPUTextureViewDimension::_2d_array
} else {
GPUTextureViewDimension::_2d
}
},
GPUTextureDimension::_3d => GPUTextureViewDimension::_3d,
}
};
let format = descriptor.format.unwrap_or(self.format);
let scope_id = self.device.use_current_scope(); let scope_id = self.device.use_current_scope();
let mut valid = true; let mut valid = true;
let level_count = descriptor.mipLevelCount.and_then(|count| { let level_count = descriptor.mipLevelCount.and_then(|count| {
@ -156,14 +141,16 @@ impl GPUTextureMethods for GPUTexture {
}); });
let desc = if valid { let desc = if valid {
Some(wgt::TextureViewDescriptor { Some(resource::TextureViewDescriptor {
label: descriptor label: descriptor
.parent .parent
.label .label
.as_ref() .as_ref()
.map(|s| String::from(s.as_ref())), .map(|l| Cow::Owned(l.to_string())),
format: convert_texture_format(format), format: descriptor.format.map(|fr| convert_texture_format(fr)),
dimension: convert_texture_view_dimension(dimension), dimension: descriptor
.dimension
.map(|dm| convert_texture_view_dimension(dm)),
aspect: match descriptor.aspect { aspect: match descriptor.aspect {
GPUTextureAspect::All => wgt::TextureAspect::All, GPUTextureAspect::All => wgt::TextureAspect::All,
GPUTextureAspect::Stencil_only => wgt::TextureAspect::StencilOnly, GPUTextureAspect::Stencil_only => wgt::TextureAspect::StencilOnly,

96
components/webgpu/lib.rs
View file

@ -21,9 +21,7 @@ use servo_config::pref;
use smallvec::SmallVec; use smallvec::SmallVec;
use std::borrow::Cow; use std::borrow::Cow;
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::ffi::CString;
use std::num::NonZeroU64; use std::num::NonZeroU64;
use std::ptr;
use std::rc::Rc; use std::rc::Rc;
use std::slice; use std::slice;
use std::sync::{Arc, Mutex}; use std::sync::{Arc, Mutex};
@ -33,13 +31,19 @@ use webrender_traits::{
WebrenderImageSource, WebrenderImageSource,
}; };
use wgpu::{ use wgpu::{
binding_model::BindGroupDescriptor, binding_model::{BindGroupDescriptor, BindGroupLayoutDescriptor, PipelineLayoutDescriptor},
command::{BufferCopyView, ComputePass, RenderBundleEncoder, RenderPass, TextureCopyView}, command::{
BufferCopyView, ComputePass, RenderBundleDescriptor, RenderBundleEncoder, RenderPass,
TextureCopyView,
},
device::HostMap, device::HostMap,
id, id,
instance::RequestAdapterOptions, instance::RequestAdapterOptions,
pipeline::{ComputePipelineDescriptor, RenderPipelineDescriptor}, pipeline::{ComputePipelineDescriptor, RenderPipelineDescriptor},
resource::{BufferMapAsyncStatus, BufferMapOperation}, resource::{
BufferDescriptor, BufferMapAsyncStatus, BufferMapOperation, SamplerDescriptor,
TextureDescriptor, TextureViewDescriptor,
},
}; };
pub type ErrorScopeId = NonZeroU64; pub type ErrorScopeId = NonZeroU64;
@ -119,19 +123,19 @@ pub enum WebGPURequest {
CreateBindGroupLayout { CreateBindGroupLayout {
device_id: id::DeviceId, device_id: id::DeviceId,
bind_group_layout_id: id::BindGroupLayoutId, bind_group_layout_id: id::BindGroupLayoutId,
descriptor: Option<wgt::BindGroupLayoutDescriptor<'static>>, descriptor: Option<BindGroupLayoutDescriptor<'static>>,
}, },
CreateBuffer { CreateBuffer {
device_id: id::DeviceId, device_id: id::DeviceId,
buffer_id: id::BufferId, buffer_id: id::BufferId,
descriptor: Option<wgt::BufferDescriptor<Option<String>>>, descriptor: Option<BufferDescriptor<'static>>,
}, },
CreateCommandEncoder { CreateCommandEncoder {
device_id: id::DeviceId, device_id: id::DeviceId,
// TODO(zakorgy): Serialize CommandEncoderDescriptor in wgpu-core // TODO(zakorgy): Serialize CommandEncoderDescriptor in wgpu-core
// wgpu::command::CommandEncoderDescriptor, // wgpu::command::CommandEncoderDescriptor,
command_encoder_id: id::CommandEncoderId, command_encoder_id: id::CommandEncoderId,
label: Option<String>, label: Option<Cow<'static, str>>,
}, },
CreateComputePipeline { CreateComputePipeline {
device_id: id::DeviceId, device_id: id::DeviceId,
@ -142,7 +146,7 @@ pub enum WebGPURequest {
CreatePipelineLayout { CreatePipelineLayout {
device_id: id::DeviceId, device_id: id::DeviceId,
pipeline_layout_id: id::PipelineLayoutId, pipeline_layout_id: id::PipelineLayoutId,
descriptor: wgt::PipelineLayoutDescriptor<'static, id::BindGroupLayoutId>, descriptor: PipelineLayoutDescriptor<'static>,
}, },
CreateRenderPipeline { CreateRenderPipeline {
device_id: id::DeviceId, device_id: id::DeviceId,
@ -152,7 +156,7 @@ pub enum WebGPURequest {
CreateSampler { CreateSampler {
device_id: id::DeviceId, device_id: id::DeviceId,
sampler_id: id::SamplerId, sampler_id: id::SamplerId,
descriptor: wgt::SamplerDescriptor<Option<String>>, descriptor: SamplerDescriptor<'static>,
}, },
CreateShaderModule { CreateShaderModule {
device_id: id::DeviceId, device_id: id::DeviceId,
@ -170,13 +174,13 @@ pub enum WebGPURequest {
CreateTexture { CreateTexture {
device_id: id::DeviceId, device_id: id::DeviceId,
texture_id: id::TextureId, texture_id: id::TextureId,
descriptor: Option<wgt::TextureDescriptor<Option<String>>>, descriptor: Option<TextureDescriptor<'static>>,
}, },
CreateTextureView { CreateTextureView {
texture_id: id::TextureId, texture_id: id::TextureId,
texture_view_id: id::TextureViewId, texture_view_id: id::TextureViewId,
device_id: id::DeviceId, device_id: id::DeviceId,
descriptor: Option<wgt::TextureViewDescriptor<Option<String>>>, descriptor: Option<TextureViewDescriptor<'static>>,
}, },
DestroyBuffer(id::BufferId), DestroyBuffer(id::BufferId),
DestroySwapChain { DestroySwapChain {
@ -189,7 +193,7 @@ pub enum WebGPURequest {
FreeDevice(id::DeviceId), FreeDevice(id::DeviceId),
RenderBundleEncoderFinish { RenderBundleEncoderFinish {
render_bundle_encoder: RenderBundleEncoder, render_bundle_encoder: RenderBundleEncoder,
descriptor: wgt::RenderBundleDescriptor<Option<String>>, descriptor: RenderBundleDescriptor<'static>,
render_bundle_id: id::RenderBundleId, render_bundle_id: id::RenderBundleId,
device_id: id::DeviceId, device_id: id::DeviceId,
}, },
@ -579,16 +583,8 @@ impl<'a> WGPU<'a> {
} => { } => {
let global = &self.global; let global = &self.global;
if let Some(desc) = descriptor { if let Some(desc) = descriptor {
let st;
let label = match desc.label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let result = gfx_select!(buffer_id => let result = gfx_select!(buffer_id =>
global.device_create_buffer(device_id, &desc.map_label(|_| label), buffer_id)); global.device_create_buffer(device_id, &desc, buffer_id));
if result.is_err() { if result.is_err() {
let _ = gfx_select!(buffer_id => global.buffer_error(buffer_id)); let _ = gfx_select!(buffer_id => global.buffer_error(buffer_id));
} }
@ -603,14 +599,6 @@ impl<'a> WGPU<'a> {
label, label,
} => { } => {
let global = &self.global; let global = &self.global;
let st;
let label = match label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let desc = wgt::CommandEncoderDescriptor { label }; let desc = wgt::CommandEncoderDescriptor { label };
let result = gfx_select!(command_encoder_id => let result = gfx_select!(command_encoder_id =>
global.device_create_command_encoder(device_id, &desc, command_encoder_id)); global.device_create_command_encoder(device_id, &desc, command_encoder_id));
@ -626,7 +614,7 @@ impl<'a> WGPU<'a> {
} => { } => {
let global = &self.global; let global = &self.global;
let result = gfx_select!(compute_pipeline_id => let result = gfx_select!(compute_pipeline_id =>
global.device_create_compute_pipeline(device_id, &descriptor, compute_pipeline_id)); global.device_create_compute_pipeline(device_id, &descriptor, compute_pipeline_id, None));
if result.is_err() { if result.is_err() {
let _ = gfx_select!(compute_pipeline_id => let _ = gfx_select!(compute_pipeline_id =>
global.compute_pipeline_error(compute_pipeline_id)); global.compute_pipeline_error(compute_pipeline_id));
@ -664,7 +652,7 @@ impl<'a> WGPU<'a> {
let global = &self.global; let global = &self.global;
if let Some(desc) = descriptor { if let Some(desc) = descriptor {
let result = gfx_select!(render_pipeline_id => let result = gfx_select!(render_pipeline_id =>
global.device_create_render_pipeline(device_id, &desc, render_pipeline_id)); global.device_create_render_pipeline(device_id, &desc, render_pipeline_id, None));
if result.is_err() { if result.is_err() {
let _ = gfx_select!(render_pipeline_id => let _ = gfx_select!(render_pipeline_id =>
global.render_pipeline_error(render_pipeline_id)); global.render_pipeline_error(render_pipeline_id));
@ -680,17 +668,9 @@ impl<'a> WGPU<'a> {
descriptor, descriptor,
} => { } => {
let global = &self.global; let global = &self.global;
let st;
let label = match descriptor.label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let result = gfx_select!(sampler_id => global.device_create_sampler( let result = gfx_select!(sampler_id => global.device_create_sampler(
device_id, device_id,
&descriptor.map_label(|_| label), &descriptor,
sampler_id sampler_id
)); ));
if result.is_err() { if result.is_err() {
@ -763,17 +743,9 @@ impl<'a> WGPU<'a> {
} => { } => {
let global = &self.global; let global = &self.global;
if let Some(desc) = descriptor { if let Some(desc) = descriptor {
let st;
let label = match desc.label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let result = gfx_select!(texture_id => global.device_create_texture( let result = gfx_select!(texture_id => global.device_create_texture(
device_id, device_id,
&desc.map_label(|_| label), &desc,
texture_id texture_id
)); ));
if result.is_err() { if result.is_err() {
@ -792,17 +764,9 @@ impl<'a> WGPU<'a> {
} => { } => {
let global = &self.global; let global = &self.global;
if let Some(desc) = descriptor { if let Some(desc) = descriptor {
let st;
let label = match desc.label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let result = gfx_select!(texture_view_id => global.texture_create_view( let result = gfx_select!(texture_view_id => global.texture_create_view(
texture_id, texture_id,
Some(&desc.map_label(|_| label)), &desc,
texture_view_id texture_view_id
)); ));
if result.is_err() { if result.is_err() {
@ -877,17 +841,9 @@ impl<'a> WGPU<'a> {
device_id, device_id,
} => { } => {
let global = &self.global; let global = &self.global;
let st;
let label = match descriptor.label {
Some(ref s) => {
st = CString::new(s.as_bytes()).unwrap();
st.as_ptr()
},
None => ptr::null(),
};
let result = gfx_select!(render_bundle_id => global.render_bundle_encoder_finish( let result = gfx_select!(render_bundle_id => global.render_bundle_encoder_finish(
render_bundle_encoder, render_bundle_encoder,
&descriptor.map_label(|_| label), &descriptor,
render_bundle_id render_bundle_id
)); ));
if result.is_err() { if result.is_err() {
@ -1051,7 +1007,7 @@ impl<'a> WGPU<'a> {
let buffer_size = let buffer_size =
(buffer_stride * size.height as u32) as wgt::BufferAddress; (buffer_stride * size.height as u32) as wgt::BufferAddress;
let buffer_desc = wgt::BufferDescriptor { let buffer_desc = wgt::BufferDescriptor {
label: ptr::null(), label: None,
size: buffer_size, size: buffer_size,
usage: wgt::BufferUsage::MAP_READ | usage: wgt::BufferUsage::MAP_READ |
wgt::BufferUsage::COPY_DST, wgt::BufferUsage::COPY_DST,
@ -1079,7 +1035,7 @@ impl<'a> WGPU<'a> {
let buffer_size = let buffer_size =
(size.height as u32 * buffer_stride) as wgt::BufferAddress; (size.height as u32 * buffer_stride) as wgt::BufferAddress;
let comm_desc = wgt::CommandEncoderDescriptor { label: ptr::null() }; let comm_desc = wgt::CommandEncoderDescriptor { label: None };
let _ = gfx_select!(encoder_id => global.device_create_command_encoder( let _ = gfx_select!(encoder_id => global.device_create_command_encoder(
device_id, device_id,
&comm_desc, &comm_desc,