glmath 0.0.1.dev

data/lib/glmath/matrix2.rb

@@ -0,0 +1,81 @@
+module GLMath
+  class Matrix2
+
+    class << self
+      def dimension
+        2
+      end
+
+      #conter-clockwise rotation
+      def rotation(theta, homogenous = false)
+        s, c = Math.sin(theta), Math.cos(theta)
+        m = new(c, -s, s, c)
+        homogenous ? m.expand : m
+      end
+
+      def scale(x, y, homogenous = false)
+        m = diagonal(x, y)
+        homogenous ? m.expand : m
+      end
+    end
+
+    include Matrix
+
+    def *(v)
+      case v
+      when Vector2
+        v.class.new(@m[0] * v.x + @m[1] * v.y, @m[2] * v.x + @m[3] * v.y)
+      when Matrix2
+        m = v.instance_variable_get(:@m)
+        self.class.new(@m[0]*m[0] + @m[1]*m[2], @m[0]*m[1] + @m[1]*m[3],
+                       @m[2]*m[0] + @m[3]*m[2], @m[2]*m[1] + @m[3]*m[3])
+      when Numeric
+        super
+      else
+        raise ArgumentError
+      end
+    end
+
+    def adjugate!
+      @m = [ @m[3], -@m[1],
+            -@m[2],  @m[0]]
+      self
+    end
+
+    def determinant
+      @m[0] * @m[3] - @m[1] * @m[2]
+    end
+
+    def expand
+      Matrix3.new(@m[0], @m[1], 0.0,
+                  @m[2], @m[3], 0.0,
+                  0.0,   0.0,   1.0)
+    end
+
+    def inverse
+      d = determinant
+      raise ArgumentError, 'Determinant is zero' if d.zero?
+      adjugate * (1.0 / d)
+    end
+
+    def lup
+      raise ArgumentError, "Determinant is zero" if singular?
+
+      if @m[0].abs > @m[1].abs
+        a, b, c, d = 0, 1, 2, 3
+        p = self.class.new(1.0, 0.0, 0.0, 1.0)
+      else
+        a, b, c, d = 2, 3, 0, 1
+        p = self.class.new(0.0, 1.0, 1.0, 0.0)
+      end
+
+      l = self.class.new(1.0, 0.0, @m[c] / @m[a], 1.0)
+      u = self.class.new(@m[a], @m[b], 0.0, @m[d] - @m[b]*@m[c] / @m[a])
+      [l, u, p]
+    end
+
+    alias_method :det,               :determinant
+    alias_method :lup_decomposition, :lup
+
+  end
+end

data/lib/glmath/matrix3.rb

