rbgl 0.1.0

data/lib/rbgl/engine/rasterizer.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Rasterizer
+      attr_accessor :viewport
+
+      def initialize(framebuffer)
+        @framebuffer = framebuffer
+        @viewport = { x: 0, y: 0, width: framebuffer.width, height: framebuffer.height }
+      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
+      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
+      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
+
+        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
+      end
+
+      private
+
+      def viewport_transform(position)
+        ndc = if position.is_a?(Larb::Vec4)
+                position.perspective_divide
+              else
+                position
+              end
+
+        Larb::Vec3.new(
+          (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
+      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
+      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
+      end
+    end
+  end
+end

data/lib/rbgl/engine/shader.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class ShaderIO
+      def initialize
+        @data = {}
+      end
+
+      def method_missing(name, *args)
+        if name.to_s.end_with?("=")
+          @data[name.to_s.chomp("=").to_sym] = args.first
+        else
+          @data[name]
+        end
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def []=(key, value)
+        @data[key] = value
+      end
+
+      def to_h
+        @data.dup
+      end
+
+      def keys
+        @data.keys
+      end
+    end
+
+    class Uniforms
+      def initialize(data = {})
+        @data = data.transform_keys(&:to_sym)
+      end
+
+      def method_missing(name, *args)
+        if name.to_s.end_with?("=")
+          @data[name.to_s.chomp("=").to_sym] = args.first
+        else
+          @data[name]
+        end
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      def [](key)
+        @data[key.to_sym]
+      end
+
+      def []=(key, value)
+        @data[key.to_sym] = value
+      end
+
+      def merge(other)
+        Uniforms.new(@data.merge(other.to_h))
+      end
+
+      def to_h
+        @data.dup
+      end
+    end
+
+    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 vec3(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 then a.lerp(b, t)
+        when Larb::Color then a.lerp(b, t)
+        end
+      end
+      alias lerp mix
+
+      def clamp(v, min_val, max_val)
+        case v
+        when Numeric then v.clamp(min_val, max_val)
+        when Larb::Vec3
+          Larb::Vec3.new(
+            v.x.clamp(min_val, max_val),
+            v.y.clamp(min_val, max_val),
+            v.z.clamp(min_val, max_val)
+          )
+        when Larb::Color then v.clamp
+        end
+      end
+
+      def saturate(v)
+        clamp(v, 0.0, 1.0)
+      end
+
+      def smoothstep(edge0, edge1, x)
+        t = ((x - edge0) / (edge1 - edge0)).clamp(0.0, 1.0)
+        t * t * (3.0 - 2.0 * t)
+      end
+
+      def step(edge, x)
+        x < edge ? 0.0 : 1.0
+      end
+
+      def fract(x)
+        x - x.floor
+      end
+
+      def mod(x, y)
+        x - y * (x / y).floor
+      end
+
+      def abs(x)
+        case x
+        when Numeric then x.abs
+        when Larb::Vec3 then Larb::Vec3.new(x.x.abs, x.y.abs, x.z.abs)
+        end
+      end
+
+      def sign(x)
+        x <=> 0
+      end
+
+      def floor(x)
+        case x
+        when Numeric then x.floor
+        when Larb::Vec3 then Larb::Vec3.new(x.x.floor, x.y.floor, x.z.floor)
+        end
+      end
+
+      def ceil(x)
+        case x
+        when Numeric then x.ceil
+        when Larb::Vec3 then Larb::Vec3.new(x.x.ceil, x.y.ceil, x.z.ceil)
+        end
+      end
+
+      def pow(x, y)
+        case x
+        when Numeric then x**y
+        when Larb::Vec3 then Larb::Vec3.new(x.x**y, x.y**y, x.z**y)
+        end
+      end
+
+      def sqrt(x)
+        case x
+        when Numeric then Math.sqrt(x)
+        when Larb::Vec3 then Larb::Vec3.new(Math.sqrt(x.x), Math.sqrt(x.y), Math.sqrt(x.z))
+        end
+      end
+
+      def sin(x)
+        Math.sin(x)
+      end
+
+      def cos(x)
+        Math.cos(x)
+      end
+
+      def tan(x)
+        Math.tan(x)
+      end
+
+      def asin(x)
+        Math.asin(x)
+      end
+
+      def acos(x)
+        Math.acos(x)
+      end
+
+      def atan(y, x = nil)
+        x ? Math.atan2(y, x) : Math.atan(y)
+      end
+
+      def min(*args)
+        args.flatten.min
+      end
+
+      def max(*args)
+        args.flatten.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
+    end
+
+    class VertexShader
+      include ShaderBuiltins
+
+      def initialize(&block)
+        @process_block = block
+      end
+
+      def process(input, uniforms)
+        output = ShaderIO.new
+        @input = input
+        @uniforms = uniforms
+        @output = output
+
+        instance_exec(input, uniforms, output, &@process_block)
+
+        raise "VertexShader must set output.position" unless output[:position]
+
+        output
+      end
+
+      attr_reader :input, :uniforms, :output
+
+      def self.create(&block)
+        new(&block)
+      end
+    end
+
+    class FragmentShader
+      include ShaderBuiltins
+
+      def initialize(&block)
+        @process_block = block
+      end
+
+      def process(input, uniforms)
+        output = ShaderIO.new
+        @input = input
+        @uniforms = uniforms
+        @output = output
+
+        instance_exec(input, uniforms, output, &@process_block)
+
+        output[:color] ||= Larb::Color.white
+
+        output
+      end
+
+      attr_reader :input, :uniforms, :output
+
+      def self.create(&block)
+        new(&block)
+      end
+    end
+  end
+end

data/lib/rbgl/engine/texture.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RBGL
+  module Engine
+    class Texture
+      attr_reader :width, :height, :data
+      attr_accessor :wrap_s, :wrap_t, :filter_min, :filter_mag
+
+      WRAP_REPEAT = :repeat
+      WRAP_CLAMP = :clamp
+      WRAP_MIRROR = :mirror
+
+      FILTER_NEAREST = :nearest
+      FILTER_LINEAR = :linear
+
+      def initialize(width, height, data = nil)
+        @width = width
+        @height = height
+        @data = data || Array.new(width * height) { Larb::Color.black }
+        @wrap_s = WRAP_REPEAT
+        @wrap_t = WRAP_REPEAT
+        @filter_min = FILTER_LINEAR
+        @filter_mag = FILTER_LINEAR
+      end
+
+      def sample(u, v, lod: 0)
+        u = wrap_coord(u, @wrap_s)
+        v = wrap_coord(v, @wrap_t)
+
+        x = u * (@width - 1)
+        y = v * (@height - 1)
+
+        if @filter_mag == FILTER_NEAREST
+          sample_nearest(x, y)
+        else
+          sample_bilinear(x, y)
+        end
+      end
+
+      def get_pixel(x, y)
+        x = x.clamp(0, @width - 1).to_i
+        y = y.clamp(0, @height - 1).to_i
+        @data[y * @width + x]
+      end
+
+      def set_pixel(x, y, color)
+        return if x < 0 || x >= @width || y < 0 || y >= @height
+
+        @data[y.to_i * @width + x.to_i] = color
+      end
+
+      def self.from_ppm(filename)
+        content = File.read(filename, mode: "rb")
+        lines = content.lines.reject { |l| l.start_with?("#") }
+
+        _format = lines.shift.strip
+        dimensions = lines.shift.strip.split.map(&:to_i)
+        width, height = dimensions
+        max_val = lines.shift.strip.to_i
+
+        data = []
+        pixels = lines.join.split.map(&:to_i)
+        (pixels.size / 3).times do |i|
+          r = pixels[i * 3] / max_val.to_f
+          g = pixels[i * 3 + 1] / max_val.to_f
+          b = pixels[i * 3 + 2] / max_val.to_f
+          data << Larb::Color.rgb(r, g, b)
+        end
+
+        new(width, height, data)
+      end
+
+      def self.checker(width, height, size, color1 = Larb::Color.white, color2 = Larb::Color.black)
+        data = Array.new(width * height)
+        height.times do |y|
+          width.times do |x|
+            checker = ((x / size) + (y / size)) % 2
+            data[y * width + x] = checker == 0 ? color1 : color2
+          end
+        end
+        new(width, height, data)
+      end
+
+      def self.solid(width, height, color)
+        new(width, height, Array.new(width * height) { color })
+      end
+
+      private
+
+      def wrap_coord(coord, mode)
+        case mode
+        when WRAP_REPEAT
+          coord - coord.floor
+        when WRAP_CLAMP
+          coord.clamp(0.0, 1.0)
+        when WRAP_MIRROR
+          t = coord - coord.floor
+          coord.floor.to_i.even? ? t : 1.0 - t
+        end
+      end
+
+      def sample_nearest(x, y)
+        get_pixel(x.round, y.round)
+      end
+
+      def sample_bilinear(x, y)
+        x0 = x.floor.to_i
+        y0 = y.floor.to_i
+        x1 = x0 + 1
+        y1 = y0 + 1
+        fx = x - x0
+        fy = y - y0
+
+        c00 = get_pixel(x0, y0)
+        c10 = get_pixel(x1, y0)
+        c01 = get_pixel(x0, y1)
+        c11 = get_pixel(x1, y1)
+
+        c0 = c00.lerp(c10, fx)
+        c1 = c01.lerp(c11, fx)
+        c0.lerp(c1, fy)
+      end
+    end
+  end
+end

data/lib/rbgl/engine.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "engine/framebuffer"
+require_relative "engine/buffer"
+require_relative "engine/shader"
+require_relative "engine/texture"
+require_relative "engine/rasterizer"
+require_relative "engine/pipeline"
+require_relative "engine/context"
+
+module RBGL
+  module Engine
+    VERSION = "0.1.0"
+  end
+end