rlsl 1.0.0 → 1.0.1

data/lib/rlsl/prism/emitters/base_emitter.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "set"
+
+require_relative "../ir/traversal"
 require_relative "base_emitter/control_flow_emission"
 require_relative "base_emitter/expression_emission"
 require_relative "base_emitter/definition_emission"
@@ -66,14 +69,26 @@ module RLSL
         def initialize
           @indent_level = 0
           @return_context_stack = [false]
+          @return_struct_name_stack = []
+          @return_type_stack = []
+          @temporary_index = 0
+          @emit_depth = 0
+          @occupied_names = Set.new
         end
 
         def emit(node, needs_return: false)
+          @occupied_names = source_names(node) if @emit_depth.zero?
+          @emit_depth += 1
           with_return_context(needs_return) do
             return node.accept(self) if node.respond_to?(:accept)
 
-            raise "Unknown IR node: #{node.class}"
+            raise RLSL::InternalError, "Unknown IR node: #{node.class}"
           end
+        rescue RLSL::Error => error
+          error.with_source_location(node.location) if node.respond_to?(:location)
+          raise
+        ensure
+          @emit_depth -= 1
         end
 
         protected
@@ -82,13 +97,15 @@ module RLSL
           type.to_s
         end
 
-        def format_number(value)
+        def format_number(value, type: nil)
+          return value.to_i.to_s if type == :int || value.is_a?(Integer)
+
           if value.is_a?(Float)
             formatted = value.to_s
             formatted += ".0" unless formatted.include?(".")
             formatted
           else
-            "#{value}.0"
+            value.to_s
           end
         end
 
@@ -96,19 +113,42 @@ module RLSL
           "  " * @indent_level
         end
 
-        def emit_with_precedence(node, parent_op)
+        def emit_with_precedence(node, parent_op, side: :left)
           code = emit(node)
           return code unless node.is_a?(IR::BinaryOp)
 
           node_prec = PRECEDENCE[node.operator] || 10
           parent_prec = PRECEDENCE[parent_op] || 10
-          node_prec < parent_prec ? "(#{code})" : code
+          needs_parentheses = node_prec < parent_prec || (side == :right && node_prec == parent_prec)
+          needs_parentheses ? "(#{code})" : code
         end
 
         def function_name(name)
           name.to_s
         end
 
+        def function_qualifier
+          "static inline "
+        end
+
+        def with_return_struct_name(name)
+          @return_struct_name_stack << name
+          yield
+        ensure
+          @return_struct_name_stack.pop
+        end
+
+        def with_return_type(type)
+          @return_type_stack << type
+          yield
+        ensure
+          @return_type_stack.pop
+        end
+
+        def current_return_type
+          @return_type_stack.last
+        end
+
         def with_return_context(enabled)
           @return_context_stack << enabled
           yield
@@ -119,6 +159,27 @@ module RLSL
         def return_context?
           @return_context_stack.last
         end
+
+        def next_temporary_name(prefix)
+          loop do
+            name = :"_rlsl_#{prefix}#{@temporary_index}"
+            @temporary_index += 1
+            next if @occupied_names.include?(name)
+
+            @occupied_names.add(name)
+            return name
+          end
+        end
+
+        def source_names(node)
+          IR::Traversal.each(node).filter_map do |current|
+            if current.respond_to?(:name)
+              current.name.to_sym
+            elsif current.is_a?(IR::ForLoop)
+              current.variable.to_sym
+            end
+          end.to_set
+        end
       end
     end
   end

data/lib/rlsl/prism/emitters/c_emitter.rb

@@ -47,10 +47,12 @@ module RLSL
             abs: "fabsf",
             floor: "floorf",
             ceil: "ceilf",
+            sign: "sign_f",
+            step: "step_f",
             min: "fminf",
             max: "fmaxf",
             fract: "fract",
-            mod: "fmodf",
+            mod: "rlsl_mod",
             clamp: "clamp_f",
             mix: "mix_f",
             smoothstep: "smoothstep",
@@ -70,27 +72,72 @@ module RLSL
 
         protected
 
