rlsl 0.1.1 → 1.0.1

data/lib/rlsl/msl/translator.rb

@@ -3,33 +3,33 @@
 module RLSL
   module MSL
     class Translator < BaseTranslator
-      TYPE_MAP = {
-        "vec2" => "float2",
-        "vec3" => "float3",
-        "vec4" => "float4"
-      }.freeze
-
-      FUNC_REPLACEMENTS = BaseTranslator.common_func_replacements(
-        target_vec2: "float2",
-        target_vec3: "float3",
-        target_vec4: "float4"
-      ).freeze
+      PROFILE = BaseTranslator.build_profile(
+        uniform_target: :msl,
+        identifier_replacements: {
+          "vec2" => "float2",
+          "vec3" => "float3",
+          "vec4" => "float4"
+        },
+        call_rewrites: BaseTranslator.common_call_rewrites(
+          target_vec2: "float2",
+          target_vec3: "float3",
+          target_vec4: "float4"
+        )
+      )
 
       protected
 
-      def translate_code(c_code)
-        result = super(c_code)
-        return result if result.empty?
-
-        result.gsub!(/\bstatic\s+/, "")
-        result.gsub!(/\binline\s+/, "")
-        result
-      end
-
       def generate_shader(helpers, fragment)
         <<~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 {
@@ -40,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);
           }
@@ -64,25 +64,29 @@ module RLSL
 
       private
 
+      def profile
+        PROFILE
+      end
+
       def generate_uniform_struct
-        fields = ["float2 resolution;"]
-        @uniforms.each do |name, type|
-          msl_type = uniform_type_to_target(type)
-          fields << "#{msl_type} #{name};"
+        fields = uniform_lines(resolution_line: "#{target_vec2_type} resolution;") do |name, msl_type|
+          "#{msl_type} #{name};"
         end
         fields.join("\n    ")
       end
 
-      def target_vec2_type
-        "float2"
+      def fragment_texture_parameters
+        texture_uniforms.keys.map { |name| ", texture2d<float> #{name}" }.join
       end
 
-      def target_vec3_type
-        "float3"
+      def fragment_texture_arguments
+        texture_uniforms.keys.map { |name| ", #{name}" }.join
       end
 
-      def target_vec4_type
-        "float4"
+      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

