webxr 0.1.0

data/lib/webxr/ar/hit_test_result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module WebXR
+  module AR
+    # XRHitTestResult - Result of a hit test
+    class HitTestResult < JSWrapper
+      # @param js_result [JS::Object] The XRHitTestResult JavaScript object
+      def initialize(js_result)
+        super(js_result)
+      end
+
+      # Get the pose of the hit point relative to a base space
+      # @param base_space [Space] The base reference space
+      # @return [Pose, nil]
+      def pose(base_space)
+        js_pose = js_call(:getPose, base_space.js)
+        return nil if js_pose.nil?
+
+        Pose.new(js_pose)
+      end
+
+      # Create an anchor at this hit test result
+      # @return [Anchor]
+      def create_anchor
+        promise = js_call(:createAnchor)
+        js_anchor = js_await(promise)
+        Anchor.new(js_anchor)
+      end
+    end
+
+    # XRTransientInputHitTestResult - Hit test result for transient input
+    class TransientInputHitTestResult < JSWrapper
+      # @param js_result [JS::Object] The XRTransientInputHitTestResult JavaScript object
+      def initialize(js_result)
+        super(js_result)
+      end
+
+      # Get the input source that triggered the hit test
+      # @return [InputSource]
+      def input_source
+        InputSource.new(js_prop(:inputSource))
+      end
+
+      # Get all hit test results for this input
+      # @return [Array<HitTestResult>]
+      def results
+        js_results = js_prop(:results)
+        return [] if js_results.nil?
+
+        js_array_to_a(js_results).map { |r| HitTestResult.new(r) }
+      end
+    end
+  end
+end

data/lib/webxr/ar/hit_test_source.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module WebXR
+  module AR
+    # XRHitTestSource - Source for performing hit tests
+    class HitTestSource < JSWrapper
+      # @param js_hit_test_source [JS::Object] The XRHitTestSource JavaScript object
+      def initialize(js_hit_test_source)
+        super(js_hit_test_source)
+      end
+
+      # Cancel the hit test source
+      # Once cancelled, the source cannot be used for further hit tests
+      # @return [void]
+      def cancel
+        js_call(:cancel)
+      end
+    end
+
+    # XRTransientInputHitTestSource - Hit test source for transient input
+    class TransientInputHitTestSource < JSWrapper
+      # @param js_source [JS::Object] The XRTransientInputHitTestSource JavaScript object
+      def initialize(js_source)
+        super(js_source)
+      end
+
+      # Cancel the hit test source
+      # @return [void]
+      def cancel
+        js_call(:cancel)
+      end
+    end
+  end
+end

data/lib/webxr/ar/ray.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module WebXR
+  module AR
+    # XRRay - Represents a ray in 3D space for hit testing
+    class Ray < JSWrapper
+      # Create a new ray
+      # @param js_ray [JS::Object, nil] Existing JS ray to wrap
+      # @param origin [Hash, nil] Origin point with :x, :y, :z, :w keys
+      # @param direction [Hash, nil] Direction vector with :x, :y, :z, :w keys
+      # @param transform [RigidTransform, nil] Transform to apply
+      def initialize(js_ray = nil, origin: nil, direction: nil, transform: nil)
+        if js_ray
+          super(js_ray)
+        else
+          js_origin = origin ? create_dom_point(origin) : nil
+          js_direction = direction ? create_dom_point(direction) : nil
+
+          if transform
+            js_obj = JS.global[:XRRay].new(transform.js)
+          elsif js_origin && js_direction
+            js_obj = JS.global[:XRRay].new(js_origin, js_direction)
+          elsif js_origin
+            js_obj = JS.global[:XRRay].new(js_origin)
+          else
+            js_obj = JS.global[:XRRay].new
+          end
+
+          super(js_obj)
+        end
+      end
+
+      # Get the origin point of the ray
+      # @return [Hash] Hash with :x, :y, :z, :w keys
+      def origin
+        o = js_prop(:origin)
+        {
+          x: o[:x].to_f,
+          y: o[:y].to_f,
+          z: o[:z].to_f,
+          w: o[:w].to_f
+        }
+      end
+
+      # Get the direction vector of the ray (normalized)
+      # @return [Hash] Hash with :x, :y, :z, :w keys
+      def direction
+        d = js_prop(:direction)
+        {
+          x: d[:x].to_f,
+          y: d[:y].to_f,
+          z: d[:z].to_f,
+          w: d[:w].to_f
+        }
+      end
+
+      # Get the 4x4 transformation matrix
+      # @return [Array<Float>] 16-element array in column-major order
+      def matrix
+        js_matrix = js_prop(:matrix)
+        js_array_to_a(js_matrix).map(&:to_f)
+      end
+
+      # Get the origin as a 3-element array [x, y, z]
+      # @return [Array<Float>]
+      def origin_array
+        o = origin
+        [o[:x], o[:y], o[:z]]
+      end
+
+      # Get the direction as a 3-element array [x, y, z]
+      # @return [Array<Float>]
+      def direction_array
+        d = direction
+        [d[:x], d[:y], d[:z]]
+      end
+
+      private
+
+      def create_dom_point(hash)
+        JS.global[:DOMPointReadOnly].new(
+          hash[:x] || 0,
+          hash[:y] || 0,
+          hash[:z] || (hash.key?(:z) ? hash[:z] : -1), # Default direction is -Z
+          hash[:w] || 1
+        )
+      end
+    end
+  end
+end

