rlsl 0.1.1 → 1.0.1

data/lib/rlsl/shader_builder/shader_definition.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RLSL
+  class ShaderBuilder
+    class ShaderDefinition
+      attr_reader :uniforms, :custom_functions, :helpers_block, :helpers_mode, :fragment_block, :fragment_mode
+
+      def initialize(
+        uniforms: {},
+        custom_functions: {},
+        helpers_block: nil,
+        helpers_mode: :ruby,
+        fragment_block: nil,
+        fragment_mode: :c
+      )
+        @uniforms = normalize_hash(uniforms)
+        @custom_functions = normalize_hash(custom_functions)
+        @helpers_block = helpers_block
+        @helpers_mode = helpers_mode
+        @fragment_block = fragment_block
+        @fragment_mode = fragment_mode
+      end
+
+      def with_uniforms(uniforms)
+        copy(uniforms: uniforms)
+      end
+
+      def with_custom_functions(custom_functions)
+        copy(custom_functions: custom_functions)
+      end
+
+      def with_helpers(mode:, block:)
+        copy(helpers_mode: mode, helpers_block: block)
+      end
+
+      def with_fragment(mode:, block:)
+        copy(fragment_mode: mode, fragment_block: block)
+      end
+
+      def ruby_fragment?
+        %i[ruby ruby_source].include?(@fragment_mode)
+      end
+
+      def ruby_helpers?
+        %i[ruby ruby_source].include?(@helpers_mode)
+      end
+
+      private
+
+      def copy(**overrides)
+        self.class.new(
+          uniforms: overrides.fetch(:uniforms, @uniforms),
+          custom_functions: overrides.fetch(:custom_functions, @custom_functions),
+          helpers_block: overrides.fetch(:helpers_block, @helpers_block),
+          helpers_mode: overrides.fetch(:helpers_mode, @helpers_mode),
+          fragment_block: overrides.fetch(:fragment_block, @fragment_block),
+          fragment_mode: overrides.fetch(:fragment_mode, @fragment_mode)
+        )
+      end
+
+      def normalize_hash(hash)
+        hash.each_with_object({}) do |(name, value), normalized|
+          normalized[name.to_sym] = value
+        end.freeze
+      end
+    end
+  end
+end

data/lib/rlsl/shader_builder/source_resolver.rb

@@ -0,0 +1,109 @@
+# 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
+        if @definition.helpers_mode == :ruby_source
+          source = @definition.helpers_block.call
+          return source_snippet(
+            helpers_transpiler.transpile_helpers_source(source, target, @definition.custom_functions),
+            format: :target
+          )
+        end
+        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
+        if @definition.fragment_mode == :ruby_source
+          source = @definition.fragment_block.call
+          return source_snippet(fragment_transpiler.transpile_source(source, target), format: :target)
+        end
+        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 = if @definition.helpers_mode == :ruby_source
+                          helpers_transpiler.compile_helpers_source(
+                            @definition.helpers_block.call,
+                            @definition.custom_functions
+                          )
+                        else
+                          helpers_transpiler.compile_helpers(@definition.helpers_block, @definition.custom_functions)
+                        end
+          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,114 @@
 # 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)
-      @name = name.to_s
-      @uniforms = {}
-      @fragment_mode = :c
-      @helpers_mode = :c
-      @custom_functions = {}
+    def initialize(name, definition = ShaderDefinition.new)
+      @name = RLSL.validate_shader_name!(name)
+      @definition = definition
     end
 
     def uniforms(&block)
       if block_given?
         ctx = UniformContext.new
         ctx.instance_eval(&block)
-        @uniforms = ctx.uniforms
+        update_definition(@definition.with_uniforms(ctx.uniforms))
       else
-        @uniforms
+        @definition.uniforms
       end
     end
 
+    def uniform_types
+      @definition.uniforms
+    end
+
     def helpers(mode = :ruby, &block)
-      @helpers_block = block
-      @helpers_mode = mode
+      raise ArgumentError, "helpers requires a block" unless block
+
+      resolved_mode = mode.to_sym
+      raise ArgumentError, "helpers mode must be :c or :ruby" unless %i[c ruby].include?(resolved_mode)
+
+      if resolved_mode == :ruby
+        source_unit = Prism::SourceExtractor.new.extract_unit(block)
+        update_definition(@definition.with_helpers(mode: :ruby_source, block: -> { source_unit }))
+      else
+        update_definition(@definition.with_helpers(mode: :c, block: block))
+      end
+    end
+
+    def helpers_source(source)
+      update_definition(@definition.with_helpers(mode: :ruby_source, block: -> { source.to_s }))
     end
 
     def functions(&block)
       ctx = FunctionContext.new
       ctx.instance_eval(&block)
-      @custom_functions = ctx.functions
+      update_definition(@definition.with_custom_functions(ctx.functions))
     end
 
-    def fragment(&block)
-      @fragment_block = block
-      @fragment_mode = block.arity > 0 ? :ruby : :c
+    def fragment(mode = :auto, &block)
+      raise ArgumentError, "fragment requires a block" unless block
+
+      resolved_mode = if mode == :auto
+                        block.parameters.empty? ? :c : :ruby
+                      else
+                        mode.to_sym
+                      end
+      unless %i[c ruby].include?(resolved_mode)
+        raise ArgumentError, "fragment mode must be :c or :ruby"
+      end
+
+      if resolved_mode == :ruby
+        source_unit = Prism::SourceExtractor.new.extract_unit(block)
+        update_definition(@definition.with_fragment(mode: :ruby_source, block: -> { source_unit }))
+      else
+        update_definition(@definition.with_fragment(mode: :c, block: block))
+      end
     end
 
-    def ruby_mode?
-      @fragment_mode == :ruby
+    def fragment_source(source)
+      update_definition(@definition.with_fragment(mode: :ruby_source, block: -> { source.to_s }))
     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
+    def build_service
+      @build_service ||= BuildService.new(@name, @definition)
     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 update_definition(definition)
+      @definition = definition
+      @build_service = nil
     end
   end
 end

data/lib/rlsl/shader_name.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RLSL
+  IDENTIFIER_PATTERN = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+  SHADER_NAME_PATTERN = IDENTIFIER_PATTERN
+
+  def self.validate_identifier!(name, context: "identifier")
+    normalized = name.to_s
+    return normalized if normalized.match?(IDENTIFIER_PATTERN)
+
+    raise ArgumentError,
+          "Invalid #{context} #{name.inspect}: use an ASCII identifier beginning with a letter or underscore"
+  end
+
+  def self.validate_shader_name!(name)
+    validate_identifier!(name, context: "shader name")
+  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: "i32",
+      msl_type: "int",
+      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: "texture2d<float>",
+      compiled_supported: false,
+      runtime_supported: false,
+      function_shorthand: true
+    )
+  }.transform_values(&:freeze).freeze
+
+  UNIFORM_TYPES = UNIFORM_TYPE_SPECS.keys.freeze
+end