rlsl 0.1.1 → 1.0.0

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

@@ -3,72 +3,46 @@
 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)
           value = emit(node.initializer)
           "let #{node.name}: #{type} = #{value}"
         end
 
-        def emit_func_call(node)
-          name = node.name.to_sym
-
-          if VECTOR_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{VECTOR_CONSTRUCTORS[name]}(#{args})"
-          end
-
-          if MATRIX_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{MATRIX_CONSTRUCTORS[name]}(#{args})"
-          end
-
-          if TEXTURE_FUNCTIONS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{TEXTURE_FUNCTIONS[name]}(#{args})"
-          end
-
-          args = node.args.map { |arg| emit(arg) }.join(", ")
-          "#{name}(#{args})"
-        end
-
         def emit_for_loop(node)
           var = node.variable
           start_val = emit(node.range_start)
@@ -78,10 +52,40 @@ module RLSL
           "for (var #{var}: i32 = #{start_val}; #{var} < #{end_val}; #{var}++) {\n#{body}#{indent}}"
         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}"
+        def emit_ternary(node)
+          condition = emit(node.condition)
+          then_expr = emit(node.then_expr)
+          else_expr = emit(node.else_expr)
+          "select(#{else_expr}, #{then_expr}, #{condition})"
+        end
+
+        def emit_function_definition(node)
+          name = node.name
+          params = node.params.map do |param|
+            param_type = type_name(node.param_types[param] || :float)
+            "#{param}: #{param_type}"
+          end.join(", ")
+
+          if node.return_type.is_a?(Array)
+            @current_return_struct_name = "#{name}_result"
+            struct_def = emit_result_struct(name, node.return_type)
+            body = emit_indented_block(node.body, needs_return: true)
+            @current_return_struct_name = nil
+
+            "#{struct_def}fn #{name}(#{params}) -> #{name}_result {\n#{body}\n#{indent}}\n"
+          else
+            return_type = type_name(node.return_type || :float)
+            body = emit_indented_block(node.body, needs_return: true)
+
+            "fn #{name}(#{params}) -> #{return_type} {\n#{body}\n#{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
       end
     end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class IfStatement < Node
+        attr_reader :condition, :then_branch, :else_branch
+
+        visits :visit_if_statement
+
+        def initialize(condition, then_branch, else_branch = nil, type = nil)
+          super()
+          @condition = condition
+          @then_branch = then_branch
+          @else_branch = else_branch
+          @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
+
+        visits :visit_for_loop
+
+        def initialize(variable, range_start, range_end, body)
+          super()
+          @variable = variable
+          @range_start = range_start
+          @range_end = range_end
+          @body = body
+          @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,67 @@
+# 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
+
+        visits :visit_multiple_assignment
+
+        def initialize(targets, value)
+          super()
+          @targets = targets
+          @value = value
+          @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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class Block < Node
+        attr_reader :statements
+
+        visits :visit_block
+
+        def initialize(statements = [])
+          super()
+          @statements = statements
+        end
+      end
+
+      class VarDecl < Node
+        attr_reader :name, :initializer
+
+        visits :visit_var_decl
+
+        def initialize(name, initializer, type = nil)
+          super()
+          @name = name
+          @initializer = initializer
+          @type = type
+        end
+      end
+
+      class VarRef < Node
+        attr_reader :name
+
+        visits :visit_var_ref
+
+        def initialize(name, type = nil)
+          super()
+          @name = name
+          @type = type
+        end
+      end
+
+      class Literal < Node
+        attr_reader :value
+
+        visits :visit_literal
+
+        def initialize(value, type = nil)
+          super()
+          @value = value
+          @type = type || (value.is_a?(Float) ? :float : :int)
+        end
+      end
+
+      class BoolLiteral < Node
+        attr_reader :value
+
+        visits :visit_bool_literal
+
+        def initialize(value)
+          super()
+          @value = value
+          @type = :bool
+        end
+      end
+
+      class BinaryOp < Node
+        attr_reader :operator, :left, :right
+
+        visits :visit_binary_op
+
+        def initialize(operator, left, right, type = nil)
+          super()
+          @operator = operator
+          @left = left
+          @right = right
+          @type = type
+        end
+      end
+
+      class UnaryOp < Node
+        attr_reader :operator, :operand
+
+        visits :visit_unary_op
+
+        def initialize(operator, operand, type = nil)
+          super()
+          @operator = operator
+          @operand = operand
+          @type = type
+        end
+      end
+
+      class FuncCall < Node
+        attr_reader :name, :args, :receiver
+
+        visits :visit_func_call
+
+        def initialize(name, args = [], receiver = nil, type = nil)
+          super()
+          @name = name
+          @args = args
+          @receiver = receiver
+          @type = type
+        end
+      end
+
+      class FieldAccess < Node
+        attr_reader :receiver, :field
+
+        visits :visit_field_access
+
+        def initialize(receiver, field, type = nil)
+          super()
+          @receiver = receiver
+          @field = field
+          @type = type
+        end
+      end
+
+      class Swizzle < Node
+        attr_reader :receiver, :components
+
+        visits :visit_swizzle
+
+        def initialize(receiver, components, type = nil)
+          super()
+          @receiver = receiver
+          @components = components
+          @type = type
+        end
+      end
+
+      class Ternary < Node
+        attr_reader :condition, :then_expr, :else_expr
+
+        visits :visit_ternary
+
+        def initialize(condition, then_expr, else_expr, type = nil)
+          super()
+          @condition = condition
+          @then_expr = then_expr
+          @else_expr = else_expr
+          @type = type
+        end
+      end
+
+      class Constant < Node
+        attr_reader :name
+
+        visits :visit_constant
+
+        def initialize(name, type = :float)
+          super()
+          @name = name
+          @type = type
+        end
+      end
+
+      class Parenthesized < Node
+        attr_reader :expression
+
+        visits :visit_parenthesized
+
+        def initialize(expression)
+          super()
+          @expression = expression
+          @type = expression&.type
+        end
+      end
+
+      class ArrayLiteral < Node
+        attr_reader :elements
+
+        visits :visit_array_literal
+
+        def initialize(elements, type = nil)
+          super()
+          @elements = elements
+          @type = type
+        end
+      end
+
+      class ArrayIndex < Node
+        attr_reader :array, :index
+
+        visits :visit_array_index
+
+        def initialize(array, index, type = nil)
+          super()
+          @array = array
+          @index = index
+          @type = type
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RLSL
+  module Prism
+    module IR
+      class Node
+        attr_accessor :type
+
+        def self.visits(method_name)
+          define_method(:accept) do |visitor|
+            visitor.public_send(method_name, self)
+          end
+        end
+
+        def accept(_visitor)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end