rlsl 0.1.1 → 1.0.1

data/lib/rlsl/code_generator/uniform_struct_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    class UniformStructGenerator
+      def initialize(context)
+        @context = context
+      end
+
+      def generate
+        return "typedef struct { unsigned char _unused; } Uniforms;\n" if @context.uniform_entries.empty?
+
+        <<~C
+          typedef struct {
+          #{field_lines}
+          } Uniforms;
+        C
+      end
+
+      private
+
+      def field_lines
+        @context.uniform_entries.map do |uniform_name, spec|
+          "  #{spec.c_type} #{uniform_name};"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/rlsl/code_generator.rb

@@ -1,229 +1,57 @@
 # frozen_string_literal: true
 
+require_relative "code_generator/template_context"
+require_relative "code_generator/math_prelude"
+require_relative "code_generator/uniform_struct_generator"
+require_relative "code_generator/shader_function_generator"
+require_relative "code_generator/ruby_wrapper_generator"
+
 module RLSL
   class CodeGenerator
-    def initialize(name, uniforms, helpers_block, fragment_block)
-      @name = name
-      @uniforms = uniforms
-      @helpers_block = helpers_block
-      @fragment_block = fragment_block
+    def initialize(name, uniforms, helpers_block, fragment_block, extension_name: name)
+      @context = TemplateContext.new(
+        name: name,
+        uniforms: uniforms,
+        helpers_block: helpers_block,
+        fragment_block: fragment_block,
+        extension_name: extension_name
+      )
     end
 
     def generate
       <<~C
         #include <ruby.h>
+        #include <ruby/thread.h>
+        #include <limits.h>
         #include <math.h>
         #include <stdint.h>
         #ifdef __APPLE__
         #include <dispatch/dispatch.h>
         #endif
 
-        #{generate_types}
-        #{generate_math_helpers}
-        #{generate_uniform_struct}
-        #{generate_custom_helpers}
-        #{generate_shader_function}
-        #{generate_ruby_wrapper}
+        #{RLSL::C_TYPES}
+        #{MathPrelude.code}
+        #{UniformStructGenerator.new(@context).generate}
+        #{custom_helpers}
+        #{ShaderFunctionGenerator.new(@context).generate}
+        #{RubyWrapperGenerator.new(@context).generate}
 
-        void Init_#{@name}(void) {
-          VALUE mRLSL = rb_define_module("RLSL");
-          VALUE mShaders = rb_define_module_under(mRLSL, "CompiledShaders");
-          rb_define_module_function(mShaders, "#{@name}_render", shader_#{@name}_render, #{3 + @uniforms.size});
-        }
+        #{init_function}
       C
     end
 
     private
 