data/lib/webxr/constants.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XR session mode types
+  module SessionMode
+    INLINE = "inline"
+    IMMERSIVE_VR = "immersive-vr"
+    IMMERSIVE_AR = "immersive-ar"
+  end
+
+  # Reference space types
+  module ReferenceSpaceType
+    VIEWER = "viewer"
+    LOCAL = "local"
+    LOCAL_FLOOR = "local-floor"
+    BOUNDED_FLOOR = "bounded-floor"
+    UNBOUNDED = "unbounded"
+  end
+
+  # Session visibility states
+  module VisibilityState
+    VISIBLE = "visible"
+    VISIBLE_BLURRED = "visible-blurred"
+    HIDDEN = "hidden"
+  end
+
+  # Controller handedness
+  module Handedness
+    NONE = "none"
+    LEFT = "left"
+    RIGHT = "right"
+  end
+
+  # Input source target ray modes
+  module TargetRayMode
+    GAZE = "gaze"
+    TRACKED_POINTER = "tracked-pointer"
+    SCREEN = "screen"
+    TRANSIENT_POINTER = "transient-pointer"
+  end
+
+  # Environment blend modes (for AR)
+  module EnvironmentBlendMode
+    OPAQUE = "opaque"
+    ALPHA_BLEND = "alpha-blend"
+    ADDITIVE = "additive"
+  end
+
+  # Interaction modes
+  module InteractionMode
+    SCREEN_SPACE = "screen-space"
+    WORLD_SPACE = "world-space"
+  end
+
+  # Eye types for XRView
+  module Eye
+    NONE = "none"
+    LEFT = "left"
+    RIGHT = "right"
+  end
+end

