rbgl 0.1.0 → 1.0.1

data/lib/rbgl/engine/rasterizer.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "rasterizer/attribute_interpolator"
+require_relative "rasterizer/triangle_renderer"
+require_relative "rasterizer/line_renderer"
+require_relative "rasterizer/point_renderer"
+
 module RBGL
   module Engine
     class Rasterizer
@@ -8,112 +13,57 @@ module RBGL
       def initialize(framebuffer)
         @framebuffer = framebuffer
         @viewport = { x: 0, y: 0, width: framebuffer.width, height: framebuffer.height }
+        @attribute_interpolator = AttributeInterpolator.new
+        @triangle_renderer = TriangleRenderer.new(
+          framebuffer,
+          interpolator: @attribute_interpolator,
+          viewport_transform: method(:viewport_transform),
+          edge_function: method(:edge_function)
+        )
+        @line_renderer = LineRenderer.new(
+          framebuffer,
+          interpolator: @attribute_interpolator,
+          viewport_transform: method(:viewport_transform)
+        )
+        @point_renderer = PointRenderer.new(
+          framebuffer,
+          viewport_transform: method(:viewport_transform),
+          point_pixel_offsets: method(:point_pixel_offsets)
+        )
       end
 
-      def rasterize_triangle(v0, v1, v2, fragment_shader, uniforms, cull_mode: :none)
-        p0 = viewport_transform(v0[:position])
-        p1 = viewport_transform(v1[:position])
-        p2 = viewport_transform(v2[:position])
-
-        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)
-
-        area = edge_function(p0, p1, p2)
-        return if area.abs < 1e-10
-
-        case cull_mode
-        when :back
-          return if area < 0
-        when :front
-          return if area > 0
-        end
-
-        (min_y..max_y).each do |y|
-          (min_x..max_x).each do |x|
-            px = x + 0.5
-            py = y + 0.5
-            p = Larb::Vec2.new(px, py)
-
-            w0 = edge_function(p1, p2, p)
-            w1 = edge_function(p2, p0, p)
-            w2 = edge_function(p0, p1, p)
-
-            if (w0 >= 0 && w1 >= 0 && w2 >= 0) || (w0 <= 0 && w1 <= 0 && w2 <= 0)
-              inv_area = 1.0 / area
-              w0 *= inv_area
-              w1 *= inv_area
-              w2 *= inv_area
-
-              depth = w0 * p0.z + w1 * p1.z + w2 * p2.z
-
-              interpolated = interpolate_attributes(v0, v1, v2, w0, w1, w2)
-
-              frag_output = fragment_shader.process(interpolated, uniforms)
-              color = frag_output[:color]
-
-              @framebuffer.write_pixel(x, y, color, depth)
-            end
-          end
-        end
+      def resize(width, height)
+        @viewport = @viewport.merge(width: width, height: height)
       end
 
-      def rasterize_line(v0, v1, fragment_shader, uniforms)
-        p0 = viewport_transform(v0[:position])
-        p1 = viewport_transform(v1[:position])
-
-        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
-
-        total_dist = Math.sqrt((x1 - x0)**2 + (y1 - y0)**2)
-
-        loop do
-          current_dist = Math.sqrt((x0 - p0.x.round)**2 + (y0 - p0.y.round)**2)
-          t = total_dist > 0 ? current_dist / total_dist : 0
-
-          depth = p0.z + (p1.z - p0.z) * t
-
-          interpolated = interpolate_line_attributes(v0, v1, t)
-
-          frag_output = fragment_shader.process(interpolated, uniforms)
-          @framebuffer.write_pixel(x0, y0, frag_output[:color], depth)
-
-          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
+      def rasterize_triangle(v0, v1, v2, fragment_shader, uniforms, cull_mode: :none,
+                             depth_test: true, depth_write: true, blend_mode: :none)
+        @triangle_renderer.rasterize(v0, v1, v2, fragment_shader, uniforms, state(
+          cull_mode: cull_mode,
+          depth_test: depth_test,
+          depth_write: depth_write,
+          blend_mode: blend_mode
+        ))
       end
 
-      def rasterize_point(vertex, fragment_shader, uniforms, size: 1)
-        p = viewport_transform(vertex[:position])
-        x = p.x.round
-        y = p.y.round
-        depth = p.z
+      def rasterize_line(v0, v1, fragment_shader, uniforms, cull_mode: :none,
+                         depth_test: true, depth_write: true, blend_mode: :none)
+        @line_renderer.rasterize(v0, v1, fragment_shader, uniforms, state(
+          cull_mode: cull_mode,
+          depth_test: depth_test,
+          depth_write: depth_write,
+          blend_mode: blend_mode
+        ))
+      end
 
