rlsl 0.1.1 → 1.0.1

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "target_profile"
+
+module RLSL
+  module Prism
+    module Emitters
+      class TargetEmitter < BaseEmitter
+        protected
+
+        def type_name(type)
+          profile.type_map[type&.to_sym] || default_type_name
+        end
+
+        def emit_func_call(node)
+          resolved_call = emit_profile_call(node)
+          return resolved_call if resolved_call
+
+          name = node.name.to_sym
+
+          constructor_name = profile.vector_constructors[name] || profile.matrix_constructors[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, expected_types: node.expected_arg_types) if math_function
+
+          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, 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
+
+        def emit_texture_call(name, node)
+          return unless profile.texture_functions.key?(name)
+
+          emit_named_call(profile.texture_functions[name], node.args, expected_types: node.expected_arg_types)
+        end
+
+        def emit_named_call(name, args, receiver: nil, expected_types: [])
+          rendered_args = []
+          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
+
+          send(profile.call_resolver, node)
+        end
+
+        def emit_profile_binary_op(node)
+          return unless profile.binary_op_resolver
+
+          send(profile.binary_op_resolver, node)
+        end
+
+        def profile
+          self.class::PROFILE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module Emitters
+      TargetProfile = Struct.new(
+        :type_map,
+        :vector_constructors,
+        :matrix_constructors,
+        :texture_functions,
+        :default_type_name,
+        :math_functions,
+        :vector_ops,
+        :call_resolver,
+        :binary_op_resolver,
+        keyword_init: true
+      ) do
+        def initialize(**attributes)
+          super(
+            type_map: attributes.fetch(:type_map, {}).freeze,
+            vector_constructors: attributes.fetch(:vector_constructors, {}).freeze,
+            matrix_constructors: attributes.fetch(:matrix_constructors, {}).freeze,
+            texture_functions: attributes.fetch(:texture_functions, {}).freeze,
+            default_type_name: attributes.fetch(:default_type_name, "float"),
+            math_functions: attributes.fetch(:math_functions, {}).freeze,
+            vector_ops: attributes.fetch(:vector_ops, {}).freeze,
+            call_resolver: attributes[:call_resolver],
+            binary_op_resolver: attributes[:binary_op_resolver]
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -3,85 +3,244 @@
 module RLSL
   module Prism
     module Emitters
-      class WGSLEmitter < BaseEmitter
-        TYPE_MAP = {
-          float: "f32",
-          int: "i32",
-          bool: "bool",
-          vec2: "vec2<f32>",
-          vec3: "vec3<f32>",
-          vec4: "vec4<f32>",
-          mat2: "mat2x2<f32>",
-          mat3: "mat3x3<f32>",
-          mat4: "mat4x4<f32>",
-          sampler2D: "texture_2d<f32>"
-        }.freeze
-
-        VECTOR_CONSTRUCTORS = {
-          vec2: "vec2<f32>",
-          vec3: "vec3<f32>",
-          vec4: "vec4<f32>"
-        }.freeze
-
-        MATRIX_CONSTRUCTORS = {
-          mat2: "mat2x2<f32>",
-          mat3: "mat3x3<f32>",
-          mat4: "mat4x4<f32>"
-        }.freeze
-
-        TEXTURE_FUNCTIONS = {
-          texture2D: "textureSample",
-          texture: "textureSample",
-          textureLod: "textureSampleLevel"
-        }.freeze
+      class WGSLEmitter < TargetEmitter
+        PROFILE = TargetProfile.new(
+          type_map: {
+            float: "f32",
+            int: "i32",
+            bool: "bool",
+            vec2: "vec2<f32>",
+            vec3: "vec3<f32>",
+            vec4: "vec4<f32>",
+            mat2: "mat2x2<f32>",
+            mat3: "mat3x3<f32>",
+            mat4: "mat4x4<f32>",
+            sampler2D: "texture_2d<f32>"
+          },
+          vector_constructors: {
+            vec2: "vec2<f32>",
+            vec3: "vec3<f32>",
+            vec4: "vec4<f32>"
+          },
+          matrix_constructors: {
+            mat2: "mat2x2<f32>",
+            mat3: "mat3x3<f32>",
+            mat4: "mat4x4<f32>"
+          },
+          texture_functions: {
+            texture2D: "textureSample",
+            texture: "textureSample",
+            textureLod: "textureSampleLevel"
+          },
+          default_type_name: "f32"
+        ).freeze
 
         protected
 
-        def type_name(type)
-          TYPE_MAP[type&.to_sym] || "f32"
-        end
-
         def emit_var_decl(node)
           type = type_name(node.type || :float)
+          return "var #{node.name}: #{type}" unless node.initializer
+
+          if node.initializer.is_a?(IR::ArrayLiteral)
+            element_type_symbol = TypeShapes.element_type(node.type) || :float
+            element_type = type_name(element_type_symbol)
+            size = node.initializer.elements.length
+            values = node.initializer.elements.map do |element|
+              emit_typed_argument(element, element_type_symbol)
+            end.join(", ")
+            return "var #{node.name}: array<#{element_type}, #{size}> = array<#{element_type}, #{size}>(#{values})"
+          end
+
           value = emit(node.initializer)
-          "let #{node.name}: #{type} = #{value}"
+          binding = node.mutable ? "var" : "let"
+          "#{binding} #{node.name}: #{type} = #{value}"
+        end
+
+        def emit_for_loop(node)
+          variable = node.variable
+          counter = loop_variable_mutated?(node) ? next_temporary_name("i") : variable
+          start_val = emit(node.range_start)
+          end_val = emit(node.range_end)
+          body = emit_indented_block(node.body)
+          body = "#{indent}  var #{variable}: i32 = #{counter};\n#{body}" if counter != variable
+
+          comparison = node.exclude_end ? "<" : "<="
+          return "for (var #{counter}: i32 = #{start_val}; #{counter} #{comparison} #{end_val}; #{counter}++) {\n#{body}#{indent}}" if node.range_end.is_a?(IR::Literal)
+
+          bound = next_temporary_name("end")
+          "let #{bound}: i32 = #{end_val};\n#{indent}for (var #{counter}: i32 = #{start_val}; #{counter} #{comparison} #{bound}; #{counter}++) {\n#{body}#{indent}}"
+        end
+
+        def emit_ternary(_node)
+          raise TargetCapabilityError,
+                "WGSL conditional expressions cannot be emitted without eager branch evaluation"
+        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)
-          name = node.name.to_sym
+          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_function_definition(node)
+          name = node.name
+          mutable_params = mutated_parameters(node)
+          initializers = []
+          sampler_params = {}
+          params = node.params.flat_map do |param|
+            type = node.param_types[param] || :float
+            if type == :sampler2D
+              if mutable_params.include?(param)
+                raise TargetCapabilityError, "WGSL texture parameter #{param} cannot be reassigned"
+              end
+
+              sampler_params[param] = next_temporary_name("sampler")
+              ["#{param}: #{type_name(type)}", "#{sampler_params[param]}: sampler"]
+            elsif mutable_params.include?(param)
+              argument = next_temporary_name("param")
+              initializers << "#{indent}  var #{param}: #{type_name(type)} = #{argument};\n"
+              ["#{argument}: #{type_name(type)}"]
+            else
+              ["#{param}: #{type_name(type)}"]
+            end
+          end.join(", ")
+
+          if node.return_type.is_a?(Array)
+            struct_def = emit_result_struct(name, node.return_type)
+            body = with_return_struct_name("#{name}_result") do
+              with_sampler_parameters(sampler_params) do
+                with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+              end
+            end
+
+            "#{struct_def}fn #{name}(#{params}) -> #{name}_result {\n#{initializers.join}#{body}#{indent}}\n"
+          else
+            return_type = type_name(node.return_type || :float)
+            body = with_sampler_parameters(sampler_params) do
+              with_return_type(node.return_type) { emit_indented_block(node.body, needs_return: true) }
+            end
 