-        def format_number(value)
-          formatted = super(value)
+        def format_number(value, type: nil)
+          formatted = super(value, type: type)
+          return formatted if type == :int || value.is_a?(Integer)
+
           "#{formatted}f"
         end
 
         def emit_profile_func_call(node)
           name = node.name.to_sym
-          return emit_named_call("#{node.args.first.type}_#{name}", node.args) if vector_math_call?(name, node)
-          return emit_named_call("mix_v3", node.args) if vector_mix_call?(name, node)
+          return emit_c_vector_constructor(node) if vector_type?(name)
+          if name == :atan && node.args.length == 2
+            return emit_named_call("atan2f", node.args, expected_types: node.expected_arg_types)
+          end
+          if %i[distance cross].include?(name) && vector_type?(node.args.first&.type)
+            return emit_named_call("#{node.args.first.type}_#{name}", node.args,
+                                   expected_types: node.expected_arg_types)
+          end
+          if vector_math_call?(name, node)
+            return emit_named_call("#{node.args.first.type}_#{name}", node.args,
+                                   expected_types: node.expected_arg_types)
+          end
+          if vector_mix_call?(name, node)
+            return emit_named_call("mix_#{vector_suffix(node.args.first.type)}", node.args,
+                                   expected_types: node.expected_arg_types)
+          end
         end
 
         def emit_profile_binary_op(node)
-          return unless vector_type?(node.left.type) && profile.vector_ops.key?(node.operator)
+          return emit_float_modulo(node) if node.operator == "%" && node.type == :float
+          return unless profile.vector_ops.key?(node.operator)
+
+          emit_vector_binary_op(node)
+        end
+
+        def emit_unary_op(node)
+          if node.operator == "-" && vector_type?(node.operand.type)
+            return emit_named_call("#{node.operand.type}_mul_scalar", [node.operand, IR::Literal.new(-1.0, :float)])
+          end
 
-          emit_named_call("#{node.left.type}_#{profile.vector_ops[node.operator]}", [node.left, node.right])
+          super
         end
 
         def emit_bool_literal(node)
           node.value ? "1" : "0"
         end
 
+        def emit_field_access(node)
+          return super if node.receiver.type == :uniforms
+
+          field = node.field.to_s
+          if Builtins.single_component_field?(field)
+            component = Builtins::SWIZZLE_COMPONENTS.fetch(field)
+            return "#{emit(node.receiver)}.#{%w[x y z w].fetch(component)}"
+          end
+          return super unless Builtins.swizzle?(field)
+
+          indices = field.each_char.map { |component| Builtins::SWIZZLE_COMPONENTS.fetch(component) }
+          "#{node.receiver.type}_swizzle#{indices.length}(#{emit(node.receiver)}, #{indices.join(', ')})"
+        end
+
+        def emit_float_operand(node)
+          return emit(node) unless node.type == :int
+
+          "(float)(#{emit(node)})"
+        end
+
         private
 
         def vector_math_call?(name, node)
@@ -104,6 +151,55 @@ module RLSL
         def vector_type?(type)
           %i[vec2 vec3 vec4].include?(type)
         end
+
+        def vector_suffix(type)
+          { vec2: "v2", vec3: "v3", vec4: "v4" }.fetch(type)
+        end
+
+        def emit_float_modulo(node)
+          "rlsl_mod(#{emit_float_operand(node.left)}, #{emit_float_operand(node.right)})"
+        end
+
+        def emit_vector_binary_op(node)
+          left_vector = vector_type?(node.left.type)
+          right_vector = vector_type?(node.right.type)
+          return unless left_vector || right_vector
+
+          vector_type = left_vector ? node.left.type : node.right.type
+          operation = profile.vector_ops.fetch(node.operator)
+
+          if left_vector && right_vector
+            suffix = %w[* /].include?(node.operator) ? "_components" : ""
+            return emit_named_call("#{vector_type}_#{operation}#{suffix}", [node.left, node.right])
+          end
+
+          if left_vector
+            return emit_named_call("#{vector_type}_#{operation}_scalar", [node.left, node.right])
+          end
+
+          emit_named_call("#{vector_type}_scalar_#{operation}", [node.left, node.right])
+        end
+
+        def emit_c_vector_constructor(node)
+          size = { vec2: 2, vec3: 3, vec4: 4 }.fetch(node.name.to_sym)
+          component_count = node.args.sum { |argument| vector_size(argument.type) || 1 }
+          component_count = size if node.args.length == 1 && !vector_type?(node.args.first.type)
+
+          unless component_count == size
+            raise TargetCapabilityError,
+                  "#{node.name} constructor produces #{component_count} components on C, expected #{size}"
+          end
+
+          return "#{node.name}_splat(#{emit(node.args.first)})" if node.args.length == 1 && !vector_type?(node.args.first.type)
+          return emit_named_call("#{node.name}_new", node.args) unless node.args.any? { |argument| vector_type?(argument.type) }
+
+          signature = node.args.map { |argument| vector_type?(argument.type) ? argument.type : :float }.join("_")
+          emit_named_call("#{node.name}_from_#{signature}", node.args)
+        end
+
+        def vector_size(type)
+          { vec2: 2, vec3: 3, vec4: 4 }[type]
+        end
       end
     end
   end

