rbgl 0.1.0 → 1.0.1

data/lib/rbgl/engine/context.rb

@@ -8,6 +8,7 @@ module RBGL
       def initialize(width:, height:)
         @framebuffer = Framebuffer.new(width, height)
         @rasterizer = Rasterizer.new(@framebuffer)
+        @clipper = ClipSpaceClipper.new
         @pipeline = nil
         @uniforms = Uniforms.new
         @vertex_buffer = nil
@@ -38,119 +39,188 @@ module RBGL
         @framebuffer.clear(color: color, depth: depth)
       end
 
+      def resize(width:, height:)
+        @framebuffer.resize(width, height)
+        @rasterizer.resize(width, height)
+      end
+
       def draw_arrays(mode, first, count)
+        validate_draw_state!
+        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)
+        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
+
+      def width
+        @framebuffer.width
+      end
+
+      def height
+        @framebuffer.height
+      end
+
+      def aspect_ratio
+        width.to_f / height
+      end
+
+      private
+
+      def validate_draw_state!(indexed: false)
         raise "No pipeline bound" unless @pipeline
         raise "No vertex buffer bound" unless @vertex_buffer
+        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
 
-        vertices = (first...first + count).map { |i| process_vertex(i) }
+      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) }
+          draw_primitive(mode, primitive)
+        end
+      end
+
+      def each_primitive(mode, vertices)
+        return enum_for(:each_primitive, mode, vertices) unless block_given?
+
+        vertices = vertices.to_a unless vertices.respond_to?(:[])
 
         case mode
         when :triangles
-          (0...vertices.size).step(3) do |i|
-            draw_triangle(vertices[i], vertices[i + 1], vertices[i + 2])
-          end
+          each_slice(vertices, 3) { |triangle| yield triangle }
         when :lines
-          (0...vertices.size).step(2) do |i|
-            draw_line(vertices[i], vertices[i + 1])
-          end
+          each_slice(vertices, 2) { |line| yield line }
         when :points
-          vertices.each { |v| draw_point(v) }
+          vertices.each { |vertex| yield [vertex] }
         when :triangle_strip
-          (0...vertices.size - 2).each do |i|
-            if i.even?
-              draw_triangle(vertices[i], vertices[i + 1], vertices[i + 2])
+          (0...(vertices.size - 2)).each do |index|
+            if index.even?
+              yield [vertices[index], vertices[index + 1], vertices[index + 2]]
             else
-              draw_triangle(vertices[i], vertices[i + 2], vertices[i + 1])
+              yield [vertices[index], vertices[index + 2], vertices[index + 1]]
             end
           end
         when :triangle_fan
-          (1...vertices.size - 1).each do |i|
-            draw_triangle(vertices[0], vertices[i], vertices[i + 1])
+          (1...(vertices.size - 1)).each do |index|
+            yield [vertices[0], vertices[index], vertices[index + 1]]
           end
+        else
+          raise ArgumentError, "Unsupported primitive mode: #{mode}"
         end
       end
 
-      def draw_elements(mode, count, offset = 0)
-        raise "No pipeline bound" unless @pipeline
-        raise "No vertex buffer bound" unless @vertex_buffer
-        raise "No index buffer bound" unless @index_buffer
+      def each_slice(vertices, size)
+        vertices.each_slice(size) do |primitive|
+          next unless primitive.size == size
 
-        indices = @index_buffer.indices[offset, count]
-        vertices = indices.map { |i| process_vertex(i) }
+          yield primitive
+        end
+      end
 
+      def draw_primitive(mode, primitive)
         case mode
-        when :triangles
-          (0...vertices.size).step(3) do |i|
-            draw_triangle(vertices[i], vertices[i + 1], vertices[i + 2])
-          end
         when :lines
-          (0...vertices.size).step(2) do |i|
-            draw_line(vertices[i], vertices[i + 1])
-          end
+          draw_line(*primitive)
+        when :points
+          draw_point(primitive.first)
+        else
+          draw_triangle(*primitive)
         end
       end
 
