rbgl 1.0.0 → 1.0.1

data/lib/rbgl/engine/framebuffer.rb

@@ -3,64 +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)
-        @width = width
-        @height = height
-        @color_buffer = Array.new(width * height) { Larb::Color.black }
-        @depth_buffer = Array.new(width * height) { Float::INFINITY }
+        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, 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
+        idx = (y * @width) + x
         return false if depth_test && depth >= @depth_buffer[idx]
 
-        @color_buffer[idx] = blend_color(@color_buffer[idx], color, blend_mode)
+        @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)
@@ -68,56 +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 = packed_color_bytes(%i[r g b])
+        pixels = packed_color_bytes(:rgb)
         header + pixels
       end
 
       def to_rgba_bytes
-        packed_color_bytes(%i[r g b a])
+        packed_color_bytes(:rgba)
       end
 
       def to_bgra_bytes
-        packed_color_bytes(%i[b g r a])
+        packed_color_bytes(:bgra)
       end
 
       private
 
-      def blend_color(destination, source, blend_mode)
-        case blend_mode
-        when :alpha
-          alpha = source.a
-          inv_alpha = 1.0 - alpha
-          Larb::Color.new(
-            source.r * alpha + destination.r * inv_alpha,
-            source.g * alpha + destination.g * inv_alpha,
-            source.b * alpha + destination.b * inv_alpha,
-            alpha + destination.a * inv_alpha
+      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)
           )
-        else
-          source
+          pixel_index += 1
+          byte_index += 4
         end
       end
 
-      def packed_color_bytes(channels)
-        @color_buffer.flat_map do |color|
-          channels.map do |channel|
-            (color.public_send(channel) * 255).round.clamp(0, 255)
+      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.pack("C*")
+        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/rasterizer/attribute_interpolator.rb

@@ -5,15 +5,37 @@ module RBGL
     class Rasterizer
       class AttributeInterpolator
         def interpolate(vertices, weights)
-          result = ShaderIO.new
+          interpolate_prepared(prepare(vertices), weights, result: ShaderIO.new)
+        end
 
-          interpolated_keys(vertices).each do |key|
+        def prepare(vertices)
+          interpolated_keys(vertices).filter_map do |key|
             values = vertices.map { |vertex| vertex[key] }
-            next if values.any?(&:nil?)
+            [key, *values] unless values.any?(&:nil?)
+          end
+        end
 
-            result[key] = interpolate_values(values, weights)
+        def interpolate_prepared(plan, weights, result:)
+          result.clear
+          plan.each do |entry|
+            result[entry[0]] = interpolate_values(entry.drop(1), weights)
           end
+          result
+        end
 
+        def interpolate_triangle(plan, w0, w1, w2, result:)
+          result.clear
+          plan.each do |key, a, b, c|
+            result[key] = interpolate_three(a, b, c, w0, w1, w2)
+          end
+          result
+        end
+
+        def interpolate_line(plan, w0, w1, result:)
+          result.clear
+          plan.each do |key, a, b|
+            result[key] = interpolate_two(a, b, w0, w1)
+          end
           result
         end
 
@@ -29,6 +51,8 @@ module RBGL
             vector4(values, weights)
           when Larb::Color
             color(values, weights)
+          when Array
+            numeric_arrays?(*values) ? array(values, weights) : first
           when Numeric
             scalar(values, weights)
           else
@@ -50,8 +74,71 @@ module RBGL
           corrected.map { |weight| weight / total }
         end
 
+        def inverse_clip_w(position)
+          return 1.0 unless position.is_a?(Larb::Vec4)
+          return 1.0 if position.w.zero?
+
+          1.0 / position.w
+        end
+
         private
 
