rbgl 0.1.0 → 1.0.1

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, :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, immutable_color(Larb::Color.black))
+        @levels = [@data]
+        @mipmaps_dirty = true
         @wrap_s = WRAP_REPEAT
         @wrap_t = WRAP_REPEAT
         @filter_min = FILTER_LINEAR
@@ -24,50 +29,60 @@ module RBGL
       end
 
       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)
+        filter = filter_for_lod(lod)
+        texel_offset = filter == FILTER_LINEAR ? -0.5 : 0.0
 
-        x = u * (@width - 1)
-        y = v * (@height - 1)
+        x = (u.to_f * level_width) + texel_offset
+        y = (v.to_f * level_height) + texel_offset
 
-        if @filter_mag == FILTER_NEAREST
-          sample_nearest(x, y)
-        else
-          sample_bilinear(x, y)
-        end
+        sample_with_filter(level, x, y, filter)
+      end
+
+      def data
+        @data.dup.freeze
       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] = immutable_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)
@@ -75,35 +90,137 @@ module RBGL
         height.times do |y|
           width.times do |x|
             checker = ((x / size) + (y / size)) % 2
-            data[y * width + x] = checker == 0 ? color1 : color2
+            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 })
+        immutable = ImmutableColor.from(color)
+        new(width, height, Array.new(width * height, immutable))
+      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, max_val)
+        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, max_val)
+        tokens = body.to_s.gsub(/#[^\n]*/, " ").split
+        expected_count = pixel_count * 3
+        raise ArgumentError, "PPM pixel data is truncated" if tokens.length < expected_count
+
+        tokens.first(expected_count).map do |token|
+          raise ArgumentError, "Invalid PPM sample: #{token}" unless /\A\d+\z/.match?(token)
+
+          value = token.to_i
+          raise ArgumentError, "PPM sample exceeds max value: #{value}" if value > max_val
+
+          value
+        end
+      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 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
+      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| immutable_color(pixel) }
       end
 
-      def sample_nearest(x, y)
-        get_pixel(x.round, y.round)
+      def validate_color!(color)
+        return color if color.is_a?(Larb::Color)
+
+        raise ArgumentError, "Texture data must contain only Larb::Color values"
       end
 
-      def sample_bilinear(x, y)
+      def immutable_color(color)
+        ImmutableColor.from(validate_color!(color))
+      end
+
+      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.floor, y.floor, wrap_s: @wrap_s, wrap_t: @wrap_t)
+      end
+
+      def filter_for_lod(lod)
+        lod.to_f.positive? ? @filter_min : @filter_mag
+      end
+
+      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 +228,111 @@ 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, wrap_s: @wrap_s, wrap_t: @wrap_t)
+        c10 = pixel_for_level(level, x1, y0, wrap_s: @wrap_s, wrap_t: @wrap_t)
+        c01 = pixel_for_level(level, x0, y1, wrap_s: @wrap_s, wrap_t: @wrap_t)
+        c11 = pixel_for_level(level, x1, y1, wrap_s: @wrap_s, wrap_t: @wrap_t)
 
         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, wrap_s: WRAP_CLAMP, wrap_t: WRAP_CLAMP)
+        level_width = width_for_level(level)
+        level_height = height_for_level(level)
+        level_data = level.zero? ? @data : level_data(level)
+        sample_x = wrap_index(x.to_i, level_width, wrap_s)
+        sample_y = wrap_index(y.to_i, level_height, wrap_t)
+        level_data[(sample_y * level_width) + sample_x]
+      end
+
+      def wrap_index(index, size, mode)
+        case mode
+        when WRAP_REPEAT
+          index % size
+        when WRAP_CLAMP
+          index.clamp(0, size - 1)
+        when WRAP_MIRROR
+          mirrored = index % (size * 2)
+          mirrored < size ? mirrored : ((size * 2) - mirrored - 1)
+        end
+      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
+          start_x = x * source_width.fdiv(target_width)
+          end_x = x == target_width - 1 ? source_width.to_f : (x + 1) * source_width.fdiv(target_width)
+          start_y = y * source_height.fdiv(target_height)
+          end_y = y == target_height - 1 ? source_height.to_f : (y + 1) * source_height.fdiv(target_height)
+          average_texel_area(source_data, source_width, start_x, end_x, start_y, end_y)
+        end
+      end
+
+      def average_texel_area(source_data, source_width, start_x, end_x, start_y, end_y)
+        red = green = blue = alpha = total_weight = 0.0
+
+        (start_y.floor...end_y.ceil).each do |y|
+          y_weight = [end_y, y + 1].min - [start_y, y].max
+          (start_x.floor...end_x.ceil).each do |x|
+            weight = ([end_x, x + 1].min - [start_x, x].max) * y_weight
+            color = source_data[(y * source_width) + x]
+            red += color.r * weight
+            green += color.g * weight
+            blue += color.b * weight
+            alpha += color.a * weight
+            total_weight += weight
+          end
+        end
+
+        immutable_color(Larb::Color.new(
+          red / total_weight,
+          green / total_weight,
+          blue / total_weight,
+          alpha / total_weight
+        ))
+      end
     end
   end
 end