rlsl 0.1.0 → 1.0.0

data/lib/rlsl/code_generator/ruby_wrapper_generator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    class RubyWrapperGenerator
+      VECTOR_CONSTRUCTORS = {
+        2 => "vec2_new",
+        3 => "vec3_new",
+        4 => "vec4_new"
+      }.freeze
+
+      def initialize(context)
+        @context = context
+      end
+
+      def generate
+        <<~C
+          static void render_scanline(uint8_t *pixels, int width, int height, int y, vec2 resolution, Uniforms uniforms) {
+            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_#{@context.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;
+            }
+          }
+
+          static VALUE shader_#{@context.name}_render(VALUE self, VALUE rb_buffer, VALUE rb_width, VALUE rb_height#{@context.uniform_argument_list}) {
+            int width = NUM2INT(rb_width);
+            int height = NUM2INT(rb_height);
+            vec2 resolution = vec2_new((float)width, (float)height);
+
+            Uniforms uniforms;
+            #{uniform_assignments}
+
+            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) {
+              render_scanline(pixels, width, height, (int)y, resolution, uniforms);
+            });
+            #else
+            for (int y = 0; y < height; y++) {
+              render_scanline(pixels, width, height, y, resolution, uniforms);
+            }
+            #endif
+
+            return Qnil;
+          }
+        C
+      end
+
+      private
+
+      def uniform_assignments
+        @context.uniform_entries.map do |uniform_name, spec|
+          generate_uniform_assignment(uniform_name, spec)
+        end.join("\n")
+      end
+
+      def generate_uniform_assignment(uniform_name, spec)
+        case spec.wrapper_kind
+        when :float
+          "  uniforms.#{uniform_name} = (float)NUM2DBL(rb_#{uniform_name});"
+        when :int
+          "  uniforms.#{uniform_name} = NUM2INT(rb_#{uniform_name});"
+        when :bool
+          "  uniforms.#{uniform_name} = RTEST(rb_#{uniform_name}) ? 1 : 0;"
+        when :vector
+          generate_vector_uniform_assignment(uniform_name, spec.vector_size)
+        else
+          raise ArgumentError, "Unsupported compiled uniform type: #{spec.c_type}"
+        end
+      end
+
+      def generate_vector_uniform_assignment(uniform_name, vector_size)
+        constructor = VECTOR_CONSTRUCTORS.fetch(vector_size)
+        components = (0...vector_size).map do |index|
+          "    (float)NUM2DBL(rb_ary_entry(rb_#{uniform_name}, #{index}))"
+        end
+
+        <<~C.strip
+          Check_Type(rb_#{uniform_name}, T_ARRAY);
+          uniforms.#{uniform_name} = #{constructor}(
+        #{components.join(",\n")}
+          );
+        C
+      end
+    end
+  end
+end

data/lib/rlsl/code_generator/shader_function_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    class ShaderFunctionGenerator
+      def initialize(context)
+        @context = context
+      end
+
+      def generate
+        <<~C
+          static vec3 shader_#{@context.name}(vec2 frag_coord, vec2 resolution, Uniforms u) {
+            #{@context.fragment_code}
+          }
+        C
+      end
+    end
+  end
+end

data/lib/rlsl/code_generator/template_context.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    class TemplateContext
+      attr_reader :name
+
+      def initialize(name:, uniforms:, helpers_block:, fragment_block:)
+        @name = name
+        @uniforms = uniforms
+        @helpers_block = helpers_block
+        @fragment_block = fragment_block
+      end
+
+      def render_arity
+        3 + @uniforms.size
+      end
+
+      def helpers_code
+        return "" unless @helpers_block
+
+        @helpers_block.call
+      end
+
+      def fragment_code
+        @fragment_block.call
+      end
+
+      def uniform_entries
+        @uniform_entries ||= @uniforms.map do |uniform_name, type|
+          [uniform_name, UniformTypes.compiled_spec(type)]
+        end
+      end
+
+      def uniform_argument_list
+        arguments = @uniforms.map { |uniform_name, _| "VALUE rb_#{uniform_name}" }
+        arguments.empty? ? "" : ", #{arguments.join(', ')}"
+      end
+    end
+  end
+end

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 {} 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,12 +1,20 @@
 # 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
+      @context = TemplateContext.new(
+        name: name,
+        uniforms: uniforms,
+        helpers_block: helpers_block,
+        fragment_block: fragment_block
+      )
     end
 
     def generate
@@ -18,212 +26,29 @@ module RLSL
         #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.name}(void) {
+          VALUE mRLSL = rb_define_module("RLSL");
+          VALUE mShaders = rb_define_module_under(mRLSL, "CompiledShaders");
+          rb_define_module_function(mShaders, "#{@context.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
-    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/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,17 +3,15 @@
 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
+      PROFILE = BaseTranslator.build_profile(
+        uniform_target: :glsl,
+        identifier_replacements: {},
+        call_rewrites: BaseTranslator.common_call_rewrites(
+          target_vec2: "vec2",
+          target_vec3: "vec3",
+          target_vec4: "vec4"
+        )
+      )
 
       def initialize(uniforms, helpers_code, fragment_code, version: "450")
         super(uniforms, helpers_code, fragment_code)
@@ -22,15 +20,6 @@ module RLSL
 
       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}
@@ -70,28 +59,20 @@ 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(binding = 1) uniform ShaderUniforms {"]
+        declarations.concat(
+          uniform_lines(resolution_line: "    #{target_vec2_type} resolution;") do |name, glsl_type|
+            "    #{glsl_type} #{name};"
+          end
+        )
         declarations << "} u;"
         declarations.join("\n")
       end
-
-      def target_vec2_type
-        "vec2"
-      end
-
-      def target_vec3_type
-        "vec3"
-      end
-
-      def target_vec4_type
-        "vec4"
-      end
     end
   end
 end

data/lib/rlsl/msl/shader.rb

@@ -9,21 +9,24 @@ end
 
 module RLSL
   module MSL
-    class Shader
+    class Shader < RuntimeShader
       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 = {}
+        @uniform_buffer_packer = UniformBufferPacker.new(@name, @uniform_types, @uniform_names)
       end
 
       def metal?
         true
       end
 
+      def render(handle, width, height, uniforms = {})
+        render_metal(handle, width, height, uniforms)
+      end
+
       def render_metal(handle, width, height, uniforms = {})
         unless METACO_AVAILABLE
           raise LoadError, "metaco gem is required for Metal rendering. Install it with: gem install metaco"
@@ -43,40 +46,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