rlsl 0.1.1 → 1.0.0

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

@@ -3,139 +3,88 @@
 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",
+            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"
+          },
+          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)
           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})"
-          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
-
-          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
-          end
-
-          if MATH_FUNCTIONS.key?(name)
-            func_name = MATH_FUNCTIONS[name]
-
-            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
-
-            args = node.args.map { |arg| emit(arg) }.join(", ")
-            return "#{func_name}(#{args})"
-          end
-
-          super
+          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)
         end
 
-        def emit_binary_op(node)
-          left_type = node.left.type
-          op = node.operator
+        def emit_profile_binary_op(node)
+          return unless vector_type?(node.left.type) && profile.vector_ops.key?(node.operator)
 
-          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})"
-          end
-
-          super
+          emit_named_call("#{node.left.type}_#{profile.vector_ops[node.operator]}", [node.left, node.right])
         end
 
         def emit_bool_literal(node)
@@ -144,6 +93,14 @@ module RLSL
 
         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

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

@@ -3,71 +3,36 @@
 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
-
-        VECTOR_CONSTRUCTORS = {
-          vec2: "vec2",
-          vec3: "vec3",
-          vec4: "vec4"
-        }.freeze
-
-        MATRIX_CONSTRUCTORS = {
-          mat2: "mat2",
-          mat3: "mat3",
-          mat4: "mat4"
-        }.freeze
-
-        TEXTURE_FUNCTIONS = {
-          texture2D: "texture2D",
-          texture: "texture",
-          textureLod: "textureLod"
-        }.freeze
-
-        protected
-
-        def type_name(type)
-          TYPE_MAP[type&.to_sym] || "float"
-        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_binary_op(node)
-          left = emit_with_precedence(node.left, node.operator)
-          right = emit_with_precedence(node.right, node.operator)
-          "#{left} #{node.operator} #{right}"
-        end
+      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
       end
     end
   end

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

@@ -3,72 +3,45 @@
 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
-
-        VECTOR_CONSTRUCTORS = {
-          vec2: "float2",
-          vec3: "float3",
-          vec4: "float4"
-        }.freeze
-
-        MATRIX_CONSTRUCTORS = {
-          mat2: "float2x2",
-          mat3: "float3x3",
-          mat4: "float4x4"
-        }.freeze
-
-        TEXTURE_FUNCTIONS = {
-          texture2D: "sample",
-          texture: "sample",
-          textureLod: "sample"
-        }.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
 
         protected
 
-        def type_name(type)
-          TYPE_MAP[type&.to_sym] || "float"
-        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
-
-          # 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
-
-          args = node.args.map { |arg| emit(arg) }.join(", ")
-          "#{name}(#{args})"
-        end
+        def emit_texture_call(name, node)
+          return unless profile.texture_functions.key?(name) && node.args.length >= 2
 
-        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}"
+          texture = emit(node.args[0])
+          uv = emit(node.args[1])
+          "#{texture}.sample(textureSampler, #{uv})"
         end
       end
     end

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

@@ -0,0 +1,77 @@
+# 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]
+          return emit_named_call(constructor_name, node.args) if constructor_name
+
+          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
+
+          emit_named_call(name, node.args, receiver: node.receiver)
+        end
+
+        def emit_binary_op(node)
+          resolved_binary_op = emit_profile_binary_op(node)
+          return resolved_binary_op if resolved_binary_op
+
+          left = emit_with_precedence(node.left, node.operator)
+          right = emit_with_precedence(node.right, node.operator)
+          "#{left} #{node.operator} #{right}"
+        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)
+        end
+
+        def emit_named_call(name, args, receiver: nil)
+          rendered_args = []
+          rendered_args << emit(receiver) if receiver
+          rendered_args.concat(args.map { |arg| emit(arg) })
+          "#{name}(#{rendered_args.join(', ')})"
+        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