+        def interpolate_three(a, b, c, w0, w1, w2)
+          case a
+          when Larb::Vec2
+            Larb::Vec2.new((a.x * w0) + (b.x * w1) + (c.x * w2), (a.y * w0) + (b.y * w1) + (c.y * w2))
+          when Larb::Vec3
+            Larb::Vec3.new(
+              (a.x * w0) + (b.x * w1) + (c.x * w2),
+              (a.y * w0) + (b.y * w1) + (c.y * w2),
+              (a.z * w0) + (b.z * w1) + (c.z * w2)
+            )
+          when Larb::Vec4
+            Larb::Vec4.new(
+              (a.x * w0) + (b.x * w1) + (c.x * w2),
+              (a.y * w0) + (b.y * w1) + (c.y * w2),
+              (a.z * w0) + (b.z * w1) + (c.z * w2),
+              (a.w * w0) + (b.w * w1) + (c.w * w2)
+            )
+          when Larb::Color
+            Larb::Color.new(
+              (a.r * w0) + (b.r * w1) + (c.r * w2),
+              (a.g * w0) + (b.g * w1) + (c.g * w2),
+              (a.b * w0) + (b.b * w1) + (c.b * w2),
+              (a.a * w0) + (b.a * w1) + (c.a * w2)
+            )
+          when Array then numeric_arrays?(a, b, c) ? array([a, b, c], [w0, w1, w2]) : a
+          when Numeric then (a * w0) + (b * w1) + (c * w2)
+          else a
+          end
+        end
+
+        def interpolate_two(a, b, w0, w1)
+          case a
+          when Larb::Vec2
+            Larb::Vec2.new((a.x * w0) + (b.x * w1), (a.y * w0) + (b.y * w1))
+          when Larb::Vec3
+            Larb::Vec3.new((a.x * w0) + (b.x * w1), (a.y * w0) + (b.y * w1), (a.z * w0) + (b.z * w1))
+          when Larb::Vec4
+            Larb::Vec4.new(
+              (a.x * w0) + (b.x * w1),
+              (a.y * w0) + (b.y * w1),
+              (a.z * w0) + (b.z * w1),
+              (a.w * w0) + (b.w * w1)
+            )
+          when Larb::Color
+            Larb::Color.new(
+              (a.r * w0) + (b.r * w1),
+              (a.g * w0) + (b.g * w1),
+              (a.b * w0) + (b.b * w1),
+              (a.a * w0) + (b.a * w1)
+            )
+          when Array then numeric_arrays?(a, b) ? array([a, b], [w0, w1]) : a
+          when Numeric then (a * w0) + (b * w1)
+          else a
+          end
+        end
+
         def interpolated_keys(vertices)
           vertices.flat_map { |vertex| vertex.to_h.keys }.uniq - [:position]
         end
@@ -60,6 +147,15 @@ module RBGL
           values.zip(weights).sum { |value, weight| value * weight }
         end
 
+        def array(values, weights)
+          values.transpose.map { |components| scalar(components, weights) }
+        end
+
+        def numeric_arrays?(*values)
+          size = values.first.size
+          values.all? { |value| value.is_a?(Array) && value.size == size && value.all?(Numeric) }
+        end
+
         def vector2(values, weights)
           Larb::Vec2.new(
             scalar(values.map(&:x), weights),
@@ -93,12 +189,6 @@ module RBGL
           )
         end
 
-        def inverse_clip_w(position)
-          return 1.0 unless position.is_a?(Larb::Vec4)
-          return 1.0 if position.w.zero?
-
-          1.0 / position.w
-        end
       end
     end
   end

data/lib/rbgl/engine/rasterizer/line_renderer.rb

@@ -13,6 +13,10 @@ module RBGL
         def rasterize(v0, v1, fragment_shader, uniforms, state)
           p0 = @viewport_transform.call(v0[:position])
           p1 = @viewport_transform.call(v1[:position])
+          if ([p0.x, p0.y, p0.z] <=> [p1.x, p1.y, p1.z]).positive?
+            p0, p1 = p1, p0
+            v0, v1 = v1, v0
+          end
 
           x0 = p0.x.round
           y0 = p0.y.round
@@ -24,18 +28,28 @@ module RBGL
           sx = x0 < x1 ? 1 : -1
           sy = y0 < y1 ? 1 : -1
           err = dx + dy
-          total_dist = Math.sqrt((x1 - x0)**2 + (y1 - y0)**2)
+          line_dx = p1.x - p0.x
+          line_dy = p1.y - p0.y
+          line_length_squared = (line_dx * line_dx) + (line_dy * line_dy)
+          inverse_w0 = @interpolator.inverse_clip_w(v0[:position])
+          inverse_w1 = @interpolator.inverse_clip_w(v1[:position])
+          interpolation_plan = @interpolator.prepare([v0, v1])
+          attributes = ShaderIO.new
+          fragment_output = ShaderIO.new
 
           loop do
