snow-math 1.1.0 → 1.2.1

data/ext/snow-math/vec3.c

@@ -45,7 +45,7 @@ s_float_t vec3_length_squared(const vec3_t v)
  */
 s_float_t vec3_length(const vec3_t v)
 {
-  return sqrtf((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]));
+  return s_sqrt((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]));
 }
 
 void vec3_normalize(const vec3_t in, vec3_t out)
@@ -92,6 +92,18 @@ void vec3_inverse(const vec3_t v, vec3_t out)
   out[0] = (v[0] != 0.0 && v[0] != -0.0) ? (1.0 / v[0]) : v[0];
 }
 
+void vec3_project(const vec3_t in, const vec3_t normal, vec3_t out)
+{
+  vec3_scale(normal, vec3_dot_product(in, normal), out);
+}
+
+void vec3_reflect(const vec3_t in, const vec3_t normal, vec3_t out)
+{
+  vec3_t temp;
+  vec3_scale(normal, 2 * vec3_dot_product(in, normal), temp);
+  vec3_subtract(in, temp, out);
+}
+
 void vec3_cross_product(const vec3_t left, const vec3_t right, vec3_t out)
 {
   s_float_t x, y, z;

data/ext/snow-math/vec4.c

@@ -48,7 +48,7 @@ s_float_t vec4_length_squared(const vec4_t v)
  */
 s_float_t vec4_length(const vec4_t v)
 {
-  return sqrtf((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]) + (v[3] * v[3]));
+  return s_sqrt((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]) + (v[3] * v[3]));
 }
 
 void vec4_normalize(const vec4_t in, vec4_t out)
@@ -101,6 +101,18 @@ void vec4_inverse(const vec4_t v, vec4_t out)
   out[0] = (v[0] != 0.0 && v[0] != -0.0) ? (1.0 / v[0]) : v[0];
 }
 
