rlsl 0.1.1 → 1.0.1

data/lib/rlsl/types/value_normalizer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RLSL
+  module UniformTypes
+    module ValueNormalizer
+      def normalize_values(uniform_types, uniforms, shader_name: nil)
+        uniform_types.each_with_object({}) do |(name, type), normalized|
+          unless uniforms.key?(name)
+            raise ArgumentError, missing_uniform_message(name, shader_name)
+          end
+
+          normalized[name] = normalize_value(type, uniforms[name], name: name, shader_name: shader_name)
+        end
+      end
+
+      def normalize_value(type, value, name:, shader_name: nil)
+        return value if type.nil?
+
+        spec = fetch(type)
+        raise UniformValueError, unsupported_runtime_type_message(type, shader_name) unless spec.runtime_supported?
+
+        case spec.wrapper_kind
+        when :float
+          Float(value)
+        when :int
+          normalize_int(value, name: name, shader_name: shader_name)
+        when :bool
+          normalize_bool(value, name: name, shader_name: shader_name)
+        when :vector
+          normalize_vector(value, spec.vector_size, name: name, shader_name: shader_name)
+        else
+          raise UniformValueError, unsupported_runtime_type_message(type, shader_name)
+        end
+      rescue UniformValueError
+        raise
+      rescue TypeError, ArgumentError, RangeError
+        raise UniformValueError, invalid_uniform_message(name, type, value, shader_name)
+      end
+
+      def normalize_bool(value, name:, shader_name: nil)
+        return value if value == true || value == false
+        return false if value == 0
+        return true if value == 1
+
+        raise UniformValueError, invalid_uniform_message(name, :bool, value, shader_name)
+      end
+
+      def normalize_int(value, name:, shader_name: nil)
+        integer = Integer(value)
+        return integer if (-2**31...2**31).cover?(integer)
+
+        raise UniformValueError, invalid_uniform_message(name, :int, value, shader_name)
+      end
+
+      def normalize_vector(value, vector_size, name:, shader_name: nil)
+        unless value.is_a?(Array) && value.length == vector_size
+          raise UniformValueError, invalid_vector_message(name, vector_size, value, shader_name)
+        end
+
+        value.map { |component| Float(component) }
+      end
+
+      private
+
+      def missing_uniform_message(name, shader_name)
+        "Missing uniform #{name.inspect}#{shader_suffix(shader_name)}"
+      end
+
+      def invalid_uniform_message(name, type, value, shader_name)
+        "Invalid value for uniform #{name.inspect}#{shader_suffix(shader_name)}: expected #{type}, got #{value.inspect}"
+      end
+
+      def invalid_vector_message(name, vector_size, value, shader_name)
+        "Invalid value for uniform #{name.inspect}#{shader_suffix(shader_name)}: expected vec#{vector_size}, got #{value.inspect}"
+      end
+
+      def unsupported_runtime_type_message(type, shader_name)
+        "Unsupported runtime uniform type #{type.inspect}#{shader_suffix(shader_name)}"
+      end
+
+      def shader_suffix(shader_name)
+        shader_name ? " in #{shader_name}" : ""
+      end
+    end
+  end
+end

data/lib/rlsl/types.rb

@@ -1,36 +1,14 @@
 # frozen_string_literal: true
 
-module RLSL
-  # C type definitions for the shader system
-  C_TYPES = <<~C
-    typedef struct { float x, y; } vec2;
-    typedef struct { float x, y, z; } vec3;
-    typedef struct { float x, y, z, w; } vec4;
-    typedef struct { float m[4]; } mat2;
-    typedef struct { float m[9]; } mat3;
-    typedef struct { float m[16]; } mat4;
-    typedef struct { void* data; int width; int height; } sampler2D;
-
-    #define PI 3.14159265f
-    #define TAU 6.28318530f
-  C
+require_relative "types/type_spec"
+require_relative "types/catalog"
+require_relative "types/target_resolver"
+require_relative "types/value_normalizer"
 
