rlsl 0.1.1 → 1.0.1

data/lib/rlsl/base_translator.rb

@@ -1,92 +1,77 @@
 # frozen_string_literal: true
 
+require_relative "base_translator/code_rewriter"
+
 module RLSL
   class BaseTranslator
-    FUNC_REPLACEMENTS = [].freeze
+    SourceSnippet = Struct.new(:code, :format, keyword_init: true) do
+      def target_code?
+        format == :target
+      end
+    end
+
+    TargetProfile = Struct.new(
+      :uniform_target,
+      :identifier_replacements,
+      :call_rewrites,
+      :removed_identifiers,
+      keyword_init: true
+    ) do
+      def translate(code)
+        CodeRewriter.new(code).rewrite(
+          identifier_replacements: identifier_replacements,
+          call_rewrites: call_rewrites,
+          removed_identifiers: removed_identifiers
+        )
+      end
+    end
 
-    TYPE_MAP = {}.freeze
+    REMOVED_IDENTIFIERS = %w[static inline].freeze
 
-    def initialize(uniforms, helpers_code, fragment_code)
+    def initialize(uniforms, helpers_code, fragment_code, name: nil)
       @uniforms = uniforms
-      @helpers_code = helpers_code || ""
-      @fragment_code = fragment_code || ""
+      @shader_name = name&.to_s
+      @helpers_source = normalize_source(helpers_code)
+      @fragment_source = normalize_source(fragment_code)
     end
 
     def translate
-      helpers_translated = translate_code(@helpers_code)
-      fragment_translated = translate_code(@fragment_code)
+      helpers_translated = translate_code(@helpers_source)
+      fragment_translated = translate_code(@fragment_source)
       generate_shader(helpers_translated, fragment_translated)
     end
 
     protected
 
-    def translate_code(c_code)
-      return "" if c_code.nil? || c_code.empty?
+    def translate_code(source)
+      snippet = normalize_source(source)
+      return "" if snippet.code.empty?
+      validate_source_format!(snippet)
+      return snippet.code if snippet.target_code?
 
