rbgl 1.0.0 → 1.0.1

data/examples/multi_return_test.rb

@@ -81,7 +81,7 @@ while running && !window.should_close?
   events.each do |e|
     case e[:type]
     when :key_press
-      running = false if e[:key] == 12 || e[:key] == "q"
+      running = false if %i[escape q].include?(e[:key])
     end
   end
 

data/examples/plasma.rb

@@ -60,7 +60,7 @@ while running && !window.should_close?
 
   events = window.poll_events_raw
   events.each do |e|
-    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+    if e[:type] == :key_press && %i[escape q].include?(e[:key])
       running = false
     end
   end

data/examples/sphere_raymarch.rb

@@ -108,7 +108,7 @@ while running && !window.should_close?
 
   events = window.poll_events_raw
   events.each do |e|
-    if e[:type] == :key_press && (e[:key] == 12 || e[:key] == "q")
+    if e[:type] == :key_press && %i[escape q].include?(e[:key])
       running = false
     end
   end

data/examples/triangle_window.rb

@@ -42,7 +42,7 @@ time = 0.0
 
 window.on(:key_press) do |event|
   puts "Key: #{event.key}"
-  window.stop if event.key == 12 || event.key == "q" || event.key == "Escape"
+  window.stop if %i[escape q].include?(event.key)
 end
 
 window.on(:mouse_move) do |event|

data/exe/rbgl

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "optparse"
+
+lib_path = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require "rbgl"
+require "rbgl/cli/doctor"
+
+module RBGLCLI
+  def self.run(argv = ARGV, stdout: $stdout, stderr: $stderr)
+    options = { json: false }
+
+    parser = OptionParser.new do |parser|
+      parser.banner = "Usage: rbgl <command>\n\nCommands:\n  doctor [--json]\n"
+      parser.on("--json", "Output JSON") { options[:json] = true }
+      parser.on("-h", "--help", "Show this help") do
+        stdout.puts parser
+        return 0
+      end
+    end
+
+    parser.parse!(argv)
+
+    command = argv.shift
+    unless command == "doctor"
+      stderr.puts parser
+      return 1
+    end
+
+    RBGL::CLI::Doctor.new(json: options[:json], io: stdout).run
+  rescue OptionParser::InvalidOption, OptionParser::MissingArgument => error
+    stderr.puts error.message
+    stderr.puts parser
+    1
+  end
+end
+
+exit RBGLCLI.run

data/lib/rbgl/cli/doctor.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "tmpdir"
+
+module RBGL
+  module CLI
+    class Doctor
+      class << self
+        def default_checks
+          {
+            file_backend: ->(doctor, env, platform) { doctor.__send__(:check_file_backend, env, platform) },
+            wayland: ->(doctor, env, platform) { doctor.__send__(:check_wayland, env, platform) },
+            x11: ->(doctor, env, platform) { doctor.__send__(:check_x11, env, platform) },
+            cocoa: ->(doctor, env, platform) { doctor.__send__(:check_cocoa, env, platform) },
+            rlsl: ->(doctor, env, platform) { doctor.__send__(:check_rlsl, env, platform) }
+          }
+        end
+      end
+
+      def initialize(json: false, io: $stdout, env: ENV, platform: RUBY_PLATFORM, ruby_version: RUBY_VERSION, checks: {})
+        @json = json
+        @io = io
+        @env = env
+        @platform = platform
+        @ruby_version = ruby_version
+        @checks = self.class.default_checks.merge(checks)
+      end
+
+      def run
+        report = collect
+
+        if @json
+          output_json(report)
+        else
+          output_text(report)
+        end
+
+        0
+      end
+
+      def collect
+        {
+          rbgl_version: RBGL::VERSION,
+          ruby_version: @ruby_version,
+          platform: @platform,
+          file_backend: collect_component(:file_backend),
+          wayland: collect_component(:wayland),
+          x11: collect_component(:x11),
+          cocoa: collect_component(:cocoa),
+          rlsl: collect_component(:rlsl)
+        }
+      end
+
+      private
+
+      def collect_component(key)
+        @checks.fetch(key).call(self, @env, @platform)
+      rescue StandardError => e
+        { available: false, error: "#{e.class}: #{e.message}" }
+      end
+
+      def output_text(report)
+        @io.puts("RBGL version: #{report[:rbgl_version]}")
+        @io.puts("Ruby version: #{report[:ruby_version]}")
+        @io.puts("RUBY_PLATFORM: #{report[:platform]}")
+        @io.puts
+        dump_section("File backend", report[:file_backend])
+        dump_section("Wayland", report[:wayland])
+        dump_section("X11", report[:x11])
+        dump_section("Cocoa", report[:cocoa])
+        dump_section("RLSL", report[:rlsl])
+      end
+
+      def output_json(report)
+        @io.puts(JSON.pretty_generate(report))
+      end
+
+      def dump_section(name, values)
+        @io.puts("#{name}:")
+        values.each do |key, value|
+          @io.puts("  #{key}: #{format_value(value)}")
+        end
+        @io.puts
+      end
+
+      def format_value(value)
+        return value.is_a?(TrueClass) || value.is_a?(FalseClass) ? (value ? "yes" : "no") : value.inspect
+      end
+
+      def check_file_backend(_env, _platform)
+        output_dir = Dir.mktmpdir("rbgl-doctor")
+        backend = RBGL::GUI::FileBackend.new(1, 1, "rbgl-doctor", output_dir: output_dir)
+        backend.present(RBGL::Engine::Framebuffer.new(1, 1))
+
+        { available: true, output_dir: output_dir }
+      ensure
+        backend&.close
+        FileUtils.rm_rf(output_dir) if output_dir
+      end
+
+      def check_wayland(env, _platform)
+        require_ok, require_error = safe_require("rbgl/gui/wayland/connection")
+        {
+          display_env: env["WAYLAND_DISPLAY"],
+          display_available: !env["WAYLAND_DISPLAY"].nil?,
+          require_ok: require_ok,
+          require_error: require_error
+        }
+      end
+
+      def check_x11(env, _platform)
+        require_ok, require_error = safe_require("rbgl/gui/x11/connection")
+        {
+          display_env: env["DISPLAY"],
+          display_available: !env["DISPLAY"].nil?,
+          require_ok: require_ok,
+          require_error: require_error
+        }
+      end
+
+      def check_cocoa(_env, platform)
+        darwin = platform.include?("darwin")
+        return { platform: platform, supported: false } unless darwin
+
+        require_ok, require_error = safe_require("metaco")
+        {
+          platform: platform,
+          supported: true,
+          require_ok: require_ok,
+          require_error: require_error
+        }
+      end
+
+      def check_rlsl(_env, _platform)
+        begin
+          require "rlsl"
+          version = Gem.loaded_specs["rlsl"]&.version&.to_s
+
+          { require_ok: true, version: version }
+        rescue LoadError => e
+          { require_ok: false, error: "#{e.class}: #{e.message}" }
+        end
+      end
+
+      def safe_require(file)
+        require file
+        [true, nil]
+      rescue LoadError => e
+        [false, "#{e.class}: #{e.message}"]
+      end
+    end
+  end
+end