data/lib/rlsl/prism/emitters/glsl_emitter.rb

@@ -33,6 +33,54 @@ module RLSL
             textureLod: "textureLod"
           }
         ).freeze
+
+        protected
+
+        def function_qualifier
+          ""
+        end
+
+        def emit_binary_op(node)
+          if node.operator == "%" && (node.left.type != :int || node.right.type != :int)
+            return "mod(#{emit_float_operand(node.left)}, #{emit_float_operand(node.right)})"
+          end
+
+          super
+        end
+
+        def emit_result_struct(func_name, types)
+          fields = types.each_with_index.map { |type, index| "#{type_name(type)} v#{index};" }.join(" ")
+          "struct #{func_name}_result { #{fields} };\n"
+        end
+
+        def emit_field_access(node)
+          return node.field.to_s if node.receiver.type == :uniforms && node.type == :sampler2D
+
+          super
+        end
+
+        def emit_texture_call(name, node)
+          return unless profile.texture_functions.key?(name) && node.args.length >= 2
+
+          args = [node.args[0], node.args[1], node.args[2] || IR::Literal.new(0.0, :float)]
+          emit_named_call("textureLod", args, expected_types: node.expected_arg_types)
+        end
+
+        def emit_func_call(node)
+          if node.name.to_sym == :atan2
+            return emit_named_call("atan", node.args, expected_types: node.expected_arg_types)
+          end
+
+          super
+        end
+
+        def emit_tuple_value(node)
+          expected_types = Array(current_return_type)
+          elements = node.elements.each_with_index.map do |element, index|
+            emit_typed_argument(element, expected_types[index])
+          end.join(", ")
+          "#{current_return_struct_name}(#{elements})"
+        end
       end
     end
   end

data/lib/rlsl/prism/emitters/msl_emitter.rb

@@ -41,7 +41,49 @@ module RLSL
 
           texture = emit(node.args[0])
           uv = emit(node.args[1])
-          "#{texture}.sample(textureSampler, #{uv})"
+          if name == :textureLod
+            lod = emit_typed_argument(node.args[2], :float)
+            return "#{texture}.sample(rlsl_texture_sampler, #{uv}, level(#{lod}))"
+          end
+
+          "#{texture}.sample(rlsl_texture_sampler, #{uv})"
+        end
+
+        def emit_binary_op(node)
+          if node.operator == "%" && node.type == :float
+            return "rlsl_mod(#{emit_float_operand(node.left)}, #{emit_float_operand(node.right)})"
+          end
+
+          super
+        end
+
+        def emit_func_call(node)
+          if node.name.to_sym == :mod
+            args = node.args.map { |argument| emit_float_operand(argument) }
+            return "rlsl_mod(#{args.join(', ')})"
+          end
+          if node.name.to_sym == :atan && node.args.length == 2
+            return emit_named_call("atan2", node.args, expected_types: node.expected_arg_types)
+          end
+
+          super
+        end
+
+        def emit_field_access(node)
+          return node.field.to_s if node.receiver.type == :uniforms && node.type == :sampler2D
+
+          code = super
+          return "(#{code} != 0)" if node.receiver.type == :uniforms && node.type == :bool
+
+          code
+        end
+
+        def emit_tuple_value(node)
+          expected_types = Array(current_return_type)
+          elements = node.elements.each_with_index.map do |element, index|
+            emit_typed_argument(element, expected_types[index])
+          end.join(", ")
+          "#{current_return_struct_name}{#{elements}}"
         end
       end
     end

