rlsl 1.0.0 → 1.0.1

data/lib/rlsl/code_generator/uniform_struct_generator.rb

@@ -8,7 +8,7 @@ module RLSL
       end
 
       def generate
-        return "typedef struct {} Uniforms;\n" if @context.uniform_entries.empty?
+        return "typedef struct { unsigned char _unused; } Uniforms;\n" if @context.uniform_entries.empty?
 
         <<~C
           typedef struct {

data/lib/rlsl/code_generator.rb

@@ -8,18 +8,21 @@ require_relative "code_generator/ruby_wrapper_generator"
 
 module RLSL
   class CodeGenerator
-    def initialize(name, uniforms, helpers_block, fragment_block)
+    def initialize(name, uniforms, helpers_block, fragment_block, extension_name: name)
       @context = TemplateContext.new(
         name: name,
         uniforms: uniforms,
         helpers_block: helpers_block,
-        fragment_block: fragment_block
+        fragment_block: fragment_block,
+        extension_name: extension_name
       )
     end
 
     def generate
       <<~C
         #include <ruby.h>
+        #include <ruby/thread.h>
+        #include <limits.h>
         #include <math.h>
         #include <stdint.h>
         #ifdef __APPLE__
@@ -45,10 +48,10 @@ module RLSL
 
     def init_function
       <<~C
-        void Init_#{@context.name}(void) {
+        void Init_#{@context.extension_name}(void) {
           VALUE mRLSL = rb_define_module("RLSL");
           VALUE mShaders = rb_define_module_under(mRLSL, "CompiledShaders");
-          rb_define_module_function(mShaders, "#{@context.name}_render", shader_#{@context.name}_render, #{@context.render_arity});
+          rb_define_module_function(mShaders, "#{@context.extension_name}_render", shader_#{@context.name}_render, #{@context.render_arity});
         }
       C
     end

data/lib/rlsl/compiled_shader.rb

@@ -5,7 +5,7 @@ module RLSL
     def initialize(name, ext_name, uniforms)
       super(name, uniforms)
       @ext_name = ext_name
-      @render_method = RLSL::CompiledShaders.method("#{name}_render")
+      @render_method = RLSL::CompiledShaders.method("#{ext_name}_render")
     end
 
     def render(buffer, width, height, uniforms = {})

data/lib/rlsl/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RLSL
+  SourceLocation = Struct.new(:source_name, :line, :column, keyword_init: true) do
+    def to_s
+      "#{source_name || '(shader source)'}:#{line}:#{column}"
+    end
+  end
+
+  class Error < StandardError
+    attr_reader :source_location
+
+    def with_source_location(location)
+      @source_location ||= location
+      self
+    end
+
+    def message
+      return super unless source_location
+
+      "#{super} at #{source_location}"
+    end
+  end
+  class InternalError < Error; end
+  class ParseError < Error; end
+  class TranslationError < Error; end
+  class CompilationError < Error; end
+  class UniformValueError < ArgumentError; end
+end

data/lib/rlsl/glsl/translator.rb

@@ -10,12 +10,15 @@ module RLSL
           target_vec2: "vec2",
           target_vec3: "vec3",
           target_vec4: "vec4"
+        ).merge(
+          "fmodf" => BaseTranslator.rename_call("mod"),
+          "atan2f" => BaseTranslator.rename_call("atan")
         )
       )
 
-      def initialize(uniforms, helpers_code, fragment_code, version: "450")
-        super(uniforms, helpers_code, fragment_code)
-        @version = version
+      def initialize(uniforms, helpers_code, fragment_code, version: "450", name: nil)
+        super(uniforms, helpers_code, fragment_code, name: name)
+        @version = validate_version!(version)
       end
 
       protected
@@ -23,6 +26,7 @@ module RLSL
       def generate_shader(helpers, fragment)
         <<~GLSL
           #version #{@version}
+          #{generated_by_comment("GLSL")}
 
           // Uniforms
           #{generate_uniform_declarations}