data/lib/rbgl/engine/buffer.rb

@@ -6,6 +6,10 @@ module RBGL
       attr_reader :name, :size, :offset, :kind
 
       def initialize(name, size, offset = 0, kind: nil)
+        unless size.is_a?(Integer) && size.positive?
+          raise ArgumentError, "Vertex attribute size must be a positive Integer"
+        end
+
         @name = name.to_sym
         @size = size
         @offset = offset
@@ -96,18 +100,35 @@ module RBGL
     end
 
     class VertexLayout
-      attr_reader :attributes, :stride
+      attr_reader :stride
 
       def initialize(&block)
         @attributes = {}
         @offset = 0
+        @stride = 0
+        @finalized = false
         instance_eval(&block) if block_given?
-        @stride = @offset
       end
 
       def attribute(name, size, kind: nil)
-        @attributes[name.to_sym] = VertexAttribute.new(name, size, @offset, kind: kind)
+        raise ArgumentError, "Vertex layout is finalized" if @finalized
+
+        key = name.to_sym
+        raise ArgumentError, "Duplicate vertex attribute: #{key}" if @attributes.key?(key)
+
+        @attributes[key] = VertexAttribute.new(key, size, @offset, kind: kind)
         @offset += size
+        @stride = @offset
+      end
+
+      def attributes
+        @finalized ? @attributes : @attributes.dup.freeze
+      end
+
+      def finalize!
+        @finalized = true
+        @attributes.freeze
+        self
       end
 
       def self.position_only
@@ -143,7 +164,11 @@ module RBGL
       attr_reader :data, :layout, :vertex_count
 
       def initialize(layout)
-        @layout = layout
+        unless layout.is_a?(VertexLayout)
+          raise ArgumentError, "VertexBuffer layout must be an RBGL::Engine::VertexLayout"
+        end
+
+        @layout = layout.finalize!
         @data = []
         @vertex_count = 0
       end
@@ -199,14 +224,16 @@ module RBGL
     end
 
     class IndexBuffer
-      attr_reader :indices
-
       def initialize(indices = [])
-        @indices = indices.map(&:to_i)
+        @indices = validate_indices!(indices)
+      end
+
+      def indices
+        @indices.dup.freeze
       end
 
       def add(*idx)
-        @indices.concat(idx.flatten.map(&:to_i))
+        @indices.concat(validate_indices!(idx.flatten))
         self
       end
 
@@ -215,6 +242,8 @@ module RBGL
       end
 
       def get_triangle(index)
+        return nil unless index.is_a?(Integer) && index >= 0
+
         start = index * 3
         @indices[start, 3]
       end
@@ -224,6 +253,18 @@ module RBGL
 
         (0...triangle_count).each { |i| yield get_triangle(i) }
       end
+
+      private
+
+      def validate_indices!(indices)
+        indices.map do |index|
+          unless index.is_a?(Integer) && index >= 0
+            raise ArgumentError, "Index must be a non-negative Integer: #{index.inspect}"
+          end
+
+          index
+        end
+      end
     end
   end
 end

