webxr 0.1.0

data/lib/webxr/input/gamepad.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module WebXR
+  # Gamepad - Represents a gamepad connected to an XR input source
+  class Gamepad < JSWrapper
+    # @param js_gamepad [JS::Object] The Gamepad JavaScript object
+    def initialize(js_gamepad)
+      super(js_gamepad)
+    end
+
+    # Get the gamepad identifier
+    # @return [String]
+    def id
+      js_string(:id) || ""
+    end
+
+    # Get the gamepad index
+    # @return [Integer]
+    def index
+      js_int(:index) || -1
+    end
+
+    # Check if the gamepad is connected
+    # @return [Boolean]
+    def connected?
+      js_bool(:connected)
+    end
+
+    # Get the button/axis mapping type
+    # @return [String]
+    def mapping
+      js_string(:mapping) || ""
+    end
+
+    # Get all axis values
+    # @return [Array<Float>]
+    def axes
+      js_axes = js_prop(:axes)
+      return [] if js_axes.nil?
+
+      js_array_to_a(js_axes).map(&:to_f)
+    end
+
+    # Get all buttons
+    # @return [Array<GamepadButton>]
+    def buttons
+      js_buttons = js_prop(:buttons)
+      return [] if js_buttons.nil?
+
+      js_array_to_a(js_buttons).map { |b| GamepadButton.new(b) }
+    end
+
+    # Get a specific axis value
+    # @param index [Integer] The axis index
+    # @return [Float]
+    def axis(index)
+      axes[index] || 0.0
+    end
+
+    # Get a specific button
+    # @param index [Integer] The button index
+    # @return [GamepadButton, nil]
+    def button(index)
+      buttons[index]
+    end
+
+    # Get the thumbstick X axis (typically axis 2)
+    # @return [Float]
+    def thumbstick_x
+      axis(2)
+    end
+
+    # Get the thumbstick Y axis (typically axis 3)
+    # @return [Float]
+    def thumbstick_y
+      axis(3)
+    end
+
+    # Get the touchpad X axis (typically axis 0)
+    # @return [Float]
+    def touchpad_x
+      axis(0)
+    end
+
+    # Get the touchpad Y axis (typically axis 1)
+    # @return [Float]
+    def touchpad_y
+      axis(1)
+    end
+
+    # Get the trigger button (typically button 0)
+    # @return [GamepadButton, nil]
+    def trigger
+      button(0)
+    end
+
+    # Get the squeeze/grip button (typically button 1)
+    # @return [GamepadButton, nil]
+    def squeeze
+      button(1)
+    end
+
+    # Get the touchpad button (typically button 2)
+    # @return [GamepadButton, nil]
+    def touchpad
+      button(2)
+    end
+
+    # Get the thumbstick button (typically button 3)
+    # @return [GamepadButton, nil]
+    def thumbstick
+      button(3)
+    end
+  end
+end

data/lib/webxr/input/gamepad_button.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module WebXR
+  # GamepadButton - Represents a button on a gamepad
+  class GamepadButton < JSWrapper
+    # @param js_button [JS::Object] The GamepadButton JavaScript object
+    def initialize(js_button)
+      super(js_button)
+    end
+
+    # Check if the button is currently pressed
+    # @return [Boolean]
+    def pressed?
+      js_bool(:pressed)
+    end
+
+    # Check if the button is being touched (capacitive)
+    # @return [Boolean]
+    def touched?
+      js_bool(:touched)
+    end
+
+    # Get the analog value of the button (0.0 to 1.0)
+    # @return [Float]
+    def value
+      js_float(:value) || 0.0
+    end
+
+    # Check if the button value is above a threshold
+    # @param threshold [Float] The threshold (0.0 to 1.0)
+    # @return [Boolean]
+    def active?(threshold: 0.5)
+      value >= threshold
+    end
+  end
+end