@@ -0,0 +1,108 @@
+module GLMath
+  class Matrix3
+
+    class << self
+      def dimension
+        3
+      end
+
+      def rotation(angle, axis, homogenous = false)
+        n = axis.normalize
+        ct = Math.cos(angle)
+        st = Math.sin(angle)
+        ct1 = 1 - ct
+        xy = n.x * n.y * ct1
+        xz = n.x * n.z * ct1
+        yz = n.y * n.z * ct1
+
+        m = new(n.x*n.x*ct1 + ct, xy + n.z * st,    xz - n.y * st,
+                xy - n.z * st,    n.y*n.y*ct1 + ct, yz + n.x * st,
+                xz + n.y * st,    yz - n.x * st,    n.z*n.z*ct1 + ct)
+        homogenous ? m.expand : m
+      end
+
+      def scale(x, y, z, homogenous = false)
+        m = diagonal(x, y, z)
+        homogenous ? m.expand : m
+      end
+
+      def translation(x, y)
+        Matrix3.new(1.0, 0.0, 0.0,
+                    0.0, 1.0, 0.0,
+                    x,   y,   1.0)
+      end
+
+      def from_euler_angle(x:, y:, z:)
+        # TODO
+      end
+    end
+
+    include Matrix
+
+    def *(v)
+      case v
+        when Vector3
+          v.class.new(@m[0] * v.x + @m[1] * v.y + @m[2] * v.z,
+                      @m[3] * v.x + @m[4] * v.y + @m[5] * v.z,
+                      @m[6] * v.x + @m[7] * v.y + @m[8] * v.z)
+        when Matrix3
+          m = v.instance_variable_get(:@m)
+          self.class.new(
+            @m[0]*m[0]+@m[1]*m[3]+@m[2]*m[6], @m[0]*m[1]+@m[1]*m[4]+@m[2]*m[7], @m[0]*m[2] + @m[1]*m[5] + @m[2]*m[8],
+            @m[3]*m[0]+@m[4]*m[3]+@m[5]*m[6], @m[3]*m[1]+@m[4]*m[4]+@m[5]*m[7], @m[3]*m[2] + @m[4]*m[5] + @m[5]*m[8],
+            @m[6]*m[0]+@m[7]*m[3]+@m[8]*m[6], @m[6]*m[1]+@m[7]*m[4]+@m[8]*m[7], @m[6]*m[2] + @m[7]*m[5] + @m[8]*m[8])
+        else
+          super
+      end
+    end
+
+    def adjugate!
+      @m =[@m[4] * @m[8] - @m[5] * @m[7],
+           @m[5] * @m[6] - @m[3] * @m[8],
+           @m[3] * @m[7] - @m[4] * @m[6],
+           @m[2] * @m[7] - @m[1] * @m[8],
+           @m[0] * @m[8] - @m[2] * @m[6],
+           @m[1] * @m[6] - @m[0] * @m[7],
+           @m[1] * @m[5] - @m[2] * @m[4],
+           @m[2] * @m[3] - @m[0] * @m[5],
+           @m[0] * @m[4] - @m[1] * @m[3]]
+      self
+    end
+
+    def determinant
+      @m[0] * ( @m[4] * @m[8] - @m[5] * @m[7] ) +
+      @m[1] * ( @m[5] * @m[6] - @m[3] * @m[8] ) +
+      @m[2] * ( @m[3] * @m[7] - @m[4] * @m[6] )
+    end
+
+    def expand
+      Matrix4.new(@m[0], @m[1], @m[2], 0.0,
+                  @m[3], @m[4], @m[5], 0.0,
+                  @m[6], @m[7], @m[8], 0.0,
+                  0.0,   0.0,   0.0,   1.0)
+    end
+
+    def to_axis_angle
+      # TODO
+    end
+
+    def orthonormalize
+      # TODO
+    end
+
+    def eigen_decomposition()
+      # TODO
+    end
+
+    def to_euler_angle
+      # TODO
+    end
+
+    def slerp
+      # TODO
+    end
+
+    alias_method :det, :determinant
+
+  end
+end

data/lib/glmath/matrix4.rb

