rlsl 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0753b46ec16e2df8308ecab2b9e197cf24ab1d02f5028240d8fa6f9a886529b
-  data.tar.gz: dcaf85ad34c2e2f4aa9479dbe3f405fd063d9d46c47966a1d4e137a8c4c513cd
+  metadata.gz: 15d160bc13d36ac3efc480e1a99f20b374740d27d26a30a1eb73685883d16c67
+  data.tar.gz: 8f6a6dc93d8956138756c4e6356fb58b62b850998445b5dad8adcc02d22d4f18
 SHA512:
-  metadata.gz: 13bd3732c03a7b6f0c0244ee63cc4d49ebba3264fa1dc6e8a78237b8e1d0c69ed15129787174871556e6afb8452d8cba6fb6c8bbac3f31a5488765a9866a1977
-  data.tar.gz: e970cf8b44c96da77f52c0b6b68f578c896b710f2e5e41e5089726d652e762b51f1d6e3523393f4d31c355c9f3c845f7ca115dba2d1bba0e0e14d0e013dc06fc
+  metadata.gz: 644a31110884bacb33734231caee01dad98086a71f5d82738e343fe14e4316938a5432b0e3c3f8c47b40f8b940f534b786d46c9a3dc56ecaad2fd8414a857be4
+  data.tar.gz: fdd2eb0cb01d5dfbf5d485e5da40bbaa61dde2c92bd6d2dda9f3ebb1f3ff0538483c6ddaa0fe8beed09ef17207e24d846ced805a0f9f473473405c6d3c737db1

data/CHANGELOG.md

@@ -2,10 +2,19 @@
 
 ## Unreleased
 
+## 1.0.0 - 2026-04-05
+
+- Breaking: custom translator and emitter integrations now require explicit target `PROFILE` definitions; the old stateful Prism transpiler API and compatibility aliases have been removed.
+- Added: the Ruby shader DSL now supports ternary expressions, compound local assignments, and fragment transpilation that can reference globals/constants defined in Ruby helpers.
+- Added: `functions` now supports validated signatures via `define`, plus shorthand declarations for `int`, `bool`, `mat2`, `mat3`, `mat4`, and `sampler2D`.
+- Changed: compiled shaders and Metal shaders now validate and normalize uniform values at runtime, with clearer errors for missing uniforms and invalid scalar/vector/bool inputs.
+- Fixed: integer type inference for custom function calls is preserved, and block source extraction is more reliable for assigned `if` expressions and modifier forms.
+- Fixed: native extension builds and target capability errors are more robust, reducing backend-specific build and translation failures.
+
 ## 0.1.1 - 2026-01-04
 
 - Make metaco an optional runtime dependency and document its installation.
 
 ## 0.1.0 - 2026-01-04
 
-- Initial release.
+- Initial release.

data/README.md

