wgpu 1.0.0

data/lib/wgpu/commands/command_encoder.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module WGPU
+  class CommandEncoder
+    attr_reader :handle
+
+    def initialize(device, label: nil)
+      @device = device
+      @finished = false
+
+      desc = Native::CommandEncoderDescriptor.new
+      desc[:next_in_chain] = nil
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+
+      @handle = Native.wgpuDeviceCreateCommandEncoder(device.handle, desc)
+      raise CommandError, "Failed to create command encoder" if @handle.null?
+    end
+
+    def begin_compute_pass(label: nil, timestamp_writes: nil)
+      raise CommandError, "Encoder already finished" if @finished
+      ComputePass.new(self, label: label, timestamp_writes: timestamp_writes)
+    end
+
+    def begin_render_pass(color_attachments:, depth_stencil_attachment: nil, occlusion_query_set: nil, timestamp_writes: nil, max_draw_count: nil, label: nil)
+      raise CommandError, "Encoder already finished" if @finished
+      RenderPass.new(self,
+        color_attachments: color_attachments,
+        depth_stencil_attachment: depth_stencil_attachment,
+        occlusion_query_set: occlusion_query_set,
+        timestamp_writes: timestamp_writes,
+        max_draw_count: max_draw_count,
+        label: label
+      )
+    end
+
+    def copy_buffer_to_buffer(source:, source_offset: 0, destination:, destination_offset: 0, size:)
+      raise CommandError, "Encoder already finished" if @finished
+      Native.wgpuCommandEncoderCopyBufferToBuffer(
+        @handle,
+        source.handle, source_offset,
+        destination.handle, destination_offset,
+        size
+      )
+    end
+
+    def copy_buffer_to_texture(source:, destination:, copy_size:)
+      raise CommandError, "Encoder already finished" if @finished
+
+      size = Native::Extent3D.new
+      size[:width] = copy_size[:width] || copy_size[0]
+      size[:height] = copy_size[:height] || copy_size[1] || 1
+      size[:depth_or_array_layers] = copy_size[:depth_or_array_layers] || copy_size[2] || 1
+
+      src = Native::ImageCopyBuffer.new
+      src[:layout][:offset] = source[:offset] || 0
+      src[:layout][:bytes_per_row] = source[:bytes_per_row]
+      src[:layout][:rows_per_image] = source[:rows_per_image] || size[:height]
+      src[:buffer] = source[:buffer].handle
+
+      dst = Native::ImageCopyTexture.new
+      dst[:texture] = destination[:texture].handle
+      dst[:mip_level] = destination[:mip_level] || 0
+      dst[:origin][:x] = destination.dig(:origin, :x) || 0
+      dst[:origin][:y] = destination.dig(:origin, :y) || 0
+      dst[:origin][:z] = destination.dig(:origin, :z) || 0
+      dst[:aspect] = destination[:aspect] || :all
+
+      Native.wgpuCommandEncoderCopyBufferToTexture(@handle, src, dst, size)
+    end
+
+    def copy_texture_to_buffer(source:, destination:, copy_size:)
+      raise CommandError, "Encoder already finished" if @finished
+
+      size = Native::Extent3D.new
+      size[:width] = copy_size[:width] || copy_size[0]
+      size[:height] = copy_size[:height] || copy_size[1] || 1
+      size[:depth_or_array_layers] = copy_size[:depth_or_array_layers] || copy_size[2] || 1
+
+      src = Native::ImageCopyTexture.new
+      src[:texture] = source[:texture].handle
+      src[:mip_level] = source[:mip_level] || 0
+      src[:origin][:x] = source.dig(:origin, :x) || 0
+      src[:origin][:y] = source.dig(:origin, :y) || 0
+      src[:origin][:z] = source.dig(:origin, :z) || 0
+      src[:aspect] = source[:aspect] || :all
+
+      dst = Native::ImageCopyBuffer.new
+      dst[:layout][:offset] = destination[:offset] || 0
+      dst[:layout][:bytes_per_row] = destination[:bytes_per_row]
+      dst[:layout][:rows_per_image] = destination[:rows_per_image] || size[:height]
+      dst[:buffer] = destination[:buffer].handle
+
+      Native.wgpuCommandEncoderCopyTextureToBuffer(@handle, src, dst, size)
+    end
+
+    def copy_texture_to_texture(source:, destination:, copy_size:)
+      raise CommandError, "Encoder already finished" if @finished
+
+      src = Native::ImageCopyTexture.new
+      src[:texture] = source[:texture].handle
+      src[:mip_level] = source[:mip_level] || 0
+      src[:origin][:x] = source.dig(:origin, :x) || 0
+      src[:origin][:y] = source.dig(:origin, :y) || 0
+      src[:origin][:z] = source.dig(:origin, :z) || 0
+      src[:aspect] = source[:aspect] || :all
+
+      dst = Native::ImageCopyTexture.new
+      dst[:texture] = destination[:texture].handle
+      dst[:mip_level] = destination[:mip_level] || 0
+      dst[:origin][:x] = destination.dig(:origin, :x) || 0
+      dst[:origin][:y] = destination.dig(:origin, :y) || 0
+      dst[:origin][:z] = destination.dig(:origin, :z) || 0
+      dst[:aspect] = destination[:aspect] || :all
+
+      size = Native::Extent3D.new
+      size[:width] = copy_size[:width] || copy_size[0]
+      size[:height] = copy_size[:height] || copy_size[1] || 1
+      size[:depth_or_array_layers] = copy_size[:depth_or_array_layers] || copy_size[2] || 1
+
+      Native.wgpuCommandEncoderCopyTextureToTexture(@handle, src, dst, size)
+    end
+
+    def resolve_query_set(query_set:, first_query:, query_count:, destination:, destination_offset:)
+      raise CommandError, "Encoder already finished" if @finished
+      Native.wgpuCommandEncoderResolveQuerySet(
+        @handle,
+        query_set.handle,
+        first_query,
+        query_count,
+        destination.handle,
+        destination_offset
+      )
+    end
+
+    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
+
+    def write_timestamp(query_set, query_index)
+      raise CommandError, "Encoder already finished" if @finished
+      Native.wgpuCommandEncoderWriteTimestamp(@handle, query_set.handle, query_index)
+    end
+
+    def push_debug_group(label)
+      raise CommandError, "Encoder already finished" if @finished
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuCommandEncoderPushDebugGroup(@handle, label_view)
+    end
+
+    def pop_debug_group
+      raise CommandError, "Encoder already finished" if @finished
+      Native.wgpuCommandEncoderPopDebugGroup(@handle)
+    end
+
+    def insert_debug_marker(label)
+      raise CommandError, "Encoder already finished" if @finished
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuCommandEncoderInsertDebugMarker(@handle, label_view)
+    end
+
+    def finish(label: nil)
+      raise CommandError, "Encoder already finished" if @finished
+      @finished = true
+
+      desc = nil
+      if label
+        desc = Native::CommandBufferDescriptor.new
+        desc[:next_in_chain] = nil
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      end
+
+      buffer_handle = Native.wgpuCommandEncoderFinish(@handle, desc)
+      raise CommandError, "Failed to finish command encoder" if buffer_handle.null?
+
+      CommandBuffer.new(buffer_handle)
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuCommandEncoderRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/commands/compute_pass.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module WGPU
+  class ComputePass
+    attr_reader :handle
+
+    def initialize(encoder, label: nil, timestamp_writes: nil)
+      desc = Native::ComputePassDescriptor.new
+      desc[:next_in_chain] = nil
+      if label
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+      @timestamp_writes = nil
+      if timestamp_writes
+        @timestamp_writes = Native::ComputePassTimestampWrites.new
+        @timestamp_writes[:query_set] = timestamp_writes.fetch(:query_set).handle
+        @timestamp_writes[:beginning_of_pass_write_index] = timestamp_writes[:beginning_of_pass_write_index] || 0xFFFFFFFF
+        @timestamp_writes[:end_of_pass_write_index] = timestamp_writes[:end_of_pass_write_index] || 0xFFFFFFFF
+        desc[:timestamp_writes] = @timestamp_writes.to_ptr
+      else
+        desc[:timestamp_writes] = nil
+      end
+
+      @handle = Native.wgpuCommandEncoderBeginComputePass(encoder.handle, desc)
+      raise CommandError, "Failed to begin compute pass" if @handle.null?
+    end
+
+    def set_pipeline(pipeline)
+      Native.wgpuComputePassEncoderSetPipeline(@handle, pipeline.handle)
+    end
+
+    def set_bind_group(index, bind_group, dynamic_offsets: [])
+      if dynamic_offsets.empty?
+        Native.wgpuComputePassEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
+      else
+        offsets_ptr = FFI::MemoryPointer.new(:uint32, dynamic_offsets.size)
+        offsets_ptr.write_array_of_uint32(dynamic_offsets)
+        Native.wgpuComputePassEncoderSetBindGroup(@handle, index, bind_group.handle, dynamic_offsets.size, offsets_ptr)
+      end
+    end
+
+    def dispatch_workgroups(x, y = 1, z = 1)
+      Native.wgpuComputePassEncoderDispatchWorkgroups(@handle, x, y, z)
+    end
+
+    def dispatch_workgroups_indirect(buffer, offset: 0)
+      Native.wgpuComputePassEncoderDispatchWorkgroupsIndirect(@handle, buffer.handle, offset)
+    end
+
+    def push_debug_group(label)
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuComputePassEncoderPushDebugGroup(@handle, label_view)
+    end
+
+    def pop_debug_group
+      Native.wgpuComputePassEncoderPopDebugGroup(@handle)
+    end
+
+    def insert_debug_marker(label)
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuComputePassEncoderInsertDebugMarker(@handle, label_view)
+    end
+
+    def end_pass
+      Native.wgpuComputePassEncoderEnd(@handle)
+    end
+
+    def end
+      end_pass
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuComputePassEncoderRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/commands/render_bundle.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module WGPU
+  class RenderBundle
+    attr_reader :handle
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    def release
+      return if @handle.null?
+
+      Native.wgpuRenderBundleRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/commands/render_bundle_encoder.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module WGPU
+  class RenderBundleEncoder
+    attr_reader :handle
+
+    def initialize(device, color_formats:, depth_stencil_format: nil, sample_count: 1,
+                   depth_read_only: false, stencil_read_only: false, label: nil)
+      @device = device
+      @finished = false
+
+      desc = Native::RenderBundleEncoderDescriptor.new
+      desc[:next_in_chain] = nil
+
+      if label
+        @label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = @label_ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+
+      formats = Array(color_formats).map { |f| Native::TextureFormat[f] }
+      @formats_ptr = FFI::MemoryPointer.new(:uint32, formats.size)
+      @formats_ptr.write_array_of_uint32(formats)
+      desc[:color_format_count] = formats.size
+      desc[:color_formats] = @formats_ptr
+
+      desc[:depth_stencil_format] = depth_stencil_format || :undefined
+      desc[:sample_count] = sample_count
+      desc[:depth_read_only] = depth_read_only ? 1 : 0
+      desc[:stencil_read_only] = stencil_read_only ? 1 : 0
+
+      @handle = Native.wgpuDeviceCreateRenderBundleEncoder(device.handle, desc)
+      raise RenderBundleError, "Failed to create render bundle encoder" if @handle.null?
+    end
+
+    def set_pipeline(pipeline)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      Native.wgpuRenderBundleEncoderSetPipeline(@handle, pipeline.handle)
+    end
+
+    def set_bind_group(index, bind_group, dynamic_offsets: nil)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      if dynamic_offsets && !dynamic_offsets.empty?
+        offsets_ptr = FFI::MemoryPointer.new(:uint32, dynamic_offsets.size)
+        offsets_ptr.write_array_of_uint32(dynamic_offsets)
+        Native.wgpuRenderBundleEncoderSetBindGroup(@handle, index, bind_group.handle, dynamic_offsets.size, offsets_ptr)
+      else
+        Native.wgpuRenderBundleEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
+      end
+    end
+
+    def set_vertex_buffer(slot, buffer, offset: 0, size: nil)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      size ||= buffer.size - offset
+      Native.wgpuRenderBundleEncoderSetVertexBuffer(@handle, slot, buffer.handle, offset, size)
+    end
+
+    def set_index_buffer(buffer, format: :uint32, offset: 0, size: nil)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      size ||= buffer.size - offset
+      Native.wgpuRenderBundleEncoderSetIndexBuffer(@handle, buffer.handle, format, offset, size)
+    end
+
+    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
+
+    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
+
+    def draw_indirect(buffer, offset: 0)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      Native.wgpuRenderBundleEncoderDrawIndirect(@handle, buffer.handle, offset)
+    end
+
+    def draw_indexed_indirect(buffer, offset: 0)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      Native.wgpuRenderBundleEncoderDrawIndexedIndirect(@handle, buffer.handle, offset)
+    end
+
+    def push_debug_group(label)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuRenderBundleEncoderPushDebugGroup(@handle, label_view)
+    end
+
+    def pop_debug_group
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      Native.wgpuRenderBundleEncoderPopDebugGroup(@handle)
+    end
+
+    def insert_debug_marker(label)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuRenderBundleEncoderInsertDebugMarker(@handle, label_view)
+    end
+
+    def finish(label: nil)
+      raise RenderBundleError, "Encoder already finished" if @finished
+
+      @finished = true
+
+      desc = nil
+      if label
+        desc = Native::RenderBundleDescriptor.new
+        desc[:next_in_chain] = nil
+        label_ptr = FFI::MemoryPointer.from_string(label)
+        desc[:label][:data] = label_ptr
+        desc[:label][:length] = label.bytesize
+      end
+
+      bundle_handle = Native.wgpuRenderBundleEncoderFinish(@handle, desc)
+      raise RenderBundleError, "Failed to finish render bundle encoder" if bundle_handle.null?
+
+      RenderBundle.new(bundle_handle)
+    end
+
+    def release
+      return if @handle.null?
+
+      Native.wgpuRenderBundleEncoderRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+  end
+end