@@ -33,8 +37,7 @@ module RLSL
           #{helpers}
 
           vec3 shader_fragment(vec2 frag_coord, vec2 resolution) {
-              vec2 uv = frag_coord / resolution.y;
-              #{fragment}
+          #{indent_source(fragment, 4)}
           }
 
           layout(local_size_x = 8, local_size_y = 8) in;
@@ -64,15 +67,25 @@ module RLSL
       end
 
       def generate_uniform_declarations
-        declarations = ["layout(binding = 1) uniform ShaderUniforms {"]
+        declarations = ["layout(std140, binding = 1) uniform ShaderUniforms {"]
         declarations.concat(
           uniform_lines(resolution_line: "    #{target_vec2_type} resolution;") do |name, glsl_type|
             "    #{glsl_type} #{name};"
           end
         )
         declarations << "} u;"
+        texture_uniforms.each_with_index do |(name, _type), index|
+          declarations << "layout(binding = #{index + 2}) uniform sampler2D #{name};"
+        end
         declarations.join("\n")
       end
+
+      def validate_version!(version)
+        normalized = version.to_s
+        return normalized if normalized.match?(/\A[1-9]\d{2}(?: (?:core|compatibility|es))?\z/)
+
+        raise ArgumentError, "Invalid GLSL version: #{version.inspect}"
+      end
     end
   end
 end

data/lib/rlsl/msl/shader.rb

@@ -1,22 +1,24 @@
 # frozen_string_literal: true
 
-begin
-  require "metaco"
-  METACO_AVAILABLE = true
-rescue LoadError
-  METACO_AVAILABLE = false
-end
-
 module RLSL
   module MSL
+    begin
+      require "metaco"
+      METACO_AVAILABLE = true
+    rescue LoadError
+      METACO_AVAILABLE = false
+    end
+
     class Shader < RuntimeShader
+      COMPILED_HANDLE_CACHE_LIMIT = 64
       attr_reader :name, :msl_source
 
       def initialize(name, uniforms, msl_source)
         super(name, uniforms)
         @msl_source = msl_source
         @compiled_handles = {}
-        @uniform_buffer_packer = UniformBufferPacker.new(@name, @uniform_types, @uniform_names)
+        value_uniform_types = @uniform_types.reject { |_name, type| type == :sampler2D }
+        @uniform_buffer_packer = UniformBufferPacker.new(@name, value_uniform_types, value_uniform_types.keys)
       end
 
       def metal?
@@ -27,7 +29,7 @@ module RLSL
         render_metal(handle, width, height, uniforms)
       end
 
-      def render_metal(handle, width, height, uniforms = {})
+      def prepare(handle)
         unless METACO_AVAILABLE
           raise LoadError, "metaco gem is required for Metal rendering. Install it with: gem install metaco"
         end
@@ -35,10 +37,26 @@ module RLSL
         unless @compiled_handles[handle]
           Metaco.compile_compute_shader(handle, @msl_source)
           @compiled_handles[handle] = true
+          @compiled_handles.shift while @compiled_handles.length > COMPILED_HANDLE_CACHE_LIMIT
         end
+        self
+      end
+
+      def render_metal(handle, width, height, uniforms = {}, textures: {})
+        prepare(handle)
 
         uniform_data = pack_uniforms(uniforms, width, height)
 
+        sampler_names = @uniform_types.filter_map { |name, type| name if type == :sampler2D }
+        sampler_names.each do |name|
+          texture = textures[name] || textures[name.to_s]
+          raise ArgumentError, "missing texture uniform: #{name}" unless texture
+          unless Metaco.respond_to?(:bind_compute_texture)
+            raise LoadError, "metaco texture support is required for sampler2D uniforms"
+          end
+          Metaco.bind_compute_texture(handle, sampler_names.index(name), texture)
+        end
+
         Metaco.dispatch_compute(handle, uniform_data)
         Metaco.present_compute(handle)
       end

data/lib/rlsl/msl/translator.rb