@@ -0,0 +1,145 @@
+module GLMath
+  # Left Handed
+  class Matrix4
+    class << self
+      def dimension
+        4
+      end
+
+      def look_at(eye, center, up)
+        f = (center - eye).normalize!
+        s = f.cross(up).normalize!
+        u = s.cross(f).normalize!
+        new(s.x,    u.x,   -f.x,   0.0,
+            s.y,    u.y,   -f.y,   0.0,
+            s.z,    u.z,   -f.z,   0.0,
+           -eye.x, -eye.y, -eye.z, 1.0)
+      end
+
+      def ortho(left, right, bottom, top, near, far)
+        rl = right.to_f - left.to_f
+        tb = top.to_f   - bottom.to_f
+        fn = far.to_f   - near.to_f
+
+        new(2.0/rl,              0.0,                0.0,                 0.0,
+            0.0,                 2.0/tb,             0.0,                 0.0,
+            0.0,                 0.0,               -2.0/fn,              0.0,
+            -(right + left)/rl, -(top + bottom)/tb, -(far + near)/fn,     1.0)
+      end
+
+      def perspective(fovy, aspect, near, far)
+        zoom  = 1.0 / Math.tan(fovy * 0.5)
+        fn = 1.0 / (far - near)
+        new(zoom/aspect,  0.0,             0.0,  0.0,
+            0.0,         zoom,             0.0,  0.0,
+            0.0,          0.0,  (far + near)*fn, 1.0,
+            0.0,          0.0, -2.0*far*near*fn, 0.0)
+      end
+
+      def rotation(angle, axis)
+        Matrix3.rotation(angle, axis, true)
+      end
+
+      def scale(x, y, z, w = 1.0)
+        diagonal(x, y, z, w)
+      end
+
+      def translation(x, y, z)
+        Matrix4.new(1.0, 0.0, 0.0, 0.0,
+                    0.0, 1.0, 0.0, 0.0,
+                    0.0, 0.0, 1.0, 0.0,
+                    x,   y,   z,   1.0)
+      end
+    end
+
+    include Matrix
+
+    def *(v)
+      case v
+      when Vector4
+        v.class.new(
+          @m[ 0] * v.x + @m[ 1] * v.y + @m[ 2] * v.z + @m[ 3] * v.w,
+          @m[ 4] * v.x + @m[ 5] * v.y + @m[ 6] * v.z + @m[ 7] * v.w,
+          @m[ 8] * v.x + @m[ 9] * v.y + @m[10] * v.z + @m[11] * v.w,
+          @m[12] * v.x + @m[13] * v.y + @m[14] * v.z + @m[15] * v.w)
+        when Matrix4
+          m = v.instance_variable_get(:@m)
+          self.class.new(
+            @m[ 0] * m[0] + @m[ 1] * m[4] + @m[ 2] * m[ 8] + @m[ 3] * m[12],
+            @m[ 0] * m[1] + @m[ 1] * m[5] + @m[ 2] * m[ 9] + @m[ 3] * m[13],
+            @m[ 0] * m[2] + @m[ 1] * m[6] + @m[ 2] * m[10] + @m[ 3] * m[14],
+            @m[ 0] * m[3] + @m[ 1] * m[7] + @m[ 2] * m[11] + @m[ 3] * m[15],
+            @m[ 4] * m[0] + @m[ 5] * m[4] + @m[ 6] * m[ 8] + @m[ 7] * m[12],
+            @m[ 4] * m[1] + @m[ 5] * m[5] + @m[ 6] * m[ 9] + @m[ 7] * m[13],
+            @m[ 4] * m[2] + @m[ 5] * m[6] + @m[ 6] * m[10] + @m[ 7] * m[14],
+            @m[ 4] * m[3] + @m[ 5] * m[7] + @m[ 6] * m[11] + @m[ 7] * m[15],
+            @m[ 8] * m[0] + @m[ 9] * m[4] + @m[10] * m[ 8] + @m[11] * m[12],
+            @m[ 8] * m[1] + @m[ 9] * m[5] + @m[10] * m[ 9] + @m[11] * m[13],
+            @m[ 8] * m[2] + @m[ 9] * m[6] + @m[10] * m[10] + @m[11] * m[14],
+            @m[ 8] * m[3] + @m[ 9] * m[7] + @m[10] * m[11] + @m[11] * m[15],
+            @m[12] * m[0] + @m[13] * m[4] + @m[14] * m[ 8] + @m[15] * m[12],
+            @m[12] * m[1] + @m[13] * m[5] + @m[14] * m[ 9] + @m[15] * m[13],
+            @m[12] * m[2] + @m[13] * m[6] + @m[14] * m[10] + @m[15] * m[14],
+            @m[12] * m[3] + @m[13] * m[7] + @m[14] * m[11] + @m[15] * m[15])
+      else
+        super
+      end
+    end
+
+    def adjoint!
+      a =  @m[4] *  @m[9] -  @m[5] *  @m[8]
+      b =  @m[4] * @m[10] -  @m[6] *  @m[8]
+      c =  @m[4] * @m[11] -  @m[7] *  @m[8]
+      d =  @m[4] * @m[13] -  @m[5] * @m[12]
+      f =  @m[4] * @m[14] -  @m[6] * @m[12]
+      g =  @m[4] * @m[15] -  @m[7] * @m[12]
+      h =  @m[5] * @m[10] -  @m[6] *  @m[9]
+      i =  @m[5] * @m[11] -  @m[7] *  @m[9]
+      j =  @m[5] * @m[14] -  @m[6] * @m[13]
+      k =  @m[5] * @m[15] -  @m[7] * @m[13]
+      l =  @m[6] * @m[11] -  @m[7] * @m[10]
+      m =  @m[6] * @m[15] -  @m[7] * @m[14]
+      n =  @m[8] * @m[13] -  @m[9] * @m[12]
+      o =  @m[8] * @m[14] - @m[10] * @m[12]
+      p =  @m[8] * @m[15] - @m[11] * @m[12]
+      q =  @m[9] * @m[14] - @m[10] * @m[13]
+      r =  @m[9] * @m[15] - @m[11] * @m[13]
+      s = @m[10] * @m[15] - @m[11] * @m[14]
+
+      @m = [+ @m[5] * s - @m[6] * r + @m[7] * q,
+            - @m[4] * s + @m[6] * p - @m[7] * o,
+            + @m[4] * r - @m[5] * p + @m[7] * n,
+            - @m[4] * q + @m[5] * o - @m[6] * n,
+            - @m[1] * s + @m[2] * r - @m[3] * q,
+            + @m[0] * s - @m[2] * p + @m[3] * o,
+            - @m[0] * r + @m[1] * p - @m[3] * n,
+            + @m[0] * q - @m[1] * o + @m[2] * n,
+            + @m[1] * m - @m[2] * k + @m[3] * j,
+            - @m[0] * m + @m[2] * g - @m[3] * f,
+            + @m[0] * k - @m[1] * g + @m[3] * d,
+            - @m[0] * j + @m[1] * f - @m[2] * d,
+            - @m[1] * l + @m[2] * i - @m[3] * h,
+            + @m[0] * l - @m[2] * c + @m[3] * b,
+            - @m[0] * i + @m[1] * c - @m[3] * a,
+            + @m[0] * h - @m[1] * b + @m[2] * a]
+      self
+    end
+
+    def determinant
+      a = @m[10] * @m[15] - @m[11] * @m[14]
+      b = @m[11] * @m[13] - @m[9]  * @m[15]
+      c = @m[9]  * @m[14] - @m[10] * @m[13]
+      d = @m[8]  * @m[15] - @m[11] * @m[12]
+      e = @m[10] * @m[12] - @m[8]  * @m[14]
+      f = @m[8]  * @m[13] - @m[9]  * @m[12]
+
+      @m[0] * ( @m[5] * a + @m[6] * b + @m[7] * c) +
+        @m[1] * (-@m[4] * a + @m[6] * d + @m[7] * e) +
+        @m[2] * (-@m[4] * b - @m[5] * d + @m[7] * f) +
+        @m[3] * (-@m[4] * c - @m[5] * e - @m[6] * f)
+    end
+
+    alias_method :det, :determinant
+
+  end
+end