-      def width
-        @framebuffer.width
-      end
-
-      def height
-        @framebuffer.height
-      end
-
-      def aspect_ratio
-        width.to_f / height
-      end
-
-      private
-
       def process_vertex(index)
         input = @vertex_buffer.get_vertex(index)
+        return nil unless input
+
         input_io = ShaderIO.new
         input.each { |k, v| input_io[k] = v }
 
         @pipeline.vertex_shader.process(input_io, @uniforms)
       end
 
+      def fetch_vertex(index, vertex_cache)
+        return process_vertex(index) unless vertex_cache
+        return vertex_cache[index] if vertex_cache.key?(index)
+
+        vertex_cache[index] = process_vertex(index)
+      end
+
       def draw_triangle(v0, v1, v2)
         return unless v0 && v1 && v2
-        return if clip_triangle?(v0, v1, v2)
 
-        @rasterizer.rasterize_triangle(
-          v0, v1, v2,
-          @pipeline.fragment_shader,
-          @uniforms,
-          cull_mode: @pipeline.cull_mode
-        )
+        clip_triangle(v0, v1, v2).each do |triangle|
+          @rasterizer.rasterize_triangle(
+            *triangle,
+            @pipeline.fragment_shader,
+            @uniforms,
+            **rasterizer_state
+          )
+        end
       end
 
       def draw_line(v0, v1)
         return unless v0 && v1
+        clipped = clip_line(v0, v1)
+        return unless clipped
 
-        @rasterizer.rasterize_line(v0, v1, @pipeline.fragment_shader, @uniforms)
+        @rasterizer.rasterize_line(*clipped, @pipeline.fragment_shader, @uniforms, **rasterizer_state)
       end
 
       def draw_point(v)
         return unless v
+        clipped = @clipper.clip_point(v)
+        return unless clipped
 
-        @rasterizer.rasterize_point(v, @pipeline.fragment_shader, @uniforms)
+        @rasterizer.rasterize_point(
+          clipped,
+          @pipeline.fragment_shader,
+          @uniforms,
+          depth_test: @pipeline.depth_test,
+          depth_write: @pipeline.depth_write,
+          blend_mode: @pipeline.blend_mode
+        )
+      end
+
+      def clip_triangle(v0, v1, v2)
+        @clipper.clip(v0, v1, v2)
+      end
+
+      def clip_line(v0, v1)
+        @clipper.clip_line(v0, v1)
       end
 
       def clip_triangle?(v0, v1, v2)
-        positions = [v0[:position], v1[:position], v2[:position]].map do |p|
-          if p.is_a?(Larb::Vec4)
-            p.perspective_divide
-          else
-            p
-          end
-        end
+        clip_triangle(v0, v1, v2).empty?
+      end
+
+      def point_visible?(vertex)
+        @clipper.visible_point?(vertex)
+      end
 
-        positions.all? { |p| p.x < -1 } ||
-          positions.all? { |p| p.x > 1 } ||
-          positions.all? { |p| p.y < -1 } ||
-          positions.all? { |p| p.y > 1 } ||
-          positions.all? { |p| p.z < -1 } ||
-          positions.all? { |p| p.z > 1 }
+      def rasterizer_state
+        {
+          cull_mode: @pipeline.cull_mode,
+          depth_test: @pipeline.depth_test,
+          depth_write: @pipeline.depth_write,
+          blend_mode: @pipeline.blend_mode
+        }
       end
     end
   end

data/lib/rbgl/engine/framebuffer.rb

@@ -3,59 +3,80 @@
 module RBGL
   module Engine
     class Framebuffer
-      attr_reader :width, :height, :color_buffer, :depth_buffer
+      attr_reader :width, :height, :depth_buffer
+
+      def self.from_rgba_bytes(width, height, buffer)
+        new(width, height).tap { |framebuffer| framebuffer.send(:load_rgba_bytes, buffer) }
+      end
 
       def initialize(width, height)