data/lib/wgpu/commands/render_pass.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module WGPU
+  class RenderPass
+    attr_reader :handle
+
+    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 = []
+      @max_draw_count = max_draw_count
+
+      desc = Native::RenderPassDescriptor.new
+      desc[:next_in_chain] = nil
+      setup_label(desc, label)
+
+      color_attachments_ptr = setup_color_attachments(color_attachments)
+      desc[:color_attachment_count] = color_attachments.size
+      desc[:color_attachments] = color_attachments_ptr
+
+      if depth_stencil_attachment
+        ds_ptr = setup_depth_stencil_attachment(depth_stencil_attachment)
+        desc[:depth_stencil_attachment] = ds_ptr
+      else
+        desc[:depth_stencil_attachment] = nil
+      end
+
+      desc[:occlusion_query_set] = occlusion_query_set&.handle
+      if timestamp_writes
+        ts = Native::RenderPassTimestampWrites.new
+        ts[:query_set] = timestamp_writes.fetch(:query_set).handle
+        ts[:beginning_of_pass_write_index] = timestamp_writes[:beginning_of_pass_write_index] || 0xFFFFFFFF
+        ts[:end_of_pass_write_index] = timestamp_writes[:end_of_pass_write_index] || 0xFFFFFFFF
+        @pointers << ts
+        desc[:timestamp_writes] = ts.to_ptr
+      else
+        desc[:timestamp_writes] = nil
+      end
+
+      @handle = Native.wgpuCommandEncoderBeginRenderPass(encoder.handle, desc)
+      raise CommandError, "Failed to begin render pass" if @handle.null?
+    end
+
+    def set_pipeline(pipeline)
+      Native.wgpuRenderPassEncoderSetPipeline(@handle, pipeline.handle)
+    end
+
+    def set_bind_group(index, bind_group, dynamic_offsets: [])
+      if dynamic_offsets.empty?
+        Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, bind_group.handle, 0, nil)
+      else
+        offsets_ptr = FFI::MemoryPointer.new(:uint32, dynamic_offsets.size)
+        offsets_ptr.write_array_of_uint32(dynamic_offsets)
+        Native.wgpuRenderPassEncoderSetBindGroup(@handle, index, bind_group.handle, dynamic_offsets.size, offsets_ptr)
+      end
+    end
+
+    def set_vertex_buffer(slot, buffer, offset: 0, size: nil)
+      size ||= buffer.size - offset
+      Native.wgpuRenderPassEncoderSetVertexBuffer(@handle, slot, buffer.handle, offset, size)
+    end
+
+    def set_index_buffer(buffer, format, offset: 0, size: nil)
+      size ||= buffer.size - offset
+      Native.wgpuRenderPassEncoderSetIndexBuffer(@handle, buffer.handle, format, offset, size)
+    end
+
+    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
+
+    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
+
+    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
+
+    def set_scissor_rect(x, y, width, height)
+      Native.wgpuRenderPassEncoderSetScissorRect(@handle, x, y, width, height)
+    end
+
+    def set_blend_constant(r: 0.0, g: 0.0, b: 0.0, a: 1.0)
+      color = Native::Color.new
+      color[:r] = r
+      color[:g] = g
+      color[:b] = b
+      color[:a] = a
+      Native.wgpuRenderPassEncoderSetBlendConstant(@handle, color.to_ptr)
+    end
+
+    def set_stencil_reference(reference)
+      Native.wgpuRenderPassEncoderSetStencilReference(@handle, reference)
+    end
+
+    def draw_indirect(buffer, offset: 0)
+      Native.wgpuRenderPassEncoderDrawIndirect(@handle, buffer.handle, offset)
+    end
+
+    def draw_indexed_indirect(buffer, offset: 0)
+      Native.wgpuRenderPassEncoderDrawIndexedIndirect(@handle, buffer.handle, offset)
+    end
+
+    def execute_bundles(bundles)
+      bundle_handles = bundles.map(&:handle)
+      bundles_ptr = FFI::MemoryPointer.new(:pointer, bundle_handles.size)
+      bundles_ptr.write_array_of_pointer(bundle_handles)
+      Native.wgpuRenderPassEncoderExecuteBundles(@handle, bundle_handles.size, bundles_ptr)
+    end
+
+    def begin_occlusion_query(query_index)
+      Native.wgpuRenderPassEncoderBeginOcclusionQuery(@handle, query_index)
+    end
+
+    def end_occlusion_query
+      Native.wgpuRenderPassEncoderEndOcclusionQuery(@handle)
+    end
+
+    def push_debug_group(label)
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuRenderPassEncoderPushDebugGroup(@handle, label_view)
+    end
+
+    def pop_debug_group
+      Native.wgpuRenderPassEncoderPopDebugGroup(@handle)
+    end
+
+    def insert_debug_marker(label)
+      label_view = Native::StringView.new
+      label_ptr = FFI::MemoryPointer.from_string(label)
+      label_view[:data] = label_ptr
+      label_view[:length] = label.bytesize
+      Native.wgpuRenderPassEncoderInsertDebugMarker(@handle, label_view)
+    end
+
+    def end_pass
+      Native.wgpuRenderPassEncoderEnd(@handle)
+    end
+
+    def end
+      end_pass
+    end
+
+    def release
+      return if @handle.null?
+      Native.wgpuRenderPassEncoderRelease(@handle)
+      @handle = FFI::Pointer::NULL
+    end
+
+    private
+
+    def setup_label(desc, label)
+      if label
+        ptr = FFI::MemoryPointer.from_string(label)
+        @pointers << ptr
+        desc[:label][:data] = ptr
+        desc[:label][:length] = label.bytesize
+      else
+        desc[:label][:data] = nil
+        desc[:label][:length] = 0
+      end
+    end
+
+    def setup_color_attachments(attachments)
+      ptr = FFI::MemoryPointer.new(Native::RenderPassColorAttachment, attachments.size)
+      @pointers << ptr
+
+      attachments.each_with_index do |att, i|
+        ca = Native::RenderPassColorAttachment.new(ptr + i * Native::RenderPassColorAttachment.size)
+        ca[:next_in_chain] = nil
+        ca[:view] = att[:view].handle
+        ca[:depth_slice] = att[:depth_slice] || 0xFFFFFFFF
+        ca[:resolve_target] = att[:resolve_target]&.handle
+        ca[:load_op] = att[:load_op] || :clear
+        ca[:store_op] = att[:store_op] || :store
+
+        clear = att[:clear_value] || { r: 0.0, g: 0.0, b: 0.0, a: 1.0 }
+        ca[:clear_value][:r] = clear[:r] || 0.0
+        ca[:clear_value][:g] = clear[:g] || 0.0
+        ca[:clear_value][:b] = clear[:b] || 0.0
+        ca[:clear_value][:a] = clear[:a] || 1.0
+      end
+
+      ptr
+    end
+
+    def setup_depth_stencil_attachment(att)
+      ds = Native::RenderPassDepthStencilAttachment.new
+      @pointers << ds
+
+      ds[:view] = att[:view].handle
+      ds[:depth_load_op] = att[:depth_load_op] || :clear
+      ds[:depth_store_op] = att[:depth_store_op] || :store
+      ds[:depth_clear_value] = att[:depth_clear_value] || 1.0
+      ds[:depth_read_only] = att[:depth_read_only] ? 1 : 0
+      ds[:stencil_load_op] = att[:stencil_load_op] || :clear
+      ds[:stencil_store_op] = att[:stencil_store_op] || :store
+      ds[:stencil_clear_value] = att[:stencil_clear_value] || 0
+      ds[:stencil_read_only] = att[:stencil_read_only] ? 1 : 0
+
+      ds.to_ptr
+    end
+  end
+end