rbgl 0.1.0 → 1.0.0

data/lib/rbgl/engine/shader.rb

@@ -1,324 +1,11 @@
 # frozen_string_literal: true
 
+require_relative "shader/dynamic_data"
+require_relative "shader/builtins"
+require_relative "shader/base_shader"
+
 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
+    private_constant :DynamicData
   end
 end

data/lib/rbgl/engine/texture.rb

@@ -3,8 +3,11 @@
 module RBGL
   module Engine
     class Texture
-      attr_reader :width, :height, :data
-      attr_accessor :wrap_s, :wrap_t, :filter_min, :filter_mag
+      PPM_HEADER = /\A(P[36])(?:\s+|#[^\n]*\n)+(\d+)(?:\s+|#[^\n]*\n)+(\d+)(?:\s+|#[^\n]*\n)+(\d+)\s/m
+      WRAP_MODES = %i[repeat clamp mirror].freeze
+      FILTER_MODES = %i[nearest linear].freeze
+
+      attr_reader :width, :height, :data, :wrap_s, :wrap_t, :filter_min, :filter_mag
 
       WRAP_REPEAT = :repeat
       WRAP_CLAMP = :clamp
@@ -16,7 +19,9 @@ module RBGL
       def initialize(width, height, data = nil)
         @width = width
         @height = height
-        @data = data || Array.new(width * height) { Larb::Color.black }
+        @data = data ? normalize_data!(data) : Array.new(width * height) { Larb::Color.black }
+        @levels = [@data]
+        @mipmaps_dirty = true
         @wrap_s = WRAP_REPEAT
         @wrap_t = WRAP_REPEAT
         @filter_min = FILTER_LINEAR
@@ -26,48 +31,54 @@ module RBGL
       def sample(u, v, lod: 0)
         u = wrap_coord(u, @wrap_s)
         v = wrap_coord(v, @wrap_t)
+        level = mip_level_for(lod)
+        level_width = width_for_level(level)
+        level_height = height_for_level(level)
 
-        x = u * (@width - 1)
-        y = v * (@height - 1)
+        x = u * (level_width - 1)
+        y = v * (level_height - 1)
 
-        if @filter_mag == FILTER_NEAREST
-          sample_nearest(x, y)
-        else
-          sample_bilinear(x, y)
-        end
+        sample_with_filter(level, x, y, filter_for_lod(lod))
       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]
+        pixel_for_level(0, x, y)
       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
+        @data[y.to_i * @width + x.to_i] = validate_color!(color)
+        @mipmaps_dirty = true
+      end
+
+      def generate_mipmaps!
+        rebuild_mipmap_chain!
+        self
+      end
+
+      def wrap_s=(mode)
+        @wrap_s = validate_wrap_mode!(mode)
+      end
+
+      def wrap_t=(mode)
+        @wrap_t = validate_wrap_mode!(mode)
+      end
+
+      def filter_min=(filter)
+        @filter_min = validate_filter_mode!(filter)
+      end
+
+      def filter_mag=(filter)
+        @filter_mag = validate_filter_mode!(filter)
       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
+        content = File.binread(filename)
+        format, width, height, max_val, body_offset = parse_ppm_header(content)
+        samples = parse_ppm_samples(content, format, width * height, max_val, body_offset)
 
-        new(width, height, data)
+        new(width, height, colors_from_ppm_samples(samples, max_val))
       end
 
       def self.checker(width, height, size, color1 = Larb::Color.white, color2 = Larb::Color.black)
@@ -85,8 +96,81 @@ module RBGL
         new(width, height, Array.new(width * height) { color })
       end
 