+        resize(width, height)
+      end
+
+      def resize(width, height)
+        validate_dimensions!(width, height)
+        pixels = Array.new(width * height, pack_color(Larb::Color.black))
+        depth_buffer = Array.new(width * height) { Float::INFINITY }
+
         @width = width
         @height = height
-        @color_buffer = Array.new(width * height) { Larb::Color.black }
-        @depth_buffer = Array.new(width * height) { Float::INFINITY }
+        @pixels = pixels
+        @depth_buffer = depth_buffer
+      end
+
+      def color_buffer
+        @pixels.map { |pixel| unpack_color(pixel) }
+      end
+
+      def each_packed_pixel(&block)
+        return @pixels.each unless block
+
+        @pixels.each(&block)
       end
 
       def get_pixel(x, y)
         return nil if x < 0 || x >= @width || y < 0 || y >= @height
 
-        @color_buffer[y * @width + x]
+        unpack_color(@pixels[(y * @width) + x])
       end
 
       def set_pixel(x, y, color)
         return if x < 0 || x >= @width || y < 0 || y >= @height
 
-        @color_buffer[y * @width + x] = color
+        @pixels[(y * @width) + x] = pack_color(color)
       end
 
       def get_depth(x, y)
         return Float::INFINITY if x < 0 || x >= @width || y < 0 || y >= @height
 
-        @depth_buffer[y * @width + x]
+        @depth_buffer[(y * @width) + x]
       end
 
       def set_depth(x, y, depth)
         return if x < 0 || x >= @width || y < 0 || y >= @height
 
-        @depth_buffer[y * @width + x] = depth
+        @depth_buffer[(y * @width) + x] = depth
       end
 
-      def write_pixel(x, y, color, depth, depth_test: true)
+      def write_pixel(x, y, color, depth, depth_test: true, depth_write: true, blend_mode: :none)
         return false if x < 0 || x >= @width || y < 0 || y >= @height
+        return false unless depth.is_a?(Numeric) && depth.real? && depth.finite?
 
-        idx = y * @width + x
-        if !depth_test || depth < @depth_buffer[idx]
-          @color_buffer[idx] = color
-          @depth_buffer[idx] = depth
-          true
-        else
-          false
-        end
+        idx = (y * @width) + x
+        return false if depth_test && depth >= @depth_buffer[idx]
+
+        @pixels[idx] = blend_mode == :alpha ? blend_pixel(@pixels[idx], color) : pack_color(color)
+        @depth_buffer[idx] = depth if depth_write
+        true
       end
 
       def clear(color: Larb::Color.black, depth: Float::INFINITY)
-        @color_buffer.fill(color)
+        @pixels.fill(pack_color(color))
         @depth_buffer.fill(depth)
       end
 
       def clear_color(color)
-        @color_buffer.fill(color)
+        @pixels.fill(pack_color(color))
       end
 
       def clear_depth(depth = Float::INFINITY)
@@ -63,52 +84,136 @@ module RBGL
       end
 
       def to_ppm
-        ppm = "P3\n#{@width} #{@height}\n255\n"
+        ppm = String.new(capacity: @width * @height * 12, encoding: Encoding::BINARY)
+        ppm << "P3\n#{@width} #{@height}\n255\n"
         @height.times do |y|
-          row = @width.times.map do |x|
-            c = @color_buffer[y * @width + x]
-            bytes = c.to_bytes
-            "#{bytes[0]} #{bytes[1]} #{bytes[2]}"
+          @width.times do |x|
+            pixel = @pixels[(y * @width) + x]
+            ppm << " " unless x.zero?
+            ppm << red_byte(pixel).to_s << " " << green_byte(pixel).to_s << " " << blue_byte(pixel).to_s
           end
-          ppm += row.join(" ") + "\n"
+          ppm << "\n"
         end
         ppm
       end
 
       def to_ppm_binary
         header = "P6\n#{@width} #{@height}\n255\n"