-      result = c_code.dup
-
-      self.class::TYPE_MAP.each do |c_type, target_type|
-        result.gsub!(/\b#{c_type}\b/, target_type)
-      end
-
-      self.class::FUNC_REPLACEMENTS.each do |pattern, replacement|
-        result.gsub!(pattern, replacement)
-      end
-
-      result
+      profile.translate(snippet.code)
     end
 
+    def validate_source_format!(_source); end
+
     def generate_shader(_helpers, _fragment)
       raise NotImplementedError, "Subclasses must implement generate_shader"
     end
 
-    def self.common_func_replacements(target_vec2:, target_vec3:, target_vec4:)
-      [
-        [/vec2_new\(([^,]+),\s*([^)]+)\)/, "#{target_vec2}(\\1, \\2)"],
-        [/vec3_new\(([^,]+),\s*([^,]+),\s*([^)]+)\)/, "#{target_vec3}(\\1, \\2, \\3)"],
-        [/vec4_new\(([^,]+),\s*([^,]+),\s*([^,]+),\s*([^)]+)\)/, "#{target_vec4}(\\1, \\2, \\3, \\4)"],
-        [/vec2_add\(([^,]+),\s*([^)]+)\)/, '(\1 + \2)'],
-        [/vec3_add\(([^,]+),\s*([^)]+)\)/, '(\1 + \2)'],
-        [/vec2_sub\(([^,]+),\s*([^)]+)\)/, '(\1 - \2)'],
-        [/vec3_sub\(([^,]+),\s*([^)]+)\)/, '(\1 - \2)'],
-        [/vec2_mul\(([^,]+),\s*([^)]+)\)/, '(\1 * \2)'],
-        [/vec3_mul\(([^,]+),\s*([^)]+)\)/, '(\1 * \2)'],
-        [/vec2_div\(([^,]+),\s*([^)]+)\)/, '(\1 / \2)'],
-        [/vec3_div\(([^,]+),\s*([^)]+)\)/, '(\1 / \2)'],
-        [/vec2_dot\(([^,]+),\s*([^)]+)\)/, 'dot(\1, \2)'],
-        [/vec3_dot\(([^,]+),\s*([^)]+)\)/, 'dot(\1, \2)'],
-        [/vec2_length\(([^)]+)\)/, 'length(\1)'],
-        [/vec3_length\(([^)]+)\)/, 'length(\1)'],
-        [/vec2_normalize\(([^)]+)\)/, 'normalize(\1)'],
-        [/vec3_normalize\(([^)]+)\)/, 'normalize(\1)'],
-        [/sqrtf\(/, "sqrt("],
-        [/sinf\(/, "sin("],
-        [/cosf\(/, "cos("],
-        [/tanf\(/, "tan("],
-        [/fabsf\(/, "abs("],
-        [/fminf\(/, "min("],
-        [/fmaxf\(/, "max("],
-        [/floorf\(/, "floor("],
-        [/ceilf\(/, "ceil("],
-        [/powf\(/, "pow("],
-        [/expf\(/, "exp("],
-        [/logf\(/, "log("],
-        [/atan2f\(/, "atan2("],
-        [/fmodf\(/, "fmod("],
-        [/mix_f\(/, "mix("],
-        [/mix_v3\(/, "mix("],
-        [/clamp_f\(/, "clamp("],
-        [/smoothstep\(/, "smoothstep("],
-        [/fract\(/, "fract("]
-      ]
-    end
-
     def uniform_type_to_target(type)
       case type
       when :float then target_float_type
+      when :int then target_int_type
+      when :bool then target_bool_type
       when :vec2 then target_vec2_type
       when :vec3 then target_vec3_type
       when :vec4 then target_vec4_type
+      when :mat2 then target_mat2_type
+      when :mat3 then target_mat3_type
+      when :mat4 then target_mat4_type
+      when :sampler2D then target_sampler2d_type
+      else
+        raise ArgumentError, "Unsupported uniform type: #{type.inspect}"
       end
     end
 
@@ -94,16 +79,149 @@ module RLSL
       "float"
     end
 
+    def target_int_type
+      UniformTypes.target_type(:int, uniform_target)
+    end
+
+    def target_bool_type
+      UniformTypes.target_type(:bool, uniform_target)
+    end
+
     def target_vec2_type
-      raise NotImplementedError
+      UniformTypes.target_type(:vec2, uniform_target)
     end
 
     def target_vec3_type
-      raise NotImplementedError
+      UniformTypes.target_type(:vec3, uniform_target)
     end
 
     def target_vec4_type
-      raise NotImplementedError
+      UniformTypes.target_type(:vec4, uniform_target)
+    end
+
+    def target_mat2_type
+      UniformTypes.target_type(:mat2, uniform_target)
+    end
+
+    def target_mat3_type
+      UniformTypes.target_type(:mat3, uniform_target)
+    end
+
+    def target_mat4_type
+      UniformTypes.target_type(:mat4, uniform_target)
+    end
+
+    def target_sampler2d_type
+      UniformTypes.target_type(:sampler2D, uniform_target)
+    end
+
+    def uniform_target
+      profile.uniform_target
+    end
+
+    def uniform_lines(resolution_line:, &block)
+      lines = [resolution_line]
+      value_uniforms.each do |name, type|
+        lines << block.call(name, uniform_type_to_target(type))
+      end
+      lines
+    end
+
+    def value_uniforms
+      @uniforms.reject { |_name, type| type.to_sym == :sampler2D }
+    end
+
+    def texture_uniforms
+      @uniforms.select { |_name, type| type.to_sym == :sampler2D }
+    end
+
+    def indent_source(source, spaces)
+      prefix = " " * spaces
+      source.to_s.lines.map { |line| line.strip.empty? ? line : "#{prefix}#{line}" }.join.rstrip
+    end
+
+    def generated_by_comment(language)
+      suffix = @shader_name ? ": #{@shader_name}" : ""
+      "// #{language} shader generated by RLSL#{suffix}"
+    end
+
+    def profile
+      return self.class::PROFILE if self.class.const_defined?(:PROFILE, false)
+
+      raise NotImplementedError, "Subclasses must define PROFILE"
+    end
+
+    def self.build_profile(uniform_target:, identifier_replacements:, call_rewrites:, removed_identifiers: REMOVED_IDENTIFIERS)
+      TargetProfile.new(
+        uniform_target: uniform_target,
+        identifier_replacements: identifier_replacements.freeze,
+        call_rewrites: call_rewrites.freeze,
+        removed_identifiers: removed_identifiers.freeze
+      ).freeze
+    end
+
+    def self.common_call_rewrites(target_vec2:, target_vec3:, target_vec4:)
+      {
+        "vec2_new" => rename_call(target_vec2),
+        "vec3_new" => rename_call(target_vec3),
+        "vec4_new" => rename_call(target_vec4),
+        "vec2_add" => infix_call("+"),
+        "vec3_add" => infix_call("+"),
+        "vec2_sub" => infix_call("-"),
+        "vec3_sub" => infix_call("-"),
+        "vec2_mul" => infix_call("*"),
+        "vec3_mul" => infix_call("*"),
+        "vec2_div" => infix_call("/"),
+        "vec3_div" => infix_call("/"),
+        "vec2_dot" => rename_call("dot"),
+        "vec3_dot" => rename_call("dot"),
+        "vec2_length" => rename_call("length"),
+        "vec3_length" => rename_call("length"),
+        "vec2_normalize" => rename_call("normalize"),
+        "vec3_normalize" => rename_call("normalize"),
+        "sqrtf" => rename_call("sqrt"),
+        "sinf" => rename_call("sin"),
+        "cosf" => rename_call("cos"),
+        "tanf" => rename_call("tan"),
+        "fabsf" => rename_call("abs"),
+        "fminf" => rename_call("min"),
+        "fmaxf" => rename_call("max"),
+        "floorf" => rename_call("floor"),
+        "ceilf" => rename_call("ceil"),
+        "powf" => rename_call("pow"),
+        "expf" => rename_call("exp"),
+        "logf" => rename_call("log"),
+        "atan2f" => rename_call("atan2"),
+        "fmodf" => rename_call("fmod"),
+        "mix_f" => rename_call("mix"),
+        "mix_v3" => rename_call("mix"),
+        "clamp_f" => rename_call("clamp"),
+        "smoothstep" => rename_call("smoothstep"),
+        "fract" => rename_call("fract")
+      }.freeze
+    end
+
+    def self.rename_call(name)
+      lambda do |arguments|
+        "#{name}(#{arguments.join(', ')})"
+      end
+    end
+
+    def self.infix_call(operator)
+      lambda do |arguments|
+        raise ArgumentError, "Expected 2 arguments for #{operator} rewrite, got #{arguments.length}" unless arguments.length == 2
+
+        "(#{arguments[0]} #{operator} #{arguments[1]})"
+      end
+    end
+
+    private
+
+    def normalize_source(source)
+      return SourceSnippet.new(code: "", format: :legacy) if source.nil?
+      return source if source.is_a?(SourceSnippet)
+
+      SourceSnippet.new(code: source.to_s, format: :legacy)
     end
   end
 end

data/lib/rlsl/code_generator/math_prelude.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    module MathPrelude
+      module_function
+
+      def code
+        <<~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_splat(float x) { return vec2_new(x, x); }
+          static inline vec3 vec3_splat(float x) { return vec3_new(x, x, x); }
+          static inline vec4 vec4_splat(float x) { return vec4_new(x, x, x, x); }
+
+          static inline vec2 vec2_from_vec2(vec2 v) { return v; }
+          static inline vec3 vec3_from_vec3(vec3 v) { return v; }
+          static inline vec4 vec4_from_vec4(vec4 v) { return v; }
+          static inline vec3 vec3_from_vec2_float(vec2 v, float z) { return vec3_new(v.x, v.y, z); }
+          static inline vec3 vec3_from_float_vec2(float x, vec2 v) { return vec3_new(x, v.x, v.y); }
+          static inline vec4 vec4_from_vec3_float(vec3 v, float w) { return vec4_new(v.x, v.y, v.z, w); }
+          static inline vec4 vec4_from_float_vec3(float x, vec3 v) { return vec4_new(x, v.x, v.y, v.z); }
+          static inline vec4 vec4_from_vec2_vec2(vec2 a, vec2 b) { return vec4_new(a.x, a.y, b.x, b.y); }
+          static inline vec4 vec4_from_vec2_float_float(vec2 v, float z, float w) { return vec4_new(v.x, v.y, z, w); }
+          static inline vec4 vec4_from_float_vec2_float(float x, vec2 v, float w) { return vec4_new(x, v.x, v.y, w); }
+          static inline vec4 vec4_from_float_float_vec2(float x, float y, vec2 v) { return vec4_new(x, y, v.x, v.y); }
+
+          static inline float vec2_component(vec2 v, int i) { return i == 0 ? v.x : v.y; }
+          static inline float vec3_component(vec3 v, int i) { return i == 0 ? v.x : (i == 1 ? v.y : v.z); }
+          static inline float vec4_component(vec4 v, int i) {
+            return i == 0 ? v.x : (i == 1 ? v.y : (i == 2 ? v.z : v.w));
+          }
+
+          #define RLSL_DEFINE_SWIZZLES(type) \
+            static inline vec2 type##_swizzle2(type v, int a, int b) { \
+              return vec2_new(type##_component(v, a), type##_component(v, b)); \
+            } \
+            static inline vec3 type##_swizzle3(type v, int a, int b, int c) { \
+              return vec3_new(type##_component(v, a), type##_component(v, b), type##_component(v, c)); \
+            } \
+            static inline vec4 type##_swizzle4(type v, int a, int b, int c, int d) { \
+              return vec4_new(type##_component(v, a), type##_component(v, b), type##_component(v, c), type##_component(v, d)); \
+            }
+          RLSL_DEFINE_SWIZZLES(vec2)
+          RLSL_DEFINE_SWIZZLES(vec3)
+          RLSL_DEFINE_SWIZZLES(vec4)
+          #undef RLSL_DEFINE_SWIZZLES
+
+          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 vec4 vec4_add(vec4 a, vec4 b) { return (vec4){a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w}; }
+
+          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 vec4 vec4_sub(vec4 a, vec4 b) { return (vec4){a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w}; }
+
+          static inline vec2 vec2_add_scalar(vec2 a, float s) { return (vec2){a.x + s, a.y + s}; }
+          static inline vec3 vec3_add_scalar(vec3 a, float s) { return (vec3){a.x + s, a.y + s, a.z + s}; }
+          static inline vec4 vec4_add_scalar(vec4 a, float s) { return (vec4){a.x + s, a.y + s, a.z + s, a.w + s}; }
+          static inline vec2 vec2_scalar_add(float s, vec2 a) { return vec2_add_scalar(a, s); }
+          static inline vec3 vec3_scalar_add(float s, vec3 a) { return vec3_add_scalar(a, s); }
+          static inline vec4 vec4_scalar_add(float s, vec4 a) { return vec4_add_scalar(a, s); }
+
+          static inline vec2 vec2_sub_scalar(vec2 a, float s) { return (vec2){a.x - s, a.y - s}; }
+          static inline vec3 vec3_sub_scalar(vec3 a, float s) { return (vec3){a.x - s, a.y - s, a.z - s}; }
+          static inline vec4 vec4_sub_scalar(vec4 a, float s) { return (vec4){a.x - s, a.y - s, a.z - s, a.w - s}; }
+          static inline vec2 vec2_scalar_sub(float s, vec2 a) { return (vec2){s - a.x, s - a.y}; }
+          static inline vec3 vec3_scalar_sub(float s, vec3 a) { return (vec3){s - a.x, s - a.y, s - a.z}; }
+          static inline vec4 vec4_scalar_sub(float s, vec4 a) { return (vec4){s - a.x, s - a.y, s - a.z, s - a.w}; }
+
+          static inline vec2 vec2_mul_scalar(vec2 a, float s) { return (vec2){a.x * s, a.y * s}; }
+          static inline vec3 vec3_mul_scalar(vec3 a, float s) { return (vec3){a.x * s, a.y * s, a.z * s}; }
+          static inline vec4 vec4_mul_scalar(vec4 a, float s) { return (vec4){a.x * s, a.y * s, a.z * s, a.w * s}; }
+          static inline vec2 vec2_scalar_mul(float s, vec2 a) { return vec2_mul_scalar(a, s); }
+          static inline vec3 vec3_scalar_mul(float s, vec3 a) { return vec3_mul_scalar(a, s); }
+          static inline vec4 vec4_scalar_mul(float s, vec4 a) { return vec4_mul_scalar(a, s); }
+          static inline vec2 vec2_mul_components(vec2 a, vec2 b) { return (vec2){a.x * b.x, a.y * b.y}; }
+          static inline vec3 vec3_mul_components(vec3 a, vec3 b) { return (vec3){a.x * b.x, a.y * b.y, a.z * b.z}; }
+          static inline vec4 vec4_mul_components(vec4 a, vec4 b) { return (vec4){a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w}; }
+
+          static inline vec2 vec2_div_scalar(vec2 a, float s) { return (vec2){a.x / s, a.y / s}; }
+          static inline vec3 vec3_div_scalar(vec3 a, float s) { return (vec3){a.x / s, a.y / s, a.z / s}; }
+          static inline vec4 vec4_div_scalar(vec4 a, float s) { return (vec4){a.x / s, a.y / s, a.z / s, a.w / s}; }
+          static inline vec2 vec2_scalar_div(float s, vec2 a) { return (vec2){s / a.x, s / a.y}; }
+          static inline vec3 vec3_scalar_div(float s, vec3 a) { return (vec3){s / a.x, s / a.y, s / a.z}; }
+          static inline vec4 vec4_scalar_div(float s, vec4 a) { return (vec4){s / a.x, s / a.y, s / a.z, s / a.w}; }
+          static inline vec2 vec2_div_components(vec2 a, vec2 b) { return (vec2){a.x / b.x, a.y / b.y}; }
+          static inline vec3 vec3_div_components(vec3 a, vec3 b) { return (vec3){a.x / b.x, a.y / b.y, a.z / b.z}; }
+          static inline vec4 vec4_div_components(vec4 a, vec4 b) { return (vec4){a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w}; }
+
+          /* Legacy names used by raw C fragments. */
+          static inline vec2 vec2_mul(vec2 a, float s) { return vec2_mul_scalar(a, s); }
+          static inline vec3 vec3_mul(vec3 a, float s) { return vec3_mul_scalar(a, s); }
+          static inline vec2 vec2_div(vec2 a, float s) { return vec2_div_scalar(a, s); }
+          static inline vec3 vec3_div(vec3 a, float s) { return vec3_div_scalar(a, 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 vec4_dot(vec4 a, vec4 b) { return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; }
+
+          static inline vec3 vec3_cross(vec3 a, vec3 b) {
+            return vec3_new(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+          }
+
+          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 float vec4_length(vec4 v) { return sqrtf(vec4_dot(v, v)); }
+
+          static inline float vec2_distance(vec2 a, vec2 b) { return vec2_length(vec2_sub(a, b)); }
+          static inline float vec3_distance(vec3 a, vec3 b) { return vec3_length(vec3_sub(a, b)); }
+          static inline float vec4_distance(vec4 a, vec4 b) { return vec4_length(vec4_sub(a, b)); }
+
+          static inline vec2 vec2_normalize(vec2 v) { float l = vec2_length(v); return l > 0 ? vec2_div_scalar(v, l) : v; }
+          static inline vec3 vec3_normalize(vec3 v) { float l = vec3_length(v); return l > 0 ? vec3_div_scalar(v, l) : v; }
+          static inline vec4 vec4_normalize(vec4 v) { float l = vec4_length(v); return l > 0 ? vec4_div_scalar(v, l) : v; }
+
+          static inline float fract(float x) { return x - floorf(x); }
+          static inline float rlsl_mod(float x, float y) { return x - y * floorf(x / y); }
+          static inline float sign_f(float x) { return (x > 0.0f) - (x < 0.0f); }
+          static inline float step_f(float edge, float x) { return x < edge ? 0.0f : 1.0f; }
+          static inline float mix_f(float a, float b, float t) { return a + (b - a) * t; }
+          static inline vec2 mix_v2(vec2 a, vec2 b, float t) {
+            return (vec2){a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * 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 vec4 mix_v4(vec4 a, vec4 b, float t) {
+            return (vec4){a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * 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 x = sinf(vec2_dot(p, vec2_new(127.1f, 311.7f)));
+            float y = sinf(vec2_dot(p, vec2_new(269.5f, 183.3f)));
+            return vec2_new(fract(x * 43758.5453f), fract(y * 43758.5453f));
+          }
+
+          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);
+          }
+
+          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);
+            }
+
+            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
+    end
+  end
+end

data/lib/rlsl/code_generator/ruby_wrapper_generator.rb

@@ -0,0 +1,137 @@
+# 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);
+              size_t idx = ((size_t)y * (size_t)width + (size_t)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;
+            }
+          }
+
+          typedef struct {
+            uint8_t *pixels;
+            int width;
+            int height;
+            vec2 resolution;
+            Uniforms uniforms;
+          } render_arguments;
+
+          static void *render_without_gvl(void *opaque) {
+            render_arguments *arguments = (render_arguments *)opaque;
+
+            #ifdef __APPLE__
+            dispatch_apply(arguments->height, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t y) {
+              render_scanline(arguments->pixels, arguments->width, arguments->height, (int)y,
+                              arguments->resolution, arguments->uniforms);
+            });
+            #else
+            for (int y = 0; y < arguments->height; y++) {
+              render_scanline(arguments->pixels, arguments->width, arguments->height, y,
+                              arguments->resolution, arguments->uniforms);
+            }
+            #endif
+
+            return NULL;
+          }
+
+          static VALUE shader_#{@context.name}_render(VALUE self, VALUE rb_buffer, VALUE rb_width, VALUE rb_height#{@context.uniform_argument_list}) {
+            long long requested_width = NUM2LL(rb_width);
+            long long requested_height = NUM2LL(rb_height);
+            if (requested_width <= 0 || requested_width > INT_MAX ||
+                requested_height <= 0 || requested_height > INT_MAX) {
+              rb_raise(rb_eArgError, "width and height must be positive integers no greater than INT_MAX");
+            }
+
+            size_t width_size = (size_t)requested_width;
+            size_t height_size = (size_t)requested_height;
+            if (height_size > SIZE_MAX / width_size || width_size * height_size > SIZE_MAX / 4) {
+              rb_raise(rb_eRangeError, "render dimensions overflow the output buffer size");
+            }
+
+            size_t required_bytes = width_size * height_size * 4;
+            int width = (int)requested_width;
+            int height = (int)requested_height;
+            vec2 resolution = vec2_new((float)width, (float)height);
+
+            Uniforms uniforms;
+            #{uniform_assignments}
+
+            Check_Type(rb_buffer, T_STRING);
+            rb_str_modify(rb_buffer);
+            if ((size_t)RSTRING_LEN(rb_buffer) < required_bytes) {
+              rb_raise(rb_eArgError, "pixel buffer is too small: need %zu bytes, got %ld",
+                       required_bytes, RSTRING_LEN(rb_buffer));
+            }
+            uint8_t *pixels = (uint8_t *)RSTRING_PTR(rb_buffer);
+
+            render_arguments arguments = {pixels, width, height, resolution, uniforms};
+            rb_thread_call_without_gvl(render_without_gvl, &arguments, RUBY_UBF_IO, NULL);
+
+            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);
+          if (RARRAY_LEN(rb_#{uniform_name}) != #{vector_size}) {
+            rb_raise(rb_eArgError, "uniform #{uniform_name} must contain exactly #{vector_size} components");
+          }
+          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,44 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    class TemplateContext
+      attr_reader :name, :extension_name
+
+      def initialize(name:, uniforms:, helpers_block:, fragment_block:, extension_name: name)
+        @name = RLSL.validate_shader_name!(name)
+        @extension_name = RLSL.validate_identifier!(extension_name, context: "extension 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
+        return "" unless @fragment_block
+
+        @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