-            t = interpolation_factor(x0, y0, p0, total_dist)
-            corrected_weights = @interpolator.perspective_correct_weights(
-              [v0[:position], v1[:position]],
-              [1.0 - t, t]
-            )
-            depth = @interpolator.interpolate_depth([p0.z, p1.z], corrected_weights)
-            attributes = @interpolator.interpolate([v0, v1], corrected_weights)
+            t = interpolation_factor(x0, y0, p0, line_dx, line_dy, line_length_squared)
+            corrected_w0 = (1.0 - t) * inverse_w0
+            corrected_w1 = t * inverse_w1
+            total = corrected_w0 + corrected_w1
+            unless total.zero?
+              corrected_w0 /= total
+              corrected_w1 /= total
+            end
+            depth = (p0.z * (1.0 - t)) + (p1.z * t)
+            @interpolator.interpolate_line(interpolation_plan, corrected_w0, corrected_w1, result: attributes)
 
-            shade_fragment(x0, y0, depth, attributes, fragment_shader, uniforms, state)
+            shade_fragment(x0, y0, depth, attributes, fragment_shader, uniforms, state, fragment_output)
             break if x0 == x1 && y0 == y1
 
             e2 = 2 * err
@@ -52,13 +66,15 @@ module RBGL
 
         private
 
-        def interpolation_factor(x, y, start_point, total_dist)
-          current_dist = Math.sqrt((x - start_point.x.round)**2 + (y - start_point.y.round)**2)
-          total_dist.positive? ? current_dist / total_dist : 0.0
+        def interpolation_factor(x, y, start_point, line_dx, line_dy, line_length_squared)
+          return 0.0 unless line_length_squared.positive?
+
+          (((x - start_point.x) * line_dx) + ((y - start_point.y) * line_dy))
+            .fdiv(line_length_squared).clamp(0.0, 1.0)
         end
 