-        pixels = @color_buffer.flat_map { |c| c.to_bytes[0..2] }.pack("C*")
+        pixels = packed_color_bytes(:rgb)
         header + pixels
       end
 
       def to_rgba_bytes
-        size = @color_buffer.size
-        bytes = Array.new(size * 4)
-        i = 0
-        size.times do |idx|
-          c = @color_buffer[idx]
-          bytes[i] = (c.r * 255).round.clamp(0, 255)
-          bytes[i + 1] = (c.g * 255).round.clamp(0, 255)
-          bytes[i + 2] = (c.b * 255).round.clamp(0, 255)
-          bytes[i + 3] = (c.a * 255).round.clamp(0, 255)
-          i += 4
-        end
-        bytes.pack("C*")
+        packed_color_bytes(:rgba)
       end
 
       def to_bgra_bytes
-        size = @color_buffer.size
-        bytes = Array.new(size * 4)
-        i = 0
-        size.times do |idx|
-          c = @color_buffer[idx]
-          bytes[i] = (c.b * 255).round.clamp(0, 255)
-          bytes[i + 1] = (c.g * 255).round.clamp(0, 255)
-          bytes[i + 2] = (c.r * 255).round.clamp(0, 255)
-          bytes[i + 3] = (c.a * 255).round.clamp(0, 255)
-          i += 4
+        packed_color_bytes(:bgra)
+      end
+
+      private
+
+      def validate_dimensions!(width, height)
+        return if width.is_a?(Integer) && width.positive? && height.is_a?(Integer) && height.positive?
+
+        raise ArgumentError, "Framebuffer dimensions must be positive integers"
+      end
+
+      def load_rgba_bytes(buffer)
+        bytes = String.try_convert(buffer)
+        raise ArgumentError, "Pixel buffer must be a String" unless bytes
+
+        expected_size = @width * @height * 4
+        unless bytes.bytesize == expected_size
+          raise ArgumentError, "Pixel buffer size mismatch: expected #{expected_size}, got #{bytes.bytesize}"
+        end
+
+        @pixels = Array.new(@width * @height)
+        pixel_index = 0
+        byte_index = 0
+        while pixel_index < @pixels.length
+          @pixels[pixel_index] = pack_bytes(
+            bytes.getbyte(byte_index),
+            bytes.getbyte(byte_index + 1),
+            bytes.getbyte(byte_index + 2),
+            bytes.getbyte(byte_index + 3)
+          )
+          pixel_index += 1
+          byte_index += 4
         end
-        bytes.pack("C*")
+      end
+
+      def blend_pixel(destination, source)
+        validate_color!(source)
+        alpha = source.a
+        inv_alpha = 1.0 - alpha
+        pack_bytes(
+          color_byte((source.r * alpha) + ((red_byte(destination) / 255.0) * inv_alpha)),
+          color_byte((source.g * alpha) + ((green_byte(destination) / 255.0) * inv_alpha)),
+          color_byte((source.b * alpha) + ((blue_byte(destination) / 255.0) * inv_alpha)),
+          color_byte(alpha + ((alpha_byte(destination) / 255.0) * inv_alpha))
+        )
+      end
+
+      def pack_color(color)
+        validate_color!(color)
+        pack_bytes(color_byte(color.r), color_byte(color.g), color_byte(color.b), color_byte(color.a))
+      end
+
+      def validate_color!(color)
+        return if color.is_a?(Larb::Color)
+
+        raise ArgumentError, "Colors must be Larb::Color values"
+      end
+
+      def packed_color_bytes(format)
+        channel_count = format == :rgb ? 3 : 4
+        bytes = String.new(capacity: @pixels.length * channel_count, encoding: Encoding::BINARY)
+
+        @pixels.each do |pixel|
+          case format
+          when :rgb
+            bytes << red_byte(pixel) << green_byte(pixel) << blue_byte(pixel)
+          when :rgba
+            bytes << red_byte(pixel) << green_byte(pixel) << blue_byte(pixel) << alpha_byte(pixel)
+          when :bgra
+            bytes << blue_byte(pixel) << green_byte(pixel) << red_byte(pixel) << alpha_byte(pixel)
+          end
+        end
+        bytes
+      end
+
+      def unpack_color(pixel)
+        ImmutableColor.new(
+          red_byte(pixel) / 255.0,
+          green_byte(pixel) / 255.0,
+          blue_byte(pixel) / 255.0,
+          alpha_byte(pixel) / 255.0
+        ).freeze
+      end
+
+      def pack_bytes(red, green, blue, alpha)
+        (alpha << 24) | (red << 16) | (green << 8) | blue
+      end
+
+      def alpha_byte(pixel)
+        (pixel >> 24) & 0xFF
+      end
+
+      def red_byte(pixel)
+        (pixel >> 16) & 0xFF
+      end
+
+      def green_byte(pixel)
+        (pixel >> 8) & 0xFF
+      end
+
+      def blue_byte(pixel)
+        pixel & 0xFF
+      end
+
+      def color_byte(value)
+        (value * 255).round.clamp(0, 255)
       end
     end
   end

