rlsl 0.1.1 → 1.0.0

data/lib/rlsl/shader_builder/source_resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RLSL
+  class ShaderBuilder
+    class SourceResolver
+      def initialize(definition, transpiler_class: Prism::Transpiler)
+        @definition = definition
+        @transpiler_class = transpiler_class
+      end
+
+      def sources_for(target)
+        [helpers_code(target), fragment_code(target)]
+      end
+
+      def translation_sources_for(target)
+        [helpers_source(target), fragment_source(target)]
+      end
+
+      def helpers_code(target)
+        helpers_source(target).code
+      end
+
+      def fragment_code(target)
+        fragment_source(target).code
+      end
+
+      private
+
+      def helpers_source(target)
+        return source_snippet("") unless @definition.helpers_block
+        return source_snippet(@definition.helpers_block.call) unless ruby_helpers?
+
+        source_snippet(
+          helpers_transpiler.transpile_helpers(@definition.helpers_block, target, @definition.custom_functions),
+          format: :target
+        )
+      end
+
+      def fragment_source(target)
+        return source_snippet("") unless @definition.fragment_block
+        return source_snippet(@definition.fragment_block.call) unless ruby_fragment?
+
+        source_snippet(fragment_transpiler.transpile(@definition.fragment_block, target), format: :target)
+      end
+
+      def source_snippet(code, format: :legacy)
+        BaseTranslator::SourceSnippet.new(code: code.to_s, format: format)
+      end
+
+      def helpers_transpiler
+        @helpers_transpiler ||= build_transpiler
+      end
+
+      def fragment_transpiler
+        @fragment_transpiler ||= build_transpiler(globals: helper_globals)
+      end
+
+      def build_transpiler(globals: {})
+        @transpiler_class.new(@definition.uniforms, @definition.custom_functions, globals: globals)
+      end
+
+      def helper_globals
+        return {} unless ruby_helpers? && @definition.helpers_block
+
+        @helper_globals ||= begin
+          compilation = helpers_transpiler.compile_helpers(@definition.helpers_block, @definition.custom_functions)
+          extract_global_types(compilation.ir)
+        end
+      end
+
+      def extract_global_types(ir)
+        return {} unless ir.is_a?(Prism::IR::Block)
+
+        ir.statements.each_with_object({}) do |statement, globals|
+          next unless statement.is_a?(Prism::IR::GlobalDecl)
+          next unless statement.type
+
+          globals[statement.name] = statement.type
+        end
+      end
+
+      def ruby_helpers?
+        @definition.ruby_helpers?
+      end
+
+      def ruby_fragment?
+        @definition.ruby_fragment?
+      end
+    end
+  end
+end

data/lib/rlsl/shader_builder.rb

@@ -1,165 +1,74 @@
 # frozen_string_literal: true
 
-require "fileutils"
-require "digest"
-require "rbconfig"
+require_relative "shader_builder/shader_definition"
+require_relative "shader_builder/build_service"
+require_relative "shader_builder/source_resolver"
+require_relative "shader_builder/native_extension_compiler"
 
 module RLSL
   class ShaderBuilder
     attr_reader :name
 
-    def initialize(name)
+    def initialize(name, definition = ShaderDefinition.new)
       @name = name.to_s
-      @uniforms = {}
-      @fragment_mode = :c
-      @helpers_mode = :c
-      @custom_functions = {}
+      @definition = definition
     end
 
     def uniforms(&block)
       if block_given?
         ctx = UniformContext.new
         ctx.instance_eval(&block)
-        @uniforms = ctx.uniforms
+        @definition = @definition.with_uniforms(ctx.uniforms)
       else
-        @uniforms
+        @definition.uniforms
       end
     end
 
     def helpers(mode = :ruby, &block)
-      @helpers_block = block
-      @helpers_mode = mode
+      @definition = @definition.with_helpers(mode: mode, block: block)
     end
 
     def functions(&block)
       ctx = FunctionContext.new
       ctx.instance_eval(&block)
-      @custom_functions = ctx.functions
+      @definition = @definition.with_custom_functions(ctx.functions)
     end
 
     def fragment(&block)
