rlsl 0.1.0 → 1.0.0

data/lib/rlsl/msl/translator.rb

@@ -3,29 +3,22 @@
 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>
@@ -64,26 +57,16 @@ 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"
-      end
-
-      def target_vec3_type
-        "float3"
-      end
-
-      def target_vec4_type
-        "float4"
-      end
     end
   end
 end

data/lib/rlsl/msl/uniform_buffer_packer.rb

@@ -0,0 +1,68 @@
+# 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("ff")
+        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
+
+        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("f")
+        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("ff")
+        when 3
+          (components + [0.0]).pack("ffff")
+        when 4
+          components.pack("ffff")
+        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,96 @@
+# 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)
+          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)
+        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))
+          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)
+        end
+
+        def visit_return(node)
+          expr = node.arguments ? normalize_expression(visit(node.arguments.arguments.first)) : nil
+          IR::Return.new(expr)
+        end
+
+        def visit_range(node)
+          [visit(node.left), visit(node.right)]
+        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)
+        end
+
+        def visit_call_with_block(node)
+          return visit_plain_call(node) unless times_loop?(node)
+
+          count = visit(node.receiver)
+          block = visit(node.block)
+          var_name = extract_block_params(node.block).first || :i
+          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))
+        end
+
+        def visit_break(_node)
+          IR::Break.new
+        end
+
+        def times_loop?(node)
+          node.name.to_s == "times" && node.receiver
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# 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))
+
+          if known_variable?(name)
+            IR::Assignment.new(IR::VarRef.new(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.operator.to_s.delete_suffix("=")
+          value = normalize_expression(visit(node.value))
+
+          declare_variable(name)
+          target = IR::VarRef.new(name)
+          expr = IR::BinaryOp.new(operator, IR::VarRef.new(name), 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))
+        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)
+          targets = node.lefts.map do |target|
+            name = target.name.to_sym
+            declare_variable(name)
+            IR::VarRef.new(name)
+          end
+
+          IR::MultipleAssignment.new(targets, visit(node.value))
+        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,168 @@
+# 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)) } || []
+
+          return IR::VarRef.new(method_name.to_sym, infer_param_type(method_name.to_sym)) if parameter_reference_call?(method_name, receiver, args)
+          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)
+        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_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)
+
+          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)
+
+          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)
+          raise "Unsupported if-expression: branches must be single expressions" unless then_expr && else_expr
+
+          IR::Ternary.new(node.condition, then_expr, else_expr)
+        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)
+        end
+
+        def receiver_without_arguments?(node, receiver, args)
+          receiver && args.empty? && !node.arguments
+        end
+
+        def visit_receiver_call(method_name, receiver)
+          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
+
+        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,44 @@
+# 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 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