-        half = size / 2
-        (-half..half).each do |dy|
-          (-half..half).each do |dx|
-            frag_output = fragment_shader.process(vertex, uniforms)
-            @framebuffer.write_pixel(x + dx, y + dy, frag_output[:color], depth)
-          end
-        end
+      def rasterize_point(vertex, fragment_shader, uniforms, size: 1,
+                          depth_test: true, depth_write: true, blend_mode: :none)
+        @point_renderer.rasterize(vertex, fragment_shader, uniforms, {
+          size: size,
+          depth_test: depth_test,
+          depth_write: depth_write,
+          blend_mode: blend_mode
+        })
       end
 
       private
@@ -126,87 +76,31 @@ module RBGL
               end
 
         Larb::Vec3.new(
-          (ndc.x + 1) * 0.5 * @viewport[:width] + @viewport[:x],
-          (1 - ndc.y) * 0.5 * @viewport[:height] + @viewport[:y],
+          ((ndc.x + 1) * 0.5 * @viewport[:width]) + @viewport[:x],
+          ((1 - ndc.y) * 0.5 * @viewport[:height]) + @viewport[:y],
           (ndc.z + 1) * 0.5
         )
       end
 
       def edge_function(a, b, c)
-        (c.x - a.x) * (b.y - a.y) - (c.y - a.y) * (b.x - a.x)
-      end
-
-      def interpolate_attributes(v0, v1, v2, w0, w1, w2)
-        result = ShaderIO.new
-
-        all_keys = (v0.to_h.keys | v1.to_h.keys | v2.to_h.keys) - [:position]
-
-        all_keys.each do |key|
-          a0 = v0[key]
-          a1 = v1[key]
-          a2 = v2[key]
-          next unless a0 && a1 && a2
-
-          result[key] = interpolate_value(a0, a1, a2, w0, w1, w2)
-        end
-
-        result
+        ((c.x - a.x) * (b.y - a.y)) - ((c.y - a.y) * (b.x - a.x))
       end
 
