rlsl 0.1.0

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+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
+
+        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)
+          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
+        end
+
+        def emit_binary_op(node)
+          left_type = node.left.type
+          op = 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
+        end
+
+        def emit_bool_literal(node)
+          node.value ? "1" : "0"
+        end
+
+        private
+
+        def vector_type?(type)
+          %i[vec2 vec3 vec4].include?(type)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+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
+
+        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_binary_op(node)
+          left = emit_with_precedence(node.left, node.operator)
+          right = emit_with_precedence(node.right, node.operator)
+          "#{left} #{node.operator} #{right}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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
+
+        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)
+          end_val = emit(node.range_end)
+          body = emit_indented_block(node.body)
+
+          "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}"
+        end
+      end
+    end
+  end
+end