diff options
Diffstat (limited to 'ext/webgpu/src/render_pass.rs')
| -rw-r--r-- | ext/webgpu/src/render_pass.rs | 358 |
1 files changed, 123 insertions, 235 deletions
diff --git a/ext/webgpu/src/render_pass.rs b/ext/webgpu/src/render_pass.rs index 5d2cd6e5a..9fe5f71fc 100644 --- a/ext/webgpu/src/render_pass.rs +++ b/ext/webgpu/src/render_pass.rs @@ -3,9 +3,10 @@ use deno_core::error::type_error; use deno_core::error::AnyError; use deno_core::op; +use deno_core::OpState; +use deno_core::Resource; use deno_core::ResourceId; use deno_core::ZeroCopyBuf; -use deno_core::{OpState, Resource}; use serde::Deserialize; use std::borrow::Cow; use std::cell::RefCell; @@ -55,127 +56,97 @@ pub fn op_webgpu_render_pass_set_viewport( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetScissorRectArgs { +#[op] +pub fn op_webgpu_render_pass_set_scissor_rect( + state: &mut OpState, render_pass_rid: ResourceId, x: u32, y: u32, width: u32, height: u32, -} - -#[op] -pub fn op_webgpu_render_pass_set_scissor_rect( - state: &mut OpState, - args: RenderPassSetScissorRectArgs, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_set_scissor_rect( &mut render_pass_resource.0.borrow_mut(), - args.x, - args.y, - args.width, - args.height, + x, + y, + width, + height, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetBlendConstantArgs { - render_pass_rid: ResourceId, - color: wgpu_types::Color, -} - #[op] pub fn op_webgpu_render_pass_set_blend_constant( state: &mut OpState, - args: RenderPassSetBlendConstantArgs, + render_pass_rid: ResourceId, + color: wgpu_types::Color, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_set_blend_constant( &mut render_pass_resource.0.borrow_mut(), - &args.color, + &color, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetStencilReferenceArgs { - render_pass_rid: ResourceId, - reference: u32, -} - #[op] pub fn op_webgpu_render_pass_set_stencil_reference( state: &mut OpState, - args: RenderPassSetStencilReferenceArgs, + render_pass_rid: ResourceId, + reference: u32, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_set_stencil_reference( &mut render_pass_resource.0.borrow_mut(), - args.reference, + reference, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassBeginPipelineStatisticsQueryArgs { - render_pass_rid: ResourceId, - query_set: u32, - query_index: u32, -} - #[op] pub fn op_webgpu_render_pass_begin_pipeline_statistics_query( state: &mut OpState, - args: RenderPassBeginPipelineStatisticsQueryArgs, + render_pass_rid: ResourceId, + query_set: u32, + query_index: u32, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; let query_set_resource = state .resource_table - .get::<super::WebGpuQuerySet>(args.query_set)?; + .get::<super::WebGpuQuerySet>(query_set)?; wgpu_core::command::render_ffi::wgpu_render_pass_begin_pipeline_statistics_query( &mut render_pass_resource.0.borrow_mut(), query_set_resource.0, - args.query_index, + query_index, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassEndPipelineStatisticsQueryArgs { - render_pass_rid: ResourceId, -} - #[op] pub fn op_webgpu_render_pass_end_pipeline_statistics_query( state: &mut OpState, - args: RenderPassEndPipelineStatisticsQueryArgs, + render_pass_rid: ResourceId, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_end_pipeline_statistics_query( &mut render_pass_resource.0.borrow_mut(), @@ -184,136 +155,113 @@ pub fn op_webgpu_render_pass_end_pipeline_statistics_query( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassWriteTimestampArgs { - render_pass_rid: ResourceId, - query_set: u32, - query_index: u32, -} - #[op] pub fn op_webgpu_render_pass_write_timestamp( state: &mut OpState, - args: RenderPassWriteTimestampArgs, + render_pass_rid: ResourceId, + query_set: u32, + query_index: u32, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; let query_set_resource = state .resource_table - .get::<super::WebGpuQuerySet>(args.query_set)?; + .get::<super::WebGpuQuerySet>(query_set)?; wgpu_core::command::render_ffi::wgpu_render_pass_write_timestamp( &mut render_pass_resource.0.borrow_mut(), query_set_resource.0, - args.query_index, + query_index, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassExecuteBundlesArgs { - render_pass_rid: ResourceId, - bundles: Vec<u32>, -} - #[op] pub fn op_webgpu_render_pass_execute_bundles( state: &mut OpState, - args: RenderPassExecuteBundlesArgs, + render_pass_rid: ResourceId, + bundles: Vec<u32>, ) -> Result<WebGpuResult, AnyError> { - let mut render_bundle_ids = vec![]; - - for rid in &args.bundles { - let render_bundle_resource = - state - .resource_table - .get::<super::bundle::WebGpuRenderBundle>(*rid)?; - render_bundle_ids.push(render_bundle_resource.0); - } + let bundles = bundles + .iter() + .map(|rid| { + let render_bundle_resource = + state + .resource_table + .get::<super::bundle::WebGpuRenderBundle>(*rid)?; + Ok(render_bundle_resource.0) + }) + .collect::<Result<Vec<_>, AnyError>>()?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; // SAFETY: the raw pointer and length are of the same slice, and that slice // lives longer than the below function invocation. unsafe { wgpu_core::command::render_ffi::wgpu_render_pass_execute_bundles( &mut render_pass_resource.0.borrow_mut(), - render_bundle_ids.as_ptr(), - render_bundle_ids.len(), + bundles.as_ptr(), + bundles.len(), ); } Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassEndPassArgs { - command_encoder_rid: ResourceId, - render_pass_rid: ResourceId, -} - #[op] -pub fn op_webgpu_render_pass_end_pass( +pub fn op_webgpu_render_pass_end( state: &mut OpState, - args: RenderPassEndPassArgs, + command_encoder_rid: ResourceId, + render_pass_rid: ResourceId, ) -> Result<WebGpuResult, AnyError> { let command_encoder_resource = state .resource_table .get::<super::command_encoder::WebGpuCommandEncoder>( - args.command_encoder_rid, + command_encoder_rid, )?; let command_encoder = command_encoder_resource.0; let render_pass_resource = state .resource_table - .take::<WebGpuRenderPass>(args.render_pass_rid)?; + .take::<WebGpuRenderPass>(render_pass_rid)?; let render_pass = &render_pass_resource.0.borrow(); let instance = state.borrow::<super::Instance>(); gfx_ok!(command_encoder => instance.command_encoder_run_render_pass(command_encoder, render_pass)) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetBindGroupArgs { +#[op] +pub fn op_webgpu_render_pass_set_bind_group( + state: &mut OpState, render_pass_rid: ResourceId, index: u32, bind_group: u32, dynamic_offsets_data: ZeroCopyBuf, dynamic_offsets_data_start: usize, dynamic_offsets_data_length: usize, -} - -#[op] -pub fn op_webgpu_render_pass_set_bind_group( - state: &mut OpState, - args: RenderPassSetBindGroupArgs, ) -> Result<WebGpuResult, AnyError> { let bind_group_resource = state .resource_table - .get::<super::binding::WebGpuBindGroup>(args.bind_group)?; + .get::<super::binding::WebGpuBindGroup>(bind_group)?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; // Align the data - assert!(args.dynamic_offsets_data_start % std::mem::size_of::<u32>() == 0); + assert_eq!(dynamic_offsets_data_start % std::mem::size_of::<u32>(), 0); let (prefix, dynamic_offsets_data, suffix) = - // SAFETY: A u8 to u32 cast is safe because we asserted that the length is a - // multiple of 4. - unsafe { args.dynamic_offsets_data.align_to::<u32>() }; + // SAFETY: A u8 to u32 cast is safe because we asserted that the length is a + // multiple of 4. + unsafe { dynamic_offsets_data.align_to::<u32>() }; assert!(prefix.is_empty()); assert!(suffix.is_empty()); - let start = args.dynamic_offsets_data_start; - let len = args.dynamic_offsets_data_length; + let start = dynamic_offsets_data_start; + let len = dynamic_offsets_data_length; // Assert that length and start are both in bounds assert!(start <= dynamic_offsets_data.len()); @@ -326,7 +274,7 @@ pub fn op_webgpu_render_pass_set_bind_group( unsafe { wgpu_core::command::render_ffi::wgpu_render_pass_set_bind_group( &mut render_pass_resource.0.borrow_mut(), - args.index, + index, bind_group_resource.0, dynamic_offsets_data.as_ptr(), dynamic_offsets_data.len(), @@ -336,23 +284,17 @@ pub fn op_webgpu_render_pass_set_bind_group( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassPushDebugGroupArgs { - render_pass_rid: ResourceId, - group_label: String, -} - #[op] pub fn op_webgpu_render_pass_push_debug_group( state: &mut OpState, - args: RenderPassPushDebugGroupArgs, + render_pass_rid: ResourceId, + group_label: String, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; - let label = std::ffi::CString::new(args.group_label).unwrap(); + let label = std::ffi::CString::new(group_label).unwrap(); // SAFETY: the string the raw pointer points to lives longer than the below // function invocation. unsafe { @@ -366,20 +308,14 @@ pub fn op_webgpu_render_pass_push_debug_group( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassPopDebugGroupArgs { - render_pass_rid: ResourceId, -} - #[op] pub fn op_webgpu_render_pass_pop_debug_group( state: &mut OpState, - args: RenderPassPopDebugGroupArgs, + render_pass_rid: ResourceId, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_pop_debug_group( &mut render_pass_resource.0.borrow_mut(), @@ -388,23 +324,17 @@ pub fn op_webgpu_render_pass_pop_debug_group( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassInsertDebugMarkerArgs { - render_pass_rid: ResourceId, - marker_label: String, -} - #[op] pub fn op_webgpu_render_pass_insert_debug_marker( state: &mut OpState, - args: RenderPassInsertDebugMarkerArgs, + render_pass_rid: ResourceId, + marker_label: String, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; - let label = std::ffi::CString::new(args.marker_label).unwrap(); + let label = std::ffi::CString::new(marker_label).unwrap(); // SAFETY: the string the raw pointer points to lives longer than the below // function invocation. unsafe { @@ -418,25 +348,19 @@ pub fn op_webgpu_render_pass_insert_debug_marker( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetPipelineArgs { - render_pass_rid: ResourceId, - pipeline: u32, -} - #[op] pub fn op_webgpu_render_pass_set_pipeline( state: &mut OpState, - args: RenderPassSetPipelineArgs, + render_pass_rid: ResourceId, + pipeline: u32, ) -> Result<WebGpuResult, AnyError> { let render_pipeline_resource = state .resource_table - .get::<super::pipeline::WebGpuRenderPipeline>(args.pipeline)?; + .get::<super::pipeline::WebGpuRenderPipeline>(pipeline)?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_set_pipeline( &mut render_pass_resource.0.borrow_mut(), @@ -446,29 +370,23 @@ pub fn op_webgpu_render_pass_set_pipeline( Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetIndexBufferArgs { +#[op] +pub fn op_webgpu_render_pass_set_index_buffer( + state: &mut OpState, render_pass_rid: ResourceId, buffer: u32, index_format: wgpu_types::IndexFormat, offset: u64, size: Option<u64>, -} - -#[op] -pub fn op_webgpu_render_pass_set_index_buffer( - state: &mut OpState, - args: RenderPassSetIndexBufferArgs, ) -> Result<WebGpuResult, AnyError> { let buffer_resource = state .resource_table - .get::<super::buffer::WebGpuBuffer>(args.buffer)?; + .get::<super::buffer::WebGpuBuffer>(buffer)?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; - let size = if let Some(size) = args.size { + let size = if let Some(size) = size { Some( std::num::NonZeroU64::new(size) .ok_or_else(|| type_error("size must be larger than 0"))?, @@ -479,37 +397,31 @@ pub fn op_webgpu_render_pass_set_index_buffer( render_pass_resource.0.borrow_mut().set_index_buffer( buffer_resource.0, - args.index_format, - args.offset, + index_format, + offset, size, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassSetVertexBufferArgs { +#[op] +pub fn op_webgpu_render_pass_set_vertex_buffer( + state: &mut OpState, render_pass_rid: ResourceId, slot: u32, buffer: u32, offset: u64, size: Option<u64>, -} - -#[op] -pub fn op_webgpu_render_pass_set_vertex_buffer( - state: &mut OpState, - args: RenderPassSetVertexBufferArgs, ) -> Result<WebGpuResult, AnyError> { let buffer_resource = state .resource_table - .get::<super::buffer::WebGpuBuffer>(args.buffer)?; + .get::<super::buffer::WebGpuBuffer>(buffer)?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; - let size = if let Some(size) = args.size { + let size = if let Some(size) = size { Some( std::num::NonZeroU64::new(size) .ok_or_else(|| type_error("size must be larger than 0"))?, @@ -520,130 +432,106 @@ pub fn op_webgpu_render_pass_set_vertex_buffer( wgpu_core::command::render_ffi::wgpu_render_pass_set_vertex_buffer( &mut render_pass_resource.0.borrow_mut(), - args.slot, + slot, buffer_resource.0, - args.offset, + offset, size, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassDrawArgs { +#[op] +pub fn op_webgpu_render_pass_draw( + state: &mut OpState, render_pass_rid: ResourceId, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32, -} - -#[op] -pub fn op_webgpu_render_pass_draw( - state: &mut OpState, - args: RenderPassDrawArgs, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_draw( &mut render_pass_resource.0.borrow_mut(), - args.vertex_count, - args.instance_count, - args.first_vertex, - args.first_instance, + vertex_count, + instance_count, + first_vertex, + first_instance, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassDrawIndexedArgs { +#[op] +pub fn op_webgpu_render_pass_draw_indexed( + state: &mut OpState, render_pass_rid: ResourceId, index_count: u32, instance_count: u32, first_index: u32, base_vertex: i32, first_instance: u32, -} - -#[op] -pub fn op_webgpu_render_pass_draw_indexed( - state: &mut OpState, - args: RenderPassDrawIndexedArgs, ) -> Result<WebGpuResult, AnyError> { let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed( &mut render_pass_resource.0.borrow_mut(), - args.index_count, - args.instance_count, - args.first_index, - args.base_vertex, - args.first_instance, + index_count, + instance_count, + first_index, + base_vertex, + first_instance, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassDrawIndirectArgs { - render_pass_rid: ResourceId, - indirect_buffer: u32, - indirect_offset: u64, -} - #[op] pub fn op_webgpu_render_pass_draw_indirect( state: &mut OpState, - args: RenderPassDrawIndirectArgs, + render_pass_rid: ResourceId, + indirect_buffer: u32, + indirect_offset: u64, ) -> Result<WebGpuResult, AnyError> { let buffer_resource = state .resource_table - .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)?; + .get::<super::buffer::WebGpuBuffer>(indirect_buffer)?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_draw_indirect( &mut render_pass_resource.0.borrow_mut(), buffer_resource.0, - args.indirect_offset, + indirect_offset, ); Ok(WebGpuResult::empty()) } -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -pub struct RenderPassDrawIndexedIndirectArgs { - render_pass_rid: ResourceId, - indirect_buffer: u32, - indirect_offset: u64, -} - #[op] pub fn op_webgpu_render_pass_draw_indexed_indirect( state: &mut OpState, - args: RenderPassDrawIndexedIndirectArgs, + render_pass_rid: ResourceId, + indirect_buffer: u32, + indirect_offset: u64, ) -> Result<WebGpuResult, AnyError> { let buffer_resource = state .resource_table - .get::<super::buffer::WebGpuBuffer>(args.indirect_buffer)?; + .get::<super::buffer::WebGpuBuffer>(indirect_buffer)?; let render_pass_resource = state .resource_table - .get::<WebGpuRenderPass>(args.render_pass_rid)?; + .get::<WebGpuRenderPass>(render_pass_rid)?; wgpu_core::command::render_ffi::wgpu_render_pass_draw_indexed_indirect( &mut render_pass_resource.0.borrow_mut(), buffer_resource.0, - args.indirect_offset, + indirect_offset, ); Ok(WebGpuResult::empty()) |