wgpu 1.2.0 → 1.2.1

data/lib/wgpu/commands/command_encoder.rb

@@ -4,6 +4,10 @@ module WGPU
   class CommandEncoder
     attr_reader :handle
 
+    # Creates an encoder for commands submitted to a device queue.
+    # @param device [Device] owning device
+    # @param label [String, nil] optional debug label
+    # @raise [CommandError] if the native encoder cannot be created
     def initialize(device, label: nil)
       @device = device
       @finished = false
@@ -24,6 +28,11 @@ module WGPU
       raise CommandError, "Failed to create command encoder" if @handle.null?
     end
 
+    # Begins a compute pass, optionally yielding it for scoped recording.
+    # @param label [String, nil] optional debug label
+    # @param timestamp_writes [Hash, nil] timestamp query settings
+    # @yieldparam pass [ComputePass] newly created pass
+    # @return [ComputePass, Object] pass without a block, otherwise the block result
     def begin_compute_pass(label: nil, timestamp_writes: nil)
       ensure_can_begin_pass!
       pass = ComputePass.new(self, label: label, timestamp_writes: timestamp_writes)
@@ -42,6 +51,10 @@ module WGPU
       end
     end
 
+    # Begins a render pass, optionally yielding it for scoped recording.
+    # @param color_attachments [Array<Hash>] color attachment descriptors
+    # @yieldparam pass [RenderPass] newly created pass
+    # @return [RenderPass, Object] pass without a block, otherwise the block result
     def begin_render_pass(color_attachments:, depth_stencil_attachment: nil, occlusion_query_set: nil, timestamp_writes: nil, max_draw_count: nil, label: nil)
       ensure_can_begin_pass!
       pass = RenderPass.new(self,
@@ -67,6 +80,8 @@ module WGPU
       end
     end
 
+    # Copies bytes between buffers.
+    # @return [void]
     def copy_buffer_to_buffer(source:, source_offset: 0, destination:, destination_offset: 0, size:)
       raise CommandError, "Encoder already finished" if @finished
       Native.wgpuCommandEncoderCopyBufferToBuffer(
@@ -77,6 +92,11 @@ module WGPU
       )
     end
 
+    # Copies buffer data into a texture region.
+    # @param source [Hash] buffer and layout descriptor
+    # @param destination [Hash] texture and origin descriptor
+    # @param copy_size [Hash, Array] extent to copy
+    # @return [void]
     def copy_buffer_to_texture(source:, destination:, copy_size:)
       raise CommandError, "Encoder already finished" if @finished
 
@@ -106,6 +126,11 @@ module WGPU
       Native.wgpuCommandEncoderCopyBufferToTexture(@handle, src, dst, size)
     end
 
+    # Copies a texture region into a buffer.
+    # @param source [Hash] texture and origin descriptor
+    # @param destination [Hash] buffer and layout descriptor
+    # @param copy_size [Hash, Array] extent to copy
+    # @return [void]
     def copy_texture_to_buffer(source:, destination:, copy_size:)
       raise CommandError, "Encoder already finished" if @finished
 
@@ -135,6 +160,11 @@ module WGPU
       Native.wgpuCommandEncoderCopyTextureToBuffer(@handle, src, dst, size)
     end
 
+    # Copies one texture region into another texture.
+    # @param source [Hash] source texture and origin descriptor
+    # @param destination [Hash] destination texture and origin descriptor
+    # @param copy_size [Hash, Array] extent to copy
+    # @return [void]
     def copy_texture_to_texture(source:, destination:, copy_size:)
       raise CommandError, "Encoder already finished" if @finished
 
@@ -170,6 +200,8 @@ module WGPU
       Native.wgpuCommandEncoderCopyTextureToTexture(@handle, src, dst, size)
     end
 
+    # Resolves query results into a destination buffer.
+    # @return [void]
     def resolve_query_set(query_set:, first_query:, query_count:, destination:, destination_offset:)
       raise CommandError, "Encoder already finished" if @finished
       Native.wgpuCommandEncoderResolveQuerySet(
@@ -182,17 +214,29 @@ module WGPU
       )
     end
 
+    # Clears a byte range in a buffer to zero.
+    # @param buffer [Buffer] buffer to clear
+    # @param offset [Integer] first byte to clear
+    # @param size [Integer, nil] number of bytes to clear
+    # @return [void]
     def clear_buffer(buffer, offset: 0, size: nil)
       raise CommandError, "Encoder already finished" if @finished
       size ||= buffer.size - offset
       Native.wgpuCommandEncoderClearBuffer(@handle, buffer.handle, offset, size)
     end
 
+    # Writes a GPU timestamp to a query set.
+    # @param query_set [QuerySet] timestamp query set
+    # @param query_index [Integer] destination query index
+    # @return [void]
     def write_timestamp(query_set, query_index)
       raise CommandError, "Encoder already finished" if @finished
       Native.wgpuCommandEncoderWriteTimestamp(@handle, query_set.handle, query_index)
     end
 
+    # Starts a labeled group in GPU debugging tools.
+    # @param label [String] group label
+    # @return [void]
     def push_debug_group(label)
       raise CommandError, "Encoder already finished" if @finished
       label_view = Native::StringView.new
@@ -202,11 +246,16 @@ module WGPU
       Native.wgpuCommandEncoderPushDebugGroup(@handle, label_view)
     end
 
+    # Ends the most recently pushed debug group.
+    # @return [void]
     def pop_debug_group
       raise CommandError, "Encoder already finished" if @finished
       Native.wgpuCommandEncoderPopDebugGroup(@handle)
     end
 
+    # Inserts a labeled point in GPU debugging tools.
+    # @param label [String] marker label
+    # @return [void]
     def insert_debug_marker(label)
       raise CommandError, "Encoder already finished" if @finished
       label_view = Native::StringView.new
@@ -216,6 +265,10 @@ module WGPU
       Native.wgpuCommandEncoderInsertDebugMarker(@handle, label_view)
     end
 
+    # Finishes recording and returns a command buffer.
+    # @param label [String, nil] optional command buffer label
+    # @return [CommandBuffer]
+    # @raise [CommandError] if the encoder is finished, has an active pass, or native creation fails
     def finish(label: nil)
       raise CommandError, "Encoder already finished" if @finished
       if @active_pass && !@active_pass.ended?
@@ -235,9 +288,13 @@ module WGPU
       buffer_handle = Native.wgpuCommandEncoderFinish(@handle, desc)
       raise CommandError, "Failed to finish command encoder" if buffer_handle.null?
 
-      CommandBuffer.new(buffer_handle)
+      CommandBuffer.new(buffer_handle, device: @device)
     end
 
+    # Releases the native command encoder handle.
+    #
+    # Calling this method more than once has no effect.
+    # @return [void]
     def release
       return if @handle.null?
       Native.wgpuCommandEncoderRelease(@handle)

data/lib/wgpu/commands/compute_pass.rb

@@ -4,6 +4,11 @@ module WGPU
   class ComputePass
     attr_reader :handle
 
+    # Begins a compute pass owned by the command encoder.
+    # @param encoder [CommandEncoder] owning encoder
+    # @param label [String, nil] optional debug label
+    # @param timestamp_writes [Hash, nil] beginning and ending timestamp query settings
+    # @raise [CommandError] if the native pass cannot be created
     def initialize(encoder, label: nil, timestamp_writes: nil)
       @encoder = encoder
       @ended = false
@@ -32,10 +37,18 @@ module WGPU
       raise CommandError, "Failed to begin compute pass" if @handle.null?
     end
 
+    # Selects the compute pipeline used by subsequent dispatches.
+    # @param pipeline [ComputePipeline] pipeline to bind
+    # @return [void]
     def set_pipeline(pipeline)
       Native.wgpuComputePassEncoderSetPipeline(@handle, pipeline.handle)
     end
 
+    # Binds a resource group for subsequent dispatches.
+    # @param index [Integer] bind group index
+    # @param bind_group [BindGroup] group to bind
+    # @param dynamic_offsets [Array<Integer>] dynamic buffer offsets
+    # @return [void]
     def set_bind_group(index, bind_group, dynamic_offsets: [])
       if dynamic_offsets.empty?
         Native.wgpuComputePassEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
@@ -46,14 +59,27 @@ module WGPU
       end
     end
 
+    # Dispatches a three-dimensional compute workgroup grid.
+    # @param x [Integer] workgroup count on the x axis
+    # @param y [Integer] workgroup count on the y axis
+    # @param z [Integer] workgroup count on the z axis
+    # @return [void]
     def dispatch_workgroups(x, y = 1, z = 1)
       Native.wgpuComputePassEncoderDispatchWorkgroups(@handle, x, y, z)
     end
 
+    # Dispatches workgroups using arguments read from a buffer.
+    # @param buffer [Buffer] indirect argument buffer
+    # @param offset [Integer] byte offset of the arguments
+    # @return [void]
     def dispatch_workgroups_indirect(buffer, offset: 0)
       Native.wgpuComputePassEncoderDispatchWorkgroupsIndirect(@handle, buffer.handle, offset)
     end
 
+    # Starts a labeled group in GPU debugging tools.
+    #
+    # @param label [String] group label
+    # @return [void]
     def push_debug_group(label)
       label_view = Native::StringView.new
       label_ptr = FFI::MemoryPointer.from_string(label)
@@ -62,10 +88,17 @@ module WGPU
       Native.wgpuComputePassEncoderPushDebugGroup(@handle, label_view)
     end
 
+    # Ends the most recently pushed debug group.
+    #
+    # @return [void]
     def pop_debug_group
       Native.wgpuComputePassEncoderPopDebugGroup(@handle)
     end
 
+    # Inserts a labeled point in GPU debugging tools.
+    #
+    # @param label [String] marker label
+    # @return [void]
     def insert_debug_marker(label)
       label_view = Native::StringView.new
       label_ptr = FFI::MemoryPointer.from_string(label)
@@ -74,6 +107,8 @@ module WGPU
       Native.wgpuComputePassEncoderInsertDebugMarker(@handle, label_view)
     end
 
+    # Ends the pass if it has not already ended.
+    # @return [void]
     def end_pass
       return if @ended
 
@@ -82,14 +117,22 @@ module WGPU
       @encoder.send(:pass_ended, self)
     end
 
+    # Ends the pass.
+    # @return [void]
     def end
       end_pass
     end
 
+    # Reports whether the pass has ended.
+    # @return [Boolean]
     def ended?
       @ended
     end
 
+    # Releases the native compute pass encoder handle.
+    #
+    # Calling this method more than once has no effect.
+    # @return [void]
     def release
       return if @handle.null?
       Native.wgpuComputePassEncoderRelease(@handle)

data/lib/wgpu/commands/render_bundle.rb

@@ -4,10 +4,18 @@ module WGPU
   class RenderBundle
     attr_reader :handle
 
-    def initialize(handle)
+    # Wraps a reusable native render bundle.
+    # @param handle [FFI::Pointer] native render bundle handle
+    # @param device [Device, nil] device whose callbacks the render bundle may use
+    def initialize(handle, device: nil)
       @handle = handle
+      @device = device
     end
 
+    # Releases the native render bundle handle.
+    #
+    # Calling this method more than once has no effect.
+    # @return [void]
     def release
       return if @handle.null?
 

data/lib/wgpu/commands/render_bundle_encoder.rb

@@ -4,6 +4,15 @@ module WGPU
   class RenderBundleEncoder
     attr_reader :handle
 
+    # Creates an encoder for reusable render commands.
+    # @param device [Device] owning device
+    # @param color_formats [Array<Symbol, Integer>] color attachment formats
+    # @param depth_stencil_format [Symbol, Integer, nil] optional depth/stencil format
+    # @param sample_count [Integer] multisample count
+    # @param depth_read_only [Boolean] whether depth writes are disabled
+    # @param stencil_read_only [Boolean] whether stencil writes are disabled
+    # @param label [String, nil] optional debug label
+    # @raise [RenderBundleError] if the native encoder cannot be created
     def initialize(device, color_formats:, depth_stencil_format: nil, sample_count: 1,
                    depth_read_only: false, stencil_read_only: false, label: nil)
       @device = device
@@ -42,12 +51,21 @@ module WGPU
       raise RenderBundleError, "Failed to create render bundle encoder" if @handle.null?
     end
 
+    # Selects the pipeline used by subsequent bundle draws.
+    # @param pipeline [RenderPipeline] pipeline to bind
+    # @raise [RenderBundleError] if the encoder is finished
+    # @return [void]
     def set_pipeline(pipeline)
       raise RenderBundleError, "Encoder already finished" if @finished
 
       Native.wgpuRenderBundleEncoderSetPipeline(@handle, pipeline.handle)
     end
 
+    # Binds a resource group for subsequent bundle draws.
+    # @param index [Integer] bind group index
+    # @param bind_group [BindGroup] group to bind
+    # @param dynamic_offsets [Array<Integer>, nil] dynamic buffer offsets
+    # @return [void]
     def set_bind_group(index, bind_group, dynamic_offsets: nil)
       raise RenderBundleError, "Encoder already finished" if @finished
 
@@ -60,6 +78,10 @@ module WGPU
       end
     end
 
+    # Binds a vertex buffer to a slot.
+    # @param slot [Integer] vertex buffer slot
+    # @param buffer [Buffer] vertex data buffer
+    # @return [void]
     def set_vertex_buffer(slot, buffer, offset: 0, size: nil)
       raise RenderBundleError, "Encoder already finished" if @finished
 
@@ -67,6 +89,10 @@ module WGPU
       Native.wgpuRenderBundleEncoderSetVertexBuffer(@handle, slot, buffer.handle, offset, size)
     end
 
+    # Binds an index buffer for indexed bundle draws.
+    # @param buffer [Buffer] index data buffer
+    # @param format [Symbol, Integer] index element format
+    # @return [void]
     def set_index_buffer(buffer, format: :uint32, offset: 0, size: nil)
       raise RenderBundleError, "Encoder already finished" if @finished
 
@@ -75,30 +101,45 @@ module WGPU
       Native.wgpuRenderBundleEncoderSetIndexBuffer(@handle, buffer.handle, format_value, offset, size)
     end
 
+    # Records a non-indexed draw in the bundle.
+    # @return [void]
     def draw(vertex_count, instance_count: 1, first_vertex: 0, first_instance: 0)
       raise RenderBundleError, "Encoder already finished" if @finished
 
       Native.wgpuRenderBundleEncoderDraw(@handle, vertex_count, instance_count, first_vertex, first_instance)
     end
 
+    # Records an indexed draw in the bundle.
+    # @return [void]
     def draw_indexed(index_count, instance_count: 1, first_index: 0, base_vertex: 0, first_instance: 0)
       raise RenderBundleError, "Encoder already finished" if @finished
 
       Native.wgpuRenderBundleEncoderDrawIndexed(@handle, index_count, instance_count, first_index, base_vertex, first_instance)
     end
 
+    # Records a non-indexed draw using buffer arguments.
+    # @param buffer [Buffer] indirect argument buffer
+    # @param offset [Integer] byte offset of the arguments
+    # @return [void]
     def draw_indirect(buffer, offset: 0)
       raise RenderBundleError, "Encoder already finished" if @finished
 
       Native.wgpuRenderBundleEncoderDrawIndirect(@handle, buffer.handle, offset)
     end
 
+    # Records an indexed draw using buffer arguments.
+    # @param buffer [Buffer] indirect argument buffer
+    # @param offset [Integer] byte offset of the arguments
+    # @return [void]
     def draw_indexed_indirect(buffer, offset: 0)
       raise RenderBundleError, "Encoder already finished" if @finished
 
       Native.wgpuRenderBundleEncoderDrawIndexedIndirect(@handle, buffer.handle, offset)
     end
 
+    # Starts a labeled group in GPU debugging tools.
+    # @param label [String] group label
+    # @return [void]
     def push_debug_group(label)
       raise RenderBundleError, "Encoder already finished" if @finished
 
@@ -109,12 +150,17 @@ module WGPU
       Native.wgpuRenderBundleEncoderPushDebugGroup(@handle, label_view)
     end
 
+    # Ends the most recently pushed debug group.
+    # @return [void]
     def pop_debug_group
       raise RenderBundleError, "Encoder already finished" if @finished
 
       Native.wgpuRenderBundleEncoderPopDebugGroup(@handle)
     end
 
+    # Inserts a labeled point in GPU debugging tools.
+    # @param label [String] marker label
+    # @return [void]
     def insert_debug_marker(label)
       raise RenderBundleError, "Encoder already finished" if @finished
 
@@ -125,6 +171,10 @@ module WGPU
       Native.wgpuRenderBundleEncoderInsertDebugMarker(@handle, label_view)
     end
 
+    # Finishes recording and creates an immutable render bundle.
+    # @param label [String, nil] optional bundle label
+    # @return [RenderBundle]
+    # @raise [RenderBundleError] if already finished or native creation fails
     def finish(label: nil)
       raise RenderBundleError, "Encoder already finished" if @finished
 
@@ -142,9 +192,13 @@ module WGPU
       bundle_handle = Native.wgpuRenderBundleEncoderFinish(@handle, desc)
       raise RenderBundleError, "Failed to finish render bundle encoder" if bundle_handle.null?
 
-      RenderBundle.new(bundle_handle)
+      RenderBundle.new(bundle_handle, device: @device)
     end
 
+    # Releases the native render bundle encoder handle.
+    #
+    # Calling this method more than once has no effect.
+    # @return [void]
     def release
       return if @handle.null?
 

data/lib/wgpu/commands/render_pass.rb

@@ -4,6 +4,15 @@ module WGPU
   class RenderPass
     attr_reader :handle
 
+    # Begins a render pass owned by the command encoder.
+    # @param encoder [CommandEncoder] owning encoder
+    # @param label [String, nil] optional debug label
+    # @param color_attachments [Array<Hash>] color attachment descriptors
+    # @param depth_stencil_attachment [Hash, nil] depth/stencil attachment descriptor
+    # @param occlusion_query_set [QuerySet, nil] query set for occlusion queries
+    # @param timestamp_writes [Hash, nil] beginning and ending timestamp query settings
+    # @param max_draw_count [Integer, nil] implementation hint for the maximum draw count
+    # @raise [CommandError] if the native pass cannot be created
     def initialize(encoder, label: nil, color_attachments:, depth_stencil_attachment: nil, occlusion_query_set: nil, timestamp_writes: nil, max_draw_count: nil)
       @encoder = encoder
       @pointers = []
@@ -41,10 +50,18 @@ module WGPU
       raise CommandError, "Failed to begin render pass" if @handle.null?
     end
 
+    # Selects the render pipeline used by subsequent draws.
+    # @param pipeline [RenderPipeline] pipeline to bind
+    # @return [void]
     def set_pipeline(pipeline)
       Native.wgpuRenderPassEncoderSetPipeline(@handle, pipeline.handle)
     end
 
+    # Binds a resource group for subsequent draws.
+    # @param index [Integer] bind group index
+    # @param bind_group [BindGroup] group to bind
+    # @param dynamic_offsets [Array<Integer>] dynamic buffer offsets
+    # @return [void]
     def set_bind_group(index, bind_group, dynamic_offsets: [])
       if dynamic_offsets.empty?
         Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
@@ -55,33 +72,72 @@ module WGPU
       end
     end
 
+    # Binds a vertex buffer to a slot.
+    # @param slot [Integer] vertex buffer slot
+    # @param buffer [Buffer] vertex data buffer
+    # @param offset [Integer] first byte to bind
+    # @param size [Integer, nil] number of bytes to bind
+    # @return [void]
     def set_vertex_buffer(slot, buffer, offset: 0, size: nil)
       size ||= buffer.size - offset
       Native.wgpuRenderPassEncoderSetVertexBuffer(@handle, slot, buffer.handle, offset, size)
     end
 
+    # Binds an index buffer for indexed draws.
+    # @param buffer [Buffer] index data buffer
+    # @param format [Symbol, Integer] index element format
+    # @param offset [Integer] first byte to bind
+    # @param size [Integer, nil] number of bytes to bind
+    # @return [void]
     def set_index_buffer(buffer, format, offset: 0, size: nil)
       size ||= buffer.size - offset
       format_value = Native::EnumHelper.coerce(Native::IndexFormat, format, name: "index format")
       Native.wgpuRenderPassEncoderSetIndexBuffer(@handle, buffer.handle, format_value, offset, size)
     end
 
+    # Records a non-indexed draw.
+    # @return [void]
     def draw(vertex_count, instance_count: 1, first_vertex: 0, first_instance: 0)
       Native.wgpuRenderPassEncoderDraw(@handle, vertex_count, instance_count, first_vertex, first_instance)
     end
 
+    # Records an indexed draw.
+    # @return [void]
     def draw_indexed(index_count, instance_count: 1, first_index: 0, base_vertex: 0, first_instance: 0)
       Native.wgpuRenderPassEncoderDrawIndexed(@handle, index_count, instance_count, first_index, base_vertex, first_instance)
     end
 
+    # Sets the viewport used by subsequent draw calls.
+    #
+    # @param x [Numeric] left coordinate in pixels
+    # @param y [Numeric] top coordinate in pixels
+    # @param width [Numeric] viewport width in pixels
+    # @param height [Numeric] viewport height in pixels
+    # @param min_depth [Numeric] minimum depth value
+    # @param max_depth [Numeric] maximum depth value
+    # @return [void]
     def set_viewport(x, y, width, height, min_depth: 0.0, max_depth: 1.0)
       Native.wgpuRenderPassEncoderSetViewport(@handle, x, y, width, height, min_depth, max_depth)
     end
 
+    # Restricts rasterization to a rectangular region.
+    #
+    # @param x [Integer] left coordinate in pixels
+    # @param y [Integer] top coordinate in pixels
+    # @param width [Integer] rectangle width in pixels
+    # @param height [Integer] rectangle height in pixels
+    # @return [void]
     def set_scissor_rect(x, y, width, height)
       Native.wgpuRenderPassEncoderSetScissorRect(@handle, x, y, width, height)
     end
 
+    # Sets the constant color used by blend factors.
+    #
+    # @param r [Numeric] red component
+    # @param g [Numeric] green component
+    # @param b [Numeric] blue component
+    # @param a [Numeric] alpha component
+    # @return [void]
     def set_blend_constant(r: 0.0, g: 0.0, b: 0.0, a: 1.0)
       color = Native::Color.new
       color[:r] = r
@@ -91,18 +147,36 @@ module WGPU
       Native.wgpuRenderPassEncoderSetBlendConstant(@handle, color.to_ptr)
     end
 
+    # Sets the stencil reference used by subsequent draw calls.
+    #
+    # @param reference [Integer] unsigned stencil reference
+    # @return [void]
     def set_stencil_reference(reference)
       Native.wgpuRenderPassEncoderSetStencilReference(@handle, reference)
     end
 
+    # Draws using non-indexed arguments stored in a buffer.
+    #
+    # @param buffer [Buffer] buffer containing the indirect arguments
+    # @param offset [Integer] byte offset of the arguments
+    # @return [void]
     def draw_indirect(buffer, offset: 0)
       Native.wgpuRenderPassEncoderDrawIndirect(@handle, buffer.handle, offset)
     end
 
+    # Draws using indexed arguments stored in a buffer.
+    #
+    # @param buffer [Buffer] buffer containing the indirect arguments
+    # @param offset [Integer] byte offset of the arguments
+    # @return [void]
     def draw_indexed_indirect(buffer, offset: 0)
       Native.wgpuRenderPassEncoderDrawIndexedIndirect(@handle, buffer.handle, offset)
     end
 
+    # Executes pre-recorded render bundles.
+    #
+    # @param bundles [Array<RenderBundle>] bundles to execute in order
+    # @return [void]
     def execute_bundles(bundles)
       bundle_handles = bundles.map(&:handle)
       bundles_ptr = FFI::MemoryPointer.new(:pointer, bundle_handles.size)
@@ -110,14 +184,25 @@ module WGPU
       Native.wgpuRenderPassEncoderExecuteBundles(@handle, bundle_handles.size, bundles_ptr)
     end
 
+    # Begins an occlusion query for subsequent draw calls.
+    #
+    # @param query_index [Integer] destination index in the pass query set
+    # @return [void]
     def begin_occlusion_query(query_index)
       Native.wgpuRenderPassEncoderBeginOcclusionQuery(@handle, query_index)
     end
 
+    # Ends the active occlusion query.
+    #
+    # @return [void]
     def end_occlusion_query
       Native.wgpuRenderPassEncoderEndOcclusionQuery(@handle)
     end
 
+    # Starts a labeled group in GPU debugging tools.
+    #
+    # @param label [String] group label
+    # @return [void]
     def push_debug_group(label)
       label_view = Native::StringView.new
       label_ptr = FFI::MemoryPointer.from_string(label)
@@ -126,10 +211,17 @@ module WGPU
       Native.wgpuRenderPassEncoderPushDebugGroup(@handle, label_view)
     end
 
+    # Ends the most recently pushed debug group.
+    #
+    # @return [void]
     def pop_debug_group
       Native.wgpuRenderPassEncoderPopDebugGroup(@handle)
     end
 
+    # Inserts a labeled point in GPU debugging tools.
+    #
+    # @param label [String] marker label
+    # @return [void]
     def insert_debug_marker(label)
       label_view = Native::StringView.new
       label_ptr = FFI::MemoryPointer.from_string(label)
@@ -138,6 +230,8 @@ module WGPU
       Native.wgpuRenderPassEncoderInsertDebugMarker(@handle, label_view)
     end
 
+    # Ends the pass if it has not already ended.
+    # @return [void]
     def end_pass
       return if @ended
 
@@ -146,14 +240,22 @@ module WGPU
       @encoder.send(:pass_ended, self)
     end
 
+    # Ends the pass.
+    # @return [void]
     def end
       end_pass
     end
 
+    # Reports whether the pass has ended.
+    # @return [Boolean]
     def ended?
       @ended
     end
 
+    # Releases the native render pass encoder handle.
+    #
+    # Calling this method more than once has no effect.
+    # @return [void]
     def release
       return if @handle.null?
       Native.wgpuRenderPassEncoderRelease(@handle)