data/lib/rbgl/engine/clip_space_clipper.rb

@@ -13,7 +13,10 @@ module RBGL
       ].freeze
 
       def clip(v0, v1, v2)
-        polygon = [v0, v1, v2]
+        polygon = [v0, v1, v2].map { |vertex| normalize_vertex(vertex) }
+        outcodes = polygon.map { |vertex| outcode(vertex) }
+        return [polygon] if outcodes.reduce(:|).zero?
+        return [] unless outcodes.reduce(:&).zero?
 
         CLIP_PLANES.each do |plane|
           polygon = clip_against_plane(polygon, plane)
@@ -38,6 +41,11 @@ module RBGL
         CLIP_PLANES.all? { |plane| signed_distance(vertex, plane) >= 0 }
       end
 
+      def clip_point(vertex)
+        point = normalize_vertex(vertex)
+        visible_point?(point) ? point : nil
+      end
+
       private
 
       def clip_against_plane(vertices, plane)
@@ -102,7 +110,13 @@ module RBGL
       end
 
       def duplicate_vertex(vertex)
-        ShaderIO.new(vertex.to_h)
+        ShaderIO.new(vertex.to_h).tap do |copy|
+          copy[:position] = clip_position(vertex) if vertex[:position].is_a?(Larb::Vec2)
+        end
+      end
+
+      def normalize_vertex(vertex)
+        vertex[:position].is_a?(Larb::Vec2) ? duplicate_vertex(vertex) : vertex
       end
 
       def interpolated_keys(start_vertex, finish_vertex)
@@ -115,7 +129,7 @@ module RBGL
 
         case start_value
         when Numeric
-          start_value + (finish_value - start_value) * t
+          start_value + ((finish_value - start_value) * t)
         when Larb::Vec2, Larb::Vec3, Larb::Vec4, Larb::Color
           start_value.lerp(finish_value, t)
         else
@@ -127,6 +141,12 @@ module RBGL
         plane.call(clip_position(vertex))
       end
 
+      def outcode(vertex)
+        CLIP_PLANES.each_with_index.reduce(0) do |code, (plane, index)|
+          signed_distance(vertex, plane).negative? ? code | (1 << index) : code
+        end
+      end
+
       def clip_position(vertex)
         position = vertex[:position]
 

data/lib/rbgl/engine/context.rb

@@ -46,12 +46,18 @@ module RBGL
 
       def draw_arrays(mode, first, count)
         validate_draw_state!
-        draw_vertices(mode, first...first + count)
+        validate_draw_range!(first, count, @vertex_buffer.vertex_count)
+        draw_vertices(mode, first...(first + count))
       end
 
       def draw_elements(mode, count, offset = 0)
         validate_draw_state!(indexed: true)
-        indices = @index_buffer.indices[offset, count] || []
+        all_indices = @index_buffer.indices
+        validate_draw_range!(offset, count, all_indices.size)
+        indices = all_indices[offset, count]
+        invalid_index = indices.find { |index| index >= @vertex_buffer.vertex_count }
+        raise ArgumentError, "Vertex index out of bounds: #{invalid_index}" if invalid_index
+
         draw_vertices(mode, indices, vertex_cache: {})
       end
 
@@ -75,6 +81,15 @@ module RBGL
         raise "No index buffer bound" if indexed && !@index_buffer
       end
 
+      def validate_draw_range!(offset, count, limit)
+        unless offset.is_a?(Integer) && count.is_a?(Integer) && offset >= 0 && count >= 0
+          raise ArgumentError, "Draw offset and count must be non-negative Integers"
+        end
+        return if offset + count <= limit
+
+        raise ArgumentError, "Draw range exceeds available data"
+      end
+
       def draw_vertices(mode, indices, vertex_cache: nil)
         each_primitive(mode, indices) do |primitive_indices|
           primitive = primitive_indices.map { |index| fetch_vertex(index, vertex_cache) }
@@ -95,7 +110,7 @@ module RBGL
         when :points
           vertices.each { |vertex| yield [vertex] }
         when :triangle_strip
-          (0...vertices.size - 2).each do |index|
+          (0...(vertices.size - 2)).each do |index|
             if index.even?
               yield [vertices[index], vertices[index + 1], vertices[index + 2]]
             else
@@ -103,7 +118,7 @@ module RBGL
             end
           end
         when :triangle_fan
-          (1...vertices.size - 1).each do |index|
+          (1...(vertices.size - 1)).each do |index|
             yield [vertices[0], vertices[index], vertices[index + 1]]
           end
         else
@@ -169,10 +184,12 @@ module RBGL
       end
 
       def draw_point(v)
-        return unless v && point_visible?(v)
+        return unless v
+        clipped = @clipper.clip_point(v)
+        return unless clipped
 
         @rasterizer.rasterize_point(
-          v,
+          clipped,
           @pipeline.fragment_shader,
           @uniforms,
           depth_test: @pipeline.depth_test,