data/lib/webxr/core/frame.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRFrame - Represents a single frame of an XR session
+  # Contains pose and timing information for rendering
+  class Frame < JSWrapper
+    # @param js_frame [JS::Object] The XRFrame JavaScript object
+    def initialize(js_frame)
+      super(js_frame)
+      @active = true
+      @animation_frame = true
+    end
+
+    # Get the session this frame belongs to
+    # @return [Session]
+    def session
+      Session.new(js_prop(:session))
+    end
+
+    # Get the predicted display time
+    # @return [Float] Time in milliseconds
+    def predicted_display_time
+      js_float(:predictedDisplayTime) || 0.0
+    end
+
+    # Get the viewer pose relative to a reference space
+    # @param reference_space [ReferenceSpace] The reference space
+    # @return [ViewerPose, nil]
+    def viewer_pose(reference_space)
+      js_pose = js_call(:getViewerPose, reference_space.js)
+      return nil if js_pose.nil?
+
+      ViewerPose.new(js_pose)
+    end
+
+    # Get a pose relative to a base space
+    # @param space [Space] The space to get the pose for
+    # @param base_space [Space] The base reference space
+    # @return [Pose, nil]
+    def pose(space, base_space)
+      js_pose = js_call(:getPose, space.js, base_space.js)
+      return nil if js_pose.nil?
+
+      Pose.new(js_pose)
+    end
+
+    # Get a joint pose (for hand tracking)
+    # @param joint [Hand::JointSpace] The joint space
+    # @param base_space [Space] The base reference space
+    # @return [Hand::JointPose, nil]
+    def joint_pose(joint, base_space)
+      js_pose = js_call(:getJointPose, joint.js, base_space.js)
+      return nil if js_pose.nil?
+
+      Hand::JointPose.new(js_pose)
+    end
+
+    # Fill joint poses for an entire hand
+    # @param hand [Hand::Hand] The hand object
+    # @param base_space [Space] The base reference space
+    # @param joint_spaces [Array<Hand::JointSpace>] Array of joint spaces
+    # @param float32_array [JS::Object] Float32Array to fill
+    # @return [Boolean] True if all poses were filled
+    def fill_joint_poses(hand, base_space, joint_spaces, float32_array)
+      js_call(:fillJointPoses, joint_spaces.map(&:js), base_space.js, float32_array)
+    end
+
+    # Fill a transform array from poses
+    # @param poses [Array<Pose>] Array of poses
+    # @param float32_array [JS::Object] Float32Array to fill
+    # @return [Boolean] True if all transforms were filled
+    def fill_poses(poses, float32_array)
+      js_call(:fillPoses, poses.map(&:js), float32_array)
+    end
+
+    # Get hit test results
+    # @param hit_test_source [AR::HitTestSource] The hit test source
+    # @return [Array<AR::HitTestResult>]
+    def hit_test_results(hit_test_source)
+      js_results = js_call(:getHitTestResults, hit_test_source.js)
+      return [] if js_results.nil?
+
+      js_array_to_a(js_results).map { |r| AR::HitTestResult.new(r) }
+    end
+
+    # Get hit test results for transient input
+    # @param hit_test_source [AR::TransientInputHitTestSource] The hit test source
+    # @return [Array<AR::TransientInputHitTestResult>]
+    def hit_test_results_for_transient_input(hit_test_source)
+      js_results = js_call(:getHitTestResultsForTransientInput, hit_test_source.js)
+      return [] if js_results.nil?
+
+      js_array_to_a(js_results).map { |r| AR::TransientInputHitTestResult.new(r) }
+    end
+
+    # Create an anchor at a pose
+    # @param pose [RigidTransform] The transform for the anchor
+    # @param space [Space] The space for the anchor
+    # @return [AR::Anchor]
+    def create_anchor(pose, space)
+      promise = js_call(:createAnchor, pose.js, space.js)
+      js_anchor = js_await(promise)
+      AR::Anchor.new(js_anchor)
+    end
+
+    # Get tracked anchors
+    # @return [Set<AR::Anchor>]
+    def tracked_anchors
+      js_anchors = js_prop(:trackedAnchors)
+      return Set.new if js_anchors.nil?
+
+      anchors = Set.new
+      js_anchors.call(:forEach, ->(js_anchor) { anchors << AR::Anchor.new(js_anchor) })
+      anchors
+    end
+
+    # Get the light estimate
+    # @param light_probe [Lighting::Probe] The light probe
+    # @return [Lighting::Estimate, nil]
+    def light_estimate(light_probe)
+      js_estimate = js_call(:getLightEstimate, light_probe.js)
+      return nil if js_estimate.nil?
+
+      Lighting::Estimate.new(js_estimate)
+    end
+
+    # Get depth information
+    # @param view [View] The view to get depth for
+    # @return [Depth::Information, nil]
+    def depth_information(view)
+      js_info = js_call(:getDepthInformation, view.js)
+      return nil if js_info.nil?
+
+      Depth::Information.new(js_info)
+    end
+
+    # Check if this frame is still active
+    # @return [Boolean]
+    def active?
+      @active
+    end
+
+    # Check if this is an animation frame
+    # @return [Boolean]
+    def animation_frame?
+      @animation_frame
+    end
+
+    # Mark the frame as inactive (called after callback completes)
+    # @api private
+    def mark_inactive!
+      @active = false
+    end
+  end
+end

