diff options
Diffstat (limited to 'op_crates/webgpu/pipeline.rs')
| -rw-r--r-- | op_crates/webgpu/pipeline.rs | 643 |
1 files changed, 0 insertions, 643 deletions
diff --git a/op_crates/webgpu/pipeline.rs b/op_crates/webgpu/pipeline.rs deleted file mode 100644 index 8eb291b97..000000000 --- a/op_crates/webgpu/pipeline.rs +++ /dev/null @@ -1,643 +0,0 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. - -use deno_core::error::bad_resource_id; -use deno_core::error::AnyError; -use deno_core::ResourceId; -use deno_core::ZeroCopyBuf; -use deno_core::{OpState, Resource}; -use serde::Deserialize; -use serde::Serialize; -use std::borrow::Cow; - -use super::error::{WebGpuError, WebGpuResult}; - -pub(crate) struct WebGpuPipelineLayout( - pub(crate) wgpu_core::id::PipelineLayoutId, -); -impl Resource for WebGpuPipelineLayout { - fn name(&self) -> Cow<str> { - "webGPUPipelineLayout".into() - } -} - -pub(crate) struct WebGpuComputePipeline( - pub(crate) wgpu_core::id::ComputePipelineId, -); -impl Resource for WebGpuComputePipeline { - fn name(&self) -> Cow<str> { - "webGPUComputePipeline".into() - } -} - -pub(crate) struct WebGpuRenderPipeline( - pub(crate) wgpu_core::id::RenderPipelineId, -); -impl Resource for WebGpuRenderPipeline { - fn name(&self) -> Cow<str> { - "webGPURenderPipeline".into() - } -} - -pub fn serialize_index_format(format: String) -> wgpu_types::IndexFormat { - match format.as_str() { - "uint16" => wgpu_types::IndexFormat::Uint16, - "uint32" => wgpu_types::IndexFormat::Uint32, - _ => unreachable!(), - } -} - -fn serialize_stencil_operation( - operation: &str, -) -> wgpu_types::StencilOperation { - match operation { - "keep" => wgpu_types::StencilOperation::Keep, - "zero" => wgpu_types::StencilOperation::Zero, - "replace" => wgpu_types::StencilOperation::Replace, - "invert" => wgpu_types::StencilOperation::Invert, - "increment-clamp" => wgpu_types::StencilOperation::IncrementClamp, - "decrement-clamp" => wgpu_types::StencilOperation::DecrementClamp, - "increment-wrap" => wgpu_types::StencilOperation::IncrementWrap, - "decrement-wrap" => wgpu_types::StencilOperation::DecrementWrap, - _ => unreachable!(), - } -} - -fn serialize_stencil_face_state( - state: GpuStencilFaceState, -) -> wgpu_types::StencilFaceState { - wgpu_types::StencilFaceState { - compare: state - .compare - .as_ref() - .map_or(wgpu_types::CompareFunction::Always, |op| { - super::sampler::serialize_compare_function(op) - }), - fail_op: state - .fail_op - .as_ref() - .map_or(wgpu_types::StencilOperation::Keep, |op| { - serialize_stencil_operation(op) - }), - depth_fail_op: state - .depth_fail_op - .as_ref() - .map_or(wgpu_types::StencilOperation::Keep, |op| { - serialize_stencil_operation(op) - }), - pass_op: state - .pass_op - .as_ref() - .map_or(wgpu_types::StencilOperation::Keep, |op| { - serialize_stencil_operation(op) - }), - } -} - -fn serialize_blend_factor(blend_factor: &str) -> wgpu_types::BlendFactor { - match blend_factor { - "zero" => wgpu_types::BlendFactor::Zero, - "one" => wgpu_types::BlendFactor::One, - "src-color" => wgpu_types::BlendFactor::SrcColor, - "one-minus-src-color" => wgpu_types::BlendFactor::OneMinusSrcColor, - "src-alpha" => wgpu_types::BlendFactor::SrcAlpha, - "one-minus-src-alpha" => wgpu_types::BlendFactor::OneMinusSrcAlpha, - "dst-color" => wgpu_types::BlendFactor::DstColor, - "one-minus-dst-color" => wgpu_types::BlendFactor::OneMinusDstColor, - "dst-alpha" => wgpu_types::BlendFactor::DstAlpha, - "one-minus-dst-alpha" => wgpu_types::BlendFactor::OneMinusDstAlpha, - "src-alpha-saturated" => wgpu_types::BlendFactor::SrcAlphaSaturated, - "blend-color" => wgpu_types::BlendFactor::BlendColor, - "one-minus-blend-color" => wgpu_types::BlendFactor::OneMinusBlendColor, - _ => unreachable!(), - } -} - -fn serialize_blend_component( - blend: GpuBlendComponent, -) -> wgpu_types::BlendState { - wgpu_types::BlendState { - src_factor: blend - .src_factor - .as_ref() - .map_or(wgpu_types::BlendFactor::One, |factor| { - serialize_blend_factor(factor) - }), - dst_factor: blend - .dst_factor - .as_ref() - .map_or(wgpu_types::BlendFactor::Zero, |factor| { - serialize_blend_factor(factor) - }), - operation: match &blend.operation { - Some(operation) => match operation.as_str() { - "add" => wgpu_types::BlendOperation::Add, - "subtract" => wgpu_types::BlendOperation::Subtract, - "reverse-subtract" => wgpu_types::BlendOperation::ReverseSubtract, - "min" => wgpu_types::BlendOperation::Min, - "max" => wgpu_types::BlendOperation::Max, - _ => unreachable!(), - }, - None => wgpu_types::BlendOperation::Add, - }, - } -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuProgrammableStage { - module: u32, - entry_point: String, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct CreateComputePipelineArgs { - device_rid: ResourceId, - label: Option<String>, - layout: Option<u32>, - compute: GpuProgrammableStage, -} - -pub fn op_webgpu_create_compute_pipeline( - state: &mut OpState, - args: CreateComputePipelineArgs, - _zero_copy: Option<ZeroCopyBuf>, -) -> Result<WebGpuResult, AnyError> { - let instance = state.borrow::<super::Instance>(); - let device_resource = state - .resource_table - .get::<super::WebGpuDevice>(args.device_rid) - .ok_or_else(bad_resource_id)?; - let device = device_resource.0; - - let pipeline_layout = if let Some(rid) = args.layout { - let id = state - .resource_table - .get::<WebGpuPipelineLayout>(rid) - .ok_or_else(bad_resource_id)?; - Some(id.0) - } else { - None - }; - - let compute_shader_module_resource = state - .resource_table - .get::<super::shader::WebGpuShaderModule>(args.compute.module) - .ok_or_else(bad_resource_id)?; - - let descriptor = wgpu_core::pipeline::ComputePipelineDescriptor { - label: args.label.map(Cow::from), - layout: pipeline_layout, - stage: wgpu_core::pipeline::ProgrammableStageDescriptor { - module: compute_shader_module_resource.0, - entry_point: Cow::from(args.compute.entry_point), - }, - }; - let implicit_pipelines = match args.layout { - Some(_) => None, - None => Some(wgpu_core::device::ImplicitPipelineIds { - root_id: std::marker::PhantomData, - group_ids: &[std::marker::PhantomData; wgpu_core::MAX_BIND_GROUPS], - }), - }; - - let (compute_pipeline, _, maybe_err) = gfx_select!(device => instance.device_create_compute_pipeline( - device, - &descriptor, - std::marker::PhantomData, - implicit_pipelines - )); - - let rid = state - .resource_table - .add(WebGpuComputePipeline(compute_pipeline)); - - Ok(WebGpuResult::rid_err(rid, maybe_err)) -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct ComputePipelineGetBindGroupLayoutArgs { - compute_pipeline_rid: ResourceId, - index: u32, -} - -#[derive(Serialize)] -#[serde(rename_all = "camelCase")] -pub struct PipelineLayout { - rid: ResourceId, - label: String, - err: Option<WebGpuError>, -} - -pub fn op_webgpu_compute_pipeline_get_bind_group_layout( - state: &mut OpState, - args: ComputePipelineGetBindGroupLayoutArgs, - _zero_copy: Option<ZeroCopyBuf>, -) -> Result<PipelineLayout, AnyError> { - let instance = state.borrow::<super::Instance>(); - let compute_pipeline_resource = state - .resource_table - .get::<WebGpuComputePipeline>(args.compute_pipeline_rid) - .ok_or_else(bad_resource_id)?; - let compute_pipeline = compute_pipeline_resource.0; - - let (bind_group_layout, maybe_err) = gfx_select!(compute_pipeline => instance.compute_pipeline_get_bind_group_layout(compute_pipeline, args.index, std::marker::PhantomData)); - - let label = gfx_select!(bind_group_layout => instance.bind_group_layout_label(bind_group_layout)); - - let rid = state - .resource_table - .add(super::binding::WebGpuBindGroupLayout(bind_group_layout)); - - Ok(PipelineLayout { - rid, - label, - err: maybe_err.map(WebGpuError::from), - }) -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuPrimitiveState { - topology: Option<String>, - strip_index_format: Option<String>, - front_face: Option<String>, - cull_mode: Option<String>, -} - -#[derive(Deserialize, Clone)] -#[serde(rename_all = "camelCase")] -struct GpuBlendComponent { - src_factor: Option<String>, - dst_factor: Option<String>, - operation: Option<String>, -} - -#[derive(Deserialize, Clone)] -#[serde(rename_all = "camelCase")] -struct GpuBlendState { - color: GpuBlendComponent, - alpha: GpuBlendComponent, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuColorTargetState { - format: String, - blend: Option<GpuBlendState>, - write_mask: Option<u32>, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuStencilFaceState { - compare: Option<String>, - fail_op: Option<String>, - depth_fail_op: Option<String>, - pass_op: Option<String>, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuDepthStencilState { - format: String, - depth_write_enabled: Option<bool>, - depth_compare: Option<String>, - stencil_front: Option<GpuStencilFaceState>, - stencil_back: Option<GpuStencilFaceState>, - stencil_read_mask: Option<u32>, - stencil_write_mask: Option<u32>, - depth_bias: Option<i32>, - depth_bias_slope_scale: Option<f32>, - depth_bias_clamp: Option<f32>, - clamp_depth: Option<bool>, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuVertexAttribute { - format: String, - offset: u64, - shader_location: u32, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuVertexBufferLayout { - array_stride: u64, - step_mode: Option<String>, - attributes: Vec<GpuVertexAttribute>, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuVertexState { - module: u32, - entry_point: String, - buffers: Option<Vec<Option<GpuVertexBufferLayout>>>, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuMultisampleState { - count: Option<u32>, - mask: Option<u64>, // against spec, but future proof - alpha_to_coverage_enabled: Option<bool>, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct GpuFragmentState { - targets: Vec<GpuColorTargetState>, - module: u32, - entry_point: String, -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct CreateRenderPipelineArgs { - device_rid: ResourceId, - label: Option<String>, - layout: Option<u32>, - vertex: GpuVertexState, - primitive: Option<GpuPrimitiveState>, - depth_stencil: Option<GpuDepthStencilState>, - multisample: Option<GpuMultisampleState>, - fragment: Option<GpuFragmentState>, -} - -pub fn op_webgpu_create_render_pipeline( - state: &mut OpState, - args: CreateRenderPipelineArgs, - _zero_copy: Option<ZeroCopyBuf>, -) -> Result<WebGpuResult, AnyError> { - let instance = state.borrow::<super::Instance>(); - let device_resource = state - .resource_table - .get::<super::WebGpuDevice>(args.device_rid) - .ok_or_else(bad_resource_id)?; - let device = device_resource.0; - - let layout = if let Some(rid) = args.layout { - let pipeline_layout_resource = state - .resource_table - .get::<WebGpuPipelineLayout>(rid) - .ok_or_else(bad_resource_id)?; - Some(pipeline_layout_resource.0) - } else { - None - }; - - let vertex_shader_module_resource = state - .resource_table - .get::<super::shader::WebGpuShaderModule>(args.vertex.module) - .ok_or_else(bad_resource_id)?; - - let descriptor = wgpu_core::pipeline::RenderPipelineDescriptor { - label: args.label.map(Cow::from), - layout, - vertex: wgpu_core::pipeline::VertexState { - stage: wgpu_core::pipeline::ProgrammableStageDescriptor { - module: vertex_shader_module_resource.0, - entry_point: Cow::from(args.vertex.entry_point), - }, - buffers: Cow::from(if let Some(buffers) = args.vertex.buffers { - let mut return_buffers = vec![]; - for buffer in buffers.into_iter().flatten() { - return_buffers.push(wgpu_core::pipeline::VertexBufferLayout { - array_stride: buffer.array_stride, - step_mode: match buffer.step_mode { - Some(step_mode) => match step_mode.as_str() { - "vertex" => wgpu_types::InputStepMode::Vertex, - "instance" => wgpu_types::InputStepMode::Instance, - _ => unreachable!(), - }, - None => wgpu_types::InputStepMode::Vertex, - }, - attributes: Cow::from( - buffer - .attributes - .iter() - .map(|attribute| wgpu_types::VertexAttribute { - format: match attribute.format.as_str() { - "uchar2" => wgpu_types::VertexFormat::Uchar2, - "uchar4" => wgpu_types::VertexFormat::Uchar4, - "char2" => wgpu_types::VertexFormat::Char2, - "char4" => wgpu_types::VertexFormat::Char4, - "uchar2norm" => wgpu_types::VertexFormat::Uchar2Norm, - "uchar4norm" => wgpu_types::VertexFormat::Uchar4, - "char2norm" => wgpu_types::VertexFormat::Char2Norm, - "char4norm" => wgpu_types::VertexFormat::Char4Norm, - "ushort2" => wgpu_types::VertexFormat::Ushort2, - "ushort4" => wgpu_types::VertexFormat::Ushort4, - "short2" => wgpu_types::VertexFormat::Short2, - "short4" => wgpu_types::VertexFormat::Short4, - "ushort2norm" => wgpu_types::VertexFormat::Ushort2Norm, - "ushort4norm" => wgpu_types::VertexFormat::Ushort4Norm, - "short2norm" => wgpu_types::VertexFormat::Short2Norm, - "short4norm" => wgpu_types::VertexFormat::Short4Norm, - "half2" => wgpu_types::VertexFormat::Half2, - "half4" => wgpu_types::VertexFormat::Half4, - "float" => wgpu_types::VertexFormat::Float, - "float2" => wgpu_types::VertexFormat::Float2, - "float3" => wgpu_types::VertexFormat::Float3, - "float4" => wgpu_types::VertexFormat::Float4, - "uint" => wgpu_types::VertexFormat::Uint, - "uint2" => wgpu_types::VertexFormat::Uint2, - "uint3" => wgpu_types::VertexFormat::Uint3, - "uint4" => wgpu_types::VertexFormat::Uint4, - "int" => wgpu_types::VertexFormat::Int, - "int2" => wgpu_types::VertexFormat::Int2, - "int3" => wgpu_types::VertexFormat::Int3, - "int4" => wgpu_types::VertexFormat::Int4, - _ => unreachable!(), - }, - offset: attribute.offset, - shader_location: attribute.shader_location, - }) - .collect::<Vec<wgpu_types::VertexAttribute>>(), - ), - }); - } - return_buffers - } else { - vec![] - }), - }, - primitive: args.primitive.map_or(Default::default(), |primitive| { - wgpu_types::PrimitiveState { - topology: match primitive.topology { - Some(topology) => match topology.as_str() { - "point-list" => wgpu_types::PrimitiveTopology::PointList, - "line-list" => wgpu_types::PrimitiveTopology::LineList, - "line-strip" => wgpu_types::PrimitiveTopology::LineStrip, - "triangle-list" => wgpu_types::PrimitiveTopology::TriangleList, - "triangle-strip" => wgpu_types::PrimitiveTopology::TriangleStrip, - _ => unreachable!(), - }, - None => wgpu_types::PrimitiveTopology::TriangleList, - }, - strip_index_format: primitive - .strip_index_format - .map(serialize_index_format), - front_face: match primitive.front_face { - Some(front_face) => match front_face.as_str() { - "ccw" => wgpu_types::FrontFace::Ccw, - "cw" => wgpu_types::FrontFace::Cw, - _ => unreachable!(), - }, - None => wgpu_types::FrontFace::Ccw, - }, - cull_mode: match primitive.cull_mode { - Some(cull_mode) => match cull_mode.as_str() { - "none" => wgpu_types::CullMode::None, - "front" => wgpu_types::CullMode::Front, - "back" => wgpu_types::CullMode::Back, - _ => unreachable!(), - }, - None => wgpu_types::CullMode::None, - }, - polygon_mode: Default::default(), // native-only - } - }), - depth_stencil: args.depth_stencil.map(|depth_stencil| { - wgpu_types::DepthStencilState { - format: super::texture::serialize_texture_format(&depth_stencil.format) - .unwrap(), - depth_write_enabled: depth_stencil.depth_write_enabled.unwrap_or(false), - depth_compare: match depth_stencil.depth_compare { - Some(depth_compare) => { - super::sampler::serialize_compare_function(&depth_compare) - } - None => wgpu_types::CompareFunction::Always, - }, - stencil: wgpu_types::StencilState { - front: depth_stencil - .stencil_front - .map_or(Default::default(), serialize_stencil_face_state), - back: depth_stencil - .stencil_back - .map_or(Default::default(), serialize_stencil_face_state), - read_mask: depth_stencil.stencil_read_mask.unwrap_or(0xFFFFFFFF), - write_mask: depth_stencil.stencil_write_mask.unwrap_or(0xFFFFFFFF), - }, - bias: wgpu_types::DepthBiasState { - constant: depth_stencil.depth_bias.unwrap_or(0), - slope_scale: depth_stencil.depth_bias_slope_scale.unwrap_or(0.0), - clamp: depth_stencil.depth_bias_clamp.unwrap_or(0.0), - }, - clamp_depth: depth_stencil.clamp_depth.unwrap_or(false), - } - }), - multisample: args.multisample.map_or(Default::default(), |multisample| { - wgpu_types::MultisampleState { - count: multisample.count.unwrap_or(1), - mask: multisample.mask.unwrap_or(0xFFFFFFFF), - alpha_to_coverage_enabled: multisample - .alpha_to_coverage_enabled - .unwrap_or(false), - } - }), - fragment: args.fragment.map(|fragment| { - let fragment_shader_module_resource = state - .resource_table - .get::<super::shader::WebGpuShaderModule>(fragment.module) - .ok_or_else(bad_resource_id) - .unwrap(); - - wgpu_core::pipeline::FragmentState { - stage: wgpu_core::pipeline::ProgrammableStageDescriptor { - module: fragment_shader_module_resource.0, - entry_point: Cow::from(fragment.entry_point), - }, - targets: Cow::from( - fragment - .targets - .iter() - .map(|target| { - let blends = target.blend.clone().map(|blend| { - ( - serialize_blend_component(blend.alpha), - serialize_blend_component(blend.color), - ) - }); - - wgpu_types::ColorTargetState { - format: super::texture::serialize_texture_format( - &target.format, - ) - .unwrap(), - alpha_blend: blends - .clone() - .map_or(Default::default(), |states| states.0), - color_blend: blends - .map_or(Default::default(), |states| states.1), - write_mask: target - .write_mask - .map_or(Default::default(), |mask| { - wgpu_types::ColorWrite::from_bits(mask).unwrap() - }), - } - }) - .collect::<Vec<wgpu_types::ColorTargetState>>(), - ), - } - }), - }; - - let implicit_pipelines = match args.layout { - Some(_) => None, - None => Some(wgpu_core::device::ImplicitPipelineIds { - root_id: std::marker::PhantomData, - group_ids: &[std::marker::PhantomData; wgpu_core::MAX_BIND_GROUPS], - }), - }; - - let (render_pipeline, _, maybe_err) = gfx_select!(device => instance.device_create_render_pipeline( - device, - &descriptor, - std::marker::PhantomData, - implicit_pipelines - )); - - let rid = state - .resource_table - .add(WebGpuRenderPipeline(render_pipeline)); - - Ok(WebGpuResult::rid_err(rid, maybe_err)) -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPipelineGetBindGroupLayoutArgs { - render_pipeline_rid: ResourceId, - index: u32, -} - -pub fn op_webgpu_render_pipeline_get_bind_group_layout( - state: &mut OpState, - args: RenderPipelineGetBindGroupLayoutArgs, - _zero_copy: Option<ZeroCopyBuf>, -) -> Result<PipelineLayout, AnyError> { - let instance = state.borrow::<super::Instance>(); - let render_pipeline_resource = state - .resource_table - .get::<WebGpuRenderPipeline>(args.render_pipeline_rid) - .ok_or_else(bad_resource_id)?; - let render_pipeline = render_pipeline_resource.0; - - let (bind_group_layout, maybe_err) = gfx_select!(render_pipeline => instance.render_pipeline_get_bind_group_layout(render_pipeline, args.index, std::marker::PhantomData)); - - let label = gfx_select!(bind_group_layout => instance.bind_group_layout_label(bind_group_layout)); - - let rid = state - .resource_table - .add(super::binding::WebGpuBindGroupLayout(bind_group_layout)); - - Ok(PipelineLayout { - rid, - label, - err: maybe_err.map(WebGpuError::from), - }) -} |