+void vec4_project(const vec4_t in, const vec4_t normal, vec4_t out)
+{
+  vec4_scale(normal, vec4_dot_product(in, normal), out);
+}
+
+void vec4_reflect(const vec4_t in, const vec4_t normal, vec4_t out)
+{
+  vec4_t temp;
+  vec4_scale(normal, 2 * vec4_dot_product(in, normal), temp);
+  vec4_subtract(in, temp, out);
+}
+
 s_float_t vec4_dot_product(const vec4_t left, const vec4_t right)
 {
   return ((left[0] * right[0]) + (left[1] * right[1]) + (left[2] * right[2]) + (left[3] * right[3]));

data/lib/snow-math.rb

@@ -5,6 +5,7 @@
 require 'snow-math/bindings'
 require 'snow-math/vec3'
 require 'snow-math/vec4'
+require 'snow-math/mat3'
 require 'snow-math/mat4'
 require 'snow-math/quat'
 require 'snow-math/swizzle'

data/lib/snow-math/inspect.rb

@@ -4,17 +4,32 @@
 
 require 'snow-math'
 
-module Snow ; end
+module Snow
 
-module Snow::MathInspect
+  [:Vec3, :Vec4, :Quat, :Mat3, :Mat4].each {
+    |klass_sym|
+    if const_defined?(klass_sym)
+      const_get(klass_sym).class_exec {
 
-  def inspect
-    "<#{self.class.name}:0x#{self.address.to_s(16)} #{(0 ... self.length).map { |i| self[i] }.join(' ')}>"
-  end
+        def inspect
+          "<#{self.class.name}:0x#{self.address.to_s(16)} #{(0 ... self.length).map { |i| self.fetch(i) }.join(' ')}>"
+        end
 
-end
+      }
+    end
+  }
+
+  [:Vec3Array, :Vec4Array, :QuatArray, :Mat3Array, :Mat4Array].each {
+    |klass_sym|
+    if const_defined?(klass_sym)
+      const_get(klass_sym).class_exec {
+
+        def inspect
+          "<#{self.class.name}:0x#{self.address.to_s(16)} #{(0 ... self.length).map { |i| self.fetch(i).inspect }.join(' ')}>"
+        end
 
-class Snow::Vec3 ; include Snow::MathInspect ; end
-class Snow::Vec4 ; include Snow::MathInspect ; end
-class Snow::Quat ; include Snow::MathInspect ; end
-class Snow::Mat4 ; include Snow::MathInspect ; end
+      }
+    end
+  }
+
+end

data/lib/snow-math/mat3.rb

@@ -0,0 +1,71 @@
+# This file is part of ruby-snowmath.
+# Copyright (c) 2013 Noel Raymond Cower. All rights reserved.
+# See COPYING for license details.
+
+require 'snow-math/bindings'
+
+module Snow ; end
+
+if Snow.const_defined?(:Mat4Array)
+  class Snow::Mat3Array
+    class << self ; alias_method :[], :new ; end
+
+    alias_method :[], :fetch
+    alias_method :[]=, :store
+  end
+end
+
+class Snow::Mat3
+
+  class << self ; alias_method :[], :new ; end
+
+  alias_method :[], :fetch
+  alias_method :[]=, :store
+
+  def transpose!
+    transpose self
+  end
+
+  def inverse!
+    inverse self
+  end
+
+  def adjoint!
+    adjoint self
+  end
+
+  def cofactor!
+    cofactor self
+  end
+
+  def multiply_mat3!(rhs)
+    multiply_mat3 rhs, self
+  end
+
+  def multiply(rhs, out = nil)
+    raise "Invalid type for output, must be the same as RHS" if !out.nil? && !out.kind_of?(rhs.class)
+    case rhs
+    when ::Snow::Mat3 then multiply_mat3(rhs, out)
+    when ::Snow::Vec3 then rotate_vec3(rhs, out)
+    when Numeric      then scale(rhs, rhs, rhs, out)
+    else raise TypeError, "Invalid type for RHS"
+    end
+  end
+
+  def multiply!(rhs)
+    multiply rhs, case rhs
+      when Mat3, Numeric then self
+      when Vec3 then rhs
+      else raise TypeError, "Invalid type for RHS"
+      end
+  end
+
+  def scale!(x, y, z)
+    scale x, y, z, self
+  end
+
+  alias_method :*, :multiply
+  alias_method :**, :scale
+  alias_method :~, :transpose
+
+end

data/lib/snow-math/ptr.rb

@@ -5,34 +5,20 @@
 require 'snow-math'
 require 'fiddle'
 
-module Snow ; end
+module Snow
 
-module Snow::MathPointers
+  [:Vec3, :Vec4, :Quat, :Mat3, :Mat4,
+   :Vec3Array, :Vec4Array, :QuatArray, :Mat3Array, :Mat4Array].each {
+    |klass_sym|
+    if const_defined?(klass_sym)
+      const_get(klass_sym).class_exec {
 
-  def to_ptr
-    Fiddle::Pointer.new(self.address, self.size)
-  end
+        def to_ptr
+          Fiddle::Pointer.new(self.address, self.size)
+        end
 
-end
-
-class Snow::Vec3 ; include Snow::MathPointers ; end
-class Snow::Vec4 ; include Snow::MathPointers ; end
-class Snow::Quat ; include Snow::MathPointers ; end
-class Snow::Mat4 ; include Snow::MathPointers ; end
+      }
+    end
+  }
 
-if Snow.const_defined?(:Vec3Array)
-  class Snow::Vec3Array ; include Snow::MathPointers ; end
 end
-
-if Snow.const_defined?(:Vec4Array)
-  class Snow::Vec4Array ; include Snow::MathPointers ; end
-end
-
-if Snow.const_defined?(:QuatArray)
-  class Snow::QuatArray ; include Snow::MathPointers ; end
-end
-
-if Snow.const_defined?(:Mat4Array)
-  class Snow::Mat4Array ; include Snow::MathPointers ; end
-end
-

data/lib/snow-math/quat.rb

@@ -106,7 +106,7 @@ class Snow::Quat
   alias_method :-, :subtract
   alias_method :+, :add
   alias_method :**, :dot_product
-  alias_method :*, :scale
+  alias_method :*, :multiply
   alias_method :/, :divide
   alias_method :-@, :negate
   alias_method :~, :inverse

data/lib/snow-math/swizzle.rb

@@ -6,52 +6,57 @@ require 'snow-math'
 
 module Snow ; end
 
-module Snow::Swizzle
-
-  def method_missing(sym, *args)
-    chars = sym.to_s
-    if chars =~ self.class.class_variable_get(:@@SWIZZLE_CHARS)
-      mapping = self.class.class_variable_get(:@@SWIZZLE_MAPPING)
-      arg_indices = chars.each_char.map {
-        |char|
-        index = mapping[char]
-        if index.nil?
-          raise ArgumentError, "No index mapping for swizzle character #{char} found"
-        end
-        index
-      }
-      swizzle_klass = mapping[chars.length]
-
-      if swizzle_klass.nil?
-        raise ArgumentError, "No swizzle class defined for #{chars.length} components"
-      end
-
-      self.class.class_exec(arg_indices, swizzle_klass) {
-        |indices, klass|
-        define_method(sym) { klass.new(indices.map { |index| self.fetch(index) }) }
-      }
-      return self.send(sym)
-    end
-
-    super sym, *args
-  end
-
-end
-
 class Snow::Vec3
   @@SWIZZLE_CHARS = /^[xyz]{3,4}$/
   @@SWIZZLE_MAPPING = { 3 => self, 4 => ::Snow::Vec4, 'x' => 0, 'y' => 1, 'z' => 2 }
-  include ::Snow::Swizzle
 end
 
 class Snow::Vec4
   @@SWIZZLE_CHARS = /^[xyzw]{3,4}$/
   @@SWIZZLE_MAPPING = { 3 => ::Snow::Vec3, 4 => self, 'x' => 0, 'y' => 1, 'z' => 2, 'w' => 3 }
-  include ::Snow::Swizzle
 end
 
 class Snow::Quat
   @@SWIZZLE_CHARS = /^[xyzw]{3,4}$/
   @@SWIZZLE_MAPPING = { 3 => ::Snow::Vec3, 4 => self, 'x' => 0, 'y' => 1, 'z' => 2, 'w' => 3 }
-  include ::Snow::Swizzle
+end
+
+module Snow
+
+  [:Vec3, :Vec4, :Quat].each {
+    |klass_sym|
+
+    const_get(klass_sym).class_exec {
+
+      def method_missing(sym, *args)
+        chars = sym.to_s
+        if chars =~ self.class.class_variable_get(:@@SWIZZLE_CHARS)
+          mapping = self.class.class_variable_get(:@@SWIZZLE_MAPPING)
+          arg_indices = chars.each_char.map {
+            |char|
+            index = mapping[char]
+            if index.nil?
+              raise ArgumentError, "No index mapping for swizzle character #{char} found"
+            end
+            index
+          }
+          swizzle_klass = mapping[chars.length]
+
+          if swizzle_klass.nil?
+            raise ArgumentError, "No swizzle class defined for #{chars.length} components"
+          end
+
+          self.class.class_exec(arg_indices, swizzle_klass) {
+            |indices, klass|
+            define_method(sym) { klass.new(indices.map { |index| self.fetch(index) }) }
+          }
+          return self.send(sym)
+        end
+
+        super sym, *args
+      end
+
+    }
+  }
+
 end

data/lib/snow-math/to_a.rb

@@ -4,48 +4,45 @@
 
 require 'snow-math'
 
-module Snow ; end
-
-module Snow::EnumeratorSupport
-  include ::Enumerable
-
-  def to_a
-    (0 ... self.length).each.map { |index| fetch(index) }
-  end
-
-  def each(&block)
-    return to_enum(:each) unless block_given?
-    (0 ... self.length).each {
-      |index|
-      yield(fetch(index))
-    }
-    self
-  end
-
-  def map!(&block)
-    return to_enum(:map!) unless block_given?
-    (0 ... self.length).each {
-      |index|
-      store(index, yield(fetch(index)))
-    }
-    self
-  end
-
-  def map(&block)
-    return to_enum(:map) unless block_given?
-    self.dup.map!(&block)
-  end
+module Snow
+
+  [:Vec3, :Vec4, :Quat, :Mat3, :Mat4,
+   :Vec3Array, :Vec4Array, :QuatArray, :Mat3Array, :Mat4Array].each {
+    |klass_sym|
+    if const_defined?(klass_sym)
+      const_get(klass_sym).class_exec {
+
+        include ::Enumerable
+
+        def to_a
+          (0 ... self.length).each.map { |index| fetch(index) }
+        end
+
+        def each(&block)
+          return to_enum(:each) unless block_given?
+          (0 ... self.length).each {
+            |index|
+            yield(fetch(index))
+          }
+          self
+        end
+
+        def map!(&block)
+          return to_enum(:map!) unless block_given?
+          (0 ... self.length).each {
+            |index|
+            store(index, yield(fetch(index)))
+          }
+          self
+        end
+
+        def map(&block)
+          return to_enum(:map) unless block_given?
+          self.dup.map!(&block)
+        end
+
+      }
+    end
+  }
 
 end
-
-if Snow.const_defined?(:Vec3Array)
-  class Snow::Vec3Array ; include Snow::EnumeratorSupport ; end
-  class Snow::Vec4Array ; include Snow::EnumeratorSupport ; end
-  class Snow::QuatArray ; include Snow::EnumeratorSupport ; end
-  class Snow::Mat4Array ; include Snow::EnumeratorSupport ; end
-end
-
-class Snow::Vec3 ; include Snow::EnumeratorSupport ; end
-class Snow::Vec4 ; include Snow::EnumeratorSupport ; end
-class Snow::Quat ; include Snow::EnumeratorSupport ; end
-class Snow::Mat4 ; include Snow::EnumeratorSupport ; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snow-math
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Noel Raymond Cower
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-25 00:00:00.000000000 Z
+date: 2013-07-06 00:00:00.000000000 Z
 dependencies: []
 description: Math types built on the SnowPalm math code
 email: ncower@gmail.com
@@ -33,6 +33,7 @@ files:
 - lib/snow-math/vec3.rb
 - lib/snow-math/vec4.rb
 - lib/snow-math.rb
+- ext/snow-math/mat3.c
 - ext/snow-math/mat4.c
 - ext/snow-math/maths.c
 - ext/snow-math/quat.c