# HG changeset patch
# User John Tsiombikas <nuclear@member.fsf.org>
# Date 1412470805 -10800
# Node ID 4d6383605d64bfbd76a197bc51c055d211414eed

initial commit

diff -r 000000000000 -r 4d6383605d64 .hgignore
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,3 @@
+\.o$
+\.d$
+\.swp$
diff -r 000000000000 -r 4d6383605d64 Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,52 @@
+PREFIX = /usr/local
+
+src = $(wildcard src/*.cc)
+obj = $(src:.cc=.o)
+dep = $(obj:.o=.d)
+lib_a = libvmath4.a
+
+so_major = 4
+so_minor = 0
+
+warn = -Wall
+dbg = -g
+
+CXXFLAGS = -pedantic $(warn) $(dbg) $(pic)
+LDFLAGS = -lm
+
+ifeq ($(shell uname -s), Darwin)
+	lib_so = libvmath4.dylib
+	shared = -dynamiclib
+else
+	ldname = libvmath4.so
+	soname = libvmath4.so.$(so_major)
+	lib_so = libvmath4.so.$(so_major).$(so_minor)
+	shared = -shared -Wl,-soname=$(soname)
+	pic = -fPIC
+endif
+
+.PHONY: all
+all: $(lib_so) $(lib_a)
+
+$(lib_a): $(obj)
+	$(AR) rcs $@ $(obj)
+
+$(lib_so): $(obj)
+	$(CXX) $(shared) -o $@ $(obj) $(LDFLAGS)
+
+$(soname): $(lib_so)
+	rm -f $(soname)
+	ln -s $(lib_so) $(soname)
+
+$(ldname): $(soname)
+	rm -f $(ldname)
+	ln -s $(soname) $(ldname)
+
+-include $(dep)
+
+%.d: %.cc
+	@$(CPP) $(CXXFLAGS) $< -MM -MT $(@:.d=.o) >$@
+
+.PHONY: clean
+clean:
+	rm -f $(obj) $(bin) $(dep)
diff -r 000000000000 -r 4d6383605d64 examples/simple/.clang_complete
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/simple/.clang_complete	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,1 @@
+-I../../src
diff -r 000000000000 -r 4d6383605d64 examples/simple/main.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/simple/main.cc	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,7 @@
+#include <stdio.h>
+#include <vmath.h>
+
+int main()
+{
+
+}
diff -r 000000000000 -r 4d6383605d64 src/matrix.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/matrix.h	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,39 @@
+#ifndef MATRIX_H_
+#define MATRIX_H_
+
+namespace vmath {
+
+class Matrix3x3 {
+private:
+	float m[3][3];
+
+public:
+	static Matrix3x3 id;
+
+	Matrix3x3();
+	Matrix3x3(const float *m);
+	Matrix3x3(float m00, float m01, float m02,
+			float m10, float m11, float m12,
+			float m20, float m21, float m22);
+};
+
+class Matrix4x4 {
+private:
+	float m[4][4];
+
+public:
+	static Matrix4x4 id;
+
+	Matrix4x4();
+	Matrix4x4(const float *m);
+	Matrix4x4(float m00, float m01, float m02, float m03,
+			float m10, float m11, float m12, float m13,
+			float m20, float m21, float m22, float m23,
+			float m30, float m31, float m32, float m33);
+};
+
+#include "matrix.inl"
+
+}	// namespace vmath
+
+#endif	// MATRIX_H_
diff -r 000000000000 -r 4d6383605d64 src/matrix.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/matrix.inl	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,45 @@
+#include <string.h>
+
+Matrix3x3 Matrix3x3::id = Matrix3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);
+Matrix4x4 Matrix4x4::id = Matrix4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
+
+Matrix3x3::Matrix3x3()
+{
+	memcpy(m, Matrix3x3::id.m, sizeof m);
+}
+
+Matrix3x3::Matrix3x3(const float *m)
+{
+	memcpy(this->m, m, sizeof this->m);
+}
+
+Matrix3x3::Matrix3x3(float m00, float m01, float m02,
+					float m10, float m11, float m12,
+					float m20, float m21, float m22)
+{
+	m[0][0] = m00; m[0][1] = m01; m[0][2] = m02;
+	m[1][0] = m10; m[1][1] = m11; m[1][2] = m12;
+	m[2][0] = m20; m[2][1] = m21; m[2][2] = m22;
+}
+
+
+Matrix4x4::Matrix4x4()
+{
+	memcpy(m, Matrix4x4::id.m, sizeof m);
+}
+
+Matrix4x4::Matrix4x4(const float *m)
+{
+	memcpy(this->m, m, sizeof this->m);
+}
+
+Matrix4x4::Matrix4x4(float m00, float m01, float m02, float m03,
+					float m10, float m11, float m12, float m13,
+					float m20, float m21, float m22, float m23,
+					float m30, float m31, float m32, float m33)
+{
+	m[0][0] = m00; m[0][1] = m01; m[0][2] = m02; m[0][3] = m03;
+	m[1][0] = m10; m[1][1] = m11; m[1][2] = m12; m[1][3] = m13;
+	m[2][0] = m20; m[2][1] = m21; m[2][2] = m22; m[2][3] = m23;
+	m[3][0] = m20; m[3][1] = m21; m[3][2] = m22; m[3][3] = m23;
+}
diff -r 000000000000 -r 4d6383605d64 src/quat.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/quat.cc	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,12 @@
+#include "quat.h"
+#include "vector.h"
+
+using namespace vmath;
+
+Quat::Quat(const Vector4 &v)
+{
+	x = v.x;
+	y = v.y;
+	z = v.z;
+	w = v.w;
+}
diff -r 000000000000 -r 4d6383605d64 src/quat.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/quat.h	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,25 @@
+#ifndef QUAT_H_
+#define QUAT_H_
+
+namespace vmath {
+
+class Vector4;
+
+class Quat {
+public:
+	float x, y, z, w;
+
+	Quat();
+	Quat(float x, float y, float z, float w);
+	Quat(const float *v);
+	Quat(const Vector4 &v);
+
+	float &operator [](int idx);
+	const float &operator [](int idx) const;
+};
+
+#include "quat.inl"
+
+}	// namespace vmath
+
+#endif	// QUAT_H_
diff -r 000000000000 -r 4d6383605d64 src/quat.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/quat.inl	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,51 @@
+Quat::Quat()
+{
+	x = y = z = 0.0f;
+	w = 1.0f;
+}
+
+Quat::Quat(float x, float y, float z, float w)
+{
+	this->x = x;
+	this->y = y;
+	this->z = z;
+	this->w = w;
+}
+
+Quat::Quat(const float *v)
+{
+	x = v[0];
+	y = v[1];
+	z = v[2];
+	w = v[3];
+}
+
+float &Quat::operator [](int idx)
+{
+	switch(idx) {
+	case 1:
+		return y;
+	case 2:
+		return z;
+	case 3:
+		return w;
+	case 0:
+	default:
+		return x;
+	}
+}
+
+const float &Quat::operator [](int idx) const
+{
+	switch(idx) {
+	case 1:
+		return y;
+	case 2:
+		return z;
+	case 3:
+		return w;
+	case 0:
+	default:
+		return x;
+	}
+}
diff -r 000000000000 -r 4d6383605d64 src/vector.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/vector.h	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,199 @@
+#ifndef VMATH4_VECTOR_H_
+#define VMATH4_VECTOR_H_
+
+#include "matrix.h"
+#include "quat.h"
+
+namespace vmath {
+
+class Vector3;
+class Vector4;
+
+class Vector2 {
+public:
+	float x, y;
+
+	inline Vector2();
+	inline Vector2(float x, float y);
+	explicit inline Vector2(float *v);
+	explicit inline Vector2(float scalar);
+	explicit inline Vector2(const Vector3 &v);
+	explicit inline Vector2(const Vector4 &v);
+
+	inline float &operator [](int idx);
+	inline const float &operator [](int idx) const;
+
+	operator float* ();
+	operator const float* () const;
+};
+
+inline Vector2 operator -(const Vector2 &v);
+
+inline Vector2 operator +(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator -(const Vector2 &a, const Vector2 &b);
+
+inline Vector2 operator *(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator *(const Vector2 &v, float s);
+inline Vector2 operator *(float s, const Vector2 &v);
+
+inline Vector2 operator /(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator /(const Vector2 &v, float s);
+inline Vector2 operator /(float s, const Vector2 &v);
+
+inline Vector2 operator +=(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator -=(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator *=(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator *=(const Vector2 &v, float s);
+inline Vector2 operator /=(const Vector2 &a, const Vector2 &b);
+inline Vector2 operator /=(const Vector2 &v, float s);
+
+inline float dot(const Vector2 &a, const Vector2 &b);
+
+inline float length(const Vector2 &v);
+inline float length_sq(const Vector2 &v);
+
+inline Vector2 normalize(const Vector2 &v);
+
+
+class Vector3 {
+public:
+	float x, y, z;
+
+	inline Vector3();
+	inline Vector3(float x, float y, float z);
+	explicit inline Vector3(float *v);
+	explicit inline Vector3(float scalar);
+	explicit inline Vector3(const Vector2 &v);
+	explicit inline Vector3(const Vector4 &v);
+
+	inline float &operator [](int idx);
+	inline const float &operator [](int idx) const;
+
+	operator float* ();
+	operator const float* () const;
+};
+
+inline Vector3 operator -(const Vector3 &v);
+
+// Vector op Vector
+inline Vector3 operator +(const Vector3 &a, const Vector3 &b);
+inline Vector3 operator -(const Vector3 &a, const Vector3 &b);
+inline Vector3 operator *(const Vector3 &a, const Vector3 &b);
+inline Vector3 operator /(const Vector3 &a, const Vector3 &b);
+
+// binary op between Vector and scalar
+inline Vector3 operator +(const Vector3 &v, float s);
+inline Vector3 operator +(float s, const Vector3 &v);
+inline Vector3 operator -(const Vector3 &v, float s);
+inline Vector3 operator -(float s, const Vector3 &v);
+inline Vector3 operator *(const Vector3 &v, float s);
+inline Vector3 operator *(float s, const Vector3 &v);
+inline Vector3 operator /(const Vector3 &v, float s);
+inline Vector3 operator /(float s, const Vector3 &v);
+
+// binary op between Vector and Matrix
+inline Vector3 operator *(const Vector3 &v, const Matrix3x3 &m);
+inline Vector3 operator *(const Vector3 &v, const Matrix4x4 &m);
+inline Vector3 operator *(const Matrix3x3 &m, const Vector3 &v);
+inline Vector3 operator *(const Matrix4x4 &m, const Vector3 &v);
+
+inline Vector3 operator +=(const Vector3 &a, const Vector3 &b);
+inline Vector3 operator -=(const Vector3 &a, const Vector3 &b);
+inline Vector3 operator *=(const Vector3 &a, const Vector3 &b);
+inline Vector3 operator /=(const Vector3 &a, const Vector3 &b);
+
+inline Vector3 operator +=(const Vector3 &v, float s);
+inline Vector3 operator -=(const Vector3 &v, float s);
+inline Vector3 operator *=(const Vector3 &v, float s);
+inline Vector3 operator /=(const Vector3 &v, float s);
+
+inline Vector3 operator *=(const Vector3 &v, const Matrix3x3 &m);
+inline Vector3 operator *=(const Vector3 &v, const Matrix4x4 &m);
+
+inline float dot(const Vector3 &a, const Vector3 &b);
+inline Vector3 cross(const Vector3 &a, const Vector3 &b);
+
+inline float length(const Vector3 &v);
+inline float length_sq(const Vector3 &v);
+
+inline Vector3 normalize(const Vector3 &v);
+
+// equivalent to mat * vec
+inline Vector3 transform(const Vector3 &v, const Matrix3x3 &m);
+inline Vector3 transform(const Vector3 &v, const Matrix4x4 &m);
+inline Vector3 transform(const Vector3 &v, const Quat &q);
+
+
+class Vector4 {
+public:
+	float x, y, z, w;
+
+	inline Vector4();
+	inline Vector4(float x, float y, float z, float w = 1.0f);
+	explicit inline Vector4(float *v);
+	explicit inline Vector4(float scalar);
+	explicit inline Vector4(const Vector2 &v);
+	explicit inline Vector4(const Vector3 &v);
+
+	inline float &operator [](int idx);
+	inline const float &operator [](int idx) const;
+
+	operator float* ();
+	operator const float* () const;
+};
+
+inline Vector4 operator -(const Vector4 &v);
+
+// Vector op Vector
+inline Vector4 operator +(const Vector4 &a, const Vector4 &b);
+inline Vector4 operator -(const Vector4 &a, const Vector4 &b);
+inline Vector4 operator *(const Vector4 &a, const Vector4 &b);
+inline Vector4 operator /(const Vector4 &a, const Vector4 &b);
+
+// binary op between Vector and scalar
+inline Vector4 operator +(const Vector4 &v, float s);
+inline Vector4 operator +(float s, const Vector4 &v);
+inline Vector4 operator -(const Vector4 &v, float s);
+inline Vector4 operator -(float s, const Vector4 &v);
+inline Vector4 operator *(const Vector4 &v, float s);
+inline Vector4 operator *(float s, const Vector4 &v);
+inline Vector4 operator /(const Vector4 &v, float s);
+inline Vector4 operator /(float s, const Vector4 &v);
+
+// binary op between Vector and Matrix
+inline Vector4 operator *(const Vector4 &v, const Matrix3x3 &m);
+inline Vector4 operator *(const Vector4 &v, const Matrix4x4 &m);
+inline Vector4 operator *(const Matrix3x3 &m, const Vector4 &v);
+inline Vector4 operator *(const Matrix4x4 &m, const Vector4 &v);
+
+inline Vector4 operator +=(const Vector4 &a, const Vector4 &b);
+inline Vector4 operator -=(const Vector4 &a, const Vector4 &b);
+inline Vector4 operator *=(const Vector4 &a, const Vector4 &b);
+inline Vector4 operator /=(const Vector4 &a, const Vector4 &b);
+
+inline Vector4 operator +=(const Vector4 &v, float s);
+inline Vector4 operator -=(const Vector4 &v, float s);
+inline Vector4 operator *=(const Vector4 &v, float s);
+inline Vector4 operator /=(const Vector4 &v, float s);
+
+inline Vector4 operator *=(const Vector4 &v, const Matrix3x3 &m);
+inline Vector4 operator *=(const Vector4 &v, const Matrix4x4 &m);
+
+inline float dot(const Vector4 &a, const Vector4 &b);
+inline Vector4 cross(const Vector4 &a, const Vector4 &b, const Vector4 &c);
+
+inline float length(const Vector4 &v);
+inline float length_sq(const Vector4 &v);
+
+inline Vector4 normalize(const Vector4 &v);
+
+// equivalent to mat * vec
+inline Vector4 transform(const Vector4 &v, const Matrix3x3 &m);
+inline Vector4 transform(const Vector4 &v, const Matrix4x4 &m);
+inline Vector4 transform(const Vector4 &v, const Quat &q);
+
+#include "vector.inl"
+
+}	// namespace vmath
+
+#endif	// VMATH4_VECTOR_H_
diff -r 000000000000 -r 4d6383605d64 src/vmath.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/vmath.h	Sun Oct 05 04:00:05 2014 +0300
@@ -0,0 +1,10 @@
+#ifndef VMATH4_H_
+#define VMATH4_H_
+
+#include "vector.h"
+#include "matrix.h"
+#include "quat.h"
+//#include "numalg.h"
+//#include "geom.h"
+
+#endif	/* VMATH4_H_ */