-      @fragment_block = block
-      @fragment_mode = block.arity > 0 ? :ruby : :c
-    end
-
-    def ruby_mode?
-      @fragment_mode == :ruby
+      @definition = @definition.with_fragment(
+        mode: block.arity > 0 ? :ruby : :c,
+        block: block
+      )
     end
 
     def compile_and_load
-      c_code = generate_c_code
-      code_hash = Digest::MD5.hexdigest(c_code)[0..7]
-      ext_name = "#{@name}_#{code_hash}"
-      ext_dir = File.join(RLSL.cache_dir, ext_name)
-      ext_file = File.join(ext_dir, "#{@name}.#{RbConfig::CONFIG['DLEXT']}")
-
-      unless File.exist?(ext_file)
-        compile_extension(@name, ext_dir, c_code)
-      end
-
-      require ext_file
-      CompiledShader.new(@name, ext_name, @uniforms.keys)
+      build_service.compile_and_load
     end
 
     def build_metal_shader
-      if ruby_mode?
-        fragment_code = transpile_fragment(:msl)
-        helpers_code = @helpers_block ? @helpers_block.call : ""
-      else
-        helpers_code = @helpers_block ? @helpers_block.call : ""
-        fragment_code = @fragment_block ? @fragment_block.call : ""
-      end
-
-      translator = MSL::Translator.new(@uniforms, helpers_code, fragment_code)
-      msl_source = translator.translate
-
-      MSL::Shader.new(@name, @uniforms, msl_source)
+      build_service.build_metal_shader
     end
 
     def build_wgsl_shader
-      if ruby_mode?
-        fragment_code = transpile_fragment(:wgsl)
-        helpers_code = @helpers_block ? @helpers_block.call : ""
-      else
-        helpers_code = @helpers_block ? @helpers_block.call : ""
-        fragment_code = @fragment_block ? @fragment_block.call : ""
-      end
-
-      translator = WGSL::Translator.new(@uniforms, helpers_code, fragment_code)
-      translator.translate
+      build_service.build_wgsl_shader
     end
 
     def build_glsl_shader(version: "450")
-      if ruby_mode?
-        fragment_code = transpile_fragment(:glsl)
-        helpers_code = @helpers_block ? @helpers_block.call : ""
-      else
-        helpers_code = @helpers_block ? @helpers_block.call : ""
-        fragment_code = @fragment_block ? @fragment_block.call : ""
-      end
-
-      translator = GLSL::Translator.new(@uniforms, helpers_code, fragment_code, version: version)
-      translator.translate
+      build_service.build_glsl_shader(version: version)
     end
 
     def transpile_fragment(target)
-      return "" unless @fragment_block
-
-      transpiler = Prism::Transpiler.new(@uniforms, @custom_functions)
-      transpiler.transpile(@fragment_block, target)
+      build_service.transpile_fragment(target)
     end
 
     def transpile_helpers(target)
-      return "" unless @helpers_block
-
-      transpiler = Prism::Transpiler.new(@uniforms, @custom_functions)
-      transpiler.transpile_helpers(@helpers_block, target, @custom_functions)
-    end
-
-    def helpers_ruby_mode?
-      @helpers_mode == :ruby
+      build_service.transpile_helpers(target)
     end
 
     private
 
-    def generate_c_code
-      if helpers_ruby_mode?
-        helpers_code = transpile_helpers(:c)
-        helpers_block = -> { helpers_code }
-      else
-        helpers_block = @helpers_block
-      end
-
-      if ruby_mode?
-        fragment_code = transpile_fragment(:c)
-        fragment_block = -> { fragment_code }
-      else
-        fragment_block = @fragment_block
-      end
-
-      codegen = CodeGenerator.new(@name, @uniforms, helpers_block, fragment_block)
-      codegen.generate
-    end
-
-    def compile_extension(ext_name, ext_dir, c_code)
-      FileUtils.mkdir_p(ext_dir)
-
-      File.write(File.join(ext_dir, "#{ext_name}.c"), c_code)
-
-      extconf = <<~RUBY
-        require "mkmf"
-        $CFLAGS << " -O3 -ffast-math"
-        if RUBY_PLATFORM =~ /darwin/
-          $CFLAGS << " -fblocks"
-        end
-        create_makefile("#{ext_name}")
-      RUBY
-      File.write(File.join(ext_dir, "extconf.rb"), extconf)
-
-      Dir.chdir(ext_dir) do
-        system("#{RbConfig.ruby} extconf.rb > /dev/null 2>&1") or raise "extconf failed for #{ext_name}"
-        system("/usr/bin/make > /dev/null 2>&1") or raise "make failed for #{ext_name}"
-      end
+    def build_service
+      BuildService.new(@name, @definition)
     end
   end
 end