data/lib/webxr/core/render_state.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRRenderState - Contains render configuration for a session
+  class RenderState < JSWrapper
+    # @param js_render_state [JS::Object] The XRRenderState JavaScript object
+    def initialize(js_render_state)
+      super(js_render_state)
+    end
+
+    # Get the near depth plane distance
+    # @return [Float]
+    def depth_near
+      js_float(:depthNear) || 0.1
+    end
+
+    # Get the far depth plane distance
+    # @return [Float]
+    def depth_far
+      js_float(:depthFar) || 1000.0
+    end
+
+    # Get the inline vertical field of view (for inline sessions)
+    # @return [Float, nil] Field of view in radians
+    def inline_vertical_field_of_view
+      js_float(:inlineVerticalFieldOfView)
+    end
+
+    # Get the base XR layer
+    # @return [WebGLLayer, nil]
+    def base_layer
+      js_layer = js_prop(:baseLayer)
+      return nil if js_layer.nil?
+
+      WebGLLayer.wrap(js_layer)
+    end
+
+    # Get all layers (for multi-layer rendering)
+    # @return [Array<Layer>]
+    def layers
+      js_layers = js_prop(:layers)
+      return [] if js_layers.nil?
+
+      js_array_to_a(js_layers).map { |l| Layer.wrap(l) }
+    end
+  end
+end