+      def self.parse_ppm_header(content)
+        match = PPM_HEADER.match(content)
+        raise ArgumentError, "Invalid PPM header" unless match
+
+        format = match[1]
+        width = match[2].to_i
+        height = match[3].to_i
+        max_val = match[4].to_i
+        raise ArgumentError, "Unsupported PPM max value: #{max_val}" unless max_val.between?(1, 65_535)
+
+        [format, width, height, max_val, match.end(0)]
+      end
+
+      def self.parse_ppm_samples(content, format, pixel_count, max_val, body_offset)
+        case format
+        when "P3"
+          parse_p3_samples(content.byteslice(body_offset..), pixel_count)
+        when "P6"
+          parse_p6_samples(content, body_offset, pixel_count, max_val)
+        else
+          raise ArgumentError, "Unsupported PPM format: #{format}"
+        end
+      end
+
+      def self.parse_p3_samples(body, pixel_count)
+        samples = body.to_s.gsub(/#[^\n]*/, " ").scan(/\d+/).map(&:to_i)
+        expected_count = pixel_count * 3
+        raise ArgumentError, "PPM pixel data is truncated" if samples.length < expected_count
+
+        samples.first(expected_count)
+      end
+
+      def self.parse_p6_samples(content, body_offset, pixel_count, max_val)
+        sample_size = max_val < 256 ? 1 : 2
+        expected_bytes = pixel_count * 3 * sample_size
+        body = content.byteslice(body_offset, expected_bytes)
+        raise ArgumentError, "PPM pixel data is truncated" unless body && body.bytesize == expected_bytes
+
+        if sample_size == 1
+          body.bytes
+        else
+          body.unpack("n*")
+        end
+      end
+
+      def self.colors_from_ppm_samples(samples, max_val)
+        samples.each_slice(3).map do |r, g, b|
+          Larb::Color.rgb(r / max_val.to_f, g / max_val.to_f, b / max_val.to_f)
+        end
+      end
+
+      private_class_method :parse_ppm_header, :parse_ppm_samples, :parse_p3_samples,
+                           :parse_p6_samples, :colors_from_ppm_samples
+
       private
 
+      def normalize_data!(data)
+        raise ArgumentError, "Texture data must be convertible to an Array" unless data.respond_to?(:to_a)
+
+        normalized = data.to_a
+        expected_size = @width * @height
+
+        unless normalized.size == expected_size
+          raise ArgumentError, "Texture data size mismatch: expected #{expected_size}, got #{normalized.size}"
+        end
+
+        normalized.map { |pixel| validate_color!(pixel) }
+      end
+
+      def validate_color!(color)
+        return color if color.is_a?(Larb::Color)
+
+        raise ArgumentError, "Texture data must contain only Larb::Color values"
+      end
+
       def wrap_coord(coord, mode)
         case mode
         when WRAP_REPEAT
@@ -99,11 +183,40 @@ module RBGL
         end
       end
 
-      def sample_nearest(x, y)
-        get_pixel(x.round, y.round)
+      def validate_wrap_mode!(mode)
+        normalized = mode.to_sym
+        return normalized if WRAP_MODES.include?(normalized)
+
+        raise ArgumentError, "Unsupported wrap mode: #{mode}"
+      end
+
+      def validate_filter_mode!(mode)
+        normalized = mode.to_sym
+        return normalized if FILTER_MODES.include?(normalized)
+
+        raise ArgumentError, "Unsupported filter mode: #{mode}"
+      end
+
+      def sample_nearest(level, x, y)
+        pixel_for_level(level, x.round, y.round)
+      end
+
+      def filter_for_lod(lod)
+        lod.to_f.positive? ? @filter_min : @filter_mag
       end
 
-      def sample_bilinear(x, y)
+      def sample_with_filter(level, x, y, filter)
+        case filter
+        when FILTER_NEAREST
+          sample_nearest(level, x, y)
+        when FILTER_LINEAR
+          sample_bilinear(level, x, y)
+        else
+          raise ArgumentError, "Unsupported filter mode: #{filter}"
+        end
+      end
+
+      def sample_bilinear(level, x, y)
         x0 = x.floor.to_i
         y0 = y.floor.to_i
         x1 = x0 + 1
@@ -111,15 +224,91 @@ module RBGL
         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)
+        c00 = pixel_for_level(level, x0, y0)
+        c10 = pixel_for_level(level, x1, y0)
+        c01 = pixel_for_level(level, x0, y1)
+        c11 = pixel_for_level(level, x1, y1)
 
         c0 = c00.lerp(c10, fx)
         c1 = c01.lerp(c11, fx)
         c0.lerp(c1, fy)
       end
+
+      def mip_level_for(lod)
+        return 0 unless lod.to_f.positive?
+
+        rebuild_mipmap_chain! if @mipmaps_dirty
+        [lod.floor, @levels.size - 1].min
+      end
+
+      def pixel_for_level(level, x, y)
+        level_width = width_for_level(level)
+        level_height = height_for_level(level)
+        level_data = level.zero? ? @data : level_data(level)
+        clamped_x = x.clamp(0, level_width - 1).to_i
+        clamped_y = y.clamp(0, level_height - 1).to_i
+        level_data[clamped_y * level_width + clamped_x]
+      end
+
+      def level_data(level)
+        rebuild_mipmap_chain! if @mipmaps_dirty
+        @levels[level] || @data
+      end
+
+      def width_for_level(level)
+        [@width >> level, 1].max
+      end
+
+      def height_for_level(level)
+        [@height >> level, 1].max
+      end
+
+      def rebuild_mipmap_chain!
+        @levels = [@data]
+
+        current_data = @data
+        current_width = @width
+        current_height = @height
+
+        while current_width > 1 || current_height > 1
+          next_width = [current_width / 2, 1].max
+          next_height = [current_height / 2, 1].max
+          current_data = build_next_level(current_data, current_width, current_height, next_width, next_height)
+          @levels << current_data
+          current_width = next_width
+          current_height = next_height
+        end
+
+        @mipmaps_dirty = false
+      end
+
+      def build_next_level(source_data, source_width, source_height, target_width, target_height)
+        Array.new(target_width * target_height) do |index|
+          x = index % target_width
+          y = index / target_width
+          average_texel_block(source_data, source_width, source_height, x * 2, y * 2)
+        end
+      end
+
+      def average_texel_block(source_data, source_width, source_height, start_x, start_y)
+        samples = []
+
+        2.times do |dy|
+          2.times do |dx|
+            x = [start_x + dx, source_width - 1].min
+            y = [start_y + dy, source_height - 1].min
+            samples << source_data[y * source_width + x]
+          end
+        end
+
+        sample_count = samples.length.to_f
+        Larb::Color.new(
+          samples.sum(&:r) / sample_count,
+          samples.sum(&:g) / sample_count,
+          samples.sum(&:b) / sample_count,
+          samples.sum(&:a) / sample_count
+        )
+      end
     end
   end
 end

data/lib/rbgl/engine.rb

@@ -6,6 +6,7 @@ require_relative "engine/shader"
 require_relative "engine/texture"
 require_relative "engine/rasterizer"
 require_relative "engine/pipeline"
+require_relative "engine/clip_space_clipper"
 require_relative "engine/context"
 
 module RBGL