data/lib/rlsl/types/catalog.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RLSL
+  module UniformTypes
+    module Catalog
+      def supported?(type)
+        UNIFORM_TYPE_SPECS.key?(type.to_sym)
+      end
+
+      def fetch(type)
+        UNIFORM_TYPE_SPECS.fetch(type) do
+          raise ArgumentError, "Unsupported uniform type: #{type.inspect}"
+        end
+      end
+
+      def c_type(type)
+        fetch(type).c_type
+      end
+
+      def compiled_types
+        @compiled_types ||= UNIFORM_TYPE_SPECS.select { |_type, spec| spec.compiled? }.keys.freeze
+      end
+
+      def compiled_spec(type)
+        spec = fetch(type)
+        return spec if spec.compiled?
+
+        raise ArgumentError, "Unsupported compiled uniform type: #{type}"
+      end
+
+      def metal_spec(type)
+        spec = fetch(type)
+        return spec if spec.metal_packable?
+
+        raise ArgumentError, "Unsupported Metal uniform type: #{type}"
+      end
+
+      def runtime_types
+        @runtime_types ||= UNIFORM_TYPE_SPECS.select { |_type, spec| spec.runtime_supported? }.keys.freeze
+      end
+
+      def function_shorthand_types
+        @function_shorthand_types ||= UNIFORM_TYPE_SPECS.select { |_type, spec| spec.function_shorthand? }.keys.freeze
+      end
+    end
+  end
+end

data/lib/rlsl/types/target_resolver.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RLSL
+  module UniformTypes
+    module TargetResolver
+      def target_type(type, target)
+        spec = fetch(type)
+        target_type = spec.public_send(:"#{target}_type")
+        return target_type if target_type
+
+        raise ArgumentError, "Unsupported #{target.to_s.upcase} uniform type: #{type}"
+      end
+    end
+  end
+end