data/lib/webxr/input/input_source.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRInputSource - Represents an input device (controller, hand, etc.)
+  class InputSource < JSWrapper
+    # @param js_input_source [JS::Object] The XRInputSource JavaScript object
+    def initialize(js_input_source)
+      super(js_input_source)
+    end
+
+    # Get the handedness of the input source
+    # @return [String] "none", "left", or "right"
+    def handedness
+      js_string(:handedness) || Handedness::NONE
+    end
+
+    # Get the target ray mode
+    # @return [String] "gaze", "tracked-pointer", "screen", or "transient-pointer"
+    def target_ray_mode
+      js_string(:targetRayMode) || TargetRayMode::GAZE
+    end
+
+    # Get the target ray space (pointing direction)
+    # @return [Space]
+    def target_ray_space
+      Space.new(js_prop(:targetRaySpace))
+    end
+
+    # Get the grip space (controller position/orientation)
+    # @return [Space, nil] nil if no grip space is available
+    def grip_space
+      js_space = js_prop(:gripSpace)
+      return nil if js_space.nil?
+
+      Space.new(js_space)
+    end
+
+    # Get the input source profiles
+    # @return [Array<String>]
+    def profiles
+      js_profiles = js_prop(:profiles)
+      return [] if js_profiles.nil?
+
+      js_array_to_a(js_profiles).map(&:to_s)
+    end
+
+    # Get the associated gamepad (if available)
+    # @return [Gamepad, nil]
+    def gamepad
+      js_gamepad = js_prop(:gamepad)
+      return nil if js_gamepad.nil?
+
+      Gamepad.new(js_gamepad)
+    end
+
+    # Get the associated hand (if hand tracking is enabled)
+    # @return [Hand::Hand, nil]
+    def hand
+      js_hand = js_prop(:hand)
+      return nil if js_hand.nil?
+
+      Hand::Hand.new(js_hand)
+    end
+
+    # Check if this is the left controller
+    # @return [Boolean]
+    def left?
+      handedness == Handedness::LEFT
+    end
+
+    # Check if this is the right controller
+    # @return [Boolean]
+    def right?
+      handedness == Handedness::RIGHT
+    end
+
+    # Check if this is a tracked pointer (controller)
+    # @return [Boolean]
+    def tracked_pointer?
+      target_ray_mode == TargetRayMode::TRACKED_POINTER
+    end
+
+    # Check if this is a gaze input
+    # @return [Boolean]
+    def gaze?
+      target_ray_mode == TargetRayMode::GAZE
+    end
+
+    # Check if this is a screen-based input
+    # @return [Boolean]
+    def screen?
+      target_ray_mode == TargetRayMode::SCREEN
+    end
+
+    # Check if this input has hand tracking
+    # @return [Boolean]
+    def hand_tracking?
+      !hand.nil?
+    end
+  end
+end

data/lib/webxr/input/input_source_array.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRInputSourceArray - Collection of input sources
+  class InputSourceArray < JSWrapper
+    include Enumerable
+
+    # @param js_array [JS::Object] The XRInputSourceArray JavaScript object
+    def initialize(js_array)
+      super(js_array)
+    end
+
+    # Iterate over each input source
+    # @yield [InputSource] Each input source
+    # @return [Enumerator, void]
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      length.times do |i|
+        yield self[i]
+      end
+    end
+
+    # Get an input source by index
+    # @param index [Integer] The index
+    # @return [InputSource, nil]
+    def [](index)
+      js_source = @js[index]
+      return nil if js_source.nil?
+
+      InputSource.new(js_source)
+    end
+
+    # Get the number of input sources
+    # @return [Integer]
+    def length
+      js_int(:length) || 0
+    end
+    alias size length
+
+    # Check if the array is empty
+    # @return [Boolean]
+    def empty?
+      length.zero?
+    end
+
+    # Get the first input source
+    # @return [InputSource, nil]
+    def first
+      self[0]
+    end
+
+    # Get the last input source
+    # @return [InputSource, nil]
+    def last
+      return nil if empty?
+
+      self[length - 1]
+    end
+
+    # Find input sources by handedness
+    # @param handedness [String] "left", "right", or "none"
+    # @return [Array<InputSource>]
+    def by_handedness(handedness)
+      select { |source| source.handedness == handedness }
+    end
+
+    # Get the left controller
+    # @return [InputSource, nil]
+    def left
+      find(&:left?)
+    end
+
+    # Get the right controller
+    # @return [InputSource, nil]
+    def right
+      find(&:right?)
+    end
+
+    # Get all tracked pointer inputs
+    # @return [Array<InputSource>]
+    def tracked_pointers
+      select(&:tracked_pointer?)
+    end
+  end
+end