@@ -180,6 +180,8 @@ $ bundle install
 $ rake test
 ```
 
+For a quick local coverage summary, run `COVERAGE=1 rake test`. It prints the overall `lib/` coverage and the lowest-covered files without requiring extra gems.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/rlsl/base_translator/call_parser.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RLSL
+  class BaseTranslator
+    class CallParser
+      def self.extract_group(segment, opening_index)
+        depth = 0
+        index = opening_index
+        quote = nil
+
+        while index < segment.length
+          char = segment[index]
+
+          if quote
+            quote = nil if char == quote && segment[index - 1] != "\\"
+          else
+            case char
+            when '"', "'"
+              quote = char
+            when "(", "[", "{"
+              depth += 1
+            when ")", "]", "}"
+              depth -= 1
+              return [segment[(opening_index + 1)...index], index] if depth.zero?
+            end
+          end
+
+          index += 1
+        end
+
+        raise ArgumentError, "Unbalanced delimiter in translation source"
+      end
+
+      def self.split_arguments(arguments_source)
+        arguments = []
+        depth = 0
+        quote = nil
+        start_index = 0
+
+        arguments_source.each_char.with_index do |char, index|
+          if quote
+            quote = nil if char == quote && arguments_source[index - 1] != "\\"
+            next
+          end
+
+          case char
+          when '"', "'"
+            quote = char
+          when "(", "[", "{"
+            depth += 1
+          when ")", "]", "}"
+            depth -= 1
+          when ","
+            next unless depth.zero?
+
+            arguments << arguments_source[start_index...index]
+            start_index = index + 1
+          end
+        end
+
+        tail = arguments_source[start_index..]
+        return [] if arguments.empty? && tail.to_s.strip.empty?
+
+        arguments << tail
+      end
+    end
+  end
+end

data/lib/rlsl/base_translator/code_rewriter.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "call_parser"
+require_relative "code_scanner"
+
+module RLSL
+  class BaseTranslator
+    class CodeRewriter
+      IDENTIFIER_PATTERN = /[A-Za-z_][A-Za-z0-9_]*/
+
+      def initialize(code)
+        @code = code.to_s
+      end
+
+      def rewrite(identifier_replacements:, call_rewrites:, removed_identifiers:)
+        rewrite_segment(
+          @code,
+          identifier_replacements: stringify_keys(identifier_replacements),
+          call_rewrites: stringify_keys(call_rewrites),
+          removed_identifiers: Array(removed_identifiers).map(&:to_s)
+        )
+      end
+
+      private
+
+      def rewrite_segment(segment, identifier_replacements:, call_rewrites:, removed_identifiers:)
+        CodeScanner.new(segment).each_segment.map do |code_segment|
+          code_segment.code? ? rewrite_code_segment(
+            code_segment.text,
+            identifier_replacements: identifier_replacements,
+            call_rewrites: call_rewrites,
+            removed_identifiers: removed_identifiers
+          ) : code_segment.text
+        end.join
+      end
+
+      def rewrite_code_segment(segment, identifier_replacements:, call_rewrites:, removed_identifiers:)
+        output = +""
+        index = 0
+
+        while index < segment.length
+          if identifier_start?(segment, index)
+            identifier, identifier_end = read_identifier(segment, index)
+            call_index = skip_whitespace(segment, identifier_end)
+
+            if call_rewrites.key?(identifier) && segment[call_index] == "("
+              arguments_source, closing_index = CallParser.extract_group(segment, call_index)
+              rewritten_args = CallParser.split_arguments(arguments_source).map do |argument|
+                rewrite_segment(
+                  argument,
+                  identifier_replacements: identifier_replacements,
+                  call_rewrites: call_rewrites,
+                  removed_identifiers: removed_identifiers
+                ).strip
+              end
+              output << render_call(call_rewrites.fetch(identifier), rewritten_args)
+              index = closing_index + 1
+              next
+            end
+
+            unless removed_identifiers.include?(identifier)
+              output << (identifier_replacements[identifier] || identifier)
+            end
+            index = identifier_end
+            next
+          end
+
+          output << segment[index]
+          index += 1
+        end
+
+        output
+      end
+
+      def render_call(rewriter, arguments)
+        return rewriter.call(arguments) if rewriter.respond_to?(:call)
+
+        "#{rewriter}(#{arguments.join(', ')})"
+      end
+
+      def stringify_keys(hash)
+        hash.each_with_object({}) do |(key, value), memo|
+          memo[key.to_s] = value
+        end
+      end
+
+      def identifier_start?(segment, index)
+        segment[index] =~ /[A-Za-z_]/
+      end
+
+      def read_identifier(segment, index)
+        match = IDENTIFIER_PATTERN.match(segment, index)
+        [match[0], match.end(0)]
+      end
+
+      def skip_whitespace(segment, index)
+        current_index = index
+        current_index += 1 while current_index < segment.length && whitespace?(segment[current_index])
+        current_index
+      end
+
+      def whitespace?(char)
+        char =~ /\s/
+      end
+    end
+  end
+end

data/lib/rlsl/base_translator/code_scanner.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RLSL
+  class BaseTranslator
+    class CodeScanner
+      Segment = Struct.new(:type, :text, keyword_init: true) do
+        def code?
+          type == :code
+        end
+      end
+
+      def initialize(code)
+        @code = code.to_s
+      end
+
+      def each_segment
+        return enum_for(:each_segment) unless block_given?
+
+        buffer = +""
+        index = 0
+
+        while index < @code.length
+          preserved, next_index = read_preserved_segment(index)
+          unless preserved
+            buffer << @code[index]
+            index += 1
+            next
+          end
+
+          yield Segment.new(type: :code, text: buffer) unless buffer.empty?
+          buffer = +""
+          yield Segment.new(type: preserved[:type], text: preserved[:text])
+          index = next_index
+        end
+
+        yield Segment.new(type: :code, text: buffer) unless buffer.empty?
+      end
+
+      private
+
+      def read_preserved_segment(index)
+        if line_comment_start?(index)
+          comment, next_index = read_line_comment(index)
+          return [{ type: :line_comment, text: comment }, next_index]
+        end
+
+        if block_comment_start?(index)
+          comment, next_index = read_block_comment(index)
+          return [{ type: :block_comment, text: comment }, next_index]
+        end
+
+        if string_delimiter?(@code[index])
+          literal, next_index = read_quoted(index)
+          return [{ type: :string, text: literal }, next_index]
+        end
+
+        nil
+      end
+
+      def line_comment_start?(index)
+        @code[index, 2] == "//"
+      end
+
+      def block_comment_start?(index)
+        @code[index, 2] == "/*"
+      end
+
+      def string_delimiter?(char)
+        char == '"' || char == "'"
+      end
+
+      def read_line_comment(index)
+        newline_index = @code.index("\n", index)
+        end_index = newline_index ? newline_index : @code.length
+        [@code[index...end_index], end_index]
+      end
+
+      def read_block_comment(index)
+        closing_index = @code.index("*/", index + 2)
+        raise ArgumentError, "Unterminated block comment in translation source" unless closing_index
+
+        end_index = closing_index + 2
+        [@code[index...end_index], end_index]
+      end
+
+      def read_quoted(index)
+        quote = @code[index]
+        cursor = index + 1
+
+        while cursor < @code.length
+          if @code[cursor] == quote && @code[cursor - 1] != "\\"
+            return [@code[index..cursor], cursor + 1]
+          end
+
+          cursor += 1
+        end
+
+        raise ArgumentError, "Unterminated string literal in translation source"
+      end
+    end
+  end
+end

data/lib/rlsl/base_translator.rb

@@ -1,92 +1,73 @@
 # frozen_string_literal: true
 
+require_relative "base_translator/code_rewriter"
+
 module RLSL
   class BaseTranslator
-    FUNC_REPLACEMENTS = [].freeze
+    SourceSnippet = Struct.new(:code, :format, keyword_init: true) do
+      def target_code?
+        format == :target
+      end
+    end
+
+    TargetProfile = Struct.new(
+      :uniform_target,
+      :identifier_replacements,
+      :call_rewrites,
+      :removed_identifiers,
+      keyword_init: true
+    ) do
+      def translate(code)
+        CodeRewriter.new(code).rewrite(
+          identifier_replacements: identifier_replacements,
+          call_rewrites: call_rewrites,
+          removed_identifiers: removed_identifiers
+        )
+      end
+    end
 
-    TYPE_MAP = {}.freeze
+    REMOVED_IDENTIFIERS = %w[static inline].freeze
 
     def initialize(uniforms, helpers_code, fragment_code)
       @uniforms = uniforms
-      @helpers_code = helpers_code || ""
-      @fragment_code = fragment_code || ""
+      @helpers_source = normalize_source(helpers_code)
+      @fragment_source = normalize_source(fragment_code)
     end
 
     def translate
-      helpers_translated = translate_code(@helpers_code)
-      fragment_translated = translate_code(@fragment_code)
+      helpers_translated = translate_code(@helpers_source)
+      fragment_translated = translate_code(@fragment_source)
       generate_shader(helpers_translated, fragment_translated)
     end
 
     protected
 
-    def translate_code(c_code)
-      return "" if c_code.nil? || c_code.empty?
+    def translate_code(source)
+      snippet = normalize_source(source)
+      return "" if snippet.code.empty?
+      return snippet.code if snippet.target_code?
 
-      result = c_code.dup
-
-      self.class::TYPE_MAP.each do |c_type, target_type|
-        result.gsub!(/\b#{c_type}\b/, target_type)
-      end
-
-      self.class::FUNC_REPLACEMENTS.each do |pattern, replacement|
-        result.gsub!(pattern, replacement)
-      end
-
-      result
+      profile.translate(snippet.code)
     end
 
     def generate_shader(_helpers, _fragment)
       raise NotImplementedError, "Subclasses must implement generate_shader"
     end
 
-    def self.common_func_replacements(target_vec2:, target_vec3:, target_vec4:)
-      [
-        [/vec2_new\(([^,]+),\s*([^)]+)\)/, "#{target_vec2}(\\1, \\2)"],
-        [/vec3_new\(([^,]+),\s*([^,]+),\s*([^)]+)\)/, "#{target_vec3}(\\1, \\2, \\3)"],
-        [/vec4_new\(([^,]+),\s*([^,]+),\s*([^,]+),\s*([^)]+)\)/, "#{target_vec4}(\\1, \\2, \\3, \\4)"],
-        [/vec2_add\(([^,]+),\s*([^)]+)\)/, '(\1 + \2)'],
-        [/vec3_add\(([^,]+),\s*([^)]+)\)/, '(\1 + \2)'],
-        [/vec2_sub\(([^,]+),\s*([^)]+)\)/, '(\1 - \2)'],
-        [/vec3_sub\(([^,]+),\s*([^)]+)\)/, '(\1 - \2)'],
-        [/vec2_mul\(([^,]+),\s*([^)]+)\)/, '(\1 * \2)'],
-        [/vec3_mul\(([^,]+),\s*([^)]+)\)/, '(\1 * \2)'],
-        [/vec2_div\(([^,]+),\s*([^)]+)\)/, '(\1 / \2)'],
-        [/vec3_div\(([^,]+),\s*([^)]+)\)/, '(\1 / \2)'],
-        [/vec2_dot\(([^,]+),\s*([^)]+)\)/, 'dot(\1, \2)'],
-        [/vec3_dot\(([^,]+),\s*([^)]+)\)/, 'dot(\1, \2)'],
-        [/vec2_length\(([^)]+)\)/, 'length(\1)'],
-        [/vec3_length\(([^)]+)\)/, 'length(\1)'],
-        [/vec2_normalize\(([^)]+)\)/, 'normalize(\1)'],
-        [/vec3_normalize\(([^)]+)\)/, 'normalize(\1)'],
-        [/sqrtf\(/, "sqrt("],
-        [/sinf\(/, "sin("],
-        [/cosf\(/, "cos("],
-        [/tanf\(/, "tan("],
-        [/fabsf\(/, "abs("],
-        [/fminf\(/, "min("],
-        [/fmaxf\(/, "max("],
-        [/floorf\(/, "floor("],
-        [/ceilf\(/, "ceil("],
-        [/powf\(/, "pow("],
-        [/expf\(/, "exp("],
-        [/logf\(/, "log("],
-        [/atan2f\(/, "atan2("],
-        [/fmodf\(/, "fmod("],
-        [/mix_f\(/, "mix("],
-        [/mix_v3\(/, "mix("],
-        [/clamp_f\(/, "clamp("],
-        [/smoothstep\(/, "smoothstep("],
-        [/fract\(/, "fract("]
-      ]
-    end
-
     def uniform_type_to_target(type)
       case type
       when :float then target_float_type
+      when :int then target_int_type
+      when :bool then target_bool_type
       when :vec2 then target_vec2_type
       when :vec3 then target_vec3_type
       when :vec4 then target_vec4_type
+      when :mat2 then target_mat2_type
+      when :mat3 then target_mat3_type
+      when :mat4 then target_mat4_type
+      when :sampler2D then target_sampler2d_type
+      else
+        raise ArgumentError, "Unsupported uniform type: #{type.inspect}"
       end
     end
 
@@ -94,16 +75,131 @@ module RLSL
       "float"
     end
 
+    def target_int_type
+      UniformTypes.target_type(:int, uniform_target)
+    end
+
+    def target_bool_type
+      UniformTypes.target_type(:bool, uniform_target)
+    end
+
     def target_vec2_type
-      raise NotImplementedError
+      UniformTypes.target_type(:vec2, uniform_target)
     end
 
     def target_vec3_type
-      raise NotImplementedError
+      UniformTypes.target_type(:vec3, uniform_target)
     end
 
     def target_vec4_type
-      raise NotImplementedError
+      UniformTypes.target_type(:vec4, uniform_target)
+    end
+
+    def target_mat2_type
+      UniformTypes.target_type(:mat2, uniform_target)
+    end
+
+    def target_mat3_type
+      UniformTypes.target_type(:mat3, uniform_target)
+    end
+
+    def target_mat4_type
+      UniformTypes.target_type(:mat4, uniform_target)
+    end
+
+    def target_sampler2d_type
+      UniformTypes.target_type(:sampler2D, uniform_target)
+    end
+
+    def uniform_target
+      profile.uniform_target
+    end
+
+    def uniform_lines(resolution_line:, &block)
+      lines = [resolution_line]
+      @uniforms.each do |name, type|
+        lines << block.call(name, uniform_type_to_target(type))
+      end
+      lines
+    end
+
+    def profile
+      return self.class::PROFILE if self.class.const_defined?(:PROFILE, false)
+
+      raise NotImplementedError, "Subclasses must define PROFILE"
+    end
+
+    def self.build_profile(uniform_target:, identifier_replacements:, call_rewrites:, removed_identifiers: REMOVED_IDENTIFIERS)
+      TargetProfile.new(
+        uniform_target: uniform_target,
+        identifier_replacements: identifier_replacements.freeze,
+        call_rewrites: call_rewrites.freeze,
+        removed_identifiers: removed_identifiers.freeze
+      ).freeze
+    end
+
+    def self.common_call_rewrites(target_vec2:, target_vec3:, target_vec4:)
+      {
+        "vec2_new" => rename_call(target_vec2),
+        "vec3_new" => rename_call(target_vec3),
+        "vec4_new" => rename_call(target_vec4),
+        "vec2_add" => infix_call("+"),
+        "vec3_add" => infix_call("+"),
+        "vec2_sub" => infix_call("-"),
+        "vec3_sub" => infix_call("-"),
+        "vec2_mul" => infix_call("*"),
+        "vec3_mul" => infix_call("*"),
+        "vec2_div" => infix_call("/"),
+        "vec3_div" => infix_call("/"),
+        "vec2_dot" => rename_call("dot"),
+        "vec3_dot" => rename_call("dot"),
+        "vec2_length" => rename_call("length"),
+        "vec3_length" => rename_call("length"),
+        "vec2_normalize" => rename_call("normalize"),
+        "vec3_normalize" => rename_call("normalize"),
+        "sqrtf" => rename_call("sqrt"),
+        "sinf" => rename_call("sin"),
+        "cosf" => rename_call("cos"),
+        "tanf" => rename_call("tan"),
+        "fabsf" => rename_call("abs"),
+        "fminf" => rename_call("min"),
+        "fmaxf" => rename_call("max"),
+        "floorf" => rename_call("floor"),
+        "ceilf" => rename_call("ceil"),
+        "powf" => rename_call("pow"),
+        "expf" => rename_call("exp"),
+        "logf" => rename_call("log"),
+        "atan2f" => rename_call("atan2"),
+        "fmodf" => rename_call("fmod"),
+        "mix_f" => rename_call("mix"),
+        "mix_v3" => rename_call("mix"),
+        "clamp_f" => rename_call("clamp"),
+        "smoothstep" => rename_call("smoothstep"),
+        "fract" => rename_call("fract")
+      }.freeze
+    end
+
+    def self.rename_call(name)
+      lambda do |arguments|
+        "#{name}(#{arguments.join(', ')})"
+      end
+    end
+
+    def self.infix_call(operator)
+      lambda do |arguments|
+        raise ArgumentError, "Expected 2 arguments for #{operator} rewrite, got #{arguments.length}" unless arguments.length == 2
+
+        "(#{arguments[0]} #{operator} #{arguments[1]})"
+      end
+    end
+
+    private
+
+    def normalize_source(source)
+      return SourceSnippet.new(code: "", format: :legacy) if source.nil?
+      return source if source.is_a?(SourceSnippet)
+
+      SourceSnippet.new(code: source.to_s, format: :legacy)
     end
   end
 end

data/lib/rlsl/code_generator/math_prelude.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RLSL
+  class CodeGenerator
+    module MathPrelude
+      module_function
+
+      def code
+        <<~C
+          static inline vec2 vec2_new(float x, float y) { return (vec2){x, y}; }
+          static inline vec3 vec3_new(float x, float y, float z) { return (vec3){x, y, z}; }
+          static inline vec4 vec4_new(float x, float y, float z, float w) { return (vec4){x, y, z, w}; }
+
+          static inline vec2 vec2_add(vec2 a, vec2 b) { return (vec2){a.x + b.x, a.y + b.y}; }
+          static inline vec3 vec3_add(vec3 a, vec3 b) { return (vec3){a.x + b.x, a.y + b.y, a.z + b.z}; }
+
+          static inline vec2 vec2_sub(vec2 a, vec2 b) { return (vec2){a.x - b.x, a.y - b.y}; }
+          static inline vec3 vec3_sub(vec3 a, vec3 b) { return (vec3){a.x - b.x, a.y - b.y, a.z - b.z}; }
+
+          static inline vec2 vec2_mul(vec2 a, float s) { return (vec2){a.x * s, a.y * s}; }
+          static inline vec3 vec3_mul(vec3 a, float s) { return (vec3){a.x * s, a.y * s, a.z * s}; }
+
+          static inline vec2 vec2_div(vec2 a, float s) { return (vec2){a.x / s, a.y / s}; }
+          static inline vec3 vec3_div(vec3 a, float s) { return (vec3){a.x / s, a.y / s, a.z / s}; }
+
+          static inline float vec2_dot(vec2 a, vec2 b) { return a.x * b.x + a.y * b.y; }
+          static inline float vec3_dot(vec3 a, vec3 b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
+
+          static inline float vec2_length(vec2 v) { return sqrtf(v.x * v.x + v.y * v.y); }
+          static inline float vec3_length(vec3 v) { return sqrtf(v.x * v.x + v.y * v.y + v.z * v.z); }
+
+          static inline vec2 vec2_normalize(vec2 v) { float l = vec2_length(v); return l > 0 ? vec2_div(v, l) : v; }
+          static inline vec3 vec3_normalize(vec3 v) { float l = vec3_length(v); return l > 0 ? vec3_div(v, l) : v; }
+
+          static inline float fract(float x) { return x - floorf(x); }
+          static inline float mix_f(float a, float b, float t) { return a + (b - a) * t; }
+          static inline vec3 mix_v3(vec3 a, vec3 b, float t) {
+            return (vec3){a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t};
+          }
+
+          static inline float clamp_f(float x, float lo, float hi) {
+            return x < lo ? lo : (x > hi ? hi : x);
+          }
+
+          static inline float smoothstep(float edge0, float edge1, float x) {
+            float t = clamp_f((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
+            return t * t * (3.0f - 2.0f * t);
+          }
+
+          static inline float hash21(vec2 p) {
+            float dot = p.x * 12.9898f + p.y * 78.233f;
+            return fract(sinf(dot) * 43758.5453f);
+          }
+
+          static inline vec2 hash22(vec2 p) {
+            float n = sinf(vec2_dot(p, vec2_new(127.1f, 311.7f)));
+            return vec2_new(fract(n * 43758.5453f), fract(n * 12345.6789f));
+          }
+
+          static inline vec3 reflect(vec3 I, vec3 N) {
+            float d = vec3_dot(N, I);
+            return vec3_new(I.x - 2.0f * d * N.x, I.y - 2.0f * d * N.y, I.z - 2.0f * d * N.z);
+          }
+
+          static inline vec3 refract(vec3 I, vec3 N, float eta) {
+            float d = vec3_dot(N, I);
+            float k = 1.0f - eta * eta * (1.0f - d * d);
+            if (k < 0.0f) {
+              return vec3_new(0.0f, 0.0f, 0.0f);
+            }
+
+            float s = eta * d + sqrtf(k);
+            return vec3_new(eta * I.x - s * N.x, eta * I.y - s * N.y, eta * I.z - s * N.z);
+          }
+        C
+      end
+    end
+  end
+end