rbgl 0.1.0 → 1.0.1

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

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Rasterizer
+      class AttributeInterpolator
+        def interpolate(vertices, weights)
+          interpolate_prepared(prepare(vertices), weights, result: ShaderIO.new)
+        end
+
+        def prepare(vertices)
+          interpolated_keys(vertices).filter_map do |key|
+            values = vertices.map { |vertex| vertex[key] }
+            [key, *values] unless values.any?(&:nil?)
+          end
+        end
+
+        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
+
+        def interpolate_values(values, weights)
+          first = values.first
+
+          case first
+          when Larb::Vec2
+            vector2(values, weights)
+          when Larb::Vec3
+            vector3(values, weights)
+          when Larb::Vec4
+            vector4(values, weights)
+          when Larb::Color
+            color(values, weights)
+          when Array
+            numeric_arrays?(*values) ? array(values, weights) : first
+          when Numeric
+            scalar(values, weights)
+          else
+            first
+          end
+        end
+
+        def interpolate_depth(depths, weights)
+          scalar(depths, weights)
+        end
+
+        def perspective_correct_weights(positions, weights)
+          corrected = positions.zip(weights).map do |position, weight|
+            weight * inverse_clip_w(position)
+          end
+          total = corrected.sum
+          return weights if total.zero?
+
+          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
+
+        def scalar(values, weights)
+          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),
+            scalar(values.map(&:y), weights)
+          )
+        end
+
+        def vector3(values, weights)
+          Larb::Vec3.new(
+            scalar(values.map(&:x), weights),
+            scalar(values.map(&:y), weights),
+            scalar(values.map(&:z), weights)
+          )
+        end
+
+        def vector4(values, weights)
+          Larb::Vec4.new(
+            scalar(values.map(&:x), weights),
+            scalar(values.map(&:y), weights),
+            scalar(values.map(&:z), weights),
+            scalar(values.map(&:w), weights)
+          )
+        end
+
+        def color(values, weights)
+          Larb::Color.new(
+            scalar(values.map(&:r), weights),
+            scalar(values.map(&:g), weights),
+            scalar(values.map(&:b), weights),
+            scalar(values.map(&:a), weights)
+          )
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Rasterizer
+      class LineRenderer
+        def initialize(framebuffer, interpolator:, viewport_transform:)
+          @framebuffer = framebuffer
+          @interpolator = interpolator
+          @viewport_transform = viewport_transform
+        end
+
+        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
+          x1 = p1.x.round
+          y1 = p1.y.round
+
+          dx = (x1 - x0).abs
+          dy = -(y1 - y0).abs
+          sx = x0 < x1 ? 1 : -1
+          sy = y0 < y1 ? 1 : -1
+          err = dx + dy
+          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, 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, fragment_output)
+            break if x0 == x1 && y0 == y1
+
+            e2 = 2 * err
+            if e2 >= dy
+              err += dy
+              x0 += sx
+            end
+            if e2 <= dx
+              err += dx
+              y0 += sy
+            end
+          end
+        end
+
+        private
+
+        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, 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],
+            depth_write: state[:depth_write],
+            blend_mode: state[:blend_mode]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Rasterizer
+      class PointRenderer
+        def initialize(framebuffer, viewport_transform:, point_pixel_offsets:)
+          @framebuffer = framebuffer
+          @viewport_transform = viewport_transform
+          @point_pixel_offsets = point_pixel_offsets
+        end
+
+        def rasterize(vertex, fragment_shader, uniforms, state)
+          point = @viewport_transform.call(vertex[:position])
+          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|
+              @framebuffer.write_pixel(
+                x + dx, y + dy, frag_output[:color], depth,
+                depth_test: state[:depth_test],
+                depth_write: state[:depth_write],
+                blend_mode: state[:blend_mode]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Rasterizer
+      class TriangleRenderer
+        def initialize(framebuffer, interpolator:, viewport_transform:, edge_function:)
+          @framebuffer = framebuffer
+          @interpolator = interpolator
+          @viewport_transform = viewport_transform
+          @edge_function = edge_function
+        end
+
+        def rasterize(v0, v1, v2, fragment_shader, uniforms, state)
+          p0 = @viewport_transform.call(v0[:position])
+          p1 = @viewport_transform.call(v1[:position])
+          p2 = @viewport_transform.call(v2[:position])
+
+          area = @edge_function.call(p0, p1, p2)
+          return if area.abs < 1e-10
+          return if culled?(area, state[:cull_mode])
+
+          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
+
+          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)
+          ]
+
+          (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(
+                  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
+
+        private
+
+        def bounds(p0, p1, p2)
+          min_x = [p0.x, p1.x, p2.x].min.floor.clamp(0, @framebuffer.width - 1)
+          max_x = [p0.x, p1.x, p2.x].max.ceil.clamp(0, @framebuffer.width - 1)
+          min_y = [p0.y, p1.y, p2.y].min.floor.clamp(0, @framebuffer.height - 1)
+          max_y = [p0.y, p1.y, p2.y].max.ceil.clamp(0, @framebuffer.height - 1)
+          [min_x, max_x, min_y, max_y]
+        end
+
+        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 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)
+          case cull_mode
+          when :back then area < 0
+          when :front then area > 0
+          else false
+          end
+        end
+
+        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],
+            depth_write: state[:depth_write],
+            blend_mode: state[:blend_mode]
+          )
+        end
+      end
+    end
+  end
+end