rlsl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 020a239d452eb3a27b9a40105c7c24286af2fbf4d827e2e934575008ba51c495
+  data.tar.gz: fa2f50452cfdf52213e63058a0f91ae0aac4fe94650fc091c571895e897d5d35
+SHA512:
+  metadata.gz: c2014e38c0e9f741104653c4196559f58402dc02c12ab5ac6f622f9c080b951a623b511eae7749538bbb0e601ca784c8e9f27834cb196fd20a51d62c16321e85
+  data.tar.gz: 1b4a13bd1b2bb87a6cbe2d2d0be5c72840b3f5c43dce88ec4a5b3cfa529c0ad2ea1fb71c5a1b3b747e430f91be12b8817cc22cc380e028e1847057bdb785db8e

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.0 - 2026-01-04
+
+- Initial release.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,170 @@
+# RLSL
+
+Ruby Like Shading Language - A Ruby DSL for writing shaders that transpile to multiple GPU shader languages.
+
+## Features
+
+- Write shaders using Ruby syntax
+- Transpile to multiple targets:
+  - GLSL (OpenGL Shading Language)
+  - WGSL (WebGPU Shading Language)
+  - MSL (Metal Shading Language)
+  - C (for CPU-based rendering)
+- Type inference for shader variables
+- Support for common shader operations (vec2, vec3, vec4, etc.)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rlsl'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install rlsl
+```
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'rlsl'
+
+# Generate GLSL shader
+glsl_code = RLSL.to_glsl(:my_shader) do
+  uniforms do
+    float :time
+  end
+
+  fragment do |frag_coord, resolution, u|
+    # Normalize coordinates
+    uv = frag_coord / resolution
+
+    # Create color based on position and time
+    r = sin(u.time + uv.x * 6.28) * 0.5 + 0.5
+    g = sin(u.time + uv.y * 6.28) * 0.5 + 0.5
+    b = sin(u.time) * 0.5 + 0.5
+
+    vec3(r, g, b)
+  end
+end
+
+puts glsl_code
+```
+
+### Generate WGSL (WebGPU)
+
+```ruby
+wgsl_code = RLSL.to_wgsl(:my_shader) do
+  uniforms do
+    float :time
+    vec2 :mouse
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = frag_coord / resolution.y
+    color = vec3(uv.x, uv.y, sin(u.time) * 0.5 + 0.5)
+    color
+  end
+end
+```
+
+### Generate MSL (Metal)
+
+```ruby
+metal_shader = RLSL.define_metal(:my_shader) do
+  uniforms do
+    float :time
+  end
+
+  fragment do |frag_coord, resolution, u|
+    vec3(1.0, 0.0, 0.0)
+  end
+end
+```
+
+### Using Helper Functions
+
+```ruby
+RLSL.to_glsl(:complex_shader) do
+  uniforms do
+    float :time
+  end
+
+  functions do
+    float :noise
+    vec3 :get_color
+  end
+
+  helpers(:ruby) do
+    def noise(p)
+      sin(p.x * 12.9898 + p.y * 78.233) * 43758.5453
+    end
+
+    def get_color(uv, t)
+      vec3(uv.x, uv.y, sin(t) * 0.5 + 0.5)
+    end
+  end
+
+  fragment do |frag_coord, resolution, u|
+    uv = frag_coord / resolution
+    get_color(uv, u.time)
+  end
+end
+```
+
+## Supported Types
+
+- `bool` - Boolean (conditional logic)
+- `int` - Integer (loop counters, array indices)
+- `float` - Scalar floating point
+- `vec2` - 2D vector
+- `vec3` - 3D vector
+- `vec4` - 4D vector
+- `mat4` - 4x4 matrix (MVP transformations)
+- `mat3` - 3x3 matrix (normal transformations)
+- `mat2` - 2x2 matrix (2D texture coordinate transformations)
+- `sampler2D` - 2D texture sampler
+
+## Built-in Functions
+
+RLSL supports common shader functions:
+
+- Math: `sin`, `cos`, `tan`, `sqrt`, `pow`, `exp`, `log`, `abs`, `floor`, `ceil`
+- Vector: `normalize`, `length`, `dot`, `cross`, `reflect`, `refract`
+- Interpolation: `mix`, `clamp`, `smoothstep`
+- Other: `fract`, `min`, `max`
+
+## Constants
+
+- `PI` - 3.14159265358979323846
+- `TAU` - 6.28318530717958647692
+
+## Requirements
+
+- Ruby >= 3.1.0
+- [Prism](https://github.com/ruby/prism) gem (for Ruby parsing)
+- [metaco](https://github.com/ydah/metaco) gem (for Metal shader execution)
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+```bash
+$ bundle install
+$ rake test
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/rlsl/base_translator.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RLSL
+  class BaseTranslator
+    FUNC_REPLACEMENTS = [].freeze
+
+    TYPE_MAP = {}.freeze
+
+    def initialize(uniforms, helpers_code, fragment_code)
+      @uniforms = uniforms
+      @helpers_code = helpers_code || ""
+      @fragment_code = fragment_code || ""
+    end
+
+    def translate
+      helpers_translated = translate_code(@helpers_code)
+      fragment_translated = translate_code(@fragment_code)
+      generate_shader(helpers_translated, fragment_translated)
+    end
+
+    protected
+
+    def translate_code(c_code)
+      return "" if c_code.nil? || c_code.empty?
+
+      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
+    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 :vec2 then target_vec2_type
+      when :vec3 then target_vec3_type
+      when :vec4 then target_vec4_type
+      end
+    end
+
+    def target_float_type
+      "float"
+    end
+
+    def target_vec2_type
+      raise NotImplementedError
+    end
+
+    def target_vec3_type
+      raise NotImplementedError
+    end
+
+    def target_vec4_type
+      raise NotImplementedError
+    end
+  end
+end

data/lib/rlsl/code_generator.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    def initialize(name, uniforms, helpers_block, fragment_block)
+      @name = name
+      @uniforms = uniforms
+      @helpers_block = helpers_block
+      @fragment_block = fragment_block
+    end
+
+    def generate
+      <<~C
+        #include <ruby.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}
+
+        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});
+        }
+      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
+    end
+
+    def generate_shader_function
+      shader_body = @fragment_block.call
+
+      <<~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;
+        }
+      C
+    end
+  end
+end

data/lib/rlsl/compiled_shader.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CompiledShader
+    def initialize(name, ext_name, uniform_names)
+      @name = name
+      @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
+      @render_method.call(*args)
+    end
+  end
+end

data/lib/rlsl/function_context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RLSL
+  class FunctionContext
+    attr_reader :functions
+
+    def initialize
+      @functions = {}
+    end
+
+    def float(*names)
+      names.each { |name| @functions[name.to_sym] = { returns: :float } }
+    end
+
+    def vec2(*names)
+      names.each { |name| @functions[name.to_sym] = { returns: :vec2 } }
+    end
+
+    def vec3(*names)
+      names.each { |name| @functions[name.to_sym] = { returns: :vec3 } }
+    end
+
+    def vec4(*names)
+      names.each { |name| @functions[name.to_sym] = { returns: :vec4 } }
+    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 }
+    end
+  end
+end