-    def generate_types
-      <<~C
-        typedef struct { float x, y; } vec2;
-        typedef struct { float x, y, z; } vec3;
-        typedef struct { float x, y, z, w; } vec4;
-
-        #define PI 3.14159265f
-        #define TAU 6.28318530f
-      C
-    end
-
-    def generate_math_helpers
-      <<~C
-        static inline vec2 vec2_new(float x, float y) { return (vec2){x, y}; }
-        static inline vec3 vec3_new(float x, float y, float z) { return (vec3){x, y, z}; }
-        static inline vec4 vec4_new(float x, float y, float z, float w) { return (vec4){x, y, z, w}; }
-
-        static inline vec2 vec2_add(vec2 a, vec2 b) { return (vec2){a.x + b.x, a.y + b.y}; }
-        static inline vec3 vec3_add(vec3 a, vec3 b) { return (vec3){a.x + b.x, a.y + b.y, a.z + b.z}; }
-
-        static inline vec2 vec2_sub(vec2 a, vec2 b) { return (vec2){a.x - b.x, a.y - b.y}; }
-        static inline vec3 vec3_sub(vec3 a, vec3 b) { return (vec3){a.x - b.x, a.y - b.y, a.z - b.z}; }
-
-        static inline vec2 vec2_mul(vec2 a, float s) { return (vec2){a.x * s, a.y * s}; }
-        static inline vec3 vec3_mul(vec3 a, float s) { return (vec3){a.x * s, a.y * s, a.z * s}; }
-
-        static inline vec2 vec2_div(vec2 a, float s) { return (vec2){a.x / s, a.y / s}; }
-        static inline vec3 vec3_div(vec3 a, float s) { return (vec3){a.x / s, a.y / s, a.z / s}; }
-
-        static inline float vec2_dot(vec2 a, vec2 b) { return a.x * b.x + a.y * b.y; }
-        static inline float vec3_dot(vec3 a, vec3 b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
-
-        static inline float vec2_length(vec2 v) { return sqrtf(v.x * v.x + v.y * v.y); }
-        static inline float vec3_length(vec3 v) { return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z); }
-
-        static inline vec2 vec2_normalize(vec2 v) { float l = vec2_length(v); return l > 0 ? vec2_div(v, l) : v; }
-        static inline vec3 vec3_normalize(vec3 v) { float l = vec3_length(v); return l > 0 ? vec3_div(v, l) : v; }
-
-        static inline float fract(float x) { return x - floorf(x); }
-        static inline float mix_f(float a, float b, float t) { return a + (b - a) * t; }
-        static inline vec3 mix_v3(vec3 a, vec3 b, float t) {
-          return (vec3){a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t};
-        }
-
-        static inline float clamp_f(float x, float lo, float hi) {
-          return x < lo ? lo : (x > hi ? hi : x);
-        }
-
-        static inline float smoothstep(float edge0, float edge1, float x) {
-          float t = clamp_f((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
-          return t * t * (3.0f - 2.0f * t);
-        }
-
-        static inline float hash21(vec2 p) {
-          float dot = p.x * 12.9898f + p.y * 78.233f;
-          return fract(sinf(dot) * 43758.5453f);
-        }
-
-        static inline vec2 hash22(vec2 p) {
-          float n = sinf(vec2_dot(p, vec2_new(127.1f, 311.7f)));
-          return vec2_new(fract(n * 43758.5453f), fract(n * 12345.6789f));
-        }
-
-        // reflect: I - 2 * dot(N, I) * N
-        static inline vec3 reflect(vec3 I, vec3 N) {
-          float d = vec3_dot(N, I);
-          return vec3_new(I.x - 2.0f * d * N.x, I.y - 2.0f * d * N.y, I.z - 2.0f * d * N.z);
-        }
-
-        // refract: Snell's law
-        static inline vec3 refract(vec3 I, vec3 N, float eta) {
-          float d = vec3_dot(N, I);
-          float k = 1.0f - eta * eta * (1.0f - d * d);
-          if (k < 0.0f) {
-            return vec3_new(0.0f, 0.0f, 0.0f);  // Total internal reflection
-          }
-          float s = eta * d + sqrtf(k);
-          return vec3_new(eta * I.x - s * N.x, eta * I.y - s * N.y, eta * I.z - s * N.z);
-        }
-      C
-    end
-
-    def generate_uniform_struct
-      if @uniforms.empty?
-        "typedef struct {} Uniforms;\n"
-      else
-        fields = @uniforms.map do |name, type|
-          case type
-          when :float then "  float #{name};"
-          when :vec2 then "  vec2 #{name};"
-          when :vec3 then "  vec3 #{name};"
-          when :vec4 then "  vec4 #{name};"
-          end
-        end.join("\n")
-
-        "typedef struct {\n#{fields}\n} Uniforms;\n"
-      end
-    end
-
-    def generate_custom_helpers
-      return "" unless @helpers_block
-
-      @helpers_block.call
+    def custom_helpers
+      @context.helpers_code
     end
 
-    def generate_shader_function
-      shader_body = @fragment_block.call
-
+    def init_function
       <<~C
-        static vec3 shader_#{@name}(vec2 frag_coord, vec2 resolution, Uniforms u) {
-          #{shader_body}
-        }
-      C
-    end
-
-    def generate_ruby_wrapper
-      uniform_args = @uniforms.map { |name, _| "VALUE rb_#{name}" }.join(", ")
-      uniform_args = ", " + uniform_args unless uniform_args.empty?
-
-      uniform_parsing = @uniforms.map do |name, type|
-        case type
-        when :float
-          "  uniforms.#{name} = (float)NUM2DBL(rb_#{name});"
-        when :vec2
-          <<~C.strip
-              Check_Type(rb_#{name}, T_ARRAY);
-              uniforms.#{name} = vec2_new(
-                (float)NUM2DBL(rb_ary_entry(rb_#{name}, 0)),
-                (float)NUM2DBL(rb_ary_entry(rb_#{name}, 1))
-              );
-          C
-        when :vec3
-          <<~C.strip
-              Check_Type(rb_#{name}, T_ARRAY);
-              uniforms.#{name} = vec3_new(
-                (float)NUM2DBL(rb_ary_entry(rb_#{name}, 0)),
-                (float)NUM2DBL(rb_ary_entry(rb_#{name}, 1)),
-                (float)NUM2DBL(rb_ary_entry(rb_#{name}, 2))
-              );
-          C
-        end
-      end.join("\n")
-
-      <<~C
-        static VALUE shader_#{@name}_render(VALUE self, VALUE rb_buffer, VALUE rb_width, VALUE rb_height#{uniform_args}) {
-          int width = NUM2INT(rb_width);
-          int height = NUM2INT(rb_height);
-          vec2 resolution = vec2_new((float)width, (float)height);
-
-          Uniforms uniforms;
-          #{uniform_parsing}
-
-          Check_Type(rb_buffer, T_STRING);
-          rb_str_modify(rb_buffer);
-          uint8_t *pixels = (uint8_t *)RSTRING_PTR(rb_buffer);
-
-          #ifdef __APPLE__
-          dispatch_apply(height, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t y) {
-            int flipped_y = height - 1 - (int)y;
-            for (int x = 0; x < width; x++) {
-              vec2 frag_coord = vec2_new((float)x, (float)flipped_y);
-              vec3 color = shader_#{@name}(frag_coord, resolution, uniforms);
-
-              int idx = ((int)y * width + x) * 4;
-              // Output as BGRA (macOS native format)
-              pixels[idx] = (uint8_t)(clamp_f(color.z, 0.0f, 1.0f) * 255.0f);
-              pixels[idx+1] = (uint8_t)(clamp_f(color.y, 0.0f, 1.0f) * 255.0f);
-              pixels[idx+2] = (uint8_t)(clamp_f(color.x, 0.0f, 1.0f) * 255.0f);
-              pixels[idx+3] = 255;
-            }
-          });
-          #else
-          for (int y = 0; y < height; y++) {
-            int flipped_y = height - 1 - y;
-            for (int x = 0; x < width; x++) {
-              vec2 frag_coord = vec2_new((float)x, (float)flipped_y);
-              vec3 color = shader_#{@name}(frag_coord, resolution, uniforms);
-
-              int idx = (y * width + x) * 4;
-              // Output as BGRA (macOS native format)
-              pixels[idx] = (uint8_t)(clamp_f(color.z, 0.0f, 1.0f) * 255.0f);
-              pixels[idx+1] = (uint8_t)(clamp_f(color.y, 0.0f, 1.0f) * 255.0f);
-              pixels[idx+2] = (uint8_t)(clamp_f(color.x, 0.0f, 1.0f) * 255.0f);
-              pixels[idx+3] = 255;
-            }
-          }
-          #endif
-
-          return Qnil;
+        void Init_#{@context.extension_name}(void) {
+          VALUE mRLSL = rb_define_module("RLSL");
+          VALUE mShaders = rb_define_module_under(mRLSL, "CompiledShaders");
+          rb_define_module_function(mShaders, "#{@context.extension_name}_render", shader_#{@context.name}_render, #{@context.render_arity});
         }
       C
     end

data/lib/rlsl/compiled_shader.rb

@@ -1,23 +1,15 @@
 # frozen_string_literal: true
 
 module RLSL
-  class CompiledShader
-    def initialize(name, ext_name, uniform_names)
-      @name = name
+  class CompiledShader < RuntimeShader
+    def initialize(name, ext_name, uniforms)
+      super(name, uniforms)
       @ext_name = ext_name
-      @uniform_names = uniform_names
-      @render_method = RLSL::CompiledShaders.method("#{name}_render")
-    end
-
-    def metal?
-      false
+      @render_method = RLSL::CompiledShaders.method("#{ext_name}_render")
     end
 
     def render(buffer, width, height, uniforms = {})
-      args = [buffer, width, height]
-      @uniform_names.each do |name|
-        args << uniforms[name]
-      end
+      args = [buffer, width, height] + ordered_uniform_values(uniforms)
       @render_method.call(*args)
     end
   end

data/lib/rlsl/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RLSL
+  SourceLocation = Struct.new(:source_name, :line, :column, keyword_init: true) do
+    def to_s
+      "#{source_name || '(shader source)'}:#{line}:#{column}"
+    end
+  end
+
+  class Error < StandardError
+    attr_reader :source_location
+
+    def with_source_location(location)
+      @source_location ||= location
+      self
+    end
+
+    def message
+      return super unless source_location
+
+      "#{super} at #{source_location}"
+    end
+  end
+  class InternalError < Error; end
+  class ParseError < Error; end
+  class TranslationError < Error; end
+  class CompilationError < Error; end
+  class UniformValueError < ArgumentError; end
+end

data/lib/rlsl/function_context.rb

@@ -8,28 +8,45 @@ module RLSL
       @functions = {}
     end
 
-    def float(*names)
-      names.each { |name| @functions[name.to_sym] = { returns: :float } }
+    # Full form: specify return type and parameter types
+    # @example
+    #   define :path_point, returns: :vec3, params: { z: :float }
+    #   define :noise_a, returns: :float, params: { f: :float, h: :float, k: :float, p: :vec3 }
+    def define(name, returns:, params: {})
+      @functions[name.to_sym] = {
+        returns: validate_type!(returns),
+        params: normalize_params(params)
+      }
     end
 
-    def vec2(*names)
-      names.each { |name| @functions[name.to_sym] = { returns: :vec2 } }
+    UniformTypes.function_shorthand_types.each do |type|
+      define_method(type) do |*names|
+        register_shorthand_functions(type, *names)
+      end
     end
 
-    def vec3(*names)
-      names.each { |name| @functions[name.to_sym] = { returns: :vec3 } }
+    private
+
+    def register_shorthand_functions(type, *names)
+      validated_type = validate_type!(type)
+      names.each do |name|
+        @functions[name.to_sym] = { returns: validated_type }
+      end
     end
 
-    def vec4(*names)
-      names.each { |name| @functions[name.to_sym] = { returns: :vec4 } }
+    def normalize_params(params)
+      params.each_with_object({}) do |(name, type), normalized|
+        normalized[name.to_sym] = validate_type!(type)
+      end
     end
 
-    # Full form: specify return type and parameter types
-    # @example
-    #   define :path_point, returns: :vec3, params: { z: :float }
-    #   define :noise_a, returns: :float, params: { f: :float, h: :float, k: :float, p: :vec3 }
-    def define(name, returns:, params: {})
-      @functions[name.to_sym] = { returns: returns, params: params }
+    def validate_type!(type)
+      if type.is_a?(Array)
+        return type.map { |element_type| validate_type!(element_type) }
+      end
+
+      UniformTypes.fetch(type)
+      type
     end
   end
 end

data/lib/rlsl/glsl/translator.rb

@@ -3,37 +3,30 @@
 module RLSL
   module GLSL
     class Translator < BaseTranslator
-      TYPE_MAP = {
-        "vec2" => "vec2",
-        "vec3" => "vec3",
-        "vec4" => "vec4"
-      }.freeze
-
-      FUNC_REPLACEMENTS = BaseTranslator.common_func_replacements(
-        target_vec2: "vec2",
-        target_vec3: "vec3",
-        target_vec4: "vec4"
-      ).freeze
-
-      def initialize(uniforms, helpers_code, fragment_code, version: "450")
-        super(uniforms, helpers_code, fragment_code)
-        @version = version
+      PROFILE = BaseTranslator.build_profile(
+        uniform_target: :glsl,
+        identifier_replacements: {},
+        call_rewrites: BaseTranslator.common_call_rewrites(
+          target_vec2: "vec2",
+          target_vec3: "vec3",
+          target_vec4: "vec4"
+        ).merge(
+          "fmodf" => BaseTranslator.rename_call("mod"),
+          "atan2f" => BaseTranslator.rename_call("atan")
+        )
+      )
+
+      def initialize(uniforms, helpers_code, fragment_code, version: "450", name: nil)
+        super(uniforms, helpers_code, fragment_code, name: name)
+        @version = validate_version!(version)
       end
 
       protected
 
-      def translate_code(c_code)
-        result = super(c_code)
-        return result if result.empty?
-
-        result.gsub!(/\bstatic\s+/, "")
-        result.gsub!(/\binline\s+/, "")
-        result
-      end
-
       def generate_shader(helpers, fragment)
         <<~GLSL
           #version #{@version}
+          #{generated_by_comment("GLSL")}
 
           // Uniforms
           #{generate_uniform_declarations}
@@ -44,8 +37,7 @@ module RLSL
           #{helpers}
 
           vec3 shader_fragment(vec2 frag_coord, vec2 resolution) {
-              vec2 uv = frag_coord / resolution.y;
-              #{fragment}
+          #{indent_source(fragment, 4)}
           }
 
           layout(local_size_x = 8, local_size_y = 8) in;
@@ -70,27 +62,29 @@ module RLSL
 
       private
 
+      def profile
+        PROFILE
+      end
+
       def generate_uniform_declarations
-        declarations = ["layout(binding = 1) uniform ShaderUniforms {",
-                        "    vec2 resolution;"]
-        @uniforms.each do |name, type|
-          glsl_type = uniform_type_to_target(type)
-          declarations << "    #{glsl_type} #{name};"
-        end
+        declarations = ["layout(std140, binding = 1) uniform ShaderUniforms {"]
+        declarations.concat(
+          uniform_lines(resolution_line: "    #{target_vec2_type} resolution;") do |name, glsl_type|
+            "    #{glsl_type} #{name};"
+          end
+        )
         declarations << "} u;"
+        texture_uniforms.each_with_index do |(name, _type), index|
+          declarations << "layout(binding = #{index + 2}) uniform sampler2D #{name};"
+        end
         declarations.join("\n")
       end
 
-      def target_vec2_type
-        "vec2"
-      end
-
-      def target_vec3_type
-        "vec3"
-      end
+      def validate_version!(version)
+        normalized = version.to_s
+        return normalized if normalized.match?(/\A[1-9]\d{2}(?: (?:core|compatibility|es))?\z/)
 
-      def target_vec4_type
-        "vec4"
+        raise ArgumentError, "Invalid GLSL version: #{version.inspect}"
       end
     end
   end

data/lib/rlsl/msl/shader.rb

@@ -1,30 +1,35 @@
 # frozen_string_literal: true
 
-begin
-  require "metaco"
-  METACO_AVAILABLE = true
-rescue LoadError
-  METACO_AVAILABLE = false
-end
-
 module RLSL
   module MSL
-    class Shader
+    begin
+      require "metaco"
+      METACO_AVAILABLE = true
+    rescue LoadError
+      METACO_AVAILABLE = false
+    end
+
+    class Shader < RuntimeShader
+      COMPILED_HANDLE_CACHE_LIMIT = 64
       attr_reader :name, :msl_source
 
       def initialize(name, uniforms, msl_source)
-        @name = name
-        @uniform_types = uniforms
-        @uniform_names = uniforms.keys
+        super(name, uniforms)
         @msl_source = msl_source
         @compiled_handles = {}
+        value_uniform_types = @uniform_types.reject { |_name, type| type == :sampler2D }
+        @uniform_buffer_packer = UniformBufferPacker.new(@name, value_uniform_types, value_uniform_types.keys)
       end
 
       def metal?
         true
       end
 
-      def render_metal(handle, width, height, uniforms = {})
+      def render(handle, width, height, uniforms = {})
+        render_metal(handle, width, height, uniforms)
+      end
+
+      def prepare(handle)
         unless METACO_AVAILABLE
           raise LoadError, "metaco gem is required for Metal rendering. Install it with: gem install metaco"
         end
@@ -32,10 +37,26 @@ module RLSL
         unless @compiled_handles[handle]
           Metaco.compile_compute_shader(handle, @msl_source)
           @compiled_handles[handle] = true
+          @compiled_handles.shift while @compiled_handles.length > COMPILED_HANDLE_CACHE_LIMIT
         end
+        self
+      end
+
+      def render_metal(handle, width, height, uniforms = {}, textures: {})
+        prepare(handle)
 
         uniform_data = pack_uniforms(uniforms, width, height)
 
+        sampler_names = @uniform_types.filter_map { |name, type| name if type == :sampler2D }
+        sampler_names.each do |name|
+          texture = textures[name] || textures[name.to_s]
+          raise ArgumentError, "missing texture uniform: #{name}" unless texture
+          unless Metaco.respond_to?(:bind_compute_texture)
+            raise LoadError, "metaco texture support is required for sampler2D uniforms"
+          end
+          Metaco.bind_compute_texture(handle, sampler_names.index(name), texture)
+        end
+
         Metaco.dispatch_compute(handle, uniform_data)
         Metaco.present_compute(handle)
       end
@@ -43,40 +64,7 @@ module RLSL
       private
 
       def pack_uniforms(uniforms, width, height)
-        data = [width.to_f, height.to_f].pack("ff")
-        current_offset = 8
-
-        @uniform_names.each do |name|
-          value = uniforms[name]
-          type = @uniform_types[name]
-
-          alignment = case type
-                      when :float then 4
-                      when :vec2 then 8
-                      when :vec3, :vec4 then 16
-                      end
-
-          padding_needed = (alignment - (current_offset % alignment)) % alignment
-          data += "\x00" * padding_needed
-          current_offset += padding_needed
-
-          case type
-          when :float
-            data += [value.to_f].pack("f")
-            current_offset += 4
-          when :vec2
-            data += value.pack("ff")
-            current_offset += 8
-          when :vec3
-            data += (value + [0.0]).pack("ffff")
-            current_offset += 16
-          when :vec4
-            data += value.pack("ffff")
-            current_offset += 16
-          end
-        end
-
-        data.ljust(256, "\x00")
+        @uniform_buffer_packer.pack(width, height, uniforms)
       end
     end
   end