data/lib/rlsl/prism/emitters/target_emitter.rb

@@ -19,26 +19,39 @@ module RLSL
           name = node.name.to_sym
 
           constructor_name = profile.vector_constructors[name] || profile.matrix_constructors[name]
-          return emit_named_call(constructor_name, node.args) if constructor_name
+          if constructor_name
+            return emit_named_call(constructor_name, node.args, expected_types: Array.new(node.args.length, :float))
+          end
 
           texture_call = emit_texture_call(name, node)
           return texture_call if texture_call
 
           math_function = profile.math_functions[name]
-          return emit_named_call(math_function, node.args) if math_function
+          return emit_named_call(math_function, node.args, expected_types: node.expected_arg_types) if math_function
 
-          emit_named_call(name, node.args, receiver: node.receiver)
+          emit_named_call(name, node.args, receiver: node.receiver, expected_types: node.expected_arg_types)
         end
 
         def emit_binary_op(node)
           resolved_binary_op = emit_profile_binary_op(node)
           return resolved_binary_op if resolved_binary_op
+          return emit_promoted_binary_op(node) if needs_float_promotion?(node)
 
-          left = emit_with_precedence(node.left, node.operator)
-          right = emit_with_precedence(node.right, node.operator)
+          left = emit_with_precedence(node.left, node.operator, side: :left)
+          right = emit_with_precedence(node.right, node.operator, side: :right)
           "#{left} #{node.operator} #{right}"
         end
 
+        def emit_ternary(node)
+          then_expr = emit_typed_argument(node.then_expr, node.type)
+          else_expr = emit_typed_argument(node.else_expr, node.type)
+          "(#{emit(node.condition)} ? #{then_expr} : #{else_expr})"
+        end
+
+        def emit_assignment(node)
+          "#{emit(node.target)} = #{emit_typed_argument(node.value, node.target.type)}"
+        end
+
         def default_type_name
           profile.default_type_name
         end
@@ -46,16 +59,50 @@ module RLSL
         def emit_texture_call(name, node)
           return unless profile.texture_functions.key?(name)
 
-          emit_named_call(profile.texture_functions[name], node.args)
+          emit_named_call(profile.texture_functions[name], node.args, expected_types: node.expected_arg_types)
         end
 
-        def emit_named_call(name, args, receiver: nil)
+        def emit_named_call(name, args, receiver: nil, expected_types: [])
           rendered_args = []
-          rendered_args << emit(receiver) if receiver
-          rendered_args.concat(args.map { |arg| emit(arg) })
+          rendered_args << emit_typed_argument(receiver, expected_types.first) if receiver
+          offset = receiver ? 1 : 0
+          rendered_args.concat(args.each_with_index.map do |arg, index|
+            emit_typed_argument(arg, expected_types[index + offset])
+          end)
           "#{name}(#{rendered_args.join(', ')})"
         end
 
+        def emit_typed_argument(node, expected_type)
+          return emit_float_operand(node) if expected_type == :float
+
+          emit(node)
+        end
+
+        def needs_float_promotion?(node)
+          types = [node.left.type, node.right.type]
+          return true if node.operator == "/" && types.all?(:int)
+
+          types.include?(:int) && types.any? { |type| type == :float || Builtins.vector_type?(type) || Builtins.matrix_type?(type) }
+        end
+
+        def emit_promoted_binary_op(node)
+          left = emit_promoted_operand(node.left, node.operator, :left)
+          right = emit_promoted_operand(node.right, node.operator, :right)
+          "#{left} #{node.operator} #{right}"
+        end
+
+        def emit_float_operand(node)
+          return emit(node) unless node.type == :int
+
+          "#{type_name(:float)}(#{emit(node)})"
+        end
+
+        def emit_promoted_operand(node, operator, side)
+          return emit_float_operand(node) if node.type == :int
+
+          emit_with_precedence(node, operator, side: side)
+        end
+
         def emit_profile_call(node)
           return unless profile.call_resolver