@@ -23,6 +23,13 @@ module RLSL
         <<~MSL
           #include <metal_stdlib>
           using namespace metal;
+          #{generated_by_comment("MSL")}
+
+          constexpr sampler rlsl_texture_sampler(coord::normalized, address::clamp_to_edge, filter::linear);
+
+          float rlsl_mod(float x, float y) {
+              return x - y * floor(x / y);
+          }
 
           // Uniform buffer structure
           struct Uniforms {
@@ -33,22 +40,22 @@ module RLSL
           #{helpers}
 
           // Fragment shader function
-          float3 shader_fragment(float2 frag_coord, float2 resolution, constant Uniforms& u) {
-              float2 uv = frag_coord / resolution.y;
-              #{fragment}
+          float3 shader_fragment(float2 frag_coord, float2 resolution, constant Uniforms& u#{fragment_texture_parameters}) {
+          #{indent_source(fragment, 4)}
           }
 
           // Compute kernel entry point
           kernel void compute_shader(
               texture2d<float, access::write> output [[texture(0)]],
               constant Uniforms& u [[buffer(0)]],
+          #{kernel_texture_parameters}
               uint2 gid [[thread_position_in_grid]]
           ) {
               float2 resolution = float2(output.get_width(), output.get_height());
               if (gid.x >= uint(resolution.x) || gid.y >= uint(resolution.y)) return;
 
               float2 frag_coord = float2(gid.x, resolution.y - 1.0 - float(gid.y));
-              float3 color = shader_fragment(frag_coord, resolution, u);
+              float3 color = shader_fragment(frag_coord, resolution, u#{fragment_texture_arguments});
 
               output.write(float4(clamp(color, 0.0, 1.0), 1.0), gid);
           }
@@ -67,6 +74,20 @@ module RLSL
         end
         fields.join("\n    ")
       end
+
+      def fragment_texture_parameters
+        texture_uniforms.keys.map { |name| ", texture2d<float> #{name}" }.join
+      end
+
+      def fragment_texture_arguments
+        texture_uniforms.keys.map { |name| ", #{name}" }.join
+      end
+
+      def kernel_texture_parameters
+        texture_uniforms.keys.each_with_index.map do |name, index|
+          "    texture2d<float, access::sample> #{name} [[texture(#{index + 1})]],"
+        end.join("\n")
+      end
     end
   end
 end

data/lib/rlsl/msl/uniform_buffer_packer.rb

@@ -11,7 +11,7 @@ module RLSL
 
       def pack(width, height, uniforms)
         normalized_uniforms = UniformTypes.normalize_values(@uniform_types, uniforms, shader_name: @shader_name)
-        data = [width.to_f, height.to_f].pack("ff")
+        data = [width.to_f, height.to_f].pack("e2")
         current_offset = 8
 
         @uniform_names.each do |name|
@@ -22,6 +22,10 @@ module RLSL
           current_offset += spec.metal_size
         end
 
+        if data.bytesize > 256
+          raise ArgumentError, "Metal uniform buffer exceeds 256 bytes (#{data.bytesize} bytes)"
+        end
+
         data.ljust(256, "\x00")
       end
 
@@ -37,11 +41,11 @@ module RLSL
       def pack_uniform_value(spec, value)
         case spec.wrapper_kind
         when :float
-          [value.to_f].pack("f")
+          [value.to_f].pack("e")
         when :int
-          [value.to_i].pack("l")
+          [value.to_i].pack("l<")
         when :bool
-          [value ? 1 : 0].pack("l")
+          [value ? 1 : 0].pack("l<")
         when :vector
           pack_vector_uniform(spec.vector_size, value)
         else
@@ -54,11 +58,11 @@ module RLSL
 
         case vector_size
         when 2
-          components.pack("ff")
+          components.pack("e2")
         when 3
-          (components + [0.0]).pack("ffff")
+          (components + [0.0]).pack("e4")
         when 4
-          components.pack("ffff")
+          components.pack("e4")
         else
           raise ArgumentError, "Unsupported vector size: #{vector_size}"
         end

data/lib/rlsl/prism/ast_visitor/control_flow_visiting.rb

@@ -29,58 +29,63 @@ module RLSL
 
         def visit_if(node)
           condition = visit(node.predicate)
+          hoisted_variables = hoist_branch_variables(node)
           then_branch = visit_with_scoped_vars(node.statements)
           else_branch = node.subsequent ? visit_with_scoped_vars(node.subsequent) : nil
 
-          IR::IfStatement.new(condition, then_branch, else_branch)
+          IR::IfStatement.new(condition, then_branch, else_branch, hoisted_variables: hoisted_variables)
         end
 
         def visit_else(node)
           visit(node.statements)
         end
 
-        def visit_elsif(node)
-          visit_if(node)
-        end
-
-        def visit_if_node(node)
-          visit_if(node)
-        end
-
         def visit_unless(node)
           condition = IR::UnaryOp.new("!", visit(node.predicate))
+          hoisted_variables = hoist_branch_variables(node)
           then_branch = visit_with_scoped_vars(node.statements)
           else_branch = node.else_clause ? visit_with_scoped_vars(node.else_clause) : nil
 
-          IR::IfStatement.new(condition, then_branch, else_branch)
+          IR::IfStatement.new(condition, then_branch, else_branch, hoisted_variables: hoisted_variables)
         end
 
         def visit_return(node)
-          expr = node.arguments ? normalize_expression(visit(node.arguments.arguments.first)) : nil
+          arguments = node.arguments&.arguments || []
+          if arguments.length > 1
+            raise UnsupportedSyntaxError, "Returning multiple values requires an explicitly declared tuple helper"
+          end
+
+          expr = arguments.empty? ? nil : normalize_expression(visit(arguments.first))
           IR::Return.new(expr)
         end
 
         def visit_range(node)
-          [visit(node.left), visit(node.right)]
+          [visit(node.left), visit(node.right), node.exclude_end?]
         end
 
         def visit_for(node)
           range = visit(node.collection)
-          body = visit(node.statements)
-          IR::ForLoop.new(node.index.name.to_sym, range[0], range[1], body)
+          variable = node.index.name.to_sym
+          body = visit_with_scoped_vars(node.statements, params: [variable]) || IR::Block.new
+          IR::ForLoop.new(variable, range[0], range[1], body, exclude_end: range[2])
         end
 
         def visit_call_with_block(node)
-          return visit_plain_call(node) unless times_loop?(node)
+          unless times_loop?(node)
+            raise UnsupportedSyntaxError, "Blocks are only supported for Integer#times loops"
+          end
 
           count = visit(node.receiver)
-          block = visit(node.block)
-          var_name = extract_block_params(node.block).first || :i
+          block_params = extract_block_params(node.block)
+          var_name = block_params.first || next_implicit_loop_variable
+          block = visit_with_scoped_vars(node.block.body, params: [var_name]) || IR::Block.new
           IR::ForLoop.new(var_name, IR::Literal.new(0, :int), count, block)
         end
 
         def visit_while(node)
-          IR::WhileLoop.new(visit(node.predicate), visit(node.statements))
+          condition = visit(node.predicate)
+          body = visit_with_scoped_vars(node.statements) || IR::Block.new
+          IR::WhileLoop.new(condition, body)
         end
 
         def visit_break(_node)
@@ -90,6 +95,42 @@ module RLSL
         def times_loop?(node)
           node.name.to_s == "times" && node.receiver
         end
+
+        def hoist_branch_variables(node)
+          then_names = definitely_assigned_names(node.statements)
+          else_node = node.respond_to?(:subsequent) ? node.subsequent : node.else_clause
+          else_names = definitely_assigned_names(else_node)
+
+          (then_names & else_names).each_with_object({}) do |name, variables|
+            next if known_variable?(name)
+
+            declare_variable(name)
+            variables[name] = nil
+          end
+        end
+
+        def definitely_assigned_names(node)
+          return Set.new unless node
+
+          case node
+          when ::Prism::StatementsNode
+            node.body.each_with_object(Set.new) do |statement, names|
+              names.merge(definitely_assigned_names(statement))
+            end
+          when ::Prism::LocalVariableWriteNode, ::Prism::LocalVariableOperatorWriteNode
+            Set[node.name.to_sym]
+          when ::Prism::MultiWriteNode
+            Set.new(node.lefts.map { |target| target.name.to_sym })
+          when ::Prism::IfNode
+            definitely_assigned_names(node.statements) & definitely_assigned_names(node.subsequent)
+          when ::Prism::UnlessNode
+            definitely_assigned_names(node.statements) & definitely_assigned_names(node.else_clause)
+          when ::Prism::ElseNode
+            definitely_assigned_names(node.statements)
+          else
+            Set.new
+          end
+        end
       end
     end
   end

data/lib/rlsl/prism/ast_visitor/definition_visiting.rb

@@ -20,9 +20,10 @@ module RLSL
         def visit_local_variable_write(node)
           name = node.name.to_sym
           value = normalize_expression(visit(node.value))
+          emitted_name = emitted_assignment_name(name)
 
           if known_variable?(name)
-            IR::Assignment.new(IR::VarRef.new(name), value)
+            IR::Assignment.new(IR::VarRef.new(emitted_name), value)
           else
             declare_variable(name)
             IR::VarDecl.new(name, value)
@@ -31,17 +32,23 @@ module RLSL
 
         def visit_local_variable_operator_write(node)
           name = node.name.to_sym
-          operator = node.operator.to_s.delete_suffix("=")
+          operator = node.binary_operator.to_s
           value = normalize_expression(visit(node.value))
 
-          declare_variable(name)
-          target = IR::VarRef.new(name)
-          expr = IR::BinaryOp.new(operator, IR::VarRef.new(name), value)
+          unless known_variable?(name)
+            raise UnsupportedSyntaxError, "Operator assignment requires an initialized variable: #{name}"
+          end
+          emitted_name = emitted_assignment_name(name)
+          target = IR::VarRef.new(emitted_name)
+          expr = IR::BinaryOp.new(operator, IR::VarRef.new(emitted_name), IR::Parenthesized.new(value))
           IR::Assignment.new(target, expr)
         end
 
         def visit_local_variable_read(node)
-          IR::VarRef.new(node.name.to_sym, infer_param_type(node.name.to_sym))
+          name = node.name.to_sym
+          emitted_name = fragment_parameter_reference?(name) ? emitted_parameter_name(name) : name
+          type = infer_param_type(name) if fragment_parameter_reference?(name)
+          IR::VarRef.new(emitted_name, type)
         end
 
         def visit_def(node)
@@ -59,13 +66,19 @@ module RLSL
         end
 
         def visit_multi_write(node)
+          if node.rest || !node.rights.empty?
+            raise UnsupportedSyntaxError, "Splat multiple assignment is not supported"
+          end
+
+          declarations = []
           targets = node.lefts.map do |target|
             name = target.name.to_sym
-            declare_variable(name)
-            IR::VarRef.new(name)
+            declarations << !known_variable?(name)
+            declare_variable(name) if declarations.last
+            IR::VarRef.new(emitted_assignment_name(name))
           end
 
-          IR::MultipleAssignment.new(targets, visit(node.value))
+          IR::MultipleAssignment.new(targets, visit(node.value), declarations: declarations)
         end
 
         def visit_local_variable_target(node)

data/lib/rlsl/prism/ast_visitor/expression_visiting.rb

@@ -60,11 +60,13 @@ module RLSL
           receiver = normalize_expression(visit(node.receiver)) if node.receiver
           args = node.arguments&.arguments&.map { |arg| normalize_expression(visit(arg)) } || []
 
-          return IR::VarRef.new(method_name.to_sym, infer_param_type(method_name.to_sym)) if parameter_reference_call?(method_name, receiver, args)
+          if parameter_reference_call?(method_name, receiver, args)
+            return IR::VarRef.new(emitted_parameter_name(method_name), infer_param_type(method_name))
+          end
+          return IR::UnaryOp.new("-", receiver) if method_name == "-@" && receiver
+          return IR::UnaryOp.new("!", receiver) if method_name == "!" && receiver && args.empty?
           return visit_receiver_call(method_name, receiver) if receiver_without_arguments?(node, receiver, args)
           return IR::BinaryOp.new(method_name, receiver, args.first) if binary_operator_call?(method_name, receiver, args)
-          return IR::UnaryOp.new("-", receiver) if method_name == "-@" && receiver
-          return IR::UnaryOp.new("!", args.first) if method_name == "!" && args.length == 1
           return IR::ArrayIndex.new(receiver, args.first) if method_name == "[]" && receiver && args.length == 1
 
           IR::FuncCall.new(method_name.to_sym, args, receiver)
@@ -92,12 +94,6 @@ module RLSL
           IR::ArrayLiteral.new(elements)
         end
 
-        def visit_index(node)
-          array = normalize_expression(visit(node.receiver))
-          index = normalize_expression(visit(node.arguments.arguments.first))
-          IR::ArrayIndex.new(array, index)
-        end
-
         def visit_constant_read(node)
           name = node.name.to_s
           return IR::Constant.new(name.to_sym, :float) if %w[PI TAU].include?(name)
@@ -114,6 +110,10 @@ module RLSL
           end
           path_parts.unshift(current.name.to_s) if current.respond_to?(:name)
 
+          if path_parts.first == "Math" && %w[PI TAU].include?(path_parts.last) && path_parts.length == 2
+            return IR::Constant.new(path_parts.last.to_sym, :float)
+          end
+
           IR::VarRef.new(path_parts.join("_").to_sym)
         end
 
@@ -126,9 +126,13 @@ module RLSL
 
           then_expr = extract_if_branch_expr(node.then_branch)
           else_expr = extract_if_branch_expr(node.else_branch)
-          raise "Unsupported if-expression: branches must be single expressions" unless then_expr && else_expr
+          unless then_expr && else_expr
+            raise UnsupportedSyntaxError, "Unsupported if-expression: branches must be single expressions"
+          end
 
-          IR::Ternary.new(node.condition, then_expr, else_expr)
+          IR::Ternary.new(node.condition, then_expr, else_expr).tap do |ternary|
+            ternary.location = node.location
+          end
         end
 
         def extract_if_branch_expr(branch)
@@ -144,7 +148,8 @@ module RLSL
         end
 
         def parameter_reference_call?(method_name, receiver, args)
-          !receiver && args.empty? && parameter_reference?(method_name.to_sym)
+          !receiver && args.empty? &&
+            (parameter_reference?(method_name.to_sym) || infer_param_type(method_name.to_sym))
         end
 
         def receiver_without_arguments?(node, receiver, args)
@@ -152,9 +157,8 @@ module RLSL
         end
 
         def visit_receiver_call(method_name, receiver)
+          return IR::FieldAccess.new(receiver, method_name) if receiver.type == :uniforms
           return receiver if method_name == "freeze"
-          return IR::FieldAccess.new(receiver, method_name, :float) if Builtins.single_component_field?(method_name)
-          return IR::Swizzle.new(receiver, method_name, Builtins.swizzle_type(method_name)) if Builtins.swizzle?(method_name)
 
           IR::FieldAccess.new(receiver, method_name)
         end

data/lib/rlsl/prism/ast_visitor/scope_context.rb

@@ -21,6 +21,10 @@ module RLSL
           @scopes.reverse_each.any? { |scope| scope.params.include?(name.to_sym) }
         end
 
+        def root_parameter?(name)
+          @scopes.rindex { |scope| scope.params.include?(name.to_sym) } == 0
+        end
+
         def declared?(name)
           @scopes.reverse_each.any? { |scope| scope.declared_vars.include?(name.to_sym) }
         end