-  # Uniform type symbols
-  UNIFORM_TYPES = %i[float vec2 vec3 vec4 int bool mat2 mat3 mat4 sampler2D].freeze
-
-  # Type mapping helper
-  module TypeMapping
-    C_UNIFORM_TYPES = {
-      float: "float",
-      int: "int",
-      bool: "int",
-      vec2: "vec2",
-      vec3: "vec3",
-      vec4: "vec4",
-      mat2: "mat2",
-      mat3: "mat3",
-      mat4: "mat4",
-      sampler2D: "sampler2D"
-    }.freeze
+module RLSL
+  module UniformTypes
+    extend Catalog
+    extend TargetResolver
+    extend ValueNormalizer
   end
 end

data/lib/rlsl/uniform_context.rb

@@ -3,26 +3,37 @@
 module RLSL
   # DSL context for defining uniform variables
   class UniformContext
+    RESERVED_NAMES = %i[resolution u frag_coord].freeze
+
     attr_reader :uniforms
 
     def initialize
       @uniforms = {}
     end
 
-    def float(name)
-      @uniforms[name] = :float
-    end
-
-    def vec2(name)
-      @uniforms[name] = :vec2
-    end
+    def define_uniform(name, type)
+      normalized_name = RLSL.validate_identifier!(name, context: "uniform name").to_sym
+      if RESERVED_NAMES.include?(normalized_name)
+        raise ArgumentError, "Uniform name #{normalized_name.inspect} is reserved by RLSL"
+      end
+      if @uniforms.key?(normalized_name)
+        raise ArgumentError, "Uniform #{normalized_name.inspect} is already defined"
+      end
+      generated_sampler_names = @uniforms.filter_map do |uniform_name, uniform_type|
+        :"#{uniform_name}_sampler" if uniform_type == :sampler2D
+      end
+      if generated_sampler_names.include?(normalized_name) ||
+         (type == :sampler2D && @uniforms.key?(:"#{normalized_name}_sampler"))
+        raise ArgumentError, "Uniform #{normalized_name.inspect} conflicts with a generated sampler name"
+      end
 
-    def vec3(name)
-      @uniforms[name] = :vec3
+      @uniforms[normalized_name] = type
     end
 
-    def vec4(name)
-      @uniforms[name] = :vec4
+    RLSL::UNIFORM_TYPES.each do |type|
+      define_method(type) do |name|
+        define_uniform(name, type)
+      end
     end
   end
 end

data/lib/rlsl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RLSL
-  VERSION = "0.1.1"
+  VERSION = "1.0.1"
 end

data/lib/rlsl/wgsl/translator.rb

@@ -3,46 +3,53 @@
 module RLSL
   module WGSL
     class Translator < BaseTranslator
-      TYPE_MAP = {
-        "vec2" => "vec2<f32>",
-        "vec3" => "vec3<f32>",
-        "vec4" => "vec4<f32>"
-      }.freeze
-
-      FUNC_REPLACEMENTS = BaseTranslator.common_func_replacements(
-        target_vec2: "vec2<f32>",
-        target_vec3: "vec3<f32>",
-        target_vec4: "vec4<f32>"
-      ).freeze
+      PROFILE = BaseTranslator.build_profile(
+        uniform_target: :wgsl,
+        identifier_replacements: {
+          "float" => "f32",
+          "int" => "i32",
+          "vec2" => "vec2<f32>",
+          "vec3" => "vec3<f32>",
+          "vec4" => "vec4<f32>"
+        },
+        call_rewrites: BaseTranslator.common_call_rewrites(
+          target_vec2: "vec2<f32>",
+          target_vec3: "vec3<f32>",
+          target_vec4: "vec4<f32>"
+        ).merge("fmodf" => BaseTranslator.infix_call("%"))
+      )
 
       protected
 
-      def translate_code(c_code)
-        result = super(c_code)
-        return result if result.empty?
+      def validate_source_format!(source)
+        return if source.target_code?
 
-        result.gsub!(/\bstatic\s+/, "")
-        result.gsub!(/\binline\s+/, "")
-        result.gsub!(/\bfloat\b/, "f32")
-        result
+        raise RLSL::TranslationError,
+              "WGSL generation only supports Ruby shader source; legacy C source cannot be translated to WGSL"
       end
 
       def generate_shader(helpers, fragment)
         <<~WGSL