-          if VECTOR_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{VECTOR_CONSTRUCTORS[name]}(#{args})"
+            "fn #{name}(#{params}) -> #{return_type} {\n#{initializers.join}#{body}#{indent}}\n"
           end
+        end
+
+        def emit_result_struct(func_name, types)
+          fields = types.each_with_index.map do |type, index|
+            "#{indent}v#{index}: #{type_name(type)},"
+          end.join("\n")
+          "struct #{func_name}_result {\n#{fields}\n}\n"
+        end
 
-          if MATRIX_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{MATRIX_CONSTRUCTORS[name]}(#{args})"
+        def emit_hoisted_declarations(node)
+          node.hoisted_variables.map do |name, type|
+            "#{indent}var #{name}: #{type_name(type || :float)};\n"
+          end.join
+        end
+
+        def emit_global_decl(node)
+          if node.initializer.is_a?(IR::ArrayLiteral)
+            element_type_symbol = node.element_type || TypeShapes.element_type(node.initializer.type) || :float
+            element_type = type_name(element_type_symbol)
+            size = node.array_size || node.initializer.elements.length
+            values = node.initializer.elements.map do |element|
+              emit_typed_argument(element, element_type_symbol)
+            end.join(", ")
+            prefix = node.is_const ? "const" : "var<private>"
+            return "#{prefix} #{node.name}: array<#{element_type}, #{size}> = array<#{element_type}, #{size}>(#{values})"
           end
 
-          if TEXTURE_FUNCTIONS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{TEXTURE_FUNCTIONS[name]}(#{args})"
+          prefix = node.is_const ? "const" : "var<private>"
+          "#{prefix} #{node.name}: #{type_name(node.type || :float)} = #{emit(node.initializer)}"
+        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_texture_call(name, node)
+          return unless profile.texture_functions.key?(name) && node.args.length >= 2
+
+          texture = emit(node.args[0])
+          sampler = sampler_name(node.args[0], texture)
+          uv = emit(node.args[1])
+          lod = node.args[2] ? emit_typed_argument(node.args[2], :float) : "0.0"
+          "textureSampleLevel(#{texture}, #{sampler}, #{uv}, #{lod})"
+        end
+
+        def emit_named_call(name, args, receiver: nil, expected_types: [])
+          arguments = receiver ? [receiver, *args] : args
+          rendered = arguments.each_with_index.flat_map do |argument, index|
+            if expected_types[index] == :sampler2D
+              texture = emit(argument)
+              [texture, sampler_name(argument, texture)]
+            else
+              [emit_typed_argument(argument, expected_types[index])]
+            end
           end
+          "#{name}(#{rendered.join(', ')})"
+        end
 
-          args = node.args.map { |arg| emit(arg) }.join(", ")
-          "#{name}(#{args})"
+        def emit_multiple_assignment_target(target, declaration)
+          declaration ? "var #{target.name}: #{type_name(target.type || :float)}" : target.name.to_s
         end
 
-        def emit_for_loop(node)
-          var = node.variable
-          start_val = emit(node.range_start)
-          end_val = emit(node.range_end)
-          body = emit_indented_block(node.body)
+        def emit_temporary_declaration(type, name, value)
+          "let #{name}: #{type} = #{value}"
+        end
 
-          "for (var #{var}: i32 = #{start_val}; #{var} < #{end_val}; #{var}++) {\n#{body}#{indent}}"
+        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
 
-        def emit_binary_op(node)
-          left = emit_with_precedence(node.left, node.operator)
-          right = emit_with_precedence(node.right, node.operator)
-          "#{left} #{node.operator} #{right}"
+        private
+
+        def mutated_parameters(node)
+          parameters = node.params.to_set
+          IR::Traversal.each(node.body).each_with_object(Set.new) do |current, names|
+            case current
+            when IR::Assignment
+              names.add(current.target.name) if current.target.is_a?(IR::VarRef) && parameters.include?(current.target.name)
+            when IR::MultipleAssignment
+              current.targets.each { |target| names.add(target.name) if parameters.include?(target.name) }
+            end
+          end
+        end
+
+        def with_sampler_parameters(parameters)
+          previous = @sampler_parameters
+          @sampler_parameters = parameters
+          yield
+        ensure
+          @sampler_parameters = previous
+        end
+
+        def sampler_name(argument, texture)
+          return @sampler_parameters[argument.name] if argument.is_a?(IR::VarRef) && @sampler_parameters&.key?(argument.name)
+
+          "#{texture}_sampler"
         end
       end
     end

data/lib/rlsl/prism/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module RLSL
+  module Prism
+    class UnsupportedSyntaxError < RLSL::Error; end
+  end
+end

data/lib/rlsl/prism/ir/control_flow.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class IfStatement < Node
+        attr_reader :condition, :then_branch, :else_branch, :hoisted_variables
+
+        visits :visit_if_statement
+
+        def initialize(condition, then_branch, else_branch = nil, type = nil, hoisted_variables: {})
+          super()
+          @condition = condition
+          @then_branch = then_branch
+          @else_branch = else_branch
+          @hoisted_variables = hoisted_variables
+          @type = type
+        end
+      end
+
+      class Return < Node
+        attr_reader :expression
+
+        visits :visit_return
+
+        def initialize(expression)
+          super()
+          @expression = expression
+          @type = expression&.type
+        end
+      end
+
+      class Assignment < Node
+        attr_reader :target, :value
+
+        visits :visit_assignment
+
+        def initialize(target, value)
+          super()
+          @target = target
+          @value = value
+          @type = value&.type
+        end
+      end
+
+      class ForLoop < Node
+        attr_reader :variable, :range_start, :range_end, :body, :exclude_end
+
+        visits :visit_for_loop
+
+        def initialize(variable, range_start, range_end, body, exclude_end: true)
+          super()
+          @variable = variable
+          @range_start = range_start
+          @range_end = range_end
+          @body = body
+          @exclude_end = exclude_end
+          @type = nil
+        end
+      end
+
+      class WhileLoop < Node
+        attr_reader :condition, :body
+
+        visits :visit_while_loop
+
+        def initialize(condition, body)
+          super()
+          @condition = condition
+          @body = body
+          @type = nil
+        end
+      end
+
+      class Break < Node
+        visits :visit_break
+
+        def initialize
+          super()
+          @type = nil
+        end
+      end
+    end
+  end
+end

data/lib/rlsl/prism/ir/definitions.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class GlobalDecl < Node
+        attr_reader :name, :initializer
+        attr_accessor :is_const, :is_static, :array_size, :element_type
+
+        visits :visit_global_decl
+
+        def initialize(name, initializer, type: nil, is_const: false, is_static: true, array_size: nil, element_type: nil)
+          super()
+          @name = name
+          @initializer = initializer
+          @type = type
+          @is_const = is_const
+          @is_static = is_static
+          @array_size = array_size
+          @element_type = element_type
+        end
+      end
+
+      class FunctionDefinition < Node
+        attr_reader :name, :params, :body
+        attr_accessor :return_type, :param_types
+
+        visits :visit_function_definition
+
+        def initialize(name, params, body, return_type: nil, param_types: {})
+          super()
+          @name = name
+          @params = params
+          @body = body
+          @return_type = return_type
+          @param_types = param_types
+          @type = return_type
+        end
+      end
+
+      class MultipleAssignment < Node
+        attr_reader :targets, :value, :declarations
+
+        visits :visit_multiple_assignment
+
+        def initialize(targets, value, declarations: nil)
+          super()
+          @targets = targets
+          @value = value
+          @declarations = declarations || Array.new(targets.length, true)
+          @type = nil
+        end
+      end
+
+      class TupleType
+        attr_reader :types
+
+        def initialize(*types)
+          @types = types
+        end
+
+        def to_sym
+          :"tuple_#{types.map(&:to_s).join('_')}"
+        end
+
+        def ==(other)
+          other.is_a?(self.class) && types == other.types
+        end
+
+        alias eql? ==
+
+        def hash
+          [self.class, types].hash
+        end
+
+        def inspect
+          "#<#{self.class.name} #{types.inspect}>"
+        end
+      end
+    end
+  end
+end