Class: WGPU::Instance

Inherits:
Object
  • Object
show all
Includes:
NativeResource
Defined in:
lib/wgpu/core/instance.rb,
sig/wgpu.rbs

Constant Summary

Constants included from NativeResource

NativeResource::GUARDED_METHOD_EXEMPTIONS

Instance Attribute Summary collapse

Attributes included from NativeResource

#label

Instance Method Summary collapse

Methods included from NativeResource

included, #inspect, #released?, #use

Constructor Details

#initialize ⇒ Instance

Creates a WebGPU instance.

Raises:



9
10
11
12
13
14
15
16
17
18
 
# File 'lib/wgpu/core/instance.rb', line 9

def initialize
  desc = Native::InstanceDescriptor.new
  desc[:next_in_chain] = nil
  desc[:features][:next_in_chain] = nil
  desc[:features][:timed_wait_any_enable] = 0
  desc[:features][:timed_wait_any_max_count] = 0

  @handle = Native.wgpuCreateInstance(desc)
  raise InitializationError, "Failed to create WebGPU instance" if @handle.null?
end

Instance Attribute Details

#handle ⇒ Object (readonly)

Returns the value of attribute handle.

Returns:

  • (Object) 


5
6
7
 
# File 'lib/wgpu/core/instance.rb', line 5

def handle
  @handle
end

Instance Method Details

#enumerate_adapters(backends: nil) ⇒ Array<Adapter>

Lists adapters exposed by the instance.

Parameters:

  • backends (Integer, nil) (defaults to: nil) —

    backend bit mask

  • backends: (flags, nil) (defaults to: nil)

Returns:



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/wgpu/core/instance.rb', line 54

def enumerate_adapters(backends: nil)
  options = nil
  if backends
    options = Native::InstanceEnumerateAdapterOptions.new
    options[:next_in_chain] = nil
    options[:backends] = backends
  end

  count = Native.wgpuInstanceEnumerateAdapters(@handle, options, nil)
  return [] if count == 0

  adapters_ptr = FFI::MemoryPointer.new(:pointer, count)
  Native.wgpuInstanceEnumerateAdapters(@handle, options, adapters_ptr)

  adapters_ptr.read_array_of_pointer(count).map do |ptr|
    Adapter.from_handle(ptr, instance: self)
  end
end

#enumerate_adapters_async(backends: nil) ⇒ AsyncTask

Enumerates adapters on a background task.

Parameters:

  • backends: (flags, nil) (defaults to: nil)

Returns:

  • (AsyncTask) —

    task yielding adapter objects



75
76
77
78
79
 
# File 'lib/wgpu/core/instance.rb', line 75

def enumerate_adapters_async(backends: nil)
  AsyncTask.new do
    enumerate_adapters(backends: backends)
  end
end

#get_canvas_context(present_info) ⇒ CanvasContext

Creates a canvas context from platform presentation information.

Parameters:

  • present_info (Hash) —

    platform surface information

  • (Hash[Symbol, untyped])

Returns:



84
85
86
 
# File 'lib/wgpu/core/instance.rb', line 84

def get_canvas_context(present_info)
  CanvasContext.new(self, present_info)
end

#process_events ⇒ void

This method returns an undefined value.

Processes pending instance callbacks and events.



90
91
92
 
# File 'lib/wgpu/core/instance.rb', line 90

def process_events
  Native.wgpuInstanceProcessEvents(@handle)
end

#release ⇒ void

This method returns an undefined value.

Releases the native instance handle.

Calling this method more than once has no effect.



98
99
100
101
102
 
# File 'lib/wgpu/core/instance.rb', line 98

def release
  return if @handle.null?
  Native.wgpuInstanceRelease(@handle)
  @handle = FFI::Pointer::NULL
end

#request_adapter(power_preference:, backend:, feature_level:, force_fallback_adapter:, compatible_surface:, timeout:) ⇒ Adapter #request_adapter(arg0) ⇒ Adapter

Requests an adapter matching the supplied preferences.

Overloads:

  • #request_adapter(power_preference:, backend:, feature_level:, force_fallback_adapter:, compatible_surface:, timeout:) ⇒ Adapter

    Parameters:

    • power_preference: (enum_value)
    • backend: (enum_value, nil)
    • feature_level: (enum_value)
    • force_fallback_adapter: (Boolean)
    • compatible_surface: (Surface, nil)
    • timeout: (Numeric, nil)

    Returns:

  • #request_adapter(arg0) ⇒ Adapter

    Parameters:

    • arg0 (Object)

    Returns:

Returns:



22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/wgpu/core/instance.rb', line 22

def request_adapter(power_preference: :high_performance, backend: nil, feature_level: :core,
                    force_fallback_adapter: false, compatible_surface: nil, timeout: nil)
  Adapter.request(
    self,
    power_preference: power_preference,
    backend: backend,
    feature_level: feature_level,
    force_fallback_adapter: force_fallback_adapter,
    compatible_surface: compatible_surface,
    timeout: timeout
  )
end

#request_adapter_async(power_preference:, backend:, feature_level:, force_fallback_adapter:, compatible_surface:, timeout:) ⇒ AsyncTask[Adapter] #request_adapter_async(arg0) ⇒ AsyncTask[Adapter]

Requests an adapter on a background task.

Overloads:

  • #request_adapter_async(power_preference:, backend:, feature_level:, force_fallback_adapter:, compatible_surface:, timeout:) ⇒ AsyncTask[Adapter]

    Parameters:

    • power_preference: (enum_value)
    • backend: (enum_value, nil)
    • feature_level: (enum_value)
    • force_fallback_adapter: (Boolean)
    • compatible_surface: (Surface, nil)
    • timeout: (Numeric, nil)

    Returns:

  • #request_adapter_async(arg0) ⇒ AsyncTask[Adapter]

    Parameters:

    • arg0 (Object)

    Returns:

Returns:



37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/wgpu/core/instance.rb', line 37

def request_adapter_async(power_preference: :high_performance, backend: nil, feature_level: :core,
                          force_fallback_adapter: false, compatible_surface: nil, timeout: nil)
  AsyncTask.new do
    request_adapter(
      power_preference: power_preference,
      backend: backend,
      feature_level: feature_level,
      force_fallback_adapter: force_fallback_adapter,
      compatible_surface: compatible_surface,
      timeout: timeout
    )
  end
end