rlsl 0.1.1 → 1.0.1

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

@@ -3,150 +3,203 @@
 module RLSL
   module Prism
     module Emitters
-      class CEmitter < BaseEmitter
-        TYPE_MAP = {
-          float: "float",
-          int: "int",
-          bool: "int",
-          vec2: "vec2",
-          vec3: "vec3",
-          vec4: "vec4",
-          mat2: "mat2",
-          mat3: "mat3",
-          mat4: "mat4",
-          sampler2D: "sampler2D"
-        }.freeze
-
-        VECTOR_CONSTRUCTORS = {
-          vec2: "vec2_new",
-          vec3: "vec3_new",
-          vec4: "vec4_new"
-        }.freeze
-
-        MATRIX_CONSTRUCTORS = {
-          mat2: "mat2_new",
-          mat3: "mat3_new",
-          mat4: "mat4_new"
-        }.freeze
-
-        TEXTURE_FUNCTIONS = {
-          texture2D: "texture_sample",
-          texture: "texture_sample",
-          textureLod: "texture_sample_lod"
-        }.freeze
-
-        VECTOR_OPS = {
-          "+" => "add",
-          "-" => "sub",
-          "*" => "mul",
-          "/" => "div"
-        }.freeze
-
-        MATH_FUNCTIONS = {
-          sin: "sinf",
-          cos: "cosf",
-          tan: "tanf",
-          asin: "asinf",
-          acos: "acosf",
-          atan: "atanf",
-          atan2: "atan2f",
-          sqrt: "sqrtf",
-          pow: "powf",
-          exp: "expf",
-          log: "logf",
-          abs: "fabsf",
-          floor: "floorf",
-          ceil: "ceilf",
-          min: "fminf",
-          max: "fmaxf",
-          fract: "fract",
-          mod: "fmodf",
-          clamp: "clamp_f",
-          mix: "mix_f",
-          smoothstep: "smoothstep",
-          length: "vec_length",
-          normalize: "vec_normalize",
-          dot: "vec_dot"
-        }.freeze
+      class CEmitter < TargetEmitter
+        PROFILE = TargetProfile.new(
+          type_map: {
+            float: "float",
+            int: "int",
+            bool: "int",
+            vec2: "vec2",
+            vec3: "vec3",
+            vec4: "vec4",
+            mat2: "mat2",
+            mat3: "mat3",
+            mat4: "mat4",
+            sampler2D: "sampler2D"
+          },
+          vector_constructors: {
+            vec2: "vec2_new",
+            vec3: "vec3_new",
+            vec4: "vec4_new"
+          },
+          matrix_constructors: {
+            mat2: "mat2_new",
+            mat3: "mat3_new",
+            mat4: "mat4_new"
+          },
+          texture_functions: {
+            texture2D: "texture_sample",
+            texture: "texture_sample",
+            textureLod: "texture_sample_lod"
+          },
+          math_functions: {
+            sin: "sinf",
+            cos: "cosf",
+            tan: "tanf",
+            asin: "asinf",
+            acos: "acosf",
+            atan: "atanf",
+            atan2: "atan2f",
+            sqrt: "sqrtf",
+            pow: "powf",
+            exp: "expf",
+            log: "logf",
+            abs: "fabsf",
+            floor: "floorf",
+            ceil: "ceilf",
+            sign: "sign_f",
+            step: "step_f",
+            min: "fminf",
+            max: "fmaxf",
+            fract: "fract",
+            mod: "rlsl_mod",
+            clamp: "clamp_f",
+            mix: "mix_f",
+            smoothstep: "smoothstep",
+            length: "vec_length",
+            normalize: "vec_normalize",
+            dot: "vec_dot"
+          },
+          vector_ops: {
+            "+" => "add",
+            "-" => "sub",
+            "*" => "mul",
+            "/" => "div"
+          },
+          call_resolver: :emit_profile_func_call,
+          binary_op_resolver: :emit_profile_binary_op
+        ).freeze
 
         protected
 
-        def type_name(type)
-          TYPE_MAP[type&.to_sym] || "float"
-        end
+        def format_number(value, type: nil)
+          formatted = super(value, type: type)
+          return formatted if type == :int || value.is_a?(Integer)
 