data/lib/webxr/core/session.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module WebXR
+  # XRSession - Represents an XR session
+  # Manages the rendering loop and input sources
+  class Session < JSWrapper
+    # @return [String] The session mode ("inline", "immersive-vr", "immersive-ar")
+    attr_reader :mode
+
+    # Session event types
+    EVENTS = %i[
+      end
+      select
+      selectstart
+      selectend
+      squeeze
+      squeezestart
+      squeezeend
+      inputsourceschange
+      visibilitychange
+      frameratechange
+    ].freeze
+
+    # @param js_session [JS::Object] The XRSession JavaScript object
+    def initialize(js_session)
+      super(js_session)
+      @mode = js_string(:mode)
+      @render_state = nil
+      @callbacks = EVENTS.each_with_object({}) { |event, h| h[event] = [] }
+      @animation_frame_id = nil
+    end
+
+    # Get the current visibility state
+    # @return [String] "visible", "visible-blurred", or "hidden"
+    def visibility_state
+      js_string(:visibilityState)
+    end
+
+    # Get the current frame rate
+    # @return [Float, nil]
+    def frame_rate
+      js_float(:frameRate)
+    end
+
+    # Get the supported frame rates
+    # @return [Array<Float>, nil]
+    def supported_frame_rates
+      js_array = js_prop(:supportedFrameRates)
+      return nil if js_array.nil?
+
+      js_array_to_a(js_array).map(&:to_f)
+    end
+
+    # Get the current render state
+    # @return [RenderState]
+    def render_state
+      @render_state ||= RenderState.new(js_prop(:renderState))
+    end
+
+    # Get the current input sources
+    # @return [InputSourceArray]
+    def input_sources
+      InputSourceArray.new(js_prop(:inputSources))
+    end
+
+    # Get the enabled features for this session
+    # @return [Array<String>]
+    def enabled_features
+      js_array = js_prop(:enabledFeatures)
+      return [] if js_array.nil?
+
+      js_array_to_a(js_array).map(&:to_s)
+    end
+
+    # Check if system keyboard is supported
+    # @return [Boolean]
+    def system_keyboard_supported?
+      js_bool(:isSystemKeyboardSupported)
+    end
+
+    # Get the environment blend mode
+    # @return [String] "opaque", "alpha-blend", or "additive"
+    def environment_blend_mode
+      js_string(:environmentBlendMode)
+    end
+
+    # Get the interaction mode
+    # @return [String] "screen-space" or "world-space"
+    def interaction_mode
+      js_string(:interactionMode)
+    end
+
+    # Check if the session has ended
+    # @return [Boolean]
+    def ended?
+      js_bool(:ended)
+    end
+
+    # Update the render state
+    # @param depth_near [Float, nil] Near depth plane
+    # @param depth_far [Float, nil] Far depth plane
+    # @param inline_vertical_field_of_view [Float, nil] Field of view for inline sessions
+    # @param base_layer [WebGLLayer, nil] The base WebGL layer
+    # @return [void]
+    def update_render_state(depth_near: nil, depth_far: nil, inline_vertical_field_of_view: nil, base_layer: nil)
+      js_options = JS.eval("({})")
+
+      js_options[:depthNear] = depth_near if depth_near
+      js_options[:depthFar] = depth_far if depth_far
+      js_options[:inlineVerticalFieldOfView] = inline_vertical_field_of_view if inline_vertical_field_of_view
+      js_options[:baseLayer] = base_layer.js if base_layer
+
+      js_call(:updateRenderState, js_options)
+      @render_state = nil # Clear cache
+    end
+
+    # Update the target frame rate
+    # @param rate [Float] The target frame rate in Hz
+    # @return [void]
+    def update_target_frame_rate(rate)
+      promise = js_call(:updateTargetFrameRate, rate)
+      js_await(promise)
+    end
+
+    # Request a reference space
+    # @param type [String] The reference space type
+    # @return [ReferenceSpace, BoundedReferenceSpace]
+    def request_reference_space(type)
+      promise = js_call(:requestReferenceSpace, type)
+      js_space = js_await(promise)
+
+      case type
+      when ReferenceSpaceType::BOUNDED_FLOOR
+        BoundedReferenceSpace.new(js_space)
+      else
+        ReferenceSpace.new(js_space)
+      end
+    end
+
+    # Request an animation frame
+    # @yield [Float, Frame] The callback receives time and frame
+    # @return [Integer] The animation frame handle
+    def request_animation_frame(&block)
+      return nil unless block_given?
+
+      js_callback = create_animation_frame_callback(block)
+      @animation_frame_id = js_call(:requestAnimationFrame, js_callback)
+      @animation_frame_id.to_i
+    end
+
+    # Cancel a pending animation frame
+    # @param handle [Integer, nil] The animation frame handle (uses last handle if nil)
+    # @return [void]
+    def cancel_animation_frame(handle = nil)
+      handle ||= @animation_frame_id
+      js_call(:cancelAnimationFrame, handle) if handle
+    end
+
+    # End the XR session
+    # @return [void]
+    def end_session
+      promise = js_call(:end)
+      js_await(promise)
+    end
+
+    # Register an event handler
+    # @param event [Symbol, String] The event type
+    # @yield [Event] The event callback
+    # @return [void]
+    def on(event, &block)
+      event_sym = event.to_sym
+      return unless @callbacks.key?(event_sym) && block_given?
+
+      @callbacks[event_sym] << block
+      setup_event_listener(event_sym) if @callbacks[event_sym].size == 1
+    end
+
+    private
+
+    def create_animation_frame_callback(block)
+      # Create a JS function that will invoke the Ruby block
+      JS.eval("(function(time, frame) {
+        return $callback.call(time, frame);
+      })")
+    end
+
+    def setup_event_listener(event_sym)
+      js_event = event_sym.to_s
+
+      callback = ->(js_event_obj) { dispatch_event(event_sym, js_event_obj) }
+      js_callback = JS.eval("(function(event) { return $callback.call(event); })")
+
+      js_call(:addEventListener, js_event, js_callback)
+    end
+
+    def dispatch_event(event_sym, js_event_obj)
+      event = wrap_event(event_sym, js_event_obj)
+      @callbacks[event_sym].each { |cb| cb.call(event) }
+    end
+
+    def wrap_event(event_sym, js_event_obj)
+      case event_sym
+      when :select, :selectstart, :selectend, :squeeze, :squeezestart, :squeezeend
+        InputSourceEvent.new(js_event_obj)
+      when :inputsourceschange
+        InputSourcesChangeEvent.new(js_event_obj)
+      else
+        SessionEvent.new(js_event_obj)
+      end
+    end
+  end
+end