data/lib/webxr/js_wrapper.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module WebXR
+  # Base class for wrapping JavaScript objects
+  # Provides common utilities for JS interop via ruby.wasm
+  class JSWrapper
+    # @return [JS::Object] The wrapped JavaScript object
+    attr_reader :js
+
+    # @param js_object [JS::Object] The JavaScript object to wrap
+    def initialize(js_object)
+      @js = js_object
+    end
+
+    # Check if the wrapped JS object is nil/undefined
+    # @return [Boolean]
+    def nil?
+      @js.nil?
+    end
+
+    protected
+
+    # Safely get a JS property
+    # @param name [String, Symbol] Property name
+    # @return [JS::Object, nil]
+    def js_prop(name)
+      @js[name]
+    end
+
+    # Get a JS property as a Ruby String
+    # @param name [String, Symbol] Property name
+    # @return [String, nil]
+    def js_string(name)
+      val = @js[name]
+      val.nil? ? nil : val.to_s
+    end
+
+    # Get a JS property as a Ruby Float
+    # @param name [String, Symbol] Property name
+    # @return [Float, nil]
+    def js_float(name)
+      val = @js[name]
+      val.nil? ? nil : val.to_f
+    end
+
+    # Get a JS property as a Ruby Integer
+    # @param name [String, Symbol] Property name
+    # @return [Integer, nil]
+    def js_int(name)
+      val = @js[name]
+      val.nil? ? nil : val.to_i
+    end
+
+    # Get a JS property as a Ruby Boolean
+    # @param name [String, Symbol] Property name
+    # @return [Boolean]
+    def js_bool(name)
+      !!@js[name]
+    end
+
+    # Call a JS method on the wrapped object
+    # @param method [String, Symbol] Method name
+    # @param args [Array] Arguments to pass
+    # @return [JS::Object]
+    def js_call(method, *args)
+      @js.call(method, *args)
+    end
+
+    # Wait for a JS Promise and return the result
+    # @param promise [JS::Object] A JavaScript Promise
+    # @return [JS::Object] The resolved value
+    def js_await(promise)
+      JS.await(promise)
+    end
+
+    # Convert a Ruby Hash to a JS object
+    # @param hash [Hash] Ruby hash to convert
+    # @return [JS::Object]
+    def to_js_object(hash)
+      obj = JS.eval("({})")
+      hash.each { |k, v| obj[k.to_s] = v }
+      obj
+    end
+
+    # Convert a Ruby Array to a JS array
+    # @param array [Array] Ruby array to convert
+    # @return [JS::Object]
+    def to_js_array(array)
+      arr = JS.eval("[]")
+      array.each { |item| arr.call(:push, item) }
+      arr
+    end
+
+    # Convert a JS array-like object to a Ruby Array
+    # @param js_array [JS::Object] JavaScript array
+    # @return [Array<JS::Object>]
+    def js_array_to_a(js_array)
+      return [] if js_array.nil?
+
+      length = js_array[:length].to_i
+      Array.new(length) { |i| js_array[i] }
+    end
+
+    # Create a DOMPointReadOnly from a hash
+    # @param hash [Hash] Hash with :x, :y, :z, :w keys
+    # @return [JS::Object]
+    def create_dom_point(hash)
+      JS.global[:DOMPointReadOnly].new(
+        hash[:x] || 0,
+        hash[:y] || 0,
+        hash[:z] || 0,
+        hash[:w] || 1
+      )
+    end
+  end
+end