-          // WGSL Shader generated by RLSL
+          #{generated_by_comment("WGSL")}
 
           struct Uniforms {
               #{generate_uniform_struct}
-          };
+          }
 
           @group(0) @binding(0) var<uniform> u: Uniforms;
           @group(0) @binding(1) var output_texture: texture_storage_2d<rgba8unorm, write>;
+          #{generate_texture_declarations}
+
+          fn rlsl_mod(x: f32, y: f32) -> f32 {
+              return x - y * floor(x / y);
+          }
 
           #{helpers}
 
-          fn shader_fragment(frag_coord: vec2<f32>, resolution: vec2<f32>) -> vec3<f32> {
-              let uv = frag_coord / resolution.y;
-              #{fragment}
+          fn shader_fragment(_rlsl_frag_coord: vec2<f32>, _rlsl_resolution: vec2<f32>) -> vec3<f32> {
+              var frag_coord = _rlsl_frag_coord;
+              var resolution = _rlsl_resolution;
+          #{indent_source(fragment, 4)}
           }
 
           @compute @workgroup_size(8, 8)
@@ -64,29 +71,29 @@ module RLSL
 
       private
 
-      def generate_uniform_struct
-        fields = ["resolution: vec2<f32>,"]
-        @uniforms.each do |name, type|
-          wgsl_type = uniform_type_to_target(type)
-          fields << "#{name}: #{wgsl_type},"
-        end
-        fields.join("\n    ")
+      def profile
+        PROFILE
       end
 
       def target_float_type
-        "f32"
+        UniformTypes.target_type(:float, uniform_target)
       end
 
-      def target_vec2_type
-        "vec2<f32>"
-      end
-
-      def target_vec3_type
-        "vec3<f32>"
+      def generate_uniform_struct
+        fields = uniform_lines(resolution_line: "resolution: #{target_vec2_type},") do |name, wgsl_type|
+          "#{name}: #{wgsl_type},"
+        end
+        fields.join("\n    ")
       end
 
-      def target_vec4_type
-        "vec4<f32>"
+      def generate_texture_declarations
+        texture_uniforms.each_with_index.flat_map do |(name, _type), index|
+          binding = 2 + index * 2
+          [
+            "@group(0) @binding(#{binding}) var #{name}: texture_2d<f32>;",
+            "@group(0) @binding(#{binding + 1}) var #{name}_sampler: sampler;"
+          ]
+        end.join("\n")
       end
     end
   end

data/lib/rlsl/wgsl/uniform_layout.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RLSL
+  module WGSL
+    module UniformLayout
+      TYPE_INFO = {
+        float: [4, 4], int: [4, 4], bool: [4, 4],
+        vec2: [8, 8], vec3: [12, 16], vec4: [16, 16]
+      }.freeze
+      module_function
+
+      def build(fields)
+        offset = 0
+        result = {}
+        fields.each do |name, type|
+          size, alignment = TYPE_INFO.fetch(type.to_sym) { raise ArgumentError, "unsupported WGSL uniform type: #{type}" }
+          offset = (offset + alignment - 1) / alignment * alignment
+          result[name.to_sym] = { offset: offset, type: type.to_sym }
+          offset += size
+        end
+        { fields: result, size: (offset + 15) / 16 * 16 }
+      end
+    end
+  end
+end

data/lib/rlsl.rb

@@ -1,55 +1,78 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "tmpdir"
 
 require_relative "rlsl/version"
+require_relative "rlsl/errors"
+require_relative "rlsl/shader_name"
 require_relative "rlsl/types"
 require_relative "rlsl/uniform_context"
 require_relative "rlsl/function_context"
 require_relative "rlsl/code_generator"
+require_relative "rlsl/runtime_shader"
 require_relative "rlsl/compiled_shader"
 require_relative "rlsl/base_translator"
 require_relative "rlsl/msl/translator"
+require_relative "rlsl/msl/uniform_buffer_packer"
 require_relative "rlsl/msl/shader"
 require_relative "rlsl/wgsl/translator"
+require_relative "rlsl/wgsl/uniform_layout"
 require_relative "rlsl/glsl/translator"
 require_relative "rlsl/prism/transpiler"
 require_relative "rlsl/shader_builder"
 
 module RLSL
-  CACHE_DIR = File.expand_path("~/.cache/rlsl/compiled")
+  CACHE_DIR = File.join("rlsl", "compiled").freeze
 
   class << self
     def define(name, &block)
-      builder = ShaderBuilder.new(name)
-      builder.instance_eval(&block)
-      builder.compile_and_load
+      build_shader(name, &block).compile_and_load
     end
 
     def define_metal(name, &block)
-      builder = ShaderBuilder.new(name)
-      builder.instance_eval(&block)
-      builder.build_metal_shader
+      build_shader(name, &block).build_metal_shader
+    end
+
+    def to_msl(name, &block)
+      define_metal(name, &block).msl_source
     end
 
     def to_wgsl(name, &block)
-      builder = ShaderBuilder.new(name)
-      builder.instance_eval(&block)
-      builder.build_wgsl_shader
+      build_shader(name, &block).build_wgsl_shader
     end
 
     def to_glsl(name, version: "450", &block)
-      builder = ShaderBuilder.new(name)
-      builder.instance_eval(&block)
-      builder.build_glsl_shader(version: version)
+      build_shader(name, &block).build_glsl_shader(version: version)
     end
 
     def cache_dir
       @cache_dir ||= begin
-        FileUtils.mkdir_p(CACHE_DIR)
-        CACHE_DIR
+        path = File.join(cache_root, CACHE_DIR)
+        FileUtils.mkdir_p(path)
+        path
       end
     end
+
+    private
+
+    def cache_root
+      xdg_cache_home = ENV["XDG_CACHE_HOME"]
+      return xdg_cache_home unless xdg_cache_home.to_s.empty?
+
+      home = Dir.home
+      return File.join(home, ".cache") unless home.to_s.empty?
+
+      Dir.tmpdir
+    rescue ArgumentError
+      Dir.tmpdir
+    end
+
+    def build_shader(name, &block)
+      builder = ShaderBuilder.new(name)
+      builder.instance_eval(&block)
+      builder
+    end
   end
 
   module CompiledShaders

metadata

@@ -1,28 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rlsl
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.1
 platform: ruby
 authors:
 - Yudai Takada
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 description: RLSL is a Ruby DSL for writing shaders that can be transpiled to GLSL,
   WGSL, and MSL
 email:
@@ -31,41 +32,104 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rubocop.yml"
 - CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
 - lib/rlsl.rb
 - lib/rlsl/base_translator.rb
+- lib/rlsl/base_translator/call_parser.rb
+- lib/rlsl/base_translator/code_rewriter.rb
+- lib/rlsl/base_translator/code_scanner.rb
 - lib/rlsl/code_generator.rb
+- lib/rlsl/code_generator/math_prelude.rb
+- lib/rlsl/code_generator/ruby_wrapper_generator.rb
+- lib/rlsl/code_generator/shader_function_generator.rb
+- lib/rlsl/code_generator/template_context.rb
+- lib/rlsl/code_generator/uniform_struct_generator.rb
 - lib/rlsl/compiled_shader.rb
+- lib/rlsl/errors.rb
 - lib/rlsl/function_context.rb
 - lib/rlsl/glsl/translator.rb
 - lib/rlsl/msl/shader.rb
 - lib/rlsl/msl/translator.rb
+- lib/rlsl/msl/uniform_buffer_packer.rb
 - lib/rlsl/prism/ast_visitor.rb
+- lib/rlsl/prism/ast_visitor/control_flow_visiting.rb
+- lib/rlsl/prism/ast_visitor/definition_visiting.rb
+- lib/rlsl/prism/ast_visitor/expression_visiting.rb
+- lib/rlsl/prism/ast_visitor/scope_context.rb
+- lib/rlsl/prism/ast_visitor/visitor_registry.rb
 - lib/rlsl/prism/builtins.rb
+- lib/rlsl/prism/builtins/function_registry.rb
+- lib/rlsl/prism/builtins/operator_rules.rb
+- lib/rlsl/prism/builtins/swizzle_rules.rb
+- lib/rlsl/prism/compilation_unit.rb
 - lib/rlsl/prism/emitters/base_emitter.rb
+- lib/rlsl/prism/emitters/base_emitter/control_flow_emission.rb
+- lib/rlsl/prism/emitters/base_emitter/definition_emission.rb
+- lib/rlsl/prism/emitters/base_emitter/expression_emission.rb
+- lib/rlsl/prism/emitters/base_emitter/statement_emission.rb
 - lib/rlsl/prism/emitters/c_emitter.rb
 - lib/rlsl/prism/emitters/glsl_emitter.rb
 - lib/rlsl/prism/emitters/msl_emitter.rb
+- lib/rlsl/prism/emitters/target_emitter.rb
+- lib/rlsl/prism/emitters/target_profile.rb
 - lib/rlsl/prism/emitters/wgsl_emitter.rb
+- lib/rlsl/prism/errors.rb
+- lib/rlsl/prism/ir/control_flow.rb
+- lib/rlsl/prism/ir/definitions.rb
+- lib/rlsl/prism/ir/expressions.rb
+- lib/rlsl/prism/ir/node.rb
 - lib/rlsl/prism/ir/nodes.rb
+- lib/rlsl/prism/ir/traversal.rb
+- lib/rlsl/prism/mutation_analyzer.rb
+- lib/rlsl/prism/node_traversal.rb
+- lib/rlsl/prism/parameter_list.rb
+- lib/rlsl/prism/return_flow_validator.rb
 - lib/rlsl/prism/source_extractor.rb
+- lib/rlsl/prism/source_extractor/block_locator.rb
+- lib/rlsl/prism/source_unit.rb
+- lib/rlsl/prism/source_unit/parser.rb
+- lib/rlsl/prism/target_capability_validator.rb
 - lib/rlsl/prism/transpiler.rb
 - lib/rlsl/prism/type_inference.rb
+- lib/rlsl/prism/type_inference/call_type_resolver.rb
+- lib/rlsl/prism/type_inference/call_validator.rb
+- lib/rlsl/prism/type_inference/collection_type_resolver.rb
+- lib/rlsl/prism/type_inference/control_flow_inferer.rb
+- lib/rlsl/prism/type_inference/definition_inferer.rb
+- lib/rlsl/prism/type_inference/expression_inferer.rb
+- lib/rlsl/prism/type_inference/field_type_resolver.rb
+- lib/rlsl/prism/type_inference/inferer_registry.rb
+- lib/rlsl/prism/type_inference/scope_stack.rb
+- lib/rlsl/prism/type_inference/type_environment.rb
+- lib/rlsl/prism/type_inference/type_shapes.rb
+- lib/rlsl/runtime_shader.rb
 - lib/rlsl/shader_builder.rb
+- lib/rlsl/shader_builder/build_service.rb
+- lib/rlsl/shader_builder/native_extension_compiler.rb
+- lib/rlsl/shader_builder/shader_definition.rb
+- lib/rlsl/shader_builder/source_resolver.rb
+- lib/rlsl/shader_name.rb
 - lib/rlsl/types.rb
+- lib/rlsl/types/catalog.rb
+- lib/rlsl/types/target_resolver.rb
+- lib/rlsl/types/type_spec.rb
+- lib/rlsl/types/value_normalizer.rb
 - lib/rlsl/uniform_context.rb
 - lib/rlsl/version.rb
 - lib/rlsl/wgsl/translator.rb
-homepage: https://github.com/ydah/rlsl
+- lib/rlsl/wgsl/uniform_layout.rb
+homepage: https://rbgfx.github.io/rlsl/
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/ydah/rlsl
-  source_code_uri: https://github.com/ydah/rlsl
-  changelog_uri: https://github.com/ydah/rlsl/blob/main/CHANGELOG.md
+  homepage_uri: https://rbgfx.github.io/rlsl/
+  source_code_uri: https://github.com/rbgfx/rlsl
+  changelog_uri: https://github.com/rbgfx/rlsl/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -80,7 +144,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Ruby Like Shading Language - A shader DSL for Ruby
 test_files: []