data/lib/glmath/matrix_stack.rb

@@ -0,0 +1,91 @@
+module GLMath
+  class MatrixStack
+
+    def initialize
+      @stack = [Matrix4.I]
+    end
+
+    %w'* - +'.each do |m|
+      define_method(m, ->(v) do
+        @stack[-1] = @stack.last.send(m, check(v))
+        self
+      end)
+    end
+
+    def <<(m)
+      @stack << check(m)
+      self
+    end
+
+    def current
+      @stack.last.dup
+    end
+
+    def dup
+      MatrixStack.new.tap { |ms| ms.instance_variable_set(:@stack, @stack.map(&:dup)) }
+    end
+
+    def push(m = current)
+      self << m
+      return self unless block_given?
+      yield self
+      pop
+      self
+    end
+
+    def pop(n = 1)
+      @stack.pop(n)
+    end
+
+    def load(*args)
+      @stack[-1] = case
+        when args.length == 16 then Matrix4[*args]
+        when args.length == 9  then Matrix3[*args].expand
+        when args.length == 1  then check(args[0])
+        else raise ArgumentError
+      end
+    end
+
+    def load_identity
+      load(Matrix4.I)
+    end
+
+    def look_at(eye, center, up)
+      self * Matrix4.look_at(eye, center, up)
+    end
+
+    def ortho(left, right, bottom, top, near, far)
+      self * Matrix4.ortho(left, right, bottom, top, near, far)
+    end
+
+    def perspective(fovy, aspect, near, far)
+      self * Matrix4.perspective(fovy, aspect, near, far)
+    end
+
+    def rotate(arg, axis = nil)
+      self * case axis
+               when Vector3, Vector4       then Matrix4.rotation(arg, axis)
+               when Quaternion, EulerAngle then arg.to_matrix
+               else raise ArgumentError
+             end
+    end
+
+    def scale(x, y, z, w = 1.0)
+      self * Matrix4.scale(x, y, z, w)
+    end
+
+    #def shear()
+    #  #TODO
+    #end
+
+    def translate(x, y, z)
+      self * Matrix4.translation(x, y, z)
+    end
+
+    private
+    def check(m)
+      raise ArgumentError unless m.is_a?(Matrix4)
+      m
+    end
+  end
+end

data/lib/glmath/quaternion.rb