data/lib/webxr/layers/layer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRLayer - Base class for XR rendering layers
+  class Layer < JSWrapper
+    # @param js_layer [JS::Object] The XRLayer JavaScript object
+    def initialize(js_layer)
+      super(js_layer)
+    end
+
+    # Wrap a JS layer object in the appropriate Ruby class
+    # @param js_layer [JS::Object] The JavaScript layer object
+    # @return [Layer, WebGLLayer]
+    def self.wrap(js_layer)
+      return nil if js_layer.nil?
+
+      # Check the constructor name to determine the type
+      constructor_name = js_layer[:constructor][:name].to_s
+
+      case constructor_name
+      when "XRWebGLLayer"
+        WebGLLayer.wrap(js_layer)
+      else
+        new(js_layer)
+      end
+    end
+  end
+end

data/lib/webxr/layers/webgl_binding.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRWebGLBinding - Provides advanced WebGL layer functionality
+  class WebGLBinding < JSWrapper
+    # @param session [Session] The XR session
+    # @param context [JS::Object] The WebGL2 rendering context
+    def initialize(session, context)
+      js_binding = JS.global[:XRWebGLBinding].new(session.js, context)
+      super(js_binding)
+      @context = context
+    end
+
+    # Get the native projection scale factor
+    # @return [Float]
+    def native_projection_scale_factor
+      js_float(:nativeProjectionScaleFactor) || 1.0
+    end
+
+    # Check if HDR is supported
+    # @return [Boolean]
+    def hdr_supported?
+      js_bool(:usesDepthValues)
+    end
+
+    # Get a sub-image for a layer
+    # @param layer [Layer] The XR layer
+    # @param frame [Frame] The current XR frame
+    # @param eye [String] The eye ("left", "right", "none")
+    # @return [WebGLSubImage]
+    def sub_image(layer, frame, eye = Eye::NONE)
+      js_subimage = js_call(:getSubImage, layer.js, frame.js, eye)
+      WebGLSubImage.new(js_subimage)
+    end
+
+    # Get a sub-image for a specific view
+    # @param layer [Layer] The XR layer
+    # @param view [View] The XR view
+    # @return [WebGLSubImage]
+    def view_sub_image(layer, view)
+      js_subimage = js_call(:getViewSubImage, layer.js, view.js)
+      WebGLSubImage.new(js_subimage)
+    end
+
+    # Get the reflection cube map
+    # @param light_probe [Lighting::Probe] The light probe
+    # @return [JS::Object, nil] WebGL texture or nil
+    def reflection_cube_map(light_probe)
+      js_call(:getReflectionCubeMap, light_probe.js)
+    end
+
+    # Get the camera image for AR
+    # @param view [View] The XR view
+    # @return [JS::Object, nil] WebGL texture or nil
+    def camera_image(view)
+      js_call(:getCameraImage, view.js)
+    end
+
+    # Get depth information for a view
+    # @param view [View] The XR view
+    # @return [Depth::WebGLInformation, nil]
+    def depth_information(view)
+      js_info = js_call(:getDepthInformation, view.js)
+      return nil if js_info.nil?
+
+      Depth::WebGLInformation.new(js_info)
+    end
+  end
+end