data/lib/rlsl/types/type_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RLSL
+  UniformTypeSpec = Struct.new(
+    :c_type,
+    :glsl_type,
+    :wgsl_type,
+    :msl_type,
+    :wrapper_kind,
+    :vector_size,
+    :metal_alignment,
+    :metal_size,
+    :compiled_supported,
+    :runtime_supported,
+    :function_shorthand,
+    keyword_init: true
+  ) do
+    def compiled?
+      compiled_supported
+    end
+
+    def metal_packable?
+      !metal_alignment.nil? && !metal_size.nil?
+    end
+
+    def runtime_supported?
+      runtime_supported
+    end
+
+    def function_shorthand?
+      function_shorthand
+    end
+
+    def target_supported?(target)
+      !public_send(:"#{target}_type").nil?
+    end
+  end
+
+  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
+
+  UNIFORM_TYPE_SPECS = {
+    float: UniformTypeSpec.new(
+      c_type: "float",
+      glsl_type: "float",
+      wgsl_type: "f32",
+      msl_type: "float",
+      wrapper_kind: :float,
+      metal_alignment: 4,
+      metal_size: 4,
+      compiled_supported: true,
+      runtime_supported: true,
+      function_shorthand: true
+    ),
+    vec2: UniformTypeSpec.new(
+      c_type: "vec2",
+      glsl_type: "vec2",
+      wgsl_type: "vec2<f32>",
+      msl_type: "float2",
+      wrapper_kind: :vector,
+      vector_size: 2,
+      metal_alignment: 8,
+      metal_size: 8,
+      compiled_supported: true,
+      runtime_supported: true,
+      function_shorthand: true
+    ),
+    vec3: UniformTypeSpec.new(
+      c_type: "vec3",
+      glsl_type: "vec3",
+      wgsl_type: "vec3<f32>",
+      msl_type: "float3",
+      wrapper_kind: :vector,
+      vector_size: 3,
+      metal_alignment: 16,
+      metal_size: 16,
+      compiled_supported: true,
+      runtime_supported: true,
+      function_shorthand: true
+    ),
+    vec4: UniformTypeSpec.new(
+      c_type: "vec4",
+      glsl_type: "vec4",
+      wgsl_type: "vec4<f32>",
+      msl_type: "float4",
+      wrapper_kind: :vector,
+      vector_size: 4,
+      metal_alignment: 16,
+      metal_size: 16,
+      compiled_supported: true,
+      runtime_supported: true,
+      function_shorthand: true
+    ),
+    int: UniformTypeSpec.new(
+      c_type: "int",
+      glsl_type: "int",
+      wgsl_type: "i32",
+      msl_type: "int",
+      wrapper_kind: :int,
+      metal_alignment: 4,
+      metal_size: 4,
+      compiled_supported: true,
+      runtime_supported: true,
+      function_shorthand: true
+    ),
+    bool: UniformTypeSpec.new(
+      c_type: "int",
+      glsl_type: "bool",
+      wgsl_type: "bool",
+      msl_type: "bool",
+      wrapper_kind: :bool,
+      metal_alignment: 4,
+      metal_size: 4,
+      compiled_supported: true,
+      runtime_supported: true,
+      function_shorthand: true
+    ),
+    mat2: UniformTypeSpec.new(
+      c_type: "mat2",
+      glsl_type: "mat2",
+      wgsl_type: "mat2x2<f32>",
+      msl_type: "float2x2",
+      compiled_supported: false,
+      runtime_supported: false,
+      function_shorthand: true
+    ),
+    mat3: UniformTypeSpec.new(
+      c_type: "mat3",
+      glsl_type: "mat3",
+      wgsl_type: "mat3x3<f32>",
+      msl_type: "float3x3",
+      compiled_supported: false,
+      runtime_supported: false,
+      function_shorthand: true
+    ),
+    mat4: UniformTypeSpec.new(
+      c_type: "mat4",
+      glsl_type: "mat4",
+      wgsl_type: "mat4x4<f32>",
+      msl_type: "float4x4",
+      compiled_supported: false,
+      runtime_supported: false,
+      function_shorthand: true
+    ),
+    sampler2D: UniformTypeSpec.new(
+      c_type: "sampler2D",
+      glsl_type: "sampler2D",
+      wgsl_type: "texture_2d<f32>",
+      msl_type: nil,
+      compiled_supported: false,
+      runtime_supported: false,
+      function_shorthand: true
+    )
+  }.transform_values(&:freeze).freeze
+
+  UNIFORM_TYPES = UNIFORM_TYPE_SPECS.keys.freeze
+end

data/lib/rlsl/types/value_normalizer.rb

@@ -0,0 +1,81 @@
+# 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 ArgumentError, unsupported_runtime_type_message(type, shader_name) unless spec.runtime_supported?
+
+        case spec.wrapper_kind
+        when :float
+          Float(value)
+        when :int
+          Integer(value)
+        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 ArgumentError, unsupported_runtime_type_message(type, shader_name)
+        end
+      rescue TypeError
+        raise ArgumentError, invalid_uniform_message(name, type, value, shader_name)
+      rescue ArgumentError => e
+        raise e if e.message.start_with?("Invalid value for uniform", "Unsupported runtime uniform type")
+
+        raise ArgumentError, 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 ArgumentError, invalid_uniform_message(name, :bool, value, shader_name)
+      end
+
+      def normalize_vector(value, vector_size, name:, shader_name: nil)
+        unless value.is_a?(Array) && value.length == vector_size
+          raise ArgumentError, 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,18 @@
 # 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
+module RLSL
+  module UniformTypes
+    extend Catalog
+    extend TargetResolver
+    extend ValueNormalizer
+  end
 
-  # 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
+    C_UNIFORM_TYPES = UNIFORM_TYPE_SPECS.transform_values(&:c_type).freeze
   end
 end

data/lib/rlsl/uniform_context.rb

@@ -9,20 +9,14 @@ module RLSL
       @uniforms = {}
     end
 
-    def float(name)
-      @uniforms[name] = :float
+    def define_uniform(name, type)
+      @uniforms[name] = type
     end
 
-    def vec2(name)
-      @uniforms[name] = :vec2
-    end
-
-    def vec3(name)
-      @uniforms[name] = :vec3
-    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.0"
 end