data/lib/rlsl/msl/uniform_buffer_packer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RLSL
+  module MSL
+    class UniformBufferPacker
+      def initialize(shader_name, uniform_types, uniform_names)
+        @shader_name = shader_name
+        @uniform_types = uniform_types
+        @uniform_names = uniform_names
+      end
+
+      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("e2")
+        current_offset = 8
+
+        @uniform_names.each do |name|
+          value = normalized_uniforms[name]
+          spec = UniformTypes.metal_spec(@uniform_types[name])
+          current_offset, data = append_padding(data, current_offset, spec.metal_alignment)
+          data << pack_uniform_value(spec, value)
+          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
+
+      private
+
+      def append_padding(data, current_offset, alignment)
+        padding_needed = (alignment - (current_offset % alignment)) % alignment
+        return [current_offset, data] if padding_needed.zero?
+
+        [current_offset + padding_needed, data + ("\x00" * padding_needed)]
+      end
+
+      def pack_uniform_value(spec, value)
+        case spec.wrapper_kind
+        when :float
+          [value.to_f].pack("e")
+        when :int
+          [value.to_i].pack("l<")
+        when :bool
+          [value ? 1 : 0].pack("l<")
+        when :vector
+          pack_vector_uniform(spec.vector_size, value)
+        else
+          raise ArgumentError, "Unsupported Metal uniform type: #{spec.c_type}"
+        end
+      end
+
+      def pack_vector_uniform(vector_size, value)
+        components = Array(value).map(&:to_f)
+
+        case vector_size
+        when 2
+          components.pack("e2")
+        when 3
+          (components + [0.0]).pack("e4")
+        when 4
+          components.pack("e4")
+        else
+          raise ArgumentError, "Unsupported vector size: #{vector_size}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ASTVisitor
+      module ControlFlowVisiting
+        VISITORS = {}.tap do |visitors|
+          visitors[::Prism::BlockNode] = :visit_block if defined?(::Prism::BlockNode)
+          visitors[::Prism::LambdaNode] = :visit_lambda if defined?(::Prism::LambdaNode)
+          visitors[::Prism::IfNode] = :visit_if if defined?(::Prism::IfNode)
+          visitors[::Prism::ElseNode] = :visit_else if defined?(::Prism::ElseNode)
+          visitors[::Prism::UnlessNode] = :visit_unless if defined?(::Prism::UnlessNode)
+          visitors[::Prism::ReturnNode] = :visit_return if defined?(::Prism::ReturnNode)
+          visitors[::Prism::RangeNode] = :visit_range if defined?(::Prism::RangeNode)
+          visitors[::Prism::ForNode] = :visit_for if defined?(::Prism::ForNode)
+          visitors[::Prism::WhileNode] = :visit_while if defined?(::Prism::WhileNode)
+          visitors[::Prism::BreakNode] = :visit_break if defined?(::Prism::BreakNode)
+        end.freeze
+
+        private
+
+        def visit_block(node)
+          visit_with_scoped_vars(node.body, params: extract_block_params(node))
+        end
+
+        def visit_lambda(node)
+          visit_block(node)
+        end
+
+        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, hoisted_variables: hoisted_variables)
+        end
+
+        def visit_else(node)
+          visit(node.statements)
+        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, hoisted_variables: hoisted_variables)
+        end
+
+        def visit_return(node)
+          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), node.exclude_end?]
+        end
+
+        def visit_for(node)
+          range = visit(node.collection)
+          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)
+          unless times_loop?(node)
+            raise UnsupportedSyntaxError, "Blocks are only supported for Integer#times loops"
+          end
+
+          count = visit(node.receiver)
+          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)
+          condition = visit(node.predicate)
+          body = visit_with_scoped_vars(node.statements) || IR::Block.new
+          IR::WhileLoop.new(condition, body)
+        end
+
+        def visit_break(_node)
+          IR::Break.new
+        end
+
+        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
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ASTVisitor
+      module DefinitionVisiting
+        VISITORS = {}.tap do |visitors|
+          visitors[::Prism::LocalVariableWriteNode] = :visit_local_variable_write if defined?(::Prism::LocalVariableWriteNode)
+          visitors[::Prism::LocalVariableOperatorWriteNode] = :visit_local_variable_operator_write if defined?(::Prism::LocalVariableOperatorWriteNode)
+          visitors[::Prism::LocalVariableReadNode] = :visit_local_variable_read if defined?(::Prism::LocalVariableReadNode)
+          visitors[::Prism::DefNode] = :visit_def if defined?(::Prism::DefNode)
+          visitors[::Prism::GlobalVariableWriteNode] = :visit_global_variable_write if defined?(::Prism::GlobalVariableWriteNode)
+          visitors[::Prism::ConstantWriteNode] = :visit_constant_write if defined?(::Prism::ConstantWriteNode)
+          visitors[::Prism::MultiWriteNode] = :visit_multi_write if defined?(::Prism::MultiWriteNode)
+          visitors[::Prism::LocalVariableTargetNode] = :visit_local_variable_target if defined?(::Prism::LocalVariableTargetNode)
+        end.freeze
+
+        private
+
+        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(emitted_name), value)
+          else
+            declare_variable(name)
+            IR::VarDecl.new(name, value)
+          end
+        end
+
+        def visit_local_variable_operator_write(node)
+          name = node.name.to_sym
+          operator = node.binary_operator.to_s
+          value = normalize_expression(visit(node.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)
+          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)
+          params = extract_required_params(node.parameters)
+          body = visit_with_scoped_vars(node.body, params: params)
+          IR::FunctionDefinition.new(node.name.to_sym, params, body)
+        end
+
+        def visit_global_variable_write(node)
+          IR::GlobalDecl.new(node.name.to_s.sub(/^\$/, "").to_sym, visit(node.value), is_static: true)
+        end
+
+        def visit_constant_write(node)
+          IR::GlobalDecl.new(node.name.to_sym, visit(node.value), is_const: true, is_static: true)
+        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
+            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), declarations: declarations)
+        end
+
+        def visit_local_variable_target(node)
+          name = node.name.to_sym
+          declare_variable(name)
+          IR::VarRef.new(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ASTVisitor
+      module ExpressionVisiting
+        VISITORS = {}.tap do |visitors|
+          visitors[::Prism::IntegerNode] = :visit_integer if defined?(::Prism::IntegerNode)
+          visitors[::Prism::FloatNode] = :visit_float if defined?(::Prism::FloatNode)
+          visitors[::Prism::RationalNode] = :visit_rational if defined?(::Prism::RationalNode)
+          visitors[::Prism::TrueNode] = :visit_true if defined?(::Prism::TrueNode)
+          visitors[::Prism::FalseNode] = :visit_false if defined?(::Prism::FalseNode)
+          visitors[::Prism::ParenthesesNode] = :visit_parentheses if defined?(::Prism::ParenthesesNode)
+          visitors[::Prism::CallNode] = :visit_call if defined?(::Prism::CallNode)
+          visitors[::Prism::AndNode] = :visit_and if defined?(::Prism::AndNode)
+          visitors[::Prism::OrNode] = :visit_or if defined?(::Prism::OrNode)
+          visitors[::Prism::NotNode] = :visit_not if defined?(::Prism::NotNode)
+          visitors[::Prism::ArrayNode] = :visit_array if defined?(::Prism::ArrayNode)
+          visitors[::Prism::ConstantReadNode] = :visit_constant_read if defined?(::Prism::ConstantReadNode)
+          visitors[::Prism::ConstantPathNode] = :visit_constant_path if defined?(::Prism::ConstantPathNode)
+          visitors[::Prism::GlobalVariableReadNode] = :visit_global_variable_read if defined?(::Prism::GlobalVariableReadNode)
+        end.freeze
+
+        private
+
+        def visit_integer(node)
+          IR::Literal.new(node.value, :int)
+        end
+
+        def visit_float(node)
+          IR::Literal.new(node.value, :float)
+        end
+
+        def visit_rational(node)
+          IR::Literal.new(node.value.to_f, :float)
+        end
+
+        def visit_true(_node)
+          IR::BoolLiteral.new(true)
+        end
+
+        def visit_false(_node)
+          IR::BoolLiteral.new(false)
+        end
+
+        def visit_parentheses(node)
+          inner = normalize_expression(visit(node.body))
+          inner = inner.statements.first if single_statement_block?(inner)
+          IR::Parenthesized.new(inner)
+        end
+
+        def visit_call(node)
+          return visit_call_with_block(node) if node.block
+
+          visit_plain_call(node)
+        end
+
+        def visit_plain_call(node)
+          method_name = node.name.to_s
+          receiver = normalize_expression(visit(node.receiver)) if node.receiver
+          args = node.arguments&.arguments&.map { |arg| normalize_expression(visit(arg)) } || []
+
+          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::ArrayIndex.new(receiver, args.first) if method_name == "[]" && receiver && args.length == 1
+
+          IR::FuncCall.new(method_name.to_sym, args, receiver)
+        end
+
+        def visit_and(node)
+          left = normalize_expression(visit(node.left))
+          right = normalize_expression(visit(node.right))
+          IR::BinaryOp.new("&&", left, right, :bool)
+        end
+
+        def visit_or(node)
+          left = normalize_expression(visit(node.left))
+          right = normalize_expression(visit(node.right))
+          IR::BinaryOp.new("||", left, right, :bool)
+        end
+
+        def visit_not(node)
+          operand = normalize_expression(visit(node.expression))
+          IR::UnaryOp.new("!", operand, :bool)
+        end
+
+        def visit_array(node)
+          elements = node.elements.map { |elem| normalize_expression(visit(elem)) }
+          IR::ArrayLiteral.new(elements)
+        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)
+
+          IR::VarRef.new(name.to_sym)
+        end
+
+        def visit_constant_path(node)
+          path_parts = []
+          current = node
+          while current.is_a?(::Prism::ConstantPathNode)
+            path_parts.unshift(current.name.to_s)
+            current = current.parent
+          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
+
+        def visit_global_variable_read(node)
+          IR::VarRef.new(node.name.to_s.sub(/^\$/, "").to_sym)
+        end
+
+        def normalize_expression(node)
+          return node unless node.is_a?(IR::IfStatement)
+
+          then_expr = extract_if_branch_expr(node.then_branch)
+          else_expr = extract_if_branch_expr(node.else_branch)
+          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).tap do |ternary|
+            ternary.location = node.location
+          end
+        end
+
+        def extract_if_branch_expr(branch)
+          return nil unless branch
+          return branch unless branch.is_a?(IR::Block)
+          return nil if branch.statements.empty? || branch.statements.length != 1
+
+          branch.statements.first
+        end
+
+        def single_statement_block?(node)
+          node.is_a?(IR::Block) && node.statements.length == 1
+        end
+
+        def parameter_reference_call?(method_name, receiver, args)
+          !receiver && args.empty? &&
+            (parameter_reference?(method_name.to_sym) || infer_param_type(method_name.to_sym))
+        end
+
+        def receiver_without_arguments?(node, receiver, args)
+          receiver && args.empty? && !node.arguments
+        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"
+
+          IR::FieldAccess.new(receiver, method_name)
+        end
+
+        def binary_operator_call?(method_name, receiver, args)
+          BINARY_OPERATORS.include?(method_name) && receiver && args.length == 1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ASTVisitor
+      class ScopeContext
+        Scope = Struct.new(:params, :declared_vars)
+
+        def initialize(params: [])
+          @scopes = [build_scope(params)]
+        end
+
+        def with_scope(params: [])
+          @scopes << build_scope(params)
+          yield
+        ensure
+          @scopes.pop
+        end
+
+        def parameter?(name)
+          @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
+
+        def known_variable?(name)
+          parameter?(name) || declared?(name)
+        end
+
+        def declare(name)
+          @scopes.last.declared_vars.add(name.to_sym)
+        end
+
+        private
+
+        def build_scope(params)
+          Scope.new(Set.new(Array(params).map(&:to_sym)), Set.new)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    class ASTVisitor
+      class VisitorRegistry
+        TRANSPARENT_NODES = [
+          (::Prism::ArgumentsNode if defined?(::Prism::ArgumentsNode)),
+          (::Prism::BlockParametersNode if defined?(::Prism::BlockParametersNode)),
+          (::Prism::ParametersNode if defined?(::Prism::ParametersNode))
+        ].compact.freeze
+
+        def self.build(*visitor_maps)
+          visitor_maps.each_with_object({}) do |visitor_map, merged|
+            merged.merge!(visitor_map)
+          end.freeze
+        end
+      end
+    end
+  end
+end