data/lib/webxr/layers/webgl_layer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRWebGLLayer - WebGL rendering layer for XR
+  class WebGLLayer < Layer
+    # Create a new WebGL layer
+    # @param session [Session] The XR session
+    # @param context [JS::Object] The WebGL rendering context
+    # @param antialias [Boolean] Enable antialiasing
+    # @param depth [Boolean] Enable depth buffer
+    # @param stencil [Boolean] Enable stencil buffer
+    # @param alpha [Boolean] Enable alpha channel
+    # @param ignore_depth_values [Boolean] Ignore compositor depth values
+    # @param framebuffer_scale_factor [Float] Framebuffer scale factor
+    def initialize(session, context, antialias: true, depth: true, stencil: false,
+                   alpha: true, ignore_depth_values: false, framebuffer_scale_factor: 1.0)
+      js_options = JS.eval("({})")
+      js_options[:antialias] = antialias
+      js_options[:depth] = depth
+      js_options[:stencil] = stencil
+      js_options[:alpha] = alpha
+      js_options[:ignoreDepthValues] = ignore_depth_values
+      js_options[:framebufferScaleFactor] = framebuffer_scale_factor
+
+      js_layer = JS.global[:XRWebGLLayer].new(session.js, context, js_options)
+      super(js_layer)
+      @context = context
+    end
+
+    # Wrap an existing JS XRWebGLLayer
+    # @param js_layer [JS::Object] The JavaScript XRWebGLLayer
+    # @return [WebGLLayer]
+    def self.wrap(js_layer)
+      layer = allocate
+      layer.instance_variable_set(:@js, js_layer)
+      layer
+    end
+
+    # Get the native framebuffer scale factor for a session
+    # @param session [Session] The XR session
+    # @return [Float]
+    def self.native_framebuffer_scale_factor(session)
+      JS.global[:XRWebGLLayer].call(:getNativeFramebufferScaleFactor, session.js).to_f
+    end
+
+    # Check if antialiasing is enabled
+    # @return [Boolean]
+    def antialias?
+      js_bool(:antialias)
+    end
+
+    # Check if depth values are ignored
+    # @return [Boolean]
+    def ignore_depth_values?
+      js_bool(:ignoreDepthValues)
+    end
+
+    # Get the fixed foveation level
+    # @return [Float, nil] 0.0 to 1.0, or nil if not supported
+    def fixed_foveation
+      js_float(:fixedFoveation)
+    end
+
+    # Set the fixed foveation level
+    # @param value [Float] 0.0 (no foveation) to 1.0 (maximum foveation)
+    def fixed_foveation=(value)
+      @js[:fixedFoveation] = value
+    end
+
+    # Get the WebGL framebuffer
+    # @return [JS::Object] The WebGL framebuffer
+    def framebuffer
+      js_prop(:framebuffer)
+    end
+
+    # Get the framebuffer width in pixels
+    # @return [Integer]
+    def framebuffer_width
+      js_int(:framebufferWidth) || 0
+    end
+
+    # Get the framebuffer height in pixels
+    # @return [Integer]
+    def framebuffer_height
+      js_int(:framebufferHeight) || 0
+    end
+
+    # Get the viewport for a specific view
+    # @param view [View] The XR view
+    # @return [Viewport]
+    def viewport(view)
+      js_viewport = js_call(:getViewport, view.js)
+      Viewport.new(js_viewport)
+    end
+
+    # Get the framebuffer dimensions as a hash
+    # @return [Hash] Hash with :width, :height keys
+    def framebuffer_size
+      { width: framebuffer_width, height: framebuffer_height }
+    end
+  end
+end

data/lib/webxr/layers/webgl_sub_image.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRWebGLSubImage - Represents a sub-image of a WebGL layer
+  class WebGLSubImage < JSWrapper
+    # @param js_subimage [JS::Object] The XRWebGLSubImage JavaScript object
+    def initialize(js_subimage)
+      super(js_subimage)
+    end
+
+    # Get the color texture
+    # @return [JS::Object] WebGL texture
+    def color_texture
+      js_prop(:colorTexture)
+    end
+
+    # Get the depth/stencil texture
+    # @return [JS::Object, nil] WebGL texture or nil
+    def depth_stencil_texture
+      js_prop(:depthStencilTexture)
+    end
+
+    # Get the motion vector texture
+    # @return [JS::Object, nil] WebGL texture or nil
+    def motion_vector_texture
+      js_prop(:motionVectorTexture)
+    end
+
+    # Get the image index (for texture arrays)
+    # @return [Integer, nil]
+    def image_index
+      js_int(:imageIndex)
+    end
+
+    # Get the texture width
+    # @return [Integer]
+    def texture_width
+      js_int(:textureWidth) || 0
+    end
+
+    # Get the texture height
+    # @return [Integer]
+    def texture_height
+      js_int(:textureHeight) || 0
+    end
+
+    # Get the viewport for this sub-image
+    # @return [Viewport]
+    def viewport
+      Viewport.new(js_prop(:viewport))
+    end
+
+    # Get the texture size as a hash
+    # @return [Hash] Hash with :width, :height keys
+    def texture_size
+      { width: texture_width, height: texture_height }
+    end
+  end
+end