data/lib/rbgl/engine/immutable_color.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class ImmutableColor < Larb::Color
+      def self.from(color)
+        return color if color.is_a?(self)
+        unless color.is_a?(Larb::Color)
+          raise ArgumentError, "Colors must be Larb::Color values"
+        end
+
+        new(color.r, color.g, color.b, color.a).freeze
+      end
+
+      def r=(_value)
+        raise FrozenError, "stored colors are immutable"
+      end
+
+      def g=(_value)
+        raise FrozenError, "stored colors are immutable"
+      end
+
+      def b=(_value)
+        raise FrozenError, "stored colors are immutable"
+      end
+
+      def a=(_value)
+        raise FrozenError, "stored colors are immutable"
+      end
+    end
+  end
+end

data/lib/rbgl/engine/pipeline.rb

@@ -3,18 +3,19 @@
 module RBGL
   module Engine
     class Pipeline
+      VALID_CULL_MODES = %i[none front back].freeze
+      VALID_BLEND_MODES = %i[none alpha].freeze
+
       attr_accessor :vertex_shader, :fragment_shader
-      attr_accessor :depth_test, :depth_write
-      attr_accessor :cull_mode
-      attr_accessor :blend_mode
+      attr_reader :depth_test, :depth_write, :cull_mode, :blend_mode
 
       def initialize
         @vertex_shader = nil
         @fragment_shader = nil
-        @depth_test = true
-        @depth_write = true
-        @cull_mode = :back
-        @blend_mode = :none
+        self.depth_test = true
+        self.depth_write = true
+        self.cull_mode = :back
+        self.blend_mode = :none
       end
 
       def self.create(&block)
@@ -30,6 +31,36 @@ module RBGL
       def fragment(&block)
         @fragment_shader = FragmentShader.new(&block)
       end
+
+      def depth_test=(value)
+        @depth_test = validate_boolean!(:depth_test, value)
+      end
+
+      def depth_write=(value)
+        @depth_write = validate_boolean!(:depth_write, value)
+      end
+
+      def cull_mode=(value)
+        @cull_mode = validate_enum!(:cull_mode, value, VALID_CULL_MODES)
+      end
+
+      def blend_mode=(value)
+        @blend_mode = validate_enum!(:blend_mode, value, VALID_BLEND_MODES)
+      end
+
+      private
+
+      def validate_boolean!(name, value)
+        return value if value == true || value == false
+
+        raise ArgumentError, "#{name} must be true or false"
+      end
+
+      def validate_enum!(name, value, allowed_values)
+        return value if allowed_values.include?(value)
+
+        raise ArgumentError, "#{name} must be one of: #{allowed_values.join(', ')}"
+      end
     end
   end
 end