@@ -0,0 +1,212 @@
+module GLMath
+  class Quaternion
+    class << self
+      def [](*args)
+        new(*args)
+      end
+
+      def from_angle_axis(angle, axis)
+        angle *= 0.5
+        axis = axis.normalize
+        sa = Math.sin(angle)
+        new(Math.cos(angle), sa * axis.x, sa * axis.y, sa * axis.z)
+      end
+
+      def identity
+        new(1.0, 0.0, 0.0, 0.0)
+      end
+
+      def slerp(q0, q1, t)
+        (q1 * q0.inverse).power(t) * q0
+      end
+
+      alias_method :I, :identity
+    end
+
+    def initialize(w, x, y, z)
+      @q = w, x, y, z
+      raise ArgumentError, 'arguments must be Numeric' unless @q.all? { |e| e.is_a?(Numeric) }
+    end
+
+    def +(v)
+      case v
+        when Numeric
+          self.class.new(v + w, x, y, z)
+        when Quaternion
+          self.class.new(q + v.w, x + v.x, y + v.y, z + v.z)
+        else
+          v + self
+      end
+    end
+
+    def -(q)
+      self + (-q)
+    end
+
+    def *(v)
+      case v
+        when Numeric
+          self.class.new(q * v, x * v, y * v, z * v)
+        when Quaternion
+          cross_product(v)
+      end
+    end
+
+    def /(v)
+      case v
+        when Numeric
+          self.class.new(*@q.map { |i| i/v})
+        when Quaternion
+          self * v.inverse
+      end
+    end
+
+    def -@
+      self.class.new(*@q.map(&:-@))
+    end
+
+    def ==(other)
+      self.class === other && @q == other.instance_variable_get(:@q)
+    end
+
+    %w'w x y z'.each_with_index do |m, i|
+      define_method m, ->() { @q[i] }
+      define_method "#{m}=", ->(v) { @q[i] = v }
+    end
+
+    def coerce(v)
+      case v
+        when Numeric then return Scalar.new(v), self
+        else raise TypeError, "#{self.class} can't be coerced into #{v.class}"
+      end
+    end
+
+    def conjugate
+      self.class.new(w, -x, -y, -z)
+    end
+
+    def conjugate!
+      @q = w, -x, -y, -z
+      self
+    end
+
+    #Warning: standard notation.
+    def cross_product(q)
+      self.class.new(
+        w * q.w - x * q.x - y * q.y - z * q.z,
+        w * q.x + x * q.w + y * q.z - z * q.y,
+        w * q.y - x * q.z + y * q.w + z * q.x,
+        w * q.z + x * q.y - y * q.x + z * q.w)
+    end
+
+    def difference(q)
+      q * inverse
+    end
+
+    def dot_product(q)
+      w * q.w + x * q.x + y * q.y + z * q.z
+    end
+
+    def dup
+      self.class.new(*@q)
+    end
+
+    def exp
+      a = Math.sqrt(x*x + y*y + z*z)
+      ew = Math.exp(w)
+      s = ew * Math.sin(a) / a
+      self.class.new(ew * Math.cos(a), x * s, y * s, z * s)
+    end
+
+    def imaginary
+      [x, y, z]
+    end
+
+    def inspect
+      "Quaternion[#{w}, #{x}, #{y}, #{z}]"
+    end
+
+    def inverse
+      conjugate / norm
+    end
+
+    def log
+      nv = x*x + y*y + z*z
+      nq = Math.sqrt(w*w + nv)
+      s = Math.acos(w/nq) / Math.sqrt(nv)
+      self.class.new(Math.log(nq), x * s, y * s, z * s)
+    end
+
+    def norm
+      Math.sqrt(squared_norm)
+    end
+
+    def normalize
+      self / norm
+    end
+
+    def normalize!
+      i = 1.0 / norm
+      @q.map! { |e| e * i }
+      self
+    end
+
+    def power(p)
+      (log*p).exp
+    end
+
+    def real
+      w
+    end
+
+    def rotate(v3)
+      Vector3[*(self * Quaternion[0.0, *v3] * inverse).to_a[1..-1]]
+    end
+
+    def squared_norm
+      w * w + x * x + y * y + z * z
+    end
+
+    def to_a
+      @q.dup
+    end
+
+    def to_s(notation = nil)
+      case notation
+        when :scalar_vector
+          "(#{w}, [#{x}, #{y}, #{z}])"
+        when :vertical
+          "w=#{w}\nx=#{x}\ny=#{y}\nz=#{z}"
+        when :angle_axis
+        else
+          "Quaternion[w=#{w}, x=#{x}, y=#{y}, z=#{z}]"
+      end
+    end
+
+    def to_matrix
+      xx = 2 * x * x
+      yy = 2 * y * y
+      zz = 2 * z * z
+      xy = 2 * x * y
+      wz = 2 * w * z
+      xz = 2 * x * z
+      wy = 2 * w * y
+      yz = 2 * y * z
+      wx = 2 * w * x
+
+      Matrix4[1 - yy - zz, xy - wz, xz + wy, 0,
+              xy + wz, 1 - xx - zz,  yz - wx, 0,
+              xz - wy, yz + wx, 1 - xx - yy, 0,
+              0, 0, 0, 1]
+    end
+
+    alias_method :conj,  :conjugate
+    alias_method :conj!, :conjugate
+    alias_method :cross, :cross_product
+    alias_method :dot,   :dot_product
+    alias_method :im,    :imaginary
+    alias_method :imag,  :imaginary
+    alias_method :inv,   :inverse
+    alias_method :re,    :real
+  end
+end