-        def shade_fragment(x, y, depth, attributes, fragment_shader, uniforms, state)
-          frag_output = fragment_shader.process(attributes, uniforms)
+        def shade_fragment(x, y, depth, attributes, fragment_shader, uniforms, state, fragment_output)
+          frag_output = fragment_shader.process(attributes, uniforms, output: fragment_output)
           @framebuffer.write_pixel(
             x, y, frag_output[:color], depth,
             depth_test: state[:depth_test],

data/lib/rbgl/engine/rasterizer/point_renderer.rb

@@ -12,14 +12,14 @@ module RBGL
 
         def rasterize(vertex, fragment_shader, uniforms, state)
           point = @viewport_transform.call(vertex[:position])
-          x = point.x.round
-          y = point.y.round
+          x = point.x.floor
+          y = point.y.floor
           depth = point.z
           x_offsets, y_offsets = @point_pixel_offsets.call(state[:size])
+          frag_output = fragment_shader.process(vertex, uniforms)
 
           y_offsets.each do |dy|
             x_offsets.each do |dx|
-              frag_output = fragment_shader.process(vertex, uniforms)
               @framebuffer.write_pixel(
                 x + dx, y + dy, frag_output[:color], depth,
                 depth_test: state[:depth_test],

data/lib/rbgl/engine/rasterizer/triangle_renderer.rb

@@ -22,22 +22,61 @@ module RBGL
 
           min_x, max_x, min_y, max_y = bounds(p0, p1, p2)
           inv_area = 1.0 / area
+          inverse_w0 = @interpolator.inverse_clip_w(v0[:position])
+          inverse_w1 = @interpolator.inverse_clip_w(v1[:position])
+          inverse_w2 = @interpolator.inverse_clip_w(v2[:position])
+          interpolation_plan = @interpolator.prepare([v0, v1, v2])
+          attributes = ShaderIO.new
+          fragment_output = ShaderIO.new
 
-          (min_y..max_y).each do |y|
-            (min_x..max_x).each do |x|
-              weights = barycentric_weights(p0, p1, p2, x + 0.5, y + 0.5)
-              next unless inside_triangle?(weights)
+          x = min_x + 0.5
+          y = min_y + 0.5
+          row_w0 = edge_value(p1, p2, x, y)
+          row_w1 = edge_value(p2, p0, x, y)
+          row_w2 = edge_value(p0, p1, x, y)
+          x_steps = [p2.y - p1.y, p0.y - p2.y, p1.y - p0.y]
+          y_steps = [p1.x - p2.x, p2.x - p0.x, p0.x - p1.x]
+          positive_area = area.positive?
+          inclusive_edges = [
+            inclusive_edge?(p1, p2, positive_area),
+            inclusive_edge?(p2, p0, positive_area),
+            inclusive_edge?(p0, p1, positive_area)
+          ]
 
-              screen_weights = weights.map { |weight| weight * inv_area }
-              corrected_weights = @interpolator.perspective_correct_weights(
-                [v0[:position], v1[:position], v2[:position]],
-                screen_weights
-              )
-              depth = @interpolator.interpolate_depth([p0.z, p1.z, p2.z], corrected_weights)
-              attributes = @interpolator.interpolate([v0, v1, v2], corrected_weights)
+          (min_y..max_y).each do |pixel_y|
+            w0 = row_w0
+            w1 = row_w1
+            w2 = row_w2
+            (min_x..max_x).each do |pixel_x|
+              if inside_triangle?(w0, w1, w2, positive_area, inclusive_edges)
+                screen_w0 = w0 * inv_area
+                screen_w1 = w1 * inv_area
+                screen_w2 = w2 * inv_area
+                corrected_w0 = screen_w0 * inverse_w0
+                corrected_w1 = screen_w1 * inverse_w1
+                corrected_w2 = screen_w2 * inverse_w2
+                total = corrected_w0 + corrected_w1 + corrected_w2
+                unless total.zero?
+                  corrected_w0 /= total
+                  corrected_w1 /= total
+                  corrected_w2 /= total
+                end
+                depth = (p0.z * screen_w0) + (p1.z * screen_w1) + (p2.z * screen_w2)
+                @interpolator.interpolate_triangle(
+                  interpolation_plan, corrected_w0, corrected_w1, corrected_w2, result: attributes
+                )
 
-              shade_fragment(x, y, depth, attributes, fragment_shader, uniforms, state)
+                shade_fragment(
+                  pixel_x, pixel_y, depth, attributes, fragment_shader, uniforms, state, fragment_output
+                )
+              end
+              w0 += x_steps[0]
+              w1 += x_steps[1]
+              w2 += x_steps[2]
             end
+            row_w0 += y_steps[0]
+            row_w1 += y_steps[1]
+            row_w2 += y_steps[2]
           end
         end
 
@@ -51,17 +90,27 @@ module RBGL
           [min_x, max_x, min_y, max_y]
         end
 
-        def barycentric_weights(p0, p1, p2, x, y)
-          point = Larb::Vec2.new(x, y)
-          [
-            @edge_function.call(p1, p2, point),
-            @edge_function.call(p2, p0, point),
-            @edge_function.call(p0, p1, point)
-          ]
+        def edge_value(a, b, x, y)
+          ((x - a.x) * (b.y - a.y)) - ((y - a.y) * (b.x - a.x))
+        end
+
+        def inside_triangle?(w0, w1, w2, positive_area, inclusive_edges)
+          inside_edge?(w0, positive_area, inclusive_edges[0]) &&
+            inside_edge?(w1, positive_area, inclusive_edges[1]) &&
+            inside_edge?(w2, positive_area, inclusive_edges[2])
+        end
+
+        def inside_edge?(weight, positive_area, inclusive)
+          positive_area ? weight.positive? || (weight.zero? && inclusive) :
+                          weight.negative? || (weight.zero? && inclusive)
         end
 
-        def inside_triangle?(weights)
-          weights.all? { |weight| weight >= 0 } || weights.all? { |weight| weight <= 0 }
+        def inclusive_edge?(start_point, end_point, positive_area)
+          dx = end_point.x - start_point.x
+          dy = end_point.y - start_point.y
+          dx = -dx if positive_area
+          dy = -dy if positive_area
+          dy.positive? || (dy.zero? && dx.positive?)
         end
 
         def culled?(area, cull_mode)
@@ -72,8 +121,8 @@ module RBGL
           end
         end
 
-        def shade_fragment(x, y, depth, attributes, fragment_shader, uniforms, state)
-          frag_output = fragment_shader.process(attributes, uniforms)
+        def shade_fragment(x, y, depth, attributes, fragment_shader, uniforms, state, fragment_output)
+          frag_output = fragment_shader.process(attributes, uniforms, output: fragment_output)
           @framebuffer.write_pixel(
             x, y, frag_output[:color], depth,
             depth_test: state[:depth_test],