-        def format_number(value)
-          formatted = super(value)
           "#{formatted}f"
         end
 
-        def emit_func_call(node)
+        def emit_profile_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})"
+          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 MATRIX_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{MATRIX_CONSTRUCTORS[name]}(#{args})"
+          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 TEXTURE_FUNCTIONS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{TEXTURE_FUNCTIONS[name]}(#{args})"
+          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 %i[length normalize dot].include?(name) && node.args.first&.type
-            vec_type = node.args.first.type
-            if %i[vec2 vec3 vec4].include?(vec_type)
-              func_name = "#{vec_type}_#{name}"
-              args = node.args.map { |arg| emit(arg) }.join(", ")
-              return "#{func_name}(#{args})"
-            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
 
-          if MATH_FUNCTIONS.key?(name)
-            func_name = MATH_FUNCTIONS[name]
+        def emit_profile_binary_op(node)
+          return emit_float_modulo(node) if node.operator == "%" && node.type == :float
+          return unless profile.vector_ops.key?(node.operator)
 
-            if name == :mix && node.args.first&.type
-              first_type = node.args.first.type
-              if %i[vec2 vec3 vec4].include?(first_type)
-                func_name = "mix_v3"
-              end
-            end
+          emit_vector_binary_op(node)
+        end
 
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{func_name}(#{args})"
+        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
 
           super
         end
 
-        def emit_binary_op(node)
-          left_type = node.left.type
-          op = node.operator
+        def emit_bool_literal(node)
+          node.value ? "1" : "0"
+        end
+
+        def emit_field_access(node)
+          return super if node.receiver.type == :uniforms
 
-          if vector_type?(left_type) && VECTOR_OPS.key?(op)
-            vec_func = "#{left_type}_#{VECTOR_OPS[op]}"
-            left = emit(node.left)
-            right = emit(node.right)
-            return "#{vec_func}(#{left}, #{right})"
+          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)
 
-          super
+          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_bool_literal(node)
-          node.value ? "1" : "0"
+        def emit_float_operand(node)
+          return emit(node) unless node.type == :int
+
+          "(float)(#{emit(node)})"
         end
 
         private
 
+        def vector_math_call?(name, node)
+          %i[length normalize dot].include?(name) && vector_type?(node.args.first&.type)
+        end
+
+        def vector_mix_call?(name, node)
+          name == :mix && vector_type?(node.args.first&.type)
+        end
+
         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

@@ -3,70 +3,83 @@
 module RLSL
   module Prism
     module Emitters
-      class GLSLEmitter < BaseEmitter
-        TYPE_MAP = {
-          float: "float",
-          int: "int",
-          bool: "bool",
-          vec2: "vec2",
-          vec3: "vec3",
-          vec4: "vec4",
-          mat2: "mat2",
-          mat3: "mat3",
-          mat4: "mat4",
-          sampler2D: "sampler2D"
-        }.freeze
+      class GLSLEmitter < TargetEmitter
+        PROFILE = TargetProfile.new(
+          type_map: {
+            float: "float",
+            int: "int",
+            bool: "bool",
+            vec2: "vec2",
+            vec3: "vec3",
+            vec4: "vec4",
+            mat2: "mat2",
+            mat3: "mat3",
+            mat4: "mat4",
+            sampler2D: "sampler2D"
+          },
+          vector_constructors: {
+            vec2: "vec2",
+            vec3: "vec3",
+            vec4: "vec4"
+          },
+          matrix_constructors: {
+            mat2: "mat2",
+            mat3: "mat3",
+            mat4: "mat4"
+          },
+          texture_functions: {
+            texture2D: "texture2D",
+            texture: "texture",
+            textureLod: "textureLod"
+          }
+        ).freeze
 
-        VECTOR_CONSTRUCTORS = {
-          vec2: "vec2",
-          vec3: "vec3",
-          vec4: "vec4"
-        }.freeze
+        protected
 
-        MATRIX_CONSTRUCTORS = {
-          mat2: "mat2",
-          mat3: "mat3",
-          mat4: "mat4"
-        }.freeze
+        def function_qualifier
+          ""
+        end
 
-        TEXTURE_FUNCTIONS = {
-          texture2D: "texture2D",
-          texture: "texture",
-          textureLod: "textureLod"
-        }.freeze
+        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
 
-        protected
+          super
+        end
 
-        def type_name(type)
-          TYPE_MAP[type&.to_sym] || "float"
+        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_func_call(node)
-          name = node.name.to_sym
+        def emit_field_access(node)
+          return node.field.to_s if node.receiver.type == :uniforms && node.type == :sampler2D
 
-          if VECTOR_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{VECTOR_CONSTRUCTORS[name]}(#{args})"
-          end
+          super
+        end
 
-          if MATRIX_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{MATRIX_CONSTRUCTORS[name]}(#{args})"
-          end
+        def emit_texture_call(name, node)
+          return unless profile.texture_functions.key?(name) && node.args.length >= 2
 
-          if TEXTURE_FUNCTIONS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{TEXTURE_FUNCTIONS[name]}(#{args})"
+          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
 
-          args = node.args.map { |arg| emit(arg) }.join(", ")
-          "#{name}(#{args})"
+          super
         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_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/msl_emitter.rb

@@ -3,72 +3,87 @@
 module RLSL
   module Prism
     module Emitters
-      class MSLEmitter < BaseEmitter
-        TYPE_MAP = {
-          float: "float",
-          int: "int",
-          bool: "bool",
-          vec2: "float2",
-          vec3: "float3",
-          vec4: "float4",
-          mat2: "float2x2",
-          mat3: "float3x3",
-          mat4: "float4x4",
-          sampler2D: "texture2d<float>"
-        }.freeze
+      class MSLEmitter < TargetEmitter
+        PROFILE = TargetProfile.new(
+          type_map: {
+            float: "float",
+            int: "int",
+            bool: "bool",
+            vec2: "float2",
+            vec3: "float3",
+            vec4: "float4",
+            mat2: "float2x2",
+            mat3: "float3x3",
+            mat4: "float4x4",
+            sampler2D: "texture2d<float>"
+          },
+          vector_constructors: {
+            vec2: "float2",
+            vec3: "float3",
+            vec4: "float4"
+          },
+          matrix_constructors: {
+            mat2: "float2x2",
+            mat3: "float3x3",
+            mat4: "float4x4"
+          },
+          texture_functions: {
+            texture2D: "sample",
+            texture: "sample",
+            textureLod: "sample"
+          }
+        ).freeze
 
-        VECTOR_CONSTRUCTORS = {
-          vec2: "float2",
-          vec3: "float3",
-          vec4: "float4"
-        }.freeze
+        protected
 
-        MATRIX_CONSTRUCTORS = {
-          mat2: "float2x2",
-          mat3: "float3x3",
-          mat4: "float4x4"
-        }.freeze
+        def emit_texture_call(name, node)
+          return unless profile.texture_functions.key?(name) && node.args.length >= 2
 
-        TEXTURE_FUNCTIONS = {
-          texture2D: "sample",
-          texture: "sample",
-          textureLod: "sample"
-        }.freeze
+          texture = emit(node.args[0])
+          uv = emit(node.args[1])
+          if name == :textureLod
+            lod = emit_typed_argument(node.args[2], :float)
+            return "#{texture}.sample(rlsl_texture_sampler, #{uv}, level(#{lod}))"
+          end
 
-        protected
+          "#{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
 
-        def type_name(type)
-          TYPE_MAP[type&.to_sym] || "float"
+          super
         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})"
+          if node.name.to_sym == :mod
+            args = node.args.map { |argument| emit_float_operand(argument) }
+            return "rlsl_mod(#{args.join(', ')})"
           end
-
-          if MATRIX_CONSTRUCTORS.key?(name)
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{MATRIX_CONSTRUCTORS[name]}(#{args})"
+          if node.name.to_sym == :atan && node.args.length == 2
+            return emit_named_call("atan2", node.args, expected_types: node.expected_arg_types)
           end
 
-          # MSL texture sampling: texture.sample(sampler, uv)
-          if TEXTURE_FUNCTIONS.key?(name) && node.args.length >= 2
-            texture = emit(node.args[0])
-            uv = emit(node.args[1])
-            return "#{texture}.sample(textureSampler, #{uv})"
-          end
+          super
+        end
 
-          args = node.args.map { |arg| emit(arg) }.join(", ")
-          "#{name}(#{args})"
+        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_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_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