-      def interpolate_value(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 Numeric
-          a * w0 + b * w1 + c * w2
-        else
-          a
-        end
+      def state(cull_mode:, depth_test:, depth_write:, blend_mode:)
+        {
+          cull_mode: cull_mode,
+          depth_test: depth_test,
+          depth_write: depth_write,
+          blend_mode: blend_mode
+        }
       end
 
-      def interpolate_line_attributes(v0, v1, t)
-        result = ShaderIO.new
-        all_keys = (v0.to_h.keys | v1.to_h.keys) - [:position]
-
-        all_keys.each do |key|
-          a0 = v0[key]
-          a1 = v1[key]
-          next unless a0 && a1
-
-          result[key] = case a0
-                        when Larb::Vec2, Larb::Vec3, Larb::Vec4, Larb::Color
-                          a0.lerp(a1, t)
-                        when Numeric
-                          a0 + (a1 - a0) * t
-                        else
-                          a0
-                        end
-        end
-
-        result
+      def point_pixel_offsets(size)
+        pixel_size = [size.to_i, 1].max
+        min_offset = -(pixel_size / 2.0).floor
+        max_offset = ((pixel_size - 1) / 2.0).floor
+        offsets = (min_offset..max_offset).to_a
+        [offsets, offsets]
       end
     end
   end

data/lib/rbgl/engine/shader/base_shader.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class BaseShader
+      include ShaderBuiltins
+
+      def initialize(&block)
+        @process_block = block
+      end
+
+      def process(input, uniforms, output: nil)
+        output ||= ShaderIO.new
+        output.clear
+
+        instance_exec(input, uniforms, output, &@process_block)
+        finalize_output(output)
+      end
+
+      def self.create(&block)
+        new(&block)
+      end
+
+      private
+
+      def finalize_output(output)
+        output
+      end
+    end
+
+    class VertexShader < BaseShader
+      private
+
+      def finalize_output(output)
+        raise "VertexShader must set output.position" unless output[:position]
+
+        output
+      end
+    end
+
+    class FragmentShader < BaseShader
+      private
+
+      def finalize_output(output)
+        output[:color] ||= Larb::Color.white
+
+        output
+      end
+    end
+  end
+end

data/lib/rbgl/engine/shader/builtins.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    module ShaderBuiltins
+      def vec2(x, y = nil)
+        y ||= x
+        Larb::Vec2.new(x, y)
+      end
+
+      def vec3(x, y = nil, z = nil)
+        if y.nil? && z.nil?
+          Larb::Vec3.new(x, x, x)
+        elsif z.nil? && y.is_a?(Larb::Vec2)
+          Larb::Vec3.new(x, y.x, y.y)
+        else
+          Larb::Vec3.new(x, y, z)
+        end
+      end
+
+      def vec4(x, y = nil, z = nil, w = nil)
+        case
+        when y.nil? && z.nil? && w.nil?
+          Larb::Vec4.new(x, x, x, x)
+        when x.is_a?(Larb::Vec3) && !y.nil?
+          Larb::Vec4.new(x.x, x.y, x.z, y)
+        when x.is_a?(Larb::Vec2) && y.is_a?(Larb::Vec2)
+          Larb::Vec4.new(x.x, x.y, y.x, y.y)
+        else
+          Larb::Vec4.new(x, y, z, w)
+        end
+      end
+
+      def dot(a, b)
+        a.dot(b)
+      end
+
+      def cross(a, b)
+        a.cross(b)
+      end
+
+      def normalize(v)
+        v.normalize
+      end
+
+      def length(v)
+        v.length
+      end
+
+      def reflect(v, n)
+        v.reflect(n)
+      end
+
+      def refract(v, n, eta)
+        cos_i = -dot(n, v)
+        sin_t2 = eta * eta * (1.0 - (cos_i * cos_i))
+        return v * 0 if sin_t2 > 1.0
+
+        cos_t = Math.sqrt(1.0 - sin_t2)
+        (v * eta) + (n * ((eta * cos_i) - cos_t))
+      end
+
+      def mix(a, b, t)
+        case a
+        when Numeric then a + ((b - a) * t)
+        when Larb::Vec2, Larb::Vec3, Larb::Vec4, Larb::Color then a.lerp(b, t)
+        else
+          raise ArgumentError, "Unsupported mix operand: #{a.class}"
+        end
+      end
+
+      def clamp(v, min_val, max_val)
+        case v
+        when Numeric then v.clamp(min_val, max_val)
+        when Larb::Color then Larb::Color.new(*v.to_a.map { |component| component.clamp(min_val, max_val) })
+        else
+          component_map(v) { |component| component.clamp(min_val, max_val) }
+        end
+      end
+
+      def saturate(v)
+        clamp(v, 0.0, 1.0)
+      end
+
+      def smoothstep(edge0, edge1, x)
+        component_ternary_map(edge0, edge1, x) do |e0, e1, value|
+          next value < e0 ? 0.0 : 1.0 if e0 == e1
+
+          t = (value - e0).fdiv(e1 - e0).clamp(0.0, 1.0)
+          t * t * (3.0 - (2.0 * t))
+        end
+      end
+
+      def step(edge, x)
+        component_binary_map(edge, x) { |limit, value| value < limit ? 0.0 : 1.0 }
+      end
+
+      def fract(x)
+        component_map(x) { |value| value - value.floor }
+      end
+
+      def mod(x, y)
+        component_binary_map(x, y) { |left, right| left - (right * (left / right).floor) }
+      end
+
+      def abs(x)
+        component_map(x, &:abs)
+      end
+
+      def sign(x)
+        component_map(x) { |value| value <=> 0 }
+      end
+
+      def floor(x)
+        component_map(x, &:floor)
+      end
+
+      def ceil(x)
+        component_map(x, &:ceil)
+      end
+
+      def pow(x, y)
+        component_binary_map(x, y) { |left, right| left**right }
+      end
+
+      def sqrt(x)
+        component_map(x) { |value| Math.sqrt(value) }
+      end
+
+      def sin(x)
+        component_map(x) { |value| Math.sin(value) }
+      end
+
+      def cos(x)
+        component_map(x) { |value| Math.cos(value) }
+      end
+
+      def tan(x)
+        component_map(x) { |value| Math.tan(value) }
+      end
+
+      def asin(x)
+        component_map(x) { |value| Math.asin(value) }
+      end
+
+      def acos(x)
+        component_map(x) { |value| Math.acos(value) }
+      end
+
+      def atan(y, x = nil)
+        if x
+          component_binary_map(y, x) { |left, right| Math.atan2(left, right) }
+        else
+          component_map(y) { |value| Math.atan(value) }
+        end
+      end
+
+      def min(*args)
+        values = args.flatten
+        return values.min unless values.any? { |value| vector_value?(value) }
+
+        values.reduce { |current, value| component_binary_map(current, value) { |left, right| [left, right].min } }
+      end
+
+      def max(*args)
+        values = args.flatten
+        return values.max unless values.any? { |value| vector_value?(value) }
+
+        values.reduce { |current, value| component_binary_map(current, value) { |left, right| [left, right].max } }
+      end
+
+      def texture(tex, uv)
+        tex.sample(uv.x, uv.y)
+      end
+
+      def texture_lod(tex, uv, lod)
+        tex.sample(uv.x, uv.y, lod: lod)
+      end
+
+      def rgb(r, g, b)
+        Larb::Color.rgb(r, g, b)
+      end
+
+      def rgba(r, g, b, a)
+        Larb::Color.rgba(r, g, b, a)
+      end
+
+      def color_from_vec3(v)
+        Larb::Color.from_vec3(v)
+      end
+
+      def color_from_vec4(v)
+        Larb::Color.from_vec4(v)
+      end
+
+      private
+
+      def component_map(value)
+        return yield(value) unless vector_value?(value)
+
+        rebuild_vector(value, vector_components(value).map { |component| yield(component) })
+      end
+
+      def component_binary_map(left, right)
+        return yield(left, right) unless vector_value?(left) || vector_value?(right)
+
+        template = left if vector_value?(left)
+        template ||= right
+
+        rebuilt_components = vector_components(template).each_index.map do |index|
+          yield(component_at(left, index), component_at(right, index))
+        end
+
+        rebuild_vector(template, rebuilt_components)
+      end
+
+      def component_ternary_map(first, second, third)
+        return yield(first, second, third) unless [first, second, third].any? { |value| vector_value?(value) }
+
+        template = [first, second, third].find { |value| vector_value?(value) }
+        rebuilt_components = vector_components(template).each_index.map do |index|
+          yield(component_at(first, index), component_at(second, index), component_at(third, index))
+        end
+
+        rebuild_vector(template, rebuilt_components)
+      end
+
+      def vector_value?(value)
+        value.is_a?(Larb::Vec2) || value.is_a?(Larb::Vec3) || value.is_a?(Larb::Vec4)
+      end
+
+      def vector_components(value)
+        case value
+        when Larb::Vec2 then [value.x, value.y]
+        when Larb::Vec3 then [value.x, value.y, value.z]
+        when Larb::Vec4 then [value.x, value.y, value.z, value.w]
+        else
+          []
+        end
+      end
+
+      def component_at(value, index)
+        return value unless vector_value?(value)
+
+        vector_components(value)[index]
+      end
+
+      def rebuild_vector(template, components)
+        case template
+        when Larb::Vec2 then Larb::Vec2.new(*components)
+        when Larb::Vec3 then Larb::Vec3.new(*components)
+        when Larb::Vec4 then Larb::Vec4.new(*components)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/engine/shader/dynamic_data.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class DynamicData
+      def initialize(data = {})
+        @data = {}
+        @writer_keys = {}
+        data.to_h.each { |key, value| self[key] = value }
+      end
+
+      def method_missing(name, *args)
+        key = normalize_key(name)
+        if args.empty? && @data.key?(key)
+          @data[key]
+        elsif (writer = writer_key(name))
+          self[writer] = args.first
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @data.key?(normalize_key(name)) || !writer_key(name).nil? || super
+      end
+
+      def [](key)
+        @data[normalize_key(key)]
+      end
+
+      def []=(key, value)
+        @data[normalize_key(key)] = value
+      end
+
+      def to_h
+        @data.dup
+      end
+
+      def keys
+        @data.keys
+      end
+
+      def clear
+        @data.clear
+        self
+      end
+
+      private
+
+      def normalize_key(key)
+        return key if key.is_a?(Symbol)
+
+        key.to_s.chomp("=").to_sym
+      end
+
+      def writer_key(name)
+        return @writer_keys[name] if @writer_keys.key?(name)
+
+        text = name.to_s
+        @writer_keys[name] = text.end_with?("=") ? text.chomp("=").to_sym : nil
+      end
+    end
+
+    class ShaderIO < DynamicData
+    end
+
+    class Uniforms < DynamicData
+      def merge(other)
+        Uniforms.new(@data.merge(other.to_h))
+      end
+    end
+  end
+end