diff --git a/Aquaria/AnimationEditor.cpp b/Aquaria/AnimationEditor.cpp
index af0a35c..904e028 100644
--- a/Aquaria/AnimationEditor.cpp
+++ b/Aquaria/AnimationEditor.cpp
@@ -1415,6 +1415,7 @@ void AnimationEditor::load()
 	std::string file = dsq->getUserInputString("Enter anim file to load:");
 	if (file.empty())		return;
 	this->editingFile = file;
+	SkeletalSprite::clearCache();
 	loadFile();
 }
 
@@ -1426,6 +1427,7 @@ void AnimationEditor::loadSkin()
 	if (file.empty())		return;
 	//this->editingFile = file;
 	//loadFile();
+	SkeletalSprite::clearCache();
 	editSprite->loadSkin(file);
 }
 
diff --git a/Aquaria/AquariaComboBox.cpp b/Aquaria/AquariaComboBox.cpp
index ace3175..84cd7b5 100644
--- a/Aquaria/AquariaComboBox.cpp
+++ b/Aquaria/AquariaComboBox.cpp
@@ -27,7 +27,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #define SCROLL_DELAY				0.1f
 #define SCROLL_DELAY_FIRST			0.4f
 
-AquariaComboBox::AquariaComboBox() : RenderObject()
+AquariaComboBox::AquariaComboBox(Vector textscale) : RenderObject()
 {
 	//Quad *bar, *window, *scrollBtnUp, *scrollBtnDown, *scrollBar;
 	bar = new Quad("gui/combo-drop", Vector(0,0));
@@ -47,6 +47,7 @@ AquariaComboBox::AquariaComboBox() : RenderObject()
 	selectedItemLabel->setFontSize(8);
 	selectedItemLabel->offset.y = -10;
 	selectedItemLabel->position.x = -50;
+	selectedItemLabel->scale = textscale;
 	addChild(selectedItemLabel, PM_POINTER);
 
 	numDrops = 8;
@@ -62,6 +63,8 @@ AquariaComboBox::AquariaComboBox() : RenderObject()
 
 	scrollDelay = 0;
 	firstScroll = 0;
+
+	this->textscale = textscale;
 }
 
 void AquariaComboBox::destroy()
@@ -230,7 +233,7 @@ void AquariaComboBox::open(float t)
 	{
 		if (i < items.size())
 		{
-			AquariaComboBoxItem *a = new AquariaComboBoxItem(items[i], i, this);
+			AquariaComboBoxItem *a = new AquariaComboBoxItem(items[i], i, this, textscale);
 			a->alpha = 0;
 			a->alpha.interpolateTo(1, t);
 			a->position.y = (a->getHeight()+2) * ((i-scroll)+1);
@@ -335,7 +338,7 @@ int AquariaComboBox::addItem(const std::string &n)
 Vector unselectedColor(0.7, 0.7, 0.7);
 Vector selectedColor(1,1,1);
 
-AquariaComboBoxItem::AquariaComboBoxItem(const std::string &str, int idx, AquariaComboBox *combo) : Quad()
+AquariaComboBoxItem::AquariaComboBoxItem(const std::string &str, int idx, AquariaComboBox *combo, Vector textscale) : Quad()
 {
 	this->combo = combo;
 	index = idx;
@@ -348,6 +351,7 @@ AquariaComboBoxItem::AquariaComboBoxItem(const std::string &str, int idx, Aquari
 	label->setText(str);
 	label->offset.y = -10;
 	label->position.x = -50;
+	label->scale = textscale;
 	addChild(label, PM_POINTER);
 
 	color = unselectedColor;
diff --git a/Aquaria/AquariaMenuItem.cpp b/Aquaria/AquariaMenuItem.cpp
index c288058..9f1383b 100644
--- a/Aquaria/AquariaMenuItem.cpp
+++ b/Aquaria/AquariaMenuItem.cpp
@@ -847,16 +847,17 @@ void AquariaMenuItem::useSound(const std::string &tex)
 	useSfx = tex;
 }
 
-void AquariaMenuItem::useQuad(const std::string &tex)
+bool AquariaMenuItem::useQuad(const std::string &tex)
 {
 	if (quad)
 	{
 		debugLog("trying to call useQuad twice on the same object");
-		return;
+		return true;
 	}
 	quad = new Quad;
-	quad->setTexture(tex);
+	bool good = quad->setTexture(tex);
 	addChild(quad, PM_POINTER);
+	return good;
 }
 
 void AquariaMenuItem::useGlow(const std::string &tex, int w, int h)
diff --git a/Aquaria/AquariaMenuItem.h b/Aquaria/AquariaMenuItem.h
index 95dc797..ee7a85a 100644
--- a/Aquaria/AquariaMenuItem.h
+++ b/Aquaria/AquariaMenuItem.h
@@ -81,7 +81,7 @@ public:
 	XMLElement *ability, *xmlItem;
 	int choice;
 	Quad *glow, *quad;
-	void useQuad(const std::string &tex);
+	bool useQuad(const std::string &tex);
 	void useGlow(const std::string &tex, int w, int h);
 	void useSound(const std::string &tex);
 	
@@ -195,7 +195,7 @@ class AquariaComboBox;
 class AquariaComboBoxItem : public Quad
 {
 public:
-	AquariaComboBoxItem(const std::string &str, int idx, AquariaComboBox *combo);
+	AquariaComboBoxItem(const std::string &str, int idx, AquariaComboBox *combo, Vector textscale);
 
 protected:
 	void onUpdate(float dt);
@@ -210,7 +210,7 @@ protected:
 class AquariaComboBox : public RenderObject
 {
 public:
-	AquariaComboBox();
+	AquariaComboBox(Vector textscale = Vector(1, 1));
 
 	void destroy();
 
@@ -242,6 +242,7 @@ protected:
 	int selectedItem;
 	float scrollDelay;
 	bool firstScroll;
+	Vector textscale;
 
 	std::vector<AquariaComboBoxItem*> shownItems;
 };
diff --git a/Aquaria/Avatar.cpp b/Aquaria/Avatar.cpp
index 43d334c..355f807 100644
--- a/Aquaria/Avatar.cpp
+++ b/Aquaria/Avatar.cpp
@@ -4110,33 +4110,16 @@ void Avatar::refreshNormalForm()
 	if (c.empty())
 		c = "Naija";
 	refreshModel("Naija", c);
-	if (true)
+	if(hair)
 	{
-		if (hair)
-			hair->alphaMod = 1.0;
+		hair->alphaMod = 1.0;
 		if (!c.empty() && c!="Naija")
 		{
-			if (exists(core->getBaseTextureDirectory() + "naija/cape-"+c+".png"))
-			{
-				if (hair)
-					hair->setTexture("naija/cape-"+c);
-			}
-			else
-			{
-				if (hair)
-					hair->alphaMod = 0;
-			}
+			if(!hair->setTexture("naija/cape-"+c))
+				hair->alphaMod = 0;
 		}
 		else
-		{
-			if (hair)
-				hair->setTexture("naija/cape");
-		}
-	}
-	else
-	{
-		if (hair)
-			hair->alphaMod = 0.0;
+			hair->setTexture("naija/cape");
 	}
 }
 
@@ -7127,7 +7110,7 @@ void Avatar::onUpdate(float dt)
 
 	if(!core->particlesPaused && elementEffectMult > 0)
 	{
-		ElementUpdateList& elems = dsq->game->elementUpdateList;
+		ElementUpdateList& elems = dsq->game->elementInteractionList;
 		for (ElementUpdateList::iterator it = elems.begin(); it != elems.end(); ++it)
 		{
 			(*it)->doInteraction(this, elementEffectMult, 16);
diff --git a/Aquaria/Continuity.cpp b/Aquaria/Continuity.cpp
index 8f386a9..f94a4f2 100644
--- a/Aquaria/Continuity.cpp
+++ b/Aquaria/Continuity.cpp
@@ -1368,7 +1368,19 @@ void Continuity::loadEatBank()
 {
 	eats.clear();
 
-	InStream inf("data/eats.txt");
+	std::string file;
+	bool found = false;
+	if (dsq->mod.isActive())
+	{
+		file = dsq->mod.getPath() + "eats.txt";
+		if(exists(file))
+			found = true;
+	}
+
+	if(!found)
+		file = "data/eats.txt";
+
+	InStream inf(file.c_str());
 
 	EatData curData;
 	std::string read;
@@ -3649,7 +3661,8 @@ void Continuity::reset()
 
 	speedTypes.clear();
 	InStream inFile("data/speedtypes.txt");
-	int n, spd;
+	int n;
+	float spd;
 	while (inFile >> n)
 	{
 		inFile >> spd;
@@ -3667,7 +3680,7 @@ void Continuity::reset()
 	core->resetTimer();
 }
 
-int Continuity::getSpeedType(int speedType)
+float Continuity::getSpeedType(int speedType)
 {
 	if (speedType >= speedTypes.size() || speedType < 0)
 	{
diff --git a/Aquaria/DSQ.cpp b/Aquaria/DSQ.cpp
index a331cc6..c89a7b4 100644
--- a/Aquaria/DSQ.cpp
+++ b/Aquaria/DSQ.cpp
@@ -2222,7 +2222,7 @@ void DSQ::refreshResourcesForPatch(const std::string& name)
 	{
 		for(int i = 0; i < dsq->resources.size(); ++i)
 		{
-			Resource *r = dsq->resources[i];
+			Texture *r = dsq->resources[i];
 			if(files.find(r->name) != files.end())
 				r->reload();
 		}
@@ -2313,7 +2313,7 @@ void DSQ::shutdown()
 	SkeletalSprite::clearCache();
 
 
-	cursor->setTexturePointer(0, RenderObject::NO_ADD_REF);
+	cursor->setTexturePointer(0);
 
 	UNREFTEX(texCursor);
 	UNREFTEX(texCursorSwim);
@@ -2410,7 +2410,7 @@ void DSQ::setTexturePointers()
 	texCursorSing = core->addTexture("cursor-sing");
 
 	if (cursor)
-		cursor->setTexturePointer(texCursor, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursor);
 }
 
 void DSQ::setCursor(CursorType type)
@@ -2418,22 +2418,22 @@ void DSQ::setCursor(CursorType type)
 	switch(type)
 	{
 	case CURSOR_NORMAL:
-		cursor->setTexturePointer(texCursor, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursor);
 	break;
 	case CURSOR_LOOK:
-		cursor->setTexturePointer(texCursorLook, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursorLook);
 	break;
 	case CURSOR_BURST:
-		cursor->setTexturePointer(texCursorBurst, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursorBurst);
 	break;
 	case CURSOR_SWIM:
-		cursor->setTexturePointer(texCursorSwim, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursorSwim);
 	break;
 	case CURSOR_SING:
-		cursor->setTexturePointer(texCursorSing, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursorSing);
 	break;
 	default:
-		cursor->setTexturePointer(texCursor, RenderObject::NO_ADD_REF);
+		cursor->setTexturePointer(texCursor);
 	break;
 	}
 }
@@ -3869,58 +3869,6 @@ void DSQ::jumpToSection(InStream &inFile, const std::string &section)
 	debugLog("could not find section [" + section + "]");
 }
 
-
-void DSQ::runGesture(const std::string &line)
-{
-	std::istringstream is(line);
-	std::string target;
-	is >> target;
-	debugLog("Gesture: " + line);
-	if (target == "entity")
-	{
-		std::string entName;
-		is >> entName;
-		Entity *e = getEntityByName(entName);
-		if (e)
-		{
-			std::string cmd;
-			is >> cmd;
-			if (cmd=="anim" || cmd=="animate")
-			{
-				std::string anim;
-				is >> anim;
-				int loop = 0;
-				int group = 0;
-				if (anim == "idle")
-				{
-					e->skeletalSprite.stopAllAnimations();
-					loop = -1;
-				}
-				if (line.find("upperBody")!=std::string::npos)
-				{
-					group = 1;
-				}
-				if (line.find("loop")!=std::string::npos)
-				{
-					loop = -1;
-				}
-				if (line.find("stopAll")!=std::string::npos)
-				{
-					e->skeletalSprite.stopAllAnimations();
-				}
-				e->skeletalSprite.transitionAnimate(anim, 0.2, loop, group);
-			}
-			else if (cmd == "moveToNode")
-			{
-				std::string node;
-				is >> node;
-				Path *p = dsq->game->getPathByName(node);
-				e->moveToNode(p, 0);
-			}
-		}
-	}
-}
-
 bool DSQ::runScript(const std::string &name, const std::string &function, bool ignoremissing /* = false */)
 {
 	if (!scriptInterface.runScript(name, function, ignoremissing))
@@ -4550,7 +4498,7 @@ void DSQ::onUpdate(float dt)
 	if (isDeveloperKeys() && fpsText && cmDebug && cmDebug->alpha == 1)
 	{
 		std::ostringstream os;
-		os << "FPS: " << core->fps << " | ROC: " << core->renderObjectCount << " | RC: " << Core::dbg_numRenderCalls;
+		os << "FPS: " << core->fps << " | ROC: " << core->renderObjectCount << " | RC: " << Core::dbg_numRenderCalls << " | RES: " << core->resources.size();
 		os << " | p: " << core->processedRenderObjectCount << " | t: " << core->totalRenderObjectCount;
 		os << " | s: " << dsq->continuity.seconds;
 		os << " | evQ: " << core->eventQueue.getSize();
@@ -4829,7 +4777,12 @@ void DSQ::modifyDt(float &dt)
 	if (isDeveloperKeys())
 	{
 		if (core->getKeyState(KEY_G))
-			dt *= 4;
+		{
+			if(core->getShiftState())
+				dt *= 10;
+			else
+				dt *= 4;
+		}
 		else if (core->getKeyState(KEY_F))
 		{
 			if (core->getShiftState())
diff --git a/Aquaria/DSQ.h b/Aquaria/DSQ.h
index 773e212..7acb2be 100644
--- a/Aquaria/DSQ.h
+++ b/Aquaria/DSQ.h
@@ -31,8 +31,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "AquariaMenuItem.h"
 #include "ScriptInterface.h"
 
-#include "PathFinding.h"
-
 #include "TTFFont.h"
 
 #include "tinyxml2.h"
@@ -622,12 +620,13 @@ class Path;
 
 struct GemData
 {
-	GemData() { canMove=false; }
+	GemData() { canMove=false; blink = false; }
 	std::string name;
 	std::string userString;
 	std::string mapName;
-	bool canMove;
 	Vector pos;
+	bool canMove;
+	bool blink; // not saved
 };
 
 struct BeaconData
@@ -994,7 +993,7 @@ public:
 	float getStory();
 	void setStory(float v);
 
-	int getSpeedType(int speedType);
+	float getSpeedType(int speedType);
 	void setNaijaModel(std::string model);
 
 
@@ -1161,7 +1160,7 @@ public:
 
 protected:
 	std::vector<EatData> eats;
-	std::vector<int> speedTypes;
+	std::vector<float> speedTypes;
 	float story;
 	WorldType worldType;
 
@@ -1264,7 +1263,7 @@ public:
 	Quad *bar_left, *bar_right, *bar_up, *bar_down;
 	Quad *barFade_left, *barFade_right;
 
-	Texture *texCursor, *texCursorSwim, *texCursorBurst, *texCursorSing, *texCursorLook;
+	CountedPtr<Texture> texCursor, texCursorSwim, texCursorBurst, texCursorSing, texCursorLook;
 
 	void setBlackBarsColor(Vector color);
 	
@@ -1397,8 +1396,6 @@ public:
 
 	void jumpToSection(InStream &inFile, const std::string &section);
 
-	PathFinding pathFinding;
-	void runGesture(const std::string &line);
 	void generateCollisionMask(RenderObject *r);
 	void toggleRenderCollisionShapes();
 
diff --git a/Aquaria/Element.cpp b/Aquaria/Element.cpp
index 9c8cc51..c18bac7 100644
--- a/Aquaria/Element.cpp
+++ b/Aquaria/Element.cpp
@@ -84,12 +84,8 @@ void Element::doInteraction(Entity *ent, float mult, float touchWidth)
 			eff->hitPerc = hitPerc;
 			eff->touchVel = ent->vel;
 			eff->effectMult = mult;
-			return;
 		}
 	}
-	//eff->touchVel = Vector(0, 0);
-	//eff->hitPerc = 0;
-	eff->touching = false;
 }
 
 void Element::updateEffects(float dt)
@@ -110,6 +106,7 @@ void Element::updateEffects(float dt)
 
 			if (eff->touching)
 			{
+				eff->touching = false;
 				float ramp = eff->touchVel.getLength2D()/800.0f;
 				if (ramp < 0)	ramp = 0;
 				if (ramp > 1)	ramp = 1;
diff --git a/Aquaria/Entity.cpp b/Aquaria/Entity.cpp
index b34b0af..39e9c55 100644
--- a/Aquaria/Entity.cpp
+++ b/Aquaria/Entity.cpp
@@ -26,6 +26,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "Avatar.h"
 #include "ScriptedEntity.h"
 #include "Shot.h"
+#include "PathFinding.h"
 
 //Shader Entity::blurShader;
 
@@ -254,7 +255,7 @@ Entity::Entity()
 	//debugLog("dsq->addEntity()");
 
 	dsq->addEntity(this);
-	maxSpeed = oldMaxSpeed = 300;
+	maxSpeed = 300;
 	entityDead = false;
 	health = maxHealth = 5;
 	invincibleBreak = false;
@@ -439,43 +440,45 @@ void Entity::setName(const std::string &name)
 	this->name = name;
 }
 
-void Entity::followPath(Path *p, int speedType, int dir, bool deleteOnEnd)
+float Entity::followPath(Path *p, float speed, int dir, bool deleteOnEnd)
 {
-	if (p)
-	{
-		deleteOnPathEnd = deleteOnEnd;
+	if(!speed)
+		speed = getMaxSpeed();
+	deleteOnPathEnd = deleteOnEnd;
 
-		position.stopPath();
-		position.ensureData();
-		position.data->path.clear();
-		if (dir)
+	position.stopPath();
+	position.ensureData();
+	position.data->path.clear();
+	if (dir)
+	{
+		for (int i = p->nodes.size()-1; i >=0; i--)
 		{
-			for (int i = p->nodes.size()-1; i >=0; i--)
-			{
-				PathNode pn = p->nodes[i];
-				position.data->path.addPathNode(pn.position, 1.0f-(float(i/float(p->nodes.size()))));
-			}
+			PathNode pn = p->nodes[i];
+			position.data->path.addPathNode(pn.position, 1.0f-(float(i/float(p->nodes.size()))));
 		}
-		else
-		{
-			for (int i = 0; i < p->nodes.size(); i++)
-			{
-				PathNode pn = p->nodes[i];
-				position.data->path.addPathNode(pn.position, float(i/float(p->nodes.size())));
-			}
-		}
-		//debugLog("Calculating Time");
-		float time = position.data->path.getLength()/(float)dsq->continuity.getSpeedType(speedType);
-		//debugLog("Starting");
-		position.data->path.getPathNode(0)->value = position;
-		position.startPath(time);//, 1.0f/2.0f);
 	}
+	else
+	{
+		for (int i = 0; i < p->nodes.size(); i++)
+		{
+			PathNode pn = p->nodes[i];
+			position.data->path.addPathNode(pn.position, float(i/float(p->nodes.size())));
+		}
+	}
+	//debugLog("Calculating Time");
+	float time = position.data->path.getLength()/speed;
+	//debugLog("Starting");
+	position.data->path.getPathNode(0)->value = position;
+	position.startPath(time);//, 1.0f/2.0f);
+	return time;
 }
 
-void Entity::moveToNode(Path *path, int speedType, int dieOnPathEnd, bool swim)
+float Entity::moveToPos(Vector dest, float speed, int dieOnPathEnd, bool swim)
 {
+	if(!speed)
+		speed = getMaxSpeed();
+
 	Vector start = position;
-	Vector dest = path->nodes[0].position;
 	followEntity = 0;
 	//watchingEntity = 0;
 
@@ -485,10 +488,10 @@ void Entity::moveToNode(Path *path, int speedType, int dieOnPathEnd, bool swim)
 
 	swimPath = swim;
 	//debugLog("Generating path to: " + path->name);
-	dsq->pathFinding.generatePath(this, TileVector(start), TileVector(dest));
-	int sz = position.data->path.getNumPathNodes();
-	position.data->path.addPathNode(path->nodes[0].position, 1);
-	VectorPath old = position.data->path;
+	PathFinding::generatePath(this, TileVector(start), TileVector(dest));
+	//int sz = position.data->path.getNumPathNodes();
+	//position.data->path.addPathNode(path->nodes[0].position, 1);
+	//VectorPath old = position.data->path;
 	/*std::ostringstream os;
 	os << "Path length: " << sz;
 	debugLog(os.str());*/
@@ -509,16 +512,16 @@ void Entity::moveToNode(Path *path, int speedType, int dieOnPathEnd, bool swim)
 
 	//debugLog("Molesting Path");
 
-	dsq->pathFinding.molestPath(position.data->path);
+	PathFinding::molestPath(position.data->path);
 	//position.data->path.realPercentageCalc();
 	//position.data->path.cut(4);
 
 	//debugLog("forcing path to minimum 2 nodes");
-	dsq->pathFinding.forceMinimumPath(position.data->path, start, dest);
+	PathFinding::forceMinimumPath(position.data->path, start, dest);
 	//debugLog("Done");
 
 	//debugLog("Calculating Time");
-	float time = position.data->path.getLength()/(float)dsq->continuity.getSpeedType(speedType);
+	float time = position.data->path.getLength()/speed;
 	//debugLog("Starting");
 	position.data->path.getPathNode(0)->value = position;
 	position.startPath(time);//, 1.0f/2.0f);
@@ -535,6 +538,8 @@ void Entity::moveToNode(Path *path, int speedType, int dieOnPathEnd, bool swim)
 
 	//position.startSpeedPath(dsq->continuity.getSpeedType(speedType));
 	//position.startPath(((position.data->path.getNumPathNodes()*TILE_SIZE*4)-2)/dsq->continuity.getSpeedType(speedType));
+
+	return time;
 }
 
 void Entity::stopFollowingPath()
@@ -1009,7 +1014,7 @@ bool Entity::isNearObstruction(int sz, int type, TileVector *hitTile)
 	return v;
 }
 
-bool Entity::touchAvatarDamage(int radius, float dmg, const Vector &override, int speed, float pushTime, Vector collidePos)
+bool Entity::touchAvatarDamage(int radius, float dmg, const Vector &override, float speed, float pushTime, Vector collidePos)
 {
 	if (isv(EV_BEASTBURST, 1) && isDamageTarget(DT_AVATAR_BITE) && dsq->continuity.form == FORM_BEAST && dsq->game->avatar->bursting)
 	{
@@ -1150,7 +1155,7 @@ void Entity::update(float dt)
 	Vector backupPos = position;
 	Vector backupVel = vel;
 
-	bool doUpdate = (updateCull == -1 || (position - core->screenCenter).isLength2DIn(updateCull));
+	bool doUpdate = (updateCull < 0 || (position - core->screenCenter).isLength2DIn(updateCull));
 	if (doUpdate && !(pauseFreeze && dsq->game->isPaused()))
 	{
 
@@ -2212,7 +2217,7 @@ bool Entity::isUnderWater(const Vector &override)
 	return false;
 }
 
-void Entity::push(const Vector &vec, float time, int maxSpeed, float dmg)
+void Entity::push(const Vector &vec, float time, float maxSpeed, float dmg)
 {
 	if (!this->isEntityDead())
 	{
@@ -2233,9 +2238,9 @@ void Entity::push(const Vector &vec, float time, int maxSpeed, float dmg)
 	//vel += pushVec;
 }
 
-void Entity::setMaxSpeed(int ms)
+void Entity::setMaxSpeed(float ms)
 {
-	maxSpeed = oldMaxSpeed = ms;
+	maxSpeed = ms;
 }
 
 int Entity::getMaxSpeed()
@@ -2394,11 +2399,6 @@ void Entity::onEnterState(int action)
 {
 	switch (action)
 	{
-	case STATE_IDLE:
-	{
-		maxSpeed = oldMaxSpeed;
-	}
-	break;
 	case STATE_DEAD:
 	{
 		if (!isGoingToBeEaten())
@@ -3019,7 +3019,7 @@ void Entity::shotHitEntity(Entity *hit, Shot *shot, Bone *b)
 {
 }
 
-bool Entity::doCollisionAvoidance(float dt, int search, float mod, Vector *vp, int overrideMaxSpeed, int ignoreObs, bool onlyVP)
+bool Entity::doCollisionAvoidance(float dt, int search, float mod, Vector *vp, float overrideMaxSpeed, int ignoreObs, bool onlyVP)
 {
 	Vector accum;
 	int c = 0;
diff --git a/Aquaria/Entity.h b/Aquaria/Entity.h
index e7d8d97..7532125 100644
--- a/Aquaria/Entity.h
+++ b/Aquaria/Entity.h
@@ -28,6 +28,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "DSQ.h"
 #include "Path.h"
 #include "Hair.h"
+#include "TileVector.h"
 
 #include "tinyxml2.h"
 using namespace tinyxml2;
@@ -232,7 +233,7 @@ public:
 
 	void heal(float a, int type=0);
 
-	void push(const Vector &vec, float time, int maxSpeed, float dmg);
+	void push(const Vector &vec, float time, float maxSpeed, float dmg);
 
 	bool canSetState(int state);
 	
@@ -311,9 +312,9 @@ public:
 	};
 	virtual void onNotify(Entity *notify){}
 	//void followPath(Path *p, int spd, int loop, bool deleteOnEnd = false);
-	void followPath(Path *p, int speedType, int dir, bool deleteOnEnd = false);
+	float followPath(Path *p, float speed, int dir, bool deleteOnEnd = false);
 	Entity *attachedTo;
-	bool touchAvatarDamage(int radius, float dmg, const Vector &override=Vector(-1,-1,-1), int speed=0, float pushTime = 0, Vector collidePos = Vector(0,0,0));
+	bool touchAvatarDamage(int radius, float dmg, const Vector &override=Vector(-1,-1,-1), float speed=0, float pushTime = 0, Vector collidePos = Vector(0,0,0));
 
 	void moveTowards(Vector p, float dt, int spd);
 	void moveAround(Vector p, float dt, int spd, int d);
@@ -326,10 +327,10 @@ public:
 	void moveAroundEntity(float dt, int spd, int d, Entity *e);
 	void moveTowardsGroupCenter(float dt, int spd);
 	void moveTowardsGroupHeading(float dt, int spd);
-	bool doCollisionAvoidance(float dt, int search, float mod, Vector *v = 0, int overrideMaxSpeed=0, int ignoreObs=0, bool onlyVP=false);
+	bool doCollisionAvoidance(float dt, int search, float mod, Vector *v = 0, float overrideMaxSpeed=0, int ignoreObs=0, bool onlyVP=false);
 	void doSpellAvoidance(float dt, int range, float mod);
 	void doEntityAvoidance(float dt, int range, float mod, Entity *ignore =0);
-	void setMaxSpeed(int ms);
+	void setMaxSpeed(float ms);
 	Entity *findTarget(int dist, int type, int t=0);
 	//bool hasTarget() { return target != 0; }
 	bool hasTarget(int t=0);
@@ -352,7 +353,7 @@ public:
 	void overideMaxSpeed(int ms, float time);
 	void disableOverideMaxSpeed();
 	int currentEntityTarget;
-	void moveToNode(Path *path, int speedType, int dieOnPathEnd=0, bool swim = false);
+	float moveToPos(Vector pos, float speed, int dieOnPathEnd=0, bool swim = false);
 	bool isHit();
 	bool pathBurst(bool wallJump = false);
 	Timer burstTimer;
@@ -598,7 +599,7 @@ protected:
 
 	void updateBoneLock();
 
-	int pushMaxSpeed;
+	float pushMaxSpeed;
 	std::string currentAnim;
 	
 
@@ -609,8 +610,7 @@ protected:
 private:
 
 
-	int maxSpeed;
-	int oldMaxSpeed;
+	float maxSpeed;
 
 	bool stopSoundsOnDeath;
 
diff --git a/Aquaria/Game.cpp b/Aquaria/Game.cpp
index 17b450c..824e8d2 100644
--- a/Aquaria/Game.cpp
+++ b/Aquaria/Game.cpp
@@ -42,8 +42,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 std::vector<std::string> allowedMaps;
 
-const int PATH_ACTIVATION_RANGE		 = 800;
-
 Vector worldLeftCenter(217,250), worldRightCenter(575, 250);
 Vector opt_save_original = Vector(350, 350), opt_cancel_original = Vector(450, 350);
 
@@ -3384,12 +3382,14 @@ void Game::createInGameMenu()
 	resolutionLabel->position = Vector(160, 260);
 	options->addChild(resolutionLabel, PM_POINTER);
 
-	resBox = new AquariaComboBox();
+	resBox = new AquariaComboBox(Vector(0.7f, 1.0f));
 	resBox->position = Vector(196, 285);
 	for (i = 0; i < core->screenModes.size(); i++)
 	{
 		std::ostringstream os;
 		os << core->screenModes[i].x << "x" << core->screenModes[i].y;
+		if(core->screenModes[i].hz)
+			os << " (" << core->screenModes[i].hz << "hz)";
 		resBox->addItem(os.str());
 		if (core->screenModes[i].x == dsq->user.video.resx && core->screenModes[i].y == dsq->user.video.resy)
 		{
@@ -5910,22 +5910,14 @@ void Game::rebuildElementUpdateList()
 	elementUpdateList.clear();
 	elementInteractionList.clear();
 	for (int i = 0; i < dsq->getNumElements(); i++)
-	//for (int i = LR_ELEMENTS1; i <= LR_ELEMENTS8; i++)
 	{
-		//RenderObjectLayer *rl = dsq->getRenderObjectLayer(i);
 		Element *e = dsq->getElement(i);
-		if (e && e->layer >= LR_ELEMENTS1 && e->layer <= LR_ELEMENTS8)
-		{
-			if (e->getElementEffectIndex() != -1)
-			{
-				elementUpdateList.push_back(e);
-			}
-			ElementEffect ee = dsq->getElementEffectByIndex(e->getElementEffectIndex());
-			if(ee.type == EFX_WAVY)
-			{
-				elementInteractionList.push_back(e);
-			}
-		}
+		const int eeidx = e->getElementEffectIndex();
+		if (eeidx != -1 && e->layer >= LR_ELEMENTS1 && e->layer <= LR_ELEMENTS8)
+			elementUpdateList.push_back(e);
+		ElementEffect ee = dsq->getElementEffectByIndex(eeidx);
+		if(ee.type == EFX_WAVY)
+			elementInteractionList.push_back(e);
 	}
 }
 
@@ -6460,18 +6452,9 @@ void Game::applyState()
 	}
 #endif
 
-	worldMapRender = 0;
-	dsq->continuity.worldMap.revealMap(sceneToLoad);
-
-	debugLog("Creating WorldMapRender");
-	if(dsq->mod.isActive() && dsq->mod.mapRevealMethod != REVEAL_UNSPECIFIED)
-		WorldMapRender::setRevealMethod(dsq->mod.mapRevealMethod);
-	else
-		WorldMapRender::setRevealMethod((WorldMapRevealMethod)dsq->user.video.worldMapRevealMethod);
-
-	worldMapRender = new WorldMapRender;
-	addRenderObject(worldMapRender, LR_WORLDMAP);
-
+/*
+	if (liFlag == 100)
+	*/
 
 	if (verbose) debugLog("Creating Avatar");
 	avatar = new Avatar();
@@ -6535,6 +6518,8 @@ void Game::applyState()
 	if (verbose) debugLog("...Done");
 	backupSceneColor = sceneColor;
 
+	dsq->continuity.worldMap.revealMap(sceneName);
+
 	colorTest();
 
 	if (!warpAreaType.empty())
@@ -6663,6 +6648,18 @@ void Game::applyState()
 	timerText->followCamera = 1;
 	addRenderObject(timerText, LR_MINIMAP);
 
+	worldMapRender = 0;
+
+	if(dsq->mod.isActive() && dsq->mod.mapRevealMethod != REVEAL_UNSPECIFIED)
+		WorldMapRender::setRevealMethod(dsq->mod.mapRevealMethod);
+	else
+		WorldMapRender::setRevealMethod((WorldMapRevealMethod)dsq->user.video.worldMapRevealMethod);
+
+	worldMapRender = new WorldMapRender;
+	addRenderObject(worldMapRender, LR_WORLDMAP);
+	// to hide minimap
+	//miniMapRender->position += Vector(800,0);
+
 	sceneToLoad="";
 
 	if (!fromScene.empty())
@@ -9328,7 +9325,7 @@ void Game::toggleKeyConfigMenu(bool f)
 
 		//group_keyConfig->children[group_keyConfig->children.size()-3]
 
-		RenderObjectList::reverse_iterator i = group_keyConfig->children.rbegin();
+		RenderObject::Children::reverse_iterator i = group_keyConfig->children.rbegin();
 		AquariaKeyConfig *upright0 = (AquariaKeyConfig*)(*i);
 		i++;
 		AquariaKeyConfig *upright = (AquariaKeyConfig*)(*i);
@@ -10372,7 +10369,7 @@ void Game::update(float dt)
 			{
 				Vector diff = p->nodes[0].position - dsq->game->avatar->position;
 
-				if (p->isCoordinateInside(dsq->game->avatar->position) || diff.getSquaredLength2D() < sqr(PATH_ACTIVATION_RANGE))
+				if (p->isCoordinateInside(dsq->game->avatar->position) || diff.getSquaredLength2D() < sqr(p->activationRange))
 				{
 					//if (trace(avatar->position, p->nodes[0].position))
 					{
@@ -10819,6 +10816,7 @@ void Game::removeState()
 	core->particlesPaused = false;
 
 	elementUpdateList.clear();
+	elementInteractionList.clear();
 
 	dsq->setCursor(CURSOR_NORMAL);
 	dsq->darkLayer.toggle(0);
diff --git a/Aquaria/MiniMapRender.cpp b/Aquaria/MiniMapRender.cpp
index 5e0d24b..d952e89 100644
--- a/Aquaria/MiniMapRender.cpp
+++ b/Aquaria/MiniMapRender.cpp
@@ -66,14 +66,14 @@ namespace MiniMapRenderSpace
 	const int healthMarkerSize = 20;
 
 
-	Texture *texCook = 0;
-	Texture *texWaterBit = 0;
-	Texture *texMinimapBtm = 0;
-	Texture *texMinimapTop = 0;
-	Texture *texRipple = 0;
-	Texture *texNaija = 0;
-	Texture *texHealthBar = 0;
-	Texture *texMarker = 0;
+	CountedPtr<Texture> texCook = 0;
+	CountedPtr<Texture> texWaterBit = 0;
+	CountedPtr<Texture> texMinimapBtm = 0;
+	CountedPtr<Texture> texMinimapTop = 0;
+	CountedPtr<Texture> texRipple = 0;
+	CountedPtr<Texture> texNaija = 0;
+	CountedPtr<Texture> texHealthBar = 0;
+	CountedPtr<Texture> texMarker = 0;
 
 	float waterSin = 0;
 
diff --git a/Aquaria/ModSelector.cpp b/Aquaria/ModSelector.cpp
index 2a48670..3f95a16 100644
--- a/Aquaria/ModSelector.cpp
+++ b/Aquaria/ModSelector.cpp
@@ -640,8 +640,7 @@ bool ModIconOnline::fixIcon()
 			quad->setDecayRate(2);
 			quad = 0;
 		}
-		useQuad(iconfile);
-		result = Texture::textureError == TEXERR_OK;
+		result = useQuad(iconfile);
 	}
 	if(!quad)
 	{
diff --git a/Aquaria/Path.cpp b/Aquaria/Path.cpp
index 3b1bc1f..5763e91 100644
--- a/Aquaria/Path.cpp
+++ b/Aquaria/Path.cpp
@@ -54,6 +54,7 @@ Path::Path()
 	warpType = 0;
 	spiritFreeze = true;
 	pauseFreeze = true;
+	activationRange = 800;
 }
 
 void Path::clampPosition(Vector *pos, float radius)
@@ -450,14 +451,23 @@ void Path::refreshScript()
 		//core->removeRenderObject(&emitter, Core::DO_NOT_DESTROY_RENDER_OBJECT);
 		//core->getTopStateData()->addRenderObject(&emitter, LR_PARTICLES);
 
-		if (emitter)
-		{
-			emitter->safeKill();
-			emitter = 0;
-		}
+		setEmitter(particleEffect);
+	}
+}
+
+void Path::setEmitter(const std::string& name)
+{
+	if (emitter)
+	{
+		emitter->safeKill();
+		emitter = 0;
+	}
+	if(!name.empty())
+	{
 		emitter = new ParticleEffect;
-		emitter->load(particleEffect);
-		emitter->start();
+		emitter->load(name);
+		if(active)
+			emitter->start();
 		if (!nodes.empty())
 		{
 			emitter->position = nodes[0].position;
diff --git a/Aquaria/Path.h b/Aquaria/Path.h
index 203ee92..170ff65 100644
--- a/Aquaria/Path.h
+++ b/Aquaria/Path.h
@@ -89,6 +89,7 @@ public:
 	void update(float dt);
 	void setActive(bool v);
 	bool action(int id, int state);
+	void setEmitter(const std::string& name);
 
 	PathNode *getPathNode(int idx);
 	bool isCoordinateInside(const Vector &pos, int rad=0);
@@ -144,6 +145,7 @@ public:
 	bool pauseFreeze;
 
 	PathShape pathShape;
+	float activationRange;
 
 
 	void parseWarpNodeData(const std::string &dataString);
diff --git a/Aquaria/PathFinding.cpp b/Aquaria/PathFinding.cpp
index 3a0f69e..ee450b7 100644
--- a/Aquaria/PathFinding.cpp
+++ b/Aquaria/PathFinding.cpp
@@ -24,6 +24,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "DSQ.h"
 #include "Game.h"
 
+
 class SearchGridRaw
 {
 public:
@@ -33,11 +34,19 @@ public:
 		return (game->getGridRaw(TileVector(x, y)) & blockingObsBits) == OT_EMPTY;
 	}
 
-private:
-	const ObsType blockingObsBits;
+	ObsType blockingObsBits;
 	const Game *game;
 };
 
+class PathFinding::State : public ScriptObject
+{
+public:
+	State(ObsType obs) : grid(obs), searcher(grid), result(JPS::NO_PATH) {}
+	SearchGridRaw grid;
+	JPS::Searcher<SearchGridRaw> searcher;
+	JPS::Result result;
+};
+
 static void generateVectorPath(const JPS::PathVector& rawpath, VectorPath& vp, int offx, int offy)
 {
 	for(JPS::PathVector::const_iterator it = rawpath.begin(); it != rawpath.end(); ++it)
@@ -124,7 +133,7 @@ void PathFinding::molestPath(VectorPath &path)
 		lastSuccessNode = 0;
 		hadSuccess = false;
 		Vector node = path.getPathNode(i)->value;
-		for (int j = sz-3; j >= i+adjust; j--)
+		for (int j = sz-1; j >= i+adjust; j--)
 		{
 			Vector target = path.getPathNode(j)->value;
 			if (dsq->game->trace(node, target))
@@ -183,3 +192,55 @@ bool PathFinding::generatePathSimple(VectorPath& path, const Vector& start, cons
 	molestPath(path);
 	return true;
 }
+
+PathFinding::State *PathFinding::initFindPath()
+{
+	State *state = new PathFinding::State(OT_BLOCKING);
+	return state;
+}
+
+void PathFinding::deleteFindPath(State *state)
+{
+	delete state;
+}
+
+void PathFinding::beginFindPath(PathFinding::State *state, const Vector& start, const Vector& end, unsigned int obs /* = 0 */)
+{
+	if(obs == OT_EMPTY)
+		obs = OT_BLOCKING;
+
+	state->grid.blockingObsBits = (ObsType)obs;
+	JPS::Position istart = JPS::Pos(start.x, start.y);
+	JPS::Position iend = JPS::Pos(end.x, end.y);
+	state->result = state->searcher.findPathInit(istart, iend);
+}
+
+bool PathFinding::updateFindPath(PathFinding::State *state, int limit)
+{
+	int oldres = state->result;
+	if(oldres == JPS::NEED_MORE_STEPS)
+	{
+		state->result = state->searcher.findPathStep(limit);
+		return oldres != state->result;
+	}
+	return true; // done
+}
+
+bool PathFinding::finishFindPath(PathFinding::State *state, VectorPath& path, unsigned step /* = 0 */)
+{
+	if(state->result != JPS::FOUND_PATH)
+		return false;
+
+	JPS::PathVector rawpath;
+	state->searcher.findPathFinish(rawpath, step);
+	generateVectorPath(rawpath, path, 0, 0);
+	molestPath(path);
+	return true;
+}
+
+void PathFinding::getStats(PathFinding::State *state, unsigned& stepsDone, unsigned& nodesExpanded)
+{
+	stepsDone = (unsigned)state->searcher.getStepsDone();
+	nodesExpanded = (unsigned)state->searcher.getNodesExpanded();
+}
+
diff --git a/Aquaria/PathFinding.h b/Aquaria/PathFinding.h
index 7920cbb..1193afb 100644
--- a/Aquaria/PathFinding.h
+++ b/Aquaria/PathFinding.h
@@ -30,14 +30,23 @@ class RenderObject;
 class SearchGrid;
 class Game;
 
-class PathFinding
+namespace PathFinding
 {
-public:
+	class State;
+
 	void forceMinimumPath(VectorPath &path, const Vector &start, const Vector &dest);
 	void molestPath(VectorPath &path);
 	void generatePath(RenderObject *go, TileVector g1, TileVector g2, int offx=0, int offy=0);
 
 	bool generatePathSimple(VectorPath& path, const Vector& start, const Vector& end, unsigned int step = 0, unsigned int obs = 0);
+
+	State *initFindPath();
+	void deleteFindPath(State *state);
+
+	void beginFindPath(State *state, const Vector& start, const Vector& end, unsigned int obs = 0);
+	bool updateFindPath(State *state, int limit);
+	bool finishFindPath(State *state, VectorPath& path, unsigned step = 0);
+	void getStats(State *state, unsigned& stepsDone, unsigned& nodesExpanded);
 };
 
 #endif
diff --git a/Aquaria/SchoolFish.cpp b/Aquaria/SchoolFish.cpp
index 988e810..38005f6 100644
--- a/Aquaria/SchoolFish.cpp
+++ b/Aquaria/SchoolFish.cpp
@@ -23,19 +23,19 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "Avatar.h"
 #include "../BBGE/AfterEffect.h"
 
-float strengthSeparation = 1;
-float strengthAlignment = 0.8;
-float strengthAvoidance = 1;
-float strengthCohesion = 0.5;
+const float strengthSeparation = 1;
+const float strengthAlignment = 0.8f;
+const float strengthAvoidance = 1;
+const float strengthCohesion = 0.5f;
 
-float avoidanceDistance = 128;
-float separationDistance = 128;
-float minUrgency = 5;//0.05;
-float maxUrgency = 10;//0.1;
-float maxSpeed = 400; // 1
-float maxChange = maxSpeed*maxUrgency;
+const float avoidanceDistance = 128;
+const float separationDistance = 128;
+const float minUrgency = 5;//0.05;
+const float maxUrgency = 10;//0.1;
+const float maxSpeed = 400; // 1
+const float maxChange = maxSpeed*maxUrgency;
 
-float velocityScale = 1;
+const float velocityScale = 1;
 
 
 SchoolFish::SchoolFish(const std::string &texname) : FlockEntity()
diff --git a/Aquaria/ScriptInterface.cpp b/Aquaria/ScriptInterface.cpp
index 04950c5..3e6202c 100644
--- a/Aquaria/ScriptInterface.cpp
+++ b/Aquaria/ScriptInterface.cpp
@@ -36,7 +36,9 @@ extern "C"
 #include "Web.h"
 #include "GridRender.h"
 #include "AfterEffect.h"
+#include "PathFinding.h"
 #include <algorithm>
+#include "Gradient.h"
 
 #include "../BBGE/MathFunctions.h"
 
@@ -874,7 +876,26 @@ luaFunc(fileExists)
 	safePath(L, s);
 	std::string res;
 	bool there = findFile_helper(s.c_str(), res);
-	luaReturnBool(there);
+	lua_pushboolean(L, there);
+	lua_pushstring(L, res.c_str());
+	return 2;
+}
+
+luaFunc(getModName)
+{
+	luaReturnStr(dsq->mod.isActive() ? dsq->mod.getName().c_str() : "");
+}
+
+luaFunc(getModPath)
+{
+	std::string path;
+	if (dsq->mod.isActive())
+	{
+		path = dsq->mod.getPath();
+		if(path[path.length() - 1] != '/')
+			path += '/';
+	}
+	luaReturnStr(path.c_str());
 }
 
 
@@ -890,6 +911,7 @@ MakeTypeCheckFunc(isNode, SCO_PATH);
 MakeTypeCheckFunc(isObject, SCO_RENDEROBJECT);
 MakeTypeCheckFunc(isEntity, SCO_ENTITY)
 MakeTypeCheckFunc(isScriptedEntity, SCO_SCRIPTED_ENTITY)
+MakeTypeCheckFunc(isBone, SCO_BONE)
 MakeTypeCheckFunc(isShot, SCO_SHOT)
 MakeTypeCheckFunc(isWeb, SCO_WEB)
 MakeTypeCheckFunc(isIng, SCO_INGREDIENT)
@@ -1110,9 +1132,7 @@ luaFunc(obj_setBlendType)
 luaFunc(obj_setTexture)
 {
 	RenderObject *r = robj(L);
-	if (r)
-		r->setTexture(getString(L, 2));
-	luaReturnNil();
+	luaReturnBool(r ? r->setTexture(getString(L, 2)) : false);
 }
 
 luaFunc(obj_getTexture)
@@ -1179,6 +1199,7 @@ luaFunc(obj_addChild)
 	RenderObject *r = robj(L);
 	RenderObject *which = robj(L, 2);
 	bool takeOwnership = getBool(L, 3);
+	bool front = getBool(L, 4);
 	if (r && which)
 	{
 		if (takeOwnership)
@@ -1188,7 +1209,7 @@ luaFunc(obj_addChild)
 			dsq->getState(dsq->game->name)->removeRenderObjectFromList(which);
 			which->setStateDataObject(NULL);
 			core->removeRenderObject(which, Core::DO_NOT_DESTROY_RENDER_OBJECT);
-			r->addChild(which, PM_POINTER);
+			r->addChild(which, PM_POINTER, RBP_NONE, front ? CHILD_FRONT : CHILD_BACK);
 		}
 		else
 			r->addChild(which, PM_STATIC);
@@ -1541,10 +1562,15 @@ luaFunc(obj_setUpdateCull)
 {
 	RenderObject *r = robj(L);;
 	if (r)
-		r->updateCull = lua_tointeger(L, 2);
+		r->updateCull = lua_tonumber(L, 2);
 	luaReturnNil();
 }
 
+luaFunc(obj_getUpdateCull)
+{
+	RenderObject *r = robj(L);;
+	luaReturnNum(r ? r->updateCull : 0.0f);
+}
 
 luaFunc(obj_setPositionX)
 {
@@ -1832,6 +1858,7 @@ luaFunc(quad_getBorderAlpha)
 	RO_FUNC(getter, prefix,  setCull		) \
 	RO_FUNC(getter, prefix,  setCullRadius	) \
 	RO_FUNC(getter, prefix,  setUpdateCull	) \
+	RO_FUNC(getter, prefix,  getUpdateCull	) \
 	RO_FUNC(getter, prefix,  setRenderPass	) \
 	RO_FUNC(getter, prefix,  setOverrideRenderPass	) \
 	RO_FUNC(getter, prefix,  setPositionX	) \
@@ -3129,6 +3156,11 @@ luaFunc(createShot)
 	luaReturnPtr(s);
 }
 
+luaFunc(isSkippingCutscene)
+{
+	luaReturnBool(dsq->isSkippingCutscene());
+}
+
 // deprecated, use entity_playSfx
 luaFunc(entity_sound)
 {
@@ -3318,45 +3350,67 @@ luaFunc(entity_moveToNode)
 {
 	Entity *e = entity(L);
 	Path *p = path(L, 2);
+	float time = 0;
 	if (e && p)
 	{
-		e->moveToNode(p, lua_tointeger(L, 3), lua_tointeger(L, 4), 0);
+		float speed = dsq->continuity.getSpeedType(lua_tointeger(L, 3));
+		time = e->moveToPos(p->nodes[0].position, speed, lua_tointeger(L, 4), 0);
 	}
-	luaReturnNil();
+	luaReturnNum(time);
 }
 
 luaFunc(entity_swimToNode)
 {
 	Entity *e = entity(L);
 	Path *p = path(L, 2);
+	float time = 0;
 	if (e && p)
 	{
-		e->moveToNode(p, lua_tointeger(L, 3), lua_tointeger(L, 4), 1);
-		/*
-		ScriptedEntity *se = dynamic_cast<ScriptedEntity*>(e);
-		se->swimPath = true;
-		*/
+		float speed = dsq->continuity.getSpeedType(lua_tointeger(L, 3));
+		time = e->moveToPos(p->nodes[0].position, speed, lua_tointeger(L, 4), 1);
 	}
-	luaReturnNil();
+	luaReturnNum(time);
 }
 
 luaFunc(entity_swimToPosition)
 {
 	Entity *e = entity(L);
-	//Path *p = path(L, 2);
-	Path p;
-	PathNode n;
-	n.position = Vector(lua_tonumber(L, 2), lua_tonumber(L, 3));
-	p.nodes.push_back(n);
+	float time = 0;
 	if (e)
 	{
-		e->moveToNode(&p, lua_tointeger(L, 4), lua_tointeger(L, 5), 1);
-		/*
-		ScriptedEntity *se = dynamic_cast<ScriptedEntity*>(e);
-		se->swimPath = true;
-		*/
+		float speed = dsq->continuity.getSpeedType(lua_tointeger(L, 4));
+		time = e->moveToPos(Vector(lua_tonumber(L, 2), lua_tonumber(L, 3)), speed, lua_tointeger(L, 5), 1);
 	}
-	luaReturnNil();
+	luaReturnNum(time);
+}
+
+luaFunc(entity_moveToNodeSpeed)
+{
+	Entity *e = entity(L);
+	Path *p = path(L, 2);
+	float time = 0;
+	if (e && p)
+		time = e->moveToPos(p->nodes[0].position, lua_tonumber(L, 3), lua_tointeger(L, 4), 0);
+	luaReturnNum(time);
+}
+
+luaFunc(entity_swimToNodeSpeed)
+{
+	Entity *e = entity(L);
+	Path *p = path(L, 2);
+	float time = 0;
+	if (e && p)
+		time = e->moveToPos(p->nodes[0].position, lua_tonumber(L, 3), lua_tointeger(L, 4), 1);
+	luaReturnNum(time);
+}
+
+luaFunc(entity_swimToPositionSpeed)
+{
+	Entity *e = entity(L);
+	float time = 0;
+	if (e)
+		time = e->moveToPos(Vector(lua_tonumber(L, 2), lua_tonumber(L, 3)), lua_tonumber(L, 4), lua_tointeger(L, 5), 1);
+	luaReturnNum(time);
 }
 
 
@@ -3642,15 +3696,30 @@ luaFunc(loadMap)
 luaFunc(entity_followPath)
 {
 	Entity *e = entity(L);
+	float time = 0;
 	if (e)
 	{
 		Path *p = path(L, 2);
 		int speedType = lua_tointeger(L, 3);
 		int dir = lua_tointeger(L, 4);
-
-		e->followPath(p, speedType, dir);
+		float speed = dsq->continuity.getSpeedType(speedType);
+		time = e->followPath(p, speed, dir);
 	}
-	luaReturnNil();
+	luaReturnNum(time);
+}
+
+luaFunc(entity_followPathSpeed)
+{
+	Entity *e = entity(L);
+	float time = 0;
+	if (e)
+	{
+		Path *p = path(L, 2);
+		float speed = lua_tonumber(L, 3);
+		int dir = lua_tointeger(L, 4);
+		time = e->followPath(p, speed, dir);
+	}
+	luaReturnNum(time);
 }
 
 luaFunc(spawnIngredient)
@@ -4846,12 +4915,13 @@ luaFunc(getWallNormal)
 	x = lua_tonumber(L, 1);
 	y = lua_tonumber(L, 2);
 	int range = lua_tointeger(L, 3);
+	int obs  = lua_tointeger(L, 4);
 	if (range == 0)
-	{
 		range = 5;
-	}
+	if (!obs)
+		obs = OT_BLOCKING;
 
-	Vector n = dsq->game->getWallNormal(Vector(x, y), range);
+	Vector n = dsq->game->getWallNormal(Vector(x, y), range, NULL, obs);
 
 	luaReturnVec2(n.x, n.y);
 }
@@ -4905,6 +4975,21 @@ luaFunc(getStringFlag)
 	luaReturnStr(dsq->continuity.getStringFlag(getString(L, 1)).c_str());
 }
 
+luaFunc(node_setEmitter)
+{
+	Path *p = path(L);
+	if(p)
+		p->setEmitter(getString(L, 2));
+	luaReturnPtr(p->emitter);
+}
+
+luaFunc(node_getEmitter)
+{
+	Path *p = path(L);
+	luaReturnPtr(p ? p->emitter : NULL);
+}
+
+
 luaFunc(node_setActive)
 {
 	Path *p = path(L);
@@ -4912,6 +4997,13 @@ luaFunc(node_setActive)
 	if (p)
 	{
 		p->active = v;
+		if(p->emitter)
+		{
+			if(v)
+				p->emitter->start();
+			else
+				p->emitter->stop();
+		}
 	}
 	luaReturnNil();
 }
@@ -4933,6 +5025,14 @@ luaFunc(node_setCursorActivation)
 	luaReturnNil();
 }
 
+luaFunc(node_setActivationRange)
+{
+	Path *p = path(L);
+	if(p)
+		p->activationRange = lua_tonumber(L, 2);
+	luaReturnNil();
+}
+
 luaFunc(node_setCatchActions)
 {
 	Path *p = path(L);
@@ -5523,7 +5623,7 @@ luaFunc(entity_doElementInteraction)
 		if (!touchWidth)
 			touchWidth = 16;
 
-		ElementUpdateList& elems = dsq->game->elementUpdateList;
+		ElementUpdateList& elems = dsq->game->elementInteractionList;
 		for (ElementUpdateList::iterator it = elems.begin(); it != elems.end(); ++it)
 		{
 			(*it)->doInteraction(e, mult, touchWidth);
@@ -6027,7 +6127,7 @@ luaFunc(entity_setMaxSpeed)
 {
 	Entity *e = entity(L);
 	if (e)
-		e->setMaxSpeed(lua_tointeger(L, 2));
+		e->setMaxSpeed(lua_tonumber(L, 2));
 
 	luaReturnNil();
 }
@@ -6478,7 +6578,7 @@ luaFunc(playSfx)
 	if (sfx.vol <= 0)
 		sfx.vol = 1;
 	sfx.loops = lua_tointeger(L, 4);
-	if(lua_isnumber(L, 6) && lua_isnumber(L, 7))
+	if(lua_isnumber(L, 5) && lua_isnumber(L, 6))
 	{
 		sfx.x = lua_tonumber(L, 5);
 		sfx.y =  lua_tonumber(L, 6);
@@ -7862,7 +7962,7 @@ luaFunc(entity_offsetUpdate)
 	Entity *e = entity(L);
 	if (e)
 	{
-		int uc = e->updateCull;
+		float uc = e->updateCull;
 		e->updateCull = -1;
 		float t = float(rand()%10000)/1000.0f;
 		e->update(t);
@@ -8385,6 +8485,44 @@ luaFunc(setGemPosition)
 	luaReturnBool(result);
 }
 
+luaFunc(setGemName)
+{
+	int gemId = lua_tointeger(L, 1);
+	bool result = false;
+
+	if(gemId >= 0 && gemId < dsq->continuity.gems.size())
+	{
+		Continuity::Gems::iterator it = dsq->continuity.gems.begin();
+		std::advance(it, gemId);
+		GemData& gem = *it;
+		gem.name = getString(L, 2);
+		result = true;
+	}
+	else
+		debugLog("setGemName: invalid index");
+
+	luaReturnBool(result);
+}
+
+luaFunc(setGemBlink)
+{
+	int gemId = lua_tointeger(L, 1);
+	bool result = false;
+
+	if(gemId >= 0 && gemId < dsq->continuity.gems.size())
+	{
+		Continuity::Gems::iterator it = dsq->continuity.gems.begin();
+		std::advance(it, gemId);
+		GemData& gem = *it;
+		gem.blink = getBool(L, 2);
+		result = true;
+	}
+	else
+		debugLog("setGemBlink: invalid index");
+
+	luaReturnBool(result);
+}
+
 luaFunc(removeGem)
 {
 	int gemId = lua_tointeger(L, 1);
@@ -8647,7 +8785,7 @@ luaFunc(avatar_updatePosition)
 
 luaFunc(avatar_toggleMovement)
 {
-	dsq->game->avatar->toggleMovement((bool)lua_tointeger(L, 1));
+	dsq->game->avatar->toggleMovement(getBool(L));
 	luaReturnNil();
 }
 
@@ -8729,6 +8867,43 @@ luaFunc(isShuttingDownGameState)
 	luaReturnBool(dsq->game->isShuttingDownGameState());
 }
 
+static void _fillPathfindTables(lua_State *L, VectorPath& path, int xs_idx, int ys_idx)
+{
+	const unsigned num = path.getNumPathNodes();
+
+	if(lua_istable(L, xs_idx))
+		lua_pushvalue(L, xs_idx);
+	else
+		lua_createtable(L, num, 0);
+
+	if(lua_istable(L, ys_idx))
+		lua_pushvalue(L, ys_idx);
+	else
+		lua_createtable(L, num, 0);
+
+	// [..., xs, yx]
+	for(unsigned i = 0; i < num; ++i)
+	{
+		const VectorPathNode *n = path.getPathNode(i);
+		lua_pushnumber(L, n->value.x);  // [..., xs, ys, x]
+		lua_rawseti(L, -3, i+1);        // [..., xs, ys]
+		lua_pushnumber(L, n->value.y);  // [..., xs, ys, y]
+		lua_rawseti(L, -2, i+1);        // [..., xs, ys]
+	}
+	// terminate tables
+	lua_pushnil(L);            // [..., xs, ys, nil]
+	lua_rawseti(L, -3, num+1); // [..., xs, ys]
+	lua_pushnil(L);            // [..., xs, ys, nil]
+	lua_rawseti(L, -2, num+1); // [..., xs, ys]
+}
+
+static int _pathfindDelete(lua_State *L)
+{
+	PathFinding::State *state = *(PathFinding::State**)luaL_checkudata(L, 1, "pathfinder");
+	PathFinding::deleteFindPath(state);
+	return 0;
+}
+
 // startx, starty, endx, endy [, step, xtab, ytab, obsMask]
 luaFunc(findPath)
 {
@@ -8736,55 +8911,81 @@ luaFunc(findPath)
 	Vector start(lua_tonumber(L, 1), lua_tonumber(L, 2));
 	Vector end(lua_tonumber(L, 3), lua_tonumber(L, 4));
 	ObsType obs = ObsType(lua_tointeger(L, 8));
-	if(!dsq->pathFinding.generatePathSimple(path, start, end, lua_tointeger(L, 5), obs))
+	if(!PathFinding::generatePathSimple(path, start, end, lua_tointeger(L, 5), obs))
 		luaReturnBool(false);
 
 	const unsigned num = path.getNumPathNodes();
 	lua_pushinteger(L, num);
 
-	if(lua_istable(L, 6))
-		lua_pushvalue(L, 6);
-	else
-		lua_createtable(L, num, 0);
-
-	if(lua_istable(L, 7))
-		lua_pushvalue(L, 7);
-	else
-		lua_createtable(L, num, 0);
-
-	// [true, xs, yx]
-
-	for(unsigned i = 0; i < num; ++i)
-	{
-		const VectorPathNode *n = path.getPathNode(i);
-		lua_pushnumber(L, n->value.x);  // [num, xs, ys, x]
-		lua_rawseti(L, -3, i+1);        // [num, xs, ys]
-		lua_pushnumber(L, n->value.y);  // [num, xs, ys, y]
-		lua_rawseti(L, -2, i+1);        // [num, xs, ys]
-	}
-	// terminate tables
-	lua_pushnil(L);            // [num xs, ys, nil]
-	lua_rawseti(L, -3, num+1); // [num, xs, ys]
-	lua_pushnil(L);            // [num, xs, ys, nil]
-	lua_rawseti(L, -2, num+1); // [num, xs, ys]
+	_fillPathfindTables(L, path, 6, 7);
 
 	return 3; // found path?, x positions, y positions
 }
 
+luaFunc(createFindPath)
+{
+	PathFinding::State **statep = (PathFinding::State**)lua_newuserdata(L, sizeof(void*));
+	*statep = PathFinding::initFindPath();
+	luaL_getmetatable(L, "pathfinder");
+	lua_setmetatable(L, -2);
+	return 1;
+}
+
+luaFunc(findPathBegin)
+{
+	PathFinding::State *state = *(PathFinding::State**)luaL_checkudata(L, 1, "pathfinder");
+	Vector start(lua_tonumber(L, 1), lua_tonumber(L, 2));
+	Vector end(lua_tonumber(L, 3), lua_tonumber(L, 4));
+	ObsType obs = ObsType(lua_tointeger(L, 8));
+	PathFinding::beginFindPath(state, start, end, obs);
+	luaReturnNil();
+}
+
+luaFunc(findPathUpdate)
+{
+	PathFinding::State *state = *(PathFinding::State**)luaL_checkudata(L, 1, "pathfinder");
+	int limit = lua_tointeger(L, 2);
+	bool done = PathFinding::updateFindPath(state, limit);
+	luaReturnBool(done);
+}
+
+luaFunc(findPathFinish)
+{
+	PathFinding::State *state = *(PathFinding::State**)luaL_checkudata(L, 1, "pathfinder");
+	VectorPath path;
+	bool found = PathFinding::finishFindPath(state, path);
+	if(!found)
+		luaReturnBool(false);
+
+	lua_pushinteger(L, (int)path.getNumPathNodes());
+	_fillPathfindTables(L, path, 2, 3);
+	return 3;
+}
+
+luaFunc(findPathGetStats)
+{
+	PathFinding::State *state = *(PathFinding::State**)luaL_checkudata(L, 1, "pathfinder");
+	unsigned stepsDone, nodesExpanded;
+	PathFinding::getStats(state, stepsDone, nodesExpanded);
+	lua_pushinteger(L, stepsDone);
+	lua_pushinteger(L, nodesExpanded);
+	return 2;
+}
+
 luaFunc(castLine)
 {
 	Vector v(lua_tonumber(L, 1), lua_tonumber(L, 2));
 	Vector end(lua_tonumber(L, 3), lua_tonumber(L, 4));
 	int tiletype = lua_tointeger(L, 5);
 	if(!tiletype)
-		tiletype = -1;
+		tiletype = OT_BLOCKING;
 	Vector step = end - v;
 	int steps = step.getLength2D() / TILE_SIZE;
 	step.setLength2D(TILE_SIZE);
 
 	for(int i = 0; i < steps; ++i)
 	{
-		if(dsq->game->isObstructed(TileVector(v), tiletype))
+		if(dsq->game->getGridRaw(TileVector(v)) & tiletype)
 		{
 			lua_pushinteger(L, dsq->game->getGrid(TileVector(v)));
 			lua_pushnumber(L, v.x);
@@ -8910,6 +9111,19 @@ luaFunc(learnRecipe)
 	luaReturnNil();
 }
 
+luaFunc(setBGGradient)
+{
+	if(!dsq->game->grad)
+		dsq->game->createGradient();
+	Vector c1(lua_tonumber(L, 1), lua_tonumber(L, 2), lua_tonumber(L, 3));
+	Vector c2(lua_tonumber(L, 4), lua_tonumber(L, 5), lua_tonumber(L, 6));
+	if(getBool(L, 7))
+		dsq->game->grad->makeHorizontal(c1, c2);
+	else
+		dsq->game->grad->makeVertical(c1, c2);
+	luaReturnNil();
+}
+
 luaFunc(createDebugText)
 {
 	DebugFont *txt = new DebugFont(lua_tointeger(L, 2), getString(L, 1));
@@ -8967,6 +9181,12 @@ luaFunc(text_getHeight)
 	luaReturnNum(txt ? txt->getHeight() : 0.0f);
 }
 
+luaFunc(text_getStringWidth)
+{
+	BaseText *txt = getText(L);
+	luaReturnNum(txt ? txt->getStringWidth(getString(L, 2)) : 0.0f);
+}
+
 luaFunc(loadShader)
 {
 	int handle = 0;
@@ -9064,6 +9284,24 @@ luaFunc(pe_isRunning)
 	luaReturnBool(pe && pe->isRunning());
 }
 
+luaFunc(getPerformanceCounter)
+{
+#ifdef BBGE_BUILD_SDL2
+	luaReturnNum((lua_Number)SDL_GetPerformanceCounter());
+#else
+	luaReturnNum((lua_Number)SDL_GetTicks());
+#endif
+}
+
+luaFunc(getPerformanceFreq)
+{
+#ifdef BBGE_BUILD_SDL2
+	luaReturnNum((lua_Number)SDL_GetPerformanceFrequency());
+#else
+	luaReturnNum((lua_Number)1000);
+#endif
+}
+
 //--------------------------------------------------------------------------------------------
 
 #define luaRegister(func)	{#func, l_##func}
@@ -9078,6 +9316,8 @@ static const struct {
 	{"loadfile", l_loadfile_caseinsensitive},
 
 	luaRegister(fileExists),
+	luaRegister(getModName),
+	luaRegister(getModPath),
 
 	luaRegister(debugBreak),
 	luaRegister(setIgnoreAction),
@@ -9468,6 +9708,7 @@ static const struct {
 	luaRegister(entity_stopInterpolating),
 
 	luaRegister(entity_followPath),
+	luaRegister(entity_followPathSpeed),
 	luaRegister(entity_isFollowingPath),
 	luaRegister(entity_followEntity),
 	luaRegister(entity_sound),
@@ -9580,6 +9821,8 @@ static const struct {
 
 	luaRegister(pickupGem),
 	luaRegister(setGemPosition),
+	luaRegister(setGemName),
+	luaRegister(setGemBlink),
 	luaRegister(removeGem),
 	luaRegister(setBeacon),
 	luaRegister(getBeacon),
@@ -9628,6 +9871,11 @@ static const struct {
 	luaRegister(getObstruction),
 	luaRegister(getGridRaw),
 	luaRegister(findPath),
+	luaRegister(createFindPath),
+	luaRegister(findPathBegin),
+	luaRegister(findPathUpdate),
+	luaRegister(findPathFinish),
+	luaRegister(findPathGetStats),
 	luaRegister(castLine),
 	luaRegister(getUserInputString),
 	luaRegister(getMaxCameraValues),
@@ -9716,6 +9964,7 @@ static const struct {
 
 	luaRegister(entity_warpToNode),
 	luaRegister(entity_moveToNode),
+	luaRegister(entity_moveToNodeSpeed),
 
 	luaRegister(cam_toNode),
 	luaRegister(cam_snap),
@@ -9730,7 +9979,9 @@ static const struct {
 	luaRegister(entity_flipToVel),
 
 	luaRegister(entity_swimToNode),
+	luaRegister(entity_swimToNodeSpeed),
 	luaRegister(entity_swimToPosition),
+	luaRegister(entity_swimToPositionSpeed),
 
 
 	luaRegister(createShot),
@@ -9818,6 +10069,7 @@ static const struct {
 	luaRegister(getNumberOfEntitiesNamed),
 
 	luaRegister(isNested),
+	luaRegister(isSkippingCutscene),
 
 	luaRegister(entity_idle),
 	luaRegister(entity_stopAllAnimations),
@@ -9870,6 +10122,7 @@ static const struct {
 	luaRegister(entity_isName),
 
 
+	luaRegister(node_setActivationRange),
 	luaRegister(node_setCursorActivation),
 	luaRegister(node_setCatchActions),
 
@@ -9883,6 +10136,8 @@ static const struct {
 
 	luaRegister(node_setActive),
 	luaRegister(node_isActive),
+	luaRegister(node_setEmitter),
+	luaRegister(node_getEmitter),
 
 
 	luaRegister(setSceneColor),
@@ -10011,6 +10266,7 @@ static const struct {
 	luaRegister(getScreenVirtualSize),
 	luaRegister(isMiniMapCursorOkay),
 	luaRegister(isShuttingDownGameState),
+	luaRegister(setBGGradient),
 
 	luaRegister(inv_isFull),
 	luaRegister(inv_getMaxAmount),
@@ -10034,6 +10290,7 @@ static const struct {
 	luaRegister(text_setWidth),
 	luaRegister(text_setAlign),
 	luaRegister(text_getHeight),
+	luaRegister(text_getStringWidth),
 
 	luaRegister(loadShader),
 	luaRegister(createShader),
@@ -10052,6 +10309,7 @@ static const struct {
 	luaRegister(isObject),
 	luaRegister(isEntity),
 	luaRegister(isScriptedEntity),
+	luaRegister(isBone),
 	luaRegister(isShot),
 	luaRegister(isWeb),
 	luaRegister(isIng),
@@ -10060,6 +10318,10 @@ static const struct {
 	luaRegister(isShader),
 	luaRegister(isParticleEffect),
 
+	luaRegister(getPerformanceCounter),
+	luaRegister(getPerformanceFreq),
+
+
 
 #undef MK_FUNC
 #undef MK_ALIAS
@@ -10881,6 +11143,13 @@ lua_State *ScriptInterface::createLuaVM()
 	// In case a script errors outside of any protected environment, report and exit.
 	lua_atpanic(state, l_panicHandler);
 
+	// Register Lua classes
+	luaL_newmetatable(state, "pathfinder");
+	lua_pushliteral(state, "__gc");
+	lua_pushcfunction(state, _pathfindDelete);
+	lua_settable(state, -3);
+	lua_pop(state, 1);
+
 	// All done, return the new state.
 	return state;
 }
diff --git a/Aquaria/ScriptedEntity.cpp b/Aquaria/ScriptedEntity.cpp
index 6ac9b53..6316e5f 100644
--- a/Aquaria/ScriptedEntity.cpp
+++ b/Aquaria/ScriptedEntity.cpp
@@ -153,6 +153,9 @@ void ScriptedEntity::initEmitter(int emit, const std::string &file)
 
 void ScriptedEntity::startEmitter(int emit)
 {
+	if(emit >= emitters.size())
+		return;
+
 	if (emitters[emit])
 	{
 		emitters[emit]->start();
@@ -161,6 +164,9 @@ void ScriptedEntity::startEmitter(int emit)
 
 void ScriptedEntity::stopEmitter(int emit)
 {
+	if(emit >= emitters.size())
+		return;
+
 	if (emitters[emit])
 	{
 		emitters[emit]->stop();
diff --git a/Aquaria/WorldMapRender.cpp b/Aquaria/WorldMapRender.cpp
index 55d9fe0..30c9635 100644
--- a/Aquaria/WorldMapRender.cpp
+++ b/Aquaria/WorldMapRender.cpp
@@ -48,13 +48,11 @@ namespace WorldMapRenderNamespace
 		VIS_WRITE		= 1  // Uses render-to-texture instead
 	};
 
-	VisMethod visMethod = VIS_VERTEX;
+	const VisMethod visMethod = VIS_VERTEX;
 	WorldMapRevealMethod revMethod = REVEAL_DEFAULT;
 
 	std::vector<Quad *> tiles;
 
-	std::vector<Quad *> particles;
-
 	Quad *activeQuad=0, *lastActiveQuad=0, *originalActiveQuad=0;
 	Quad *lastVisQuad=0, *visQuad=0;
 	WorldMapTile *lastVisTile=0;
@@ -512,6 +510,7 @@ static void tileDataToVis(WorldMapTile *tile, Vector **vis)
 
 	if (data != 0)
 	{
+		const float a = tile->prerevealed ? 0.4f :  baseMapSegAlpha;
 		const unsigned int rowSize = MAPVIS_SUBDIV/8;
 		for (unsigned int y = 0; y < MAPVIS_SUBDIV; y++, data += rowSize)
 		{
@@ -520,18 +519,19 @@ static void tileDataToVis(WorldMapTile *tile, Vector **vis)
 				unsigned char dataByte = data[x/8];
 				for (unsigned int x2 = 0; x2 < 8; x2++)
 				{
-					vis[x+x2][y].z = (dataByte & (1 << x2)) ? visibleMapSegAlpha : baseMapSegAlpha;
+					vis[x+x2][y].z = (dataByte & (1 << x2)) ? visibleMapSegAlpha : a;
 				}
 			}
 		}
 	}
 	else
 	{
+		const float a = tile->prerevealed ? 0.4f :  baseMapSegAlpha;
 		for (int x = 0; x < MAPVIS_SUBDIV; x++)
 		{
 			for (int y = 0; y < MAPVIS_SUBDIV; y++)
 			{
-				vis[x][y].z = baseMapSegAlpha;
+				vis[x][y].z = a;
 			}
 		}
 		return;
@@ -1342,7 +1342,7 @@ void WorldMapRender::addAllGems()
 	for (Continuity::Gems::reverse_iterator i = dsq->continuity.gems.rbegin(); i != dsq->continuity.gems.rend(); i++)
 	{
 		GemMover *g = addGem(&(*i));
-		if (c == dsq->continuity.gems.size()-1)
+		if (c == dsq->continuity.gems.size()-1 || i->blink)
 			g->setBlink(true);
 		else
 			g->setBlink(false);
diff --git a/BBGE/Base.cpp b/BBGE/Base.cpp
index 7cc5958..785e3fb 100644
--- a/BBGE/Base.cpp
+++ b/BBGE/Base.cpp
@@ -547,13 +547,13 @@ tinyxml2::XMLError readXML(const std::string& fn, tinyxml2::XMLDocument& doc)
 	return err;
 }
 
-tinyxml2::XMLDocument *readXML(const std::string& fn, tinyxml2::XMLError *perr /* = 0 */)
+tinyxml2::XMLDocument *readXML(const std::string& fn, tinyxml2::XMLError *perr /* = 0 */, bool keepEmpty /* = false */)
 {
 	tinyxml2::XMLDocument *doc = new tinyxml2::XMLDocument();
 	tinyxml2::XMLError err = readXML(fn, *doc);
 	if(perr)
 		*perr = err;
-	if(err != tinyxml2::XML_SUCCESS)
+	if(err != tinyxml2::XML_SUCCESS && !keepEmpty)
 	{
 		delete doc;
 		doc = NULL;
diff --git a/BBGE/Base.h b/BBGE/Base.h
index 8471dd4..1f650e3 100644
--- a/BBGE/Base.h
+++ b/BBGE/Base.h
@@ -144,6 +144,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "ttvfs_stdio.h"
 
 #include "tinyxml2.h"
+#include "Refcounted.h"
 
 #ifdef BBGE_BUILD_LINUX
 #  include <sys/types.h>
@@ -206,7 +207,7 @@ bool exists(const std::string &f, bool makeFatal = false, bool skipVFS = false);
 void errorLog(const std::string &s);
 void debugLog(const std::string &s);
 char *readFile(const std::string& path, unsigned long *size_ret = 0);
-tinyxml2::XMLDocument *readXML(const std::string& fn, tinyxml2::XMLError *perr = 0);
+tinyxml2::XMLDocument *readXML(const std::string& fn, tinyxml2::XMLError *perr = 0, bool keepEmpty = false);
 tinyxml2::XMLError readXML(const std::string& fn, tinyxml2::XMLDocument& doc);
 char *readCompressedFile(std::string path, unsigned long *size_ret = 0);
 void forEachFile(std::string path, std::string type, void callback(const std::string &filename, intptr_t param), intptr_t param);
diff --git a/BBGE/BaseText.h b/BBGE/BaseText.h
index 203bf18..ec84314 100644
--- a/BBGE/BaseText.h
+++ b/BBGE/BaseText.h
@@ -14,6 +14,7 @@ public:
 	virtual void setFontSize(int sz) = 0;
 	virtual void setAlign(Align a) = 0;
 	virtual float getHeight() = 0;
+	virtual float getStringWidth(const std::string& text) = 0;
 
 };
 
diff --git a/BBGE/BitmapFont.cpp b/BBGE/BitmapFont.cpp
index 9bf0fc2..277656d 100644
--- a/BBGE/BitmapFont.cpp
+++ b/BBGE/BitmapFont.cpp
@@ -45,11 +45,8 @@ void BmpFont::destroy()
 		font.Destroy();
 		loaded = false;
 	}
-	if (overrideTexture)
-	{
-		overrideTexture->removeRef();
-		overrideTexture = 0;
-	}
+
+	overrideTexture = NULL;
 }
 
 void BmpFont::load(const std::string &file, float scale, bool loadTexture)
@@ -425,6 +422,30 @@ int BitmapText::getNumLines()
 	return lines.size();
 }
 
+float BitmapText::getStringWidth(const std::string& text)
+{
+	std::string tmp;
+	int maxsize = 0;
+	tmp.reserve(text.length());
+	for (size_t i = 0; i < text.size(); i++)
+	{
+		if(text[i] == '\n')
+		{
+			std::pair<int, int> dim;
+			bmpFont->font.GetStringSize(tmp, &dim);
+			maxsize = std::max(maxsize, dim.first);
+			tmp.resize(0);
+		}
+		else
+			tmp += text[i];
+	}
+	std::pair<int, int> dim;
+	bmpFont->font.GetStringSize(tmp, &dim);
+	maxsize = std::max(maxsize, dim.first);
+
+	return maxsize * bmpFont->scale;
+}
+
 /*
 BitmapText::BitmapText() : RenderObject()
 {
diff --git a/BBGE/BitmapFont.h b/BBGE/BitmapFont.h
index 613faf9..188d4c1 100644
--- a/BBGE/BitmapFont.h
+++ b/BBGE/BitmapFont.h
@@ -48,7 +48,7 @@ struct BmpFont
 	Vector fontTopColor;
 	Vector fontBtmColor;
 
-	Texture *overrideTexture;
+	CountedPtr<Texture> overrideTexture;
 };
 
 class BitmapText : public BaseText
@@ -75,6 +75,7 @@ public:
 	virtual float getHeight();
 	void unloadDevice();
 	void reloadDevice();
+	virtual float getStringWidth(const std::string& text);
 
 	int getNumLines();
 protected:
diff --git a/BBGE/Core.cpp b/BBGE/Core.cpp
index 7a0d1a6..2e3be81 100644
--- a/BBGE/Core.cpp
+++ b/BBGE/Core.cpp
@@ -2138,7 +2138,7 @@ void Core::enumerateScreenModes()
 		SDL_GetDisplayMode(0, i, &mode);
 		if (mode.w && mode.h && (mode.w > mode.h))
 		{
-			screenModes.push_back(ScreenMode(i, mode.w, mode.h));
+			screenModes.push_back(ScreenMode(i, mode.w, mode.h, mode.refresh_rate));
 		}
 	}
 
@@ -2165,7 +2165,7 @@ void Core::enumerateScreenModes()
 		{
 			if (modes[i]->w > modes[i]->h)
 			{
-				screenModes.push_back(ScreenMode(i, modes[i]->w, modes[i]->h));
+				screenModes.push_back(ScreenMode(i, modes[i]->w, modes[i]->h, 0));
 			}
 		}
 	}
@@ -4240,26 +4240,13 @@ void Core::showBuffer()
 // when destroy is called on them
 void Core::clearResources()
 {
-	std::vector<Resource*> deletedResources;
-	int i;
-	for (i = 0; i < resources.size(); i++)
+	if(resources.size())
 	{
-		int j = 0;
-		for (j = 0; j < deletedResources.size(); j++)
-		{
-			if (deletedResources[j] == resources[i])
-				break;
-		}
-		if (j == deletedResources.size())
-		{
-			deletedResources.push_back (resources[i]);
-			Resource *r = resources[i];
-			r->destroy();
-			delete r;
-		}
+		debugLog("Warning: The following resources were not cleared:");
+		for(size_t i = 0; i < resources.size(); ++i)
+			debugLog(resources[i]->name);
+		resources.clear(); // nothing we can do; refcounting is messed up
 	}
-	resourceNames.clear();
-	resources.clear();
 }
 
 void Core::shutdownInputLibrary()
@@ -4408,20 +4395,7 @@ bool Core::exists(const std::string &filename)
 	return ::exists(filename, false); // defined in Base.cpp
 }
 
-Resource* Core::findResource(const std::string &name)
-{
-	for (int i = 0; i < resources.size(); i++)
-	{
-		if (resources[i]->name == name)
-		{
-			return resources[i];
-		}
-	}
-	return 0;
-}
-
-
-Texture* Core::findTexture(const std::string &name)
+CountedPtr<Texture> Core::findTexture(const std::string &name)
 {
 	//stringToUpper(name);
 	//std::ofstream out("texturefind.log");
@@ -4432,19 +4406,12 @@ Texture* Core::findTexture(const std::string &name)
 		//NOTE: ensure all names are lowercase before this point
 		if (resources[i]->name == name)
 		{
-			return (Texture*)resources[i];
+			return resources[i];
 		}
 	}
 	return 0;
 }
 
-std::string Core::getInternalTextureName(const std::string &name)
-{
-	std::string n = name;
-	stringToUpper(n);
-	return n;
-}
-
 // This handles unix/win32 relative paths: ./rel/path
 // Unix abs paths: /home/user/...
 // Win32 abs paths: C:/Stuff/.. and also C:\Stuff\...
@@ -4462,7 +4429,7 @@ std::string Core::getTextureLoadName(const std::string &texture)
 	return loadName;
 }
 
-Texture *Core::doTextureAdd(const std::string &texture, const std::string &loadName, std::string internalTextureName)
+std::pair<CountedPtr<Texture>, TextureLoadResult> Core::doTextureAdd(const std::string &texture, const std::string &loadName, std::string internalTextureName)
 {
 	if (texture.empty() || !ISPATHROOT(texture))
 	{
@@ -4479,48 +4446,37 @@ Texture *Core::doTextureAdd(const std::string &texture, const std::string &loadN
 	}
 
 	stringToLowerUserData(internalTextureName);
-	Texture *t = core->findTexture(internalTextureName);
+	CountedPtr<Texture> t = core->findTexture(internalTextureName);
 	if (t)
-	{
-		t->addRef();
-
-		Texture::textureError = TEXERR_OK;
-
-		/*
-		std::ostringstream os;
-		os << "reference texture: " << internalTextureName << " ref: " << t->getRef();
-		debugLog(os.str());
-		*/
-
-		//msg ("found texture " + internalTextureName);
-		return t;
-	}
+		return std::make_pair(t, TEX_SUCCESS);
 
 	t = new Texture;
 	t->name = internalTextureName;
-	t->load(loadName);
-	t->addRef();
-	//resources.push_back (t);
-	addResource(t);
+	unsigned res = TEX_FAILED;
 
-	if (debugLogTextures)
+	if(t->load(loadName))
+		res |= (TEX_LOADED | TEX_SUCCESS);
+	else
 	{
-		std::ostringstream os;
-		os << "LOADED TEXTURE FROM DISK: [" << internalTextureName << "] ref: " << t->getRef() << " idx: " << resources.size()-1;
-		debugLog(os.str());
+		t->width = 64;
+		t->height = 64;
 	}
 
-	return t;
+	return std::make_pair(t, (TextureLoadResult)res);
 }
 
-Texture* Core::addTexture(const std::string &textureName)
+CountedPtr<Texture> Core::addTexture(const std::string &textureName, TextureLoadResult *pLoadResult /* = 0 */)
 {
-	if (textureName.empty()) return 0;
-
 	BBGE_PROF(Core_addTexture);
 
-	Texture *texPointer = 0;
+	if (textureName.empty())
+	{
+		if(pLoadResult)
+			*pLoadResult = TEX_FAILED;
+		return NULL;
+	}
 
+	std::pair<CountedPtr<Texture>, TextureLoadResult> texResult;
 	std::string texture = textureName;
 	stringToLowerUserData(texture);
 	std::string internalTextureName = texture;
@@ -4537,30 +4493,35 @@ Texture* Core::addTexture(const std::string &textureName)
 		std::string ln = loadName;
 		texture = secondaryTexturePath + texture;
 		loadName = texture;
-		texPointer = doTextureAdd(texture, loadName, internalTextureName);
-		if (Texture::textureError != TEXERR_OK)
-		{
-			if (texPointer)
-			{
-				texPointer->destroy();
-				texPointer = 0;
-			}
-			texPointer = doTextureAdd(t, ln, internalTextureName);
-		}
+		texResult = doTextureAdd(texture, loadName, internalTextureName);
+		if (!texResult.second)
+			texResult = doTextureAdd(t, ln, internalTextureName);
 	}
 	else
-		texPointer = doTextureAdd(texture, loadName, internalTextureName);
+		texResult = doTextureAdd(texture, loadName, internalTextureName);
 
-	return texPointer;
+	addTexture(texResult.first.content());
+
+	if(debugLogTextures)
+	{
+		if (texResult.second & TEX_LOADED)
+		{
+			std::ostringstream os;
+			os << "LOADED TEXTURE FROM DISK: [" << internalTextureName << "] idx: " << resources.size()-1;
+			debugLog(os.str());
+		}
+		else if(!(texResult.second & TEX_SUCCESS))
+		{
+			std::ostringstream os;
+			os << "FAILED TO LOAD TEXTURE: [" << internalTextureName << "] idx: " << resources.size()-1;
+			debugLog(os.str());
+		}
+	}
+	if(pLoadResult)
+		*pLoadResult = texResult.second;
+	return texResult.first;
 }
 
-void Core::removeTexture(std::string texture)
-{
-	//std::string internalName = baseTextureDirectory + texture;
-	removeResource(texture, DESTROY);
-}
-
-
 void Core::addRenderObject(RenderObject *o, int layer)
 {
 	if (!o) return;
@@ -4603,59 +4564,36 @@ void Core::reloadResources()
 	onReloadResources();
 }
 
-void Core::addResource(Resource *r)
+void Core::addTexture(Texture *r)
 {
+	for(size_t i = 0; i < resources.size(); ++i)
+		if(resources[i] == r)
+			return;
+
 	resources.push_back(r);
-	resourceNames.push_back(r->name);
 	if (r->name.empty())
 	{
 		debugLog("Empty name resource added");
 	}
 }
 
-void Core::removeResource(std::string name, RemoveResource removeFlag)
+void Core::removeTexture(Texture *res)
 {
-	//Resource *r = findResource(name);
-	//int idx = 0;
-	int i = 0;
-	std::vector<Resource*>copy;
-	copy = resources;
-	resources.clear();
+	std::vector<Texture*> copy;
+	copy.swap(resources);
 
-
-	std::vector <std::string> copyNames;
-	copyNames = resourceNames;
-	resourceNames.clear();
-
-	bool isDestroyed = false;
-
-
-	for (i = 0; i < copy.size(); i++)
+	for (size_t i = 0; i < copy.size(); ++i)
 	{
-#ifdef _DEBUG
-			std::string s = copy[i]->name;
-#endif
-		if (!isDestroyed && copy[i]->name == name)
+		if (copy[i] == res)
 		{
-			if (removeFlag == DESTROY)
-			{
-				copy[i]->destroy();
-				delete copy[i];
-				isDestroyed = true;
-			}
-			continue;
-		}
-		// also remove other entries of the same resource
-		else if (isDestroyed && copyNames[i] == name)
-		{
-			continue;
-		}
-		else
-		{
-			resources.push_back(copy[i]);
-			resourceNames.push_back(copy[i]->name);
+			copy[i]->destroy();
+			copy[i] = copy.back();
+			copy.pop_back();
+			break;
 		}
 	}
+
+	resources.swap(copy);
 }
 
 void Core::deleteRenderObjectMemory(RenderObject *r)
@@ -4709,25 +4647,6 @@ void Core::clearGarbage()
 	}
 
 	garbage.clear();
-
-	// to clear resources
-	for (std::vector<Resource*>::iterator i = resources.begin(); i != resources.end(); )
-	{
-		if ((*i)->getRef() == 0)
-		{
-			clearedGarbageFlag = true;
-			delete (*i);
-			i = resources.erase(i);
-			continue;
-		}
-
-		if ((*i)->getRef() < 0)
-		{
-			errorLog("Texture ref < 0");
-		}
-
-		i++;
-	}
 }
 
 bool Core::canChangeState()
diff --git a/BBGE/Core.h b/BBGE/Core.h
index 55d2233..34799d8 100644
--- a/BBGE/Core.h
+++ b/BBGE/Core.h
@@ -70,10 +70,10 @@ enum TimeUpdateType
 
 struct ScreenMode
 {
-	ScreenMode() { idx = x = y = 0; }
-	ScreenMode(int i, int x, int y) : idx(i), x(x), y(y) {}
+	ScreenMode() { idx = x = y = hz = 0; }
+	ScreenMode(int i, int x, int y, int hz) : idx(i), x(x), y(y), hz(hz) {}
 
-	int idx, x, y;
+	int idx, x, y, hz;
 };
 
 struct CoreSettings
@@ -964,11 +964,6 @@ class Core : public ActionMapper, public StateManager
 {
 public:
 
-	enum RemoveResource
-	{
-		DESTROY = 0,
-		NO_DESTROY
-	};
 	// init
 	Core(const std::string &filesystem, const std::string& extraDataDir, int numRenderLayers, const std::string &appName="BBGE", int particleSize=1024, std::string userDataSubFolder="");
 	void initPlatform(const std::string &filesystem);
@@ -1023,13 +1018,12 @@ public:
 	void enable2D(int pixelScaleX=0, int pixelScaleY=0, bool forcePixelScale=false);
 	void addRenderObject(RenderObject *o, int layer=0);
 	void switchRenderObjectLayer(RenderObject *o, int toLayer);
-	void addResource(Resource *r);
-	Resource *findResource(const std::string &name);
-	Texture *findTexture(const std::string &name);
-	void removeResource(std::string name, RemoveResource removeFlag);
+	void addTexture(Texture *r);
+	CountedPtr<Texture> findTexture(const std::string &name);
+	void removeTexture(Texture *res);
+	void clearResources();
 
-	Texture *addTexture(const std::string &texture);
-	void removeTexture(std::string texture);
+	CountedPtr<Texture> addTexture(const std::string &texture, TextureLoadResult *pLoadResult = 0);
 
 	PostProcessingFX postProcessingFx;
 
@@ -1047,7 +1041,6 @@ public:
 
 	void enqueueRenderObjectDeletion(RenderObject *object);
 	void clearGarbage();
-	void clearResources();
 
 
 	bool isNested() { return nestedMains > 1; }
@@ -1103,8 +1096,7 @@ public:
 		HINSTANCE	hInstance;		// Holds The Instance Of The Application
 	#endif
 
-	std::vector<Resource*>resources;
-	std::vector<std::string> resourceNames;
+	std::vector<Texture*> resources;
 
 	RenderObjectLayer *getRenderObjectLayer(int i);
 	std::vector <int> renderObjectLayerOrder;
@@ -1247,7 +1239,6 @@ public:
 	
 
 	Joystick joystick;
-	std::string getInternalTextureName(const std::string &name);
 	void setClearColor(const Vector &c);
 	Vector getClearColor();
 	int flipMouseButtons;
@@ -1337,7 +1328,7 @@ protected:
 
 	virtual void onReloadResources();
 
-	Texture* doTextureAdd(const std::string &texture, const std::string &name, std::string internalTextureName);
+	std::pair<CountedPtr<Texture>, TextureLoadResult> doTextureAdd(const std::string &texture, const std::string &name, std::string internalTextureName);
 	
 	void deleteRenderObjectMemory(RenderObject *r);
 	bool _hasFocus;
@@ -1398,6 +1389,8 @@ protected:
 
 	int numSavedScreenshots;
 
+	CountedPtr<Texture> texError;
+
 	//unsigned int windowWidth, windowHeight;
 
 	
diff --git a/BBGE/DebugFont.cpp b/BBGE/DebugFont.cpp
index f1ffc69..0e253d8 100644
--- a/BBGE/DebugFont.cpp
+++ b/BBGE/DebugFont.cpp
@@ -52,6 +52,24 @@ float DebugFont::getHeight()
 	return fontDrawSize * lines.size() * 1.5f; // vspc in render()
 }
 
+float DebugFont::getStringWidth(const std::string& text)
+{
+	int maxchars = 0;
+	int c = 0;
+	for (size_t i = 0; i < text.size(); i++)
+	{
+		if(text[i] == '\n')
+		{
+			maxchars = std::max(maxchars, c);
+			c = 0;
+		}
+		else
+			++c;
+	}
+	maxchars = std::max(maxchars, c);
+	return float(fontDrawSize * maxchars);
+}
+
 void DebugFont::formatText()
 {
 	std::string text;
diff --git a/BBGE/DebugFont.h b/BBGE/DebugFont.h
index 2a1d5bc..d68d3e9 100644
--- a/BBGE/DebugFont.h
+++ b/BBGE/DebugFont.h
@@ -34,6 +34,7 @@ public:
 	int getNumLines() { return lines.size(); }
 	virtual void setAlign(Align align);
 	virtual float getHeight();
+	virtual float getStringWidth(const std::string& text);
 protected:
 	int fontDrawSize, textWidth;
 	void formatText();
diff --git a/BBGE/FmodOpenALBridge.cpp b/BBGE/FmodOpenALBridge.cpp
index 23b88cb..aad7b3c 100644
--- a/BBGE/FmodOpenALBridge.cpp
+++ b/BBGE/FmodOpenALBridge.cpp
@@ -630,7 +630,7 @@ class OpenALSound
 {
 public:
     OpenALSound(VFILE *_fp, const bool _looping); // ctor for ogg streamed from file
-    OpenALSound(void *_data, long _size, const bool _looping); // ctor for ogg streamed from memory
+    OpenALSound(void *_data, size_t _size, const bool _looping); // ctor for ogg streamed from memory
     OpenALSound(ALuint _bid, const bool _looping); // ctor for raw samples already assigned an opanAL buffer ID
     VFILE *getFile() const { return fp; }
     const void *getData() const { return data; }
@@ -647,7 +647,7 @@ public:
 private:
     VFILE * const fp;
     void * const data;  // Only used if fp==NULL
-    const long size;    // Only used if fp==NULL
+    const size_t size;    // Only used if fp==NULL
     const bool looping;
     int refcount;
     const bool raw; // true if buffer holds raw PCM data
@@ -667,7 +667,7 @@ OpenALSound::OpenALSound(VFILE *_fp, const bool _looping)
 {
 }
 
-OpenALSound::OpenALSound(void *_data, long _size, const bool _looping)
+OpenALSound::OpenALSound(void *_data, size_t _size, const bool _looping)
     : fp(NULL)
     , data(_data)
     , size(_size)
@@ -1436,6 +1436,11 @@ FMOD_RESULT OpenALSystem::createSound(const char *name_or_data, const FMOD_MODE
     VFILE *io = vfopen(core->adjustFilenameCase(fname).c_str(), "rb");
     if (io == NULL)
         return FMOD_ERR_INTERNAL;
+    size_t filesize = 0;
+    if(vfsize(io, &filesize))
+        return FMOD_ERR_INTERNAL;
+    if(!filesize)
+        return FMOD_ERR_INTERNAL;
 
     if (mode & FMOD_CREATESTREAM)
     {
@@ -1468,16 +1473,7 @@ FMOD_RESULT OpenALSystem::createSound(const char *name_or_data, const FMOD_MODE
     else
     {
         // Create streaming memory decoder
-        vfseek(io, 0, SEEK_END);
-        long size = vftell(io);
-        if (vfseek(io, 0, SEEK_SET) != 0)
-        {
-            debugLog("Seek error on " + std::string(fname));
-            vfclose(io);
-            return FMOD_ERR_INTERNAL;
-        }
-
-        void *data = malloc(size);
+        void *data = malloc(filesize);
         if (data == NULL)
         {
             debugLog("Out of memory for " + std::string(fname));
@@ -1485,16 +1481,16 @@ FMOD_RESULT OpenALSystem::createSound(const char *name_or_data, const FMOD_MODE
             return FMOD_ERR_INTERNAL;
         }
 
-        long nread = vfread(data, 1, size, io);
+        size_t nread = vfread(data, 1, filesize, io);
         vfclose(io);
-        if (nread != size)
+        if (nread != filesize)
         {
             debugLog("Failed to read data from " + std::string(fname));
             free(data);
             return FMOD_ERR_INTERNAL;
         }
 
-        *sound = (Sound *) new OpenALSound(data, size, (((mode & FMOD_LOOP_OFF) == 0) && (mode & FMOD_LOOP_NORMAL)));
+        *sound = (Sound *) new OpenALSound(data, filesize, (((mode & FMOD_LOOP_OFF) == 0) && (mode & FMOD_LOOP_NORMAL)));
         retval = FMOD_OK;
     }
 
diff --git a/BBGE/Localization.cpp b/BBGE/Localization.cpp
index 24c5417..333fc2f 100644
--- a/BBGE/Localization.cpp
+++ b/BBGE/Localization.cpp
@@ -7,7 +7,6 @@
 #endif
 
 #ifdef BBGE_BUILD_MACOSX
-#include <Carbon/Carbon.h>
 #include <CoreFoundation/CFLocale.h>
 #include <CoreFoundation/CFString.h>
 
@@ -112,13 +111,11 @@ std::string getSystemLocale()
 	if ((buf = (CFStringRef)CFLocaleGetValue(locale, kCFLocaleLanguageCode)) != NULL)
 	{
 		localeStr = _CFToStdString(buf);
-		CFRelease(buf);
 
 		if ((buf = (CFStringRef)CFLocaleGetValue(locale, kCFLocaleCountryCode)) != NULL)
 		{
 			localeStr += "_";
 			localeStr += _CFToStdString(buf);
-			CFRelease(buf);
 		}
 	}
 
diff --git a/BBGE/Quad.cpp b/BBGE/Quad.cpp
index ae32b08..a8c8f41 100644
--- a/BBGE/Quad.cpp
+++ b/BBGE/Quad.cpp
@@ -798,6 +798,11 @@ void Quad::onSetTexture()
 		width = this->texture->width;
 		height = this->texture->height;
 	}
+	else
+	{
+		width = 64;
+		height = 64;
+	}
 }
 
 PauseQuad::PauseQuad() : Quad(), pauseLevel(0)
diff --git a/BBGE/Refcounted.h b/BBGE/Refcounted.h
new file mode 100644
index 0000000..f79fa1b
--- /dev/null
+++ b/BBGE/Refcounted.h
@@ -0,0 +1,95 @@
+#ifndef CG_CORE_REFCOUNTED_H
+#define CG_CORE_REFCOUNTED_H
+
+#include <stddef.h>
+#include <assert.h>
+#include <algorithm>
+
+
+class Refcounted
+{
+protected:
+
+	Refcounted() : _refcount(0)
+	{
+	}
+	virtual ~Refcounted()
+	{
+		assert(_refcount == 0 && "Object was deleted with refcount != 0");
+	}
+
+public:
+
+	inline void incref()
+	{
+		++_refcount;
+	}
+	inline void decref()
+	{
+		if (!--_refcount)
+			delete this;
+	}
+
+private:
+	unsigned _refcount;
+};
+
+
+template<typename T> class CountedPtr
+{
+public:
+	inline ~CountedPtr()
+	{
+		if(_p)
+			_p->decref();
+	}
+	inline CountedPtr() : _p(NULL)
+	{}
+	inline CountedPtr(T* p) : _p(p)
+	{
+		if(p)
+			p->incref();
+	}
+	inline CountedPtr(const CountedPtr& ref) : _p(ref._p)
+	{
+		if (_p)
+			_p->incref();
+	}
+
+	// intentionally not a reference -- see http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom
+	CountedPtr& operator=(CountedPtr ref)
+	{
+		CountedPtr::swap(*this, ref);
+		return *this;
+	}
+
+	const T* operator->() const  { return _p; }
+	      T* operator->()        { return _p; }
+
+	bool operator!() const { return !_p; }
+
+	// Safe for use in if statements
+	operator bool() const  { return !!_p; }
+
+	      T* content ()       { return _p; }
+	const T* content () const { return _p; }
+
+	bool operator<(const CountedPtr& ref) const { return _p < ref._p; }
+	bool operator<=(const CountedPtr& ref) const { return _p <= ref._p; }
+	bool operator==(const CountedPtr& ref) const { return _p == ref._p; }
+	bool operator!=(const CountedPtr& ref) const { return _p != ref._p; }
+	bool operator>=(const CountedPtr& ref) const { return _p >= ref._p; }
+	bool operator>(const CountedPtr& ref) const { return _p > ref._p; }
+
+	inline static void swap(CountedPtr& a, CountedPtr& b)
+	{
+		std::swap(a._p, b._p);
+	}
+
+private:
+
+	T *_p;
+};
+
+
+#endif
diff --git a/BBGE/RenderObject.cpp b/BBGE/RenderObject.cpp
index 6268eee..f61256c 100644
--- a/BBGE/RenderObject.cpp
+++ b/BBGE/RenderObject.cpp
@@ -23,6 +23,12 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #include "MathFunctions.h"
 
 #include <assert.h>
+#include <algorithm>
+
+#ifdef BBGE_USE_GLM
+#include "glm/glm.hpp"
+#include "glm/gtx/transform.hpp"
+#endif
 
 bool	RenderObject::renderCollisionShape			= false;
 int		RenderObject::lastTextureApplied			= 0;
@@ -291,24 +297,51 @@ Vector RenderObject::getInvRotPosition(const Vector &vec)
 #endif
 }
 
-void RenderObject::matrixChain()
+#ifdef BBGE_USE_GLM
+static glm::mat4 matrixChain(const RenderObject *ro)
 {
-	if (parent)
-		parent->matrixChain();
+	glm::mat4 tranformMatrix = glm::scale(
+		glm::translate(
+			glm::rotate(
+				glm::translate(
+					ro->getParent() ? matrixChain(ro->getParent()) : glm::mat4(1.0f),
+					glm::vec3(ro->position.x+ro->offset.x, ro->position.y+ro->offset.y, 0)
+				),
+				ro->rotation.z + ro->rotationOffset.z,
+				glm::vec3(0, 0, 1)
+			),
+			glm::vec3(ro->beforeScaleOffset.x, ro->beforeScaleOffset.y, 0.0f)
+		),
+		glm::vec3(ro->scale.x, ro->scale.y, 0.0f)
+	);
+
+	if (ro->isfh())
+		tranformMatrix *= glm::rotate(180.0f, 0.0f, 1.0f, 0.0f);
+
+	tranformMatrix *= glm::translate(ro->internalOffset.x, ro->internalOffset.y, 0.0f);
+
+	return tranformMatrix;
+}
+#else
+static void matrixChain(RenderObject *ro)
+{
+	if (RenderObject *parent = ro->getParent())
+		matrixChain(parent);
 	
 #ifdef BBGE_BUILD_OPENGL
-	glTranslatef(position.x+offset.x, position.y+offset.y, 0);
-	glRotatef(rotation.z+rotationOffset.z, 0, 0, 1);
-	glTranslatef(beforeScaleOffset.x, beforeScaleOffset.y, 0);
-	glScalef(scale.x, scale.y, 0);
-	if (isfh())
+	glTranslatef(ro->position.x+ro->offset.x, ro->position.y+ro->offset.y, 0);
+	glRotatef(ro->rotation.z+ro->rotationOffset.z, 0, 0, 1);
+	glTranslatef(ro->beforeScaleOffset.x, ro->beforeScaleOffset.y, 0);
+	glScalef(ro->scale.x, ro->scale.y, 0);
+	if (ro->isfh())
 	{
 		//glDisable(GL_CULL_FACE);
 		glRotatef(180, 0, 1, 0);
 	}
-	glTranslatef(internalOffset.x, internalOffset.y, 0);
+	glTranslatef(ro->internalOffset.x, ro->internalOffset.y, 0);
 #endif
 }
+#endif
 
 float RenderObject::getWorldRotation()
 {
@@ -329,11 +362,19 @@ Vector RenderObject::getWorldPositionAndRotation()
 
 Vector RenderObject::getWorldCollidePosition(const Vector &vec)
 {
+#ifdef BBGE_USE_GLM
+	glm::mat4 transformMatrix = glm::translate(
+		matrixChain(this),
+		glm::vec3(collidePosition.x + vec.x, collidePosition.y + vec.y, 0.0f)
+	);
+
+	return Vector(transformMatrix[3][0], transformMatrix[3][1], 0);
+#else
 #ifdef BBGE_BUILD_OPENGL
 	glPushMatrix();
 	glLoadIdentity();
 
-	matrixChain();
+	matrixChain(this);
 	glTranslatef(collidePosition.x+vec.x, collidePosition.y+vec.y, 0);
 
 	float m[16];
@@ -346,6 +387,7 @@ Vector RenderObject::getWorldCollidePosition(const Vector &vec)
 #elif BBGE_BUILD_DIRECTX
 	return vec;
 #endif
+#endif
 }
 
 void RenderObject::fhTo(bool fh)
@@ -415,11 +457,8 @@ void RenderObject::destroy()
 		parent->removeChild(this);
 		parent = 0;
 	}
-	if (texture)
-	{
-		texture->removeRef(); 
-		texture = 0;
-	}
+
+	texture = NULL;
 }
 
 void RenderObject::copyProperties(RenderObject *target)
@@ -467,13 +506,29 @@ void RenderObject::toggleCull(bool value)
 
 void RenderObject::moveToFront()
 {
-	if (layer != -1)
+	if(RenderObject *p = parent)
+	{
+		if(p->children.size() && p->children[0] != this)
+		{
+			p->removeChild(this);
+			p->addChild(this, (ParentManaged)this->pm, RBP_NONE, CHILD_FRONT);
+		}
+	}
+	else if (layer != -1)
 		core->renderObjectLayers[this->layer].moveToFront(this);
 }
 
 void RenderObject::moveToBack()
 {
-	if (layer != -1)
+	if(RenderObject *p = parent)
+	{
+		if(p->children.size() && p->children[p->children.size()-1] != this)
+		{
+			p->removeChild(this);
+			p->addChild(this, (ParentManaged)this->pm, RBP_NONE, CHILD_BACK);
+		}
+	}
+	else if (layer != -1)
 		core->renderObjectLayers[this->layer].moveToBack(this);
 }
 
@@ -1099,26 +1154,6 @@ void RenderObject::lookAt(const Vector &pos, float t, float minAngle, float maxA
 	rotation.interpolateTo(Vector(0,0,angle), t);
 }
 
-void RenderObject::removeAllChildren()
-{	
-	if (!children.empty())
-	{
-		removeChild(children.front());
-		removeAllChildren();
-	}
-}
-
-void RenderObject::recursivelyRemoveEveryChild()
-{
-	if (!children.empty())
-	{
-		RenderObject *child = (children.front());
-		child->recursivelyRemoveEveryChild();
-		removeChild(child);
-		recursivelyRemoveEveryChild();
-	}
-}
-
 void RenderObject::update(float dt)
 {
 	if (ignoreUpdate)
@@ -1149,8 +1184,14 @@ void RenderObject::update(float dt)
 
 void RenderObject::removeChild(RenderObject *r)
 {
-	children.remove(r);
 	r->parent = 0;
+	Children::iterator oldend = children.end();
+	Children::iterator newend = std::remove(children.begin(), oldend, r);
+	if(oldend != newend)
+	{
+		children.resize(std::distance(children.begin(), newend));
+		return;
+	}
 
 	for (Children::iterator i = children.begin(); i != children.end(); i++)
 	{
@@ -1301,29 +1342,6 @@ void RenderObject::onUpdate(float dt)
 //	updateCullVariables();
 }
 
-void RenderObject::propogateAlpha()
-{
-	/*
-	if (!shareAlphaWithChildren) return;
-	for (int i = 0; i < children.size(); i++)
-	{
-		children[i]->alpha = this->alpha * children[i]->parentAlphaModifier.getValue();
-		children[i]->propogateAlpha();
-	}
-
-	*/
-	/*
-	if (shareAlphaWithChildren && !children.empty())
-	{
-		for (int i = 0; i < children.size(); i++)
-		{
-
-			//children[i]->alpha = this->alpha * children[i]->parentAlphaModifier.getValue();
-		}
-	}
-	*/
-}
-
 void RenderObject::unloadDevice()
 {
 	for (Children::iterator i = children.begin(); i != children.end(); i++)
@@ -1340,23 +1358,21 @@ void RenderObject::reloadDevice()
 	}
 }
 
-void RenderObject::setTexture(const std::string &n)
+bool RenderObject::setTexture(const std::string &n)
 {
 	std::string name = n;
 	stringToLowerUserData(name);
 
 	if (name.empty())
-        return;
+		return false;
 
-    if(texture && texture->name == core->getInternalTextureName(name))
-        return; // no texture change
+	if(texture && name == texture->name)
+		return true; // no texture change
 
-    Texture *oldtex = texture;
-	Texture *t = core->addTexture(name);
-	setTexturePointer(t, NO_ADD_REF);
-
-    if (oldtex)
-        oldtex->removeRef();
+	TextureLoadResult res = TEX_FAILED;
+	CountedPtr<Texture> tex = core->addTexture(name, &res);
+	setTexturePointer(tex);
+	return !!tex && res != TEX_FAILED;
 }
 
 float RenderObject::getSortDepth()
@@ -1375,7 +1391,7 @@ void RenderObject::addChild(RenderObject *r, ParentManaged pm, RenderBeforeParen
 	if (order == CHILD_BACK)
 		children.push_back(r);
 	else
-		children.push_front(r);
+		children.insert(children.begin(), r);
 
 	r->pm = pm;
 
@@ -1407,15 +1423,6 @@ void RenderObject::setOverrideCullRadius(float ovr)
 	overrideCullRadiusSqr = ovr * ovr;
 }
 
-void RenderObject::propogateParentManagedStatic()
-{
-	for (Children::iterator i = children.begin(); i != children.end(); i++)
-	{
-		(*i)->pm = PM_STATIC;
-		(*i)->propogateParentManagedStatic();
-	}
-}
-
 bool RenderObject::isCoordinateInRadius(const Vector &pos, float r)
 {
 	Vector d = pos-getRealPosition();
diff --git a/BBGE/RenderObject.h b/BBGE/RenderObject.h
index 1925570..369b3b5 100644
--- a/BBGE/RenderObject.h
+++ b/BBGE/RenderObject.h
@@ -83,21 +83,16 @@ public:
 
 	static RenderObjectLayer *rlayer;
 
-	enum AddRefChoice { NO_ADD_REF = 0, ADD_REF = 1};
-
-	void setTexturePointer(Texture *t, AddRefChoice addRefChoice)
+	void setTexturePointer(CountedPtr<Texture> t)
 	{
 		this->texture = t;
-		if (addRefChoice == ADD_REF)
-			texture->addRef();
 		onSetTexture();
 	}
 
 	void setStateDataObject(StateData *state);
-	void setTexture(const std::string &name);
+	bool setTexture(const std::string &name);
 
 	void toggleAlpha(float t = 0.2);
-	void matrixChain();
 
 	virtual void update(float dt);
 	bool isDead() const {return _dead;}
@@ -134,8 +129,8 @@ public:
 	virtual void flipHorizontal();
 	virtual void flipVertical();
 
-	bool isfh() { return _fh; }
-	bool isfv() { return _fv; }
+	bool isfh() const { return _fh; }
+	bool isfv() const { return _fv; }
 
 	// recursive
 	bool isfhr();
@@ -167,8 +162,6 @@ public:
 
 	void addChild(RenderObject *r, ParentManaged pm, RenderBeforeParent rbp = RBP_NONE, ChildOrder order = CHILD_BACK);
 	void removeChild(RenderObject *r);
-	void removeAllChildren();
-	void recursivelyRemoveEveryChild();
 
 	Vector getRealPosition();
 	Vector getRealScale();
@@ -241,7 +234,7 @@ public:
 	InterpolatedVector offset, rotationOffset, internalOffset, beforeScaleOffset;
 	InterpolatedVector velocity, gravity;
 
-	Texture *texture;
+	CountedPtr<Texture> texture;
 
 	//int mode;
 
@@ -273,13 +266,13 @@ public:
 	bool shareColorWithChildren;
 
 	bool cull;
-	int updateCull;
+	float updateCull;
 	int layer;
 
 	InterpolatedVector *positionSnapTo;
 
 	//DestroyType destroyType;
-	typedef std::list<RenderObject*> Children;
+	typedef std::vector<RenderObject*> Children;
 	Children children, childGarbage;
 
 	//Flags flags;
@@ -312,10 +305,6 @@ protected:
 	virtual void deathNotify(RenderObject *r);
 	virtual void onEndOfLife() {}
 
-	// spread parentManagedStatic flag to the entire child tree
-	void propogateParentManagedStatic();
-	void propogateAlpha();
-
 	inline void updateLife(float dt)
 	{
 		if (decayRate > 0)
diff --git a/BBGE/Resource.cpp b/BBGE/Resource.cpp
deleted file mode 100644
index eea6ac3..0000000
--- a/BBGE/Resource.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
-Copyright (C) 2007, 2010 - Bit-Blot
-
-This file is part of Aquaria.
-
-Aquaria is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public License
-as published by the Free Software Foundation; either version 2
-of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-*/
-#include "Resource.h"
-#include "Core.h"
-
-
-void Resource::destroy()
-{
-	core->removeResource(this->name, Core::NO_DESTROY);
-}
diff --git a/BBGE/Resource.h b/BBGE/Resource.h
deleted file mode 100644
index 5ea7f6d..0000000
--- a/BBGE/Resource.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
-Copyright (C) 2007, 2010 - Bit-Blot
-
-This file is part of Aquaria.
-
-Aquaria is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public License
-as published by the Free Software Foundation; either version 2
-of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
-See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-*/
-#ifndef __resource__
-#define __resource__
-
-#include "Base.h"
-
-class Resource
-{
-public:
-	Resource()
-	{
-		ref = 0;
-	}
-	~Resource()
-	{
-		destroy();
-	}
-	virtual void destroy();
-
-	void addRef()
-	{
-		ref++;
-	}
-	void removeRef()
-	{
-		ref--;
-		if (ref == 0)
-			destroy();
-	}
-	int getRef() { return ref; }
-	std::string name;
-	virtual void reload() {}
-	virtual void unload() {}
-protected:
-	int ref;
-};
-
-#endif
diff --git a/BBGE/SkeletalSprite.cpp b/BBGE/SkeletalSprite.cpp
index 3313034..8666bf4 100644
--- a/BBGE/SkeletalSprite.cpp
+++ b/BBGE/SkeletalSprite.cpp
@@ -34,13 +34,13 @@ std::string SkeletalSprite::secondaryAnimationPath		= "";
 
 static std::map<std::string, XMLDocument*> skelCache;
 
-static XMLDocument *_retrieveSkeletalXML(const std::string& name)
+static XMLDocument *_retrieveSkeletalXML(const std::string& name, bool keepEmpty)
 {
 	std::map<std::string, XMLDocument*>::iterator it = skelCache.find(name);
 	if(it != skelCache.end())
 		return it->second;
 
-	XMLDocument *doc = readXML(name);
+	XMLDocument *doc = readXML(name, NULL, keepEmpty);
 	if(doc)
 		skelCache[name] = doc;
 
@@ -49,6 +49,8 @@ static XMLDocument *_retrieveSkeletalXML(const std::string& name)
 
 void SkeletalSprite::clearCache()
 {
+	for(std::map<std::string, XMLDocument*>::iterator it = skelCache.begin(); it != skelCache.end(); ++it)
+		delete it->second;
 	skelCache.clear();
 }
 
@@ -869,7 +871,7 @@ bool SkeletalSprite::saveSkeletal(const std::string &fn)
 	}
 
 	int i = 0;
-	XMLDocument *xml = _retrieveSkeletalXML(file);
+	XMLDocument *xml = _retrieveSkeletalXML(file, true);
 	xml->Clear();
 
 	XMLElement *animationLayers = xml->NewElement("AnimationLayers");
@@ -1144,16 +1146,10 @@ void SkeletalSprite::prevAnimation()
 void SkeletalSprite::deleteBones()
 {
 	bones.clear();
-	if (!children.empty())
+	for(Children::iterator it = children.begin(); it != children.end(); ++it)
 	{
-		// remove child had better be recursive
-		Bone *b = (Bone*)children.front();
-		//removeChild(b);
-		b->destroy();
-		delete b;
-		deleteBones();
+		(*it)->safeKill();
 	}
-	children.clear();
 	bones.clear();
 }
 
@@ -1185,10 +1181,15 @@ void SkeletalSprite::loadSkin(const std::string &fn)
 
 	if (!exists(file))
 	{
-		errorLog("Could not load skin[" + file + "]");
+		errorLog("Could not load skin[" + file + "] - File not found.");
+		return;
+	}
+	XMLDocument *d = _retrieveSkeletalXML(file, false);
+	if(!d)
+	{
+		errorLog("Could not load skin[" + file + "] - Malformed XML.");
 		return;
 	}
-	XMLDocument *d = _retrieveSkeletalXML(file);
 
 	XMLElement *bonesXml = d->FirstChildElement("Bones");
 	if (bonesXml)
@@ -1290,10 +1291,7 @@ void SkeletalSprite::loadSkeletal(const std::string &fn)
 	filenameLoaded = "";
 	loaded = false;
 	stopAnimation();
-	for (int i = 0; i < animLayers.size(); i++)
-	{
-		animLayers[i].currentAnimation = 0;
-	}
+	animLayers.clear();
 	deleteBones();
 
 
@@ -1321,7 +1319,7 @@ void SkeletalSprite::loadSkeletal(const std::string &fn)
 
 	file = core->adjustFilenameCase(file);
 
-	XMLDocument *xml = _retrieveSkeletalXML(file);
+	XMLDocument *xml = _retrieveSkeletalXML(file, false);
 	if(!xml)
 	{
 		filenameLoaded = "";
diff --git a/BBGE/StateMachine.cpp b/BBGE/StateMachine.cpp
index 682a480..88895ff 100644
--- a/BBGE/StateMachine.cpp
+++ b/BBGE/StateMachine.cpp
@@ -28,7 +28,6 @@ StateMachine::StateMachine ()
 	enqueuedState = nextState = prevState = currentState = STATE_NONE;
 
 	stateCounter = 0;
-	currentStateData = enqueuedStateData = 0;
 }
 
 int StateMachine::getState()
@@ -46,7 +45,7 @@ int StateMachine::getPrevState()
 	return prevState;
 }
   
-void StateMachine::perform(int state, float time, void *stateData)
+void StateMachine::perform(int state, float time)
 {
 	//debugLog("in perform");
 	stateExtraDT = 0;
@@ -56,33 +55,30 @@ void StateMachine::perform(int state, float time, void *stateData)
 	
 	// do this to prevent scripts from repeating endlessly when running main loops
 	enqueuedState = STATE_NONE;
-	enqueuedStateData = 0;
 
  	onExitState(currentState);
 	stateCounter = 0;
 	stateTime = time;
 	currentState = state;
 	nextState = STATE_NONE;
-	this->currentStateData = stateData;
 	//debugLog("onActionInit");
 	onEnterState(currentState);
 	
 	//debugLog("done");
 }	 
 
-void StateMachine::setState(int state, float time, bool force, void *stateData)
+void StateMachine::setState(int state, float time, bool force)
 {
 	if (canSetState(state))
 	{
 		if (force)
 		{
-			perform(state, time, stateData);
+			perform(state, time);
 		}
 		else
 		{
 			enqueuedState = state;
 			enqueuedTime = time;
-			enqueuedStateData = stateData;
 		}
 	}
 }
@@ -140,64 +136,9 @@ void StateMachine::onUpdate (float dt)
 	}
 	if (enqueuedState != STATE_NONE)
 	{
-		perform(enqueuedState, enqueuedTime, enqueuedStateData);
+		perform(enqueuedState, enqueuedTime);
 		enqueuedState = STATE_NONE;
 		enqueuedTime = -1;
 	}
 }
 
-void StateMachine::addCooldown(int state, float time)
-{
-	Cooldown c;
-	c.state = state;
-	c.timer.start(time);
-	cooldowns.push_back(c);
-}
-
-bool StateMachine::isCooldown(int state)
-{
-	for (Cooldowns::iterator i = cooldowns.begin(); i != cooldowns.end(); i++)
-	{
-		if ((*i).state == state && (*i).timer.isActive())
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-void StateMachine::removeCooldown(int state)
-{
-	for (Cooldowns::iterator i = cooldowns.begin(); i != cooldowns.end(); i++)
-	{
-		if ((*i).state == state)
-		{
-			cooldowns.erase(i);
-			break;
-		}
-	}
-}
-
-void StateMachine::updateCooldowns(float dt)
-{
-	std::queue<int> coolqueue;
-
-	for (Cooldowns::iterator i = cooldowns.begin(); i != cooldowns.end(); i++)
-	{
-		Cooldown *c = &((*i));
-		if (c->timer.updateCheck(dt)) {
-			coolqueue.push(c->state);
-		}
-	}
-
-	while (!coolqueue.empty())
-	{
-		removeCooldown(coolqueue.back());
-		coolqueue.pop();
-	}
-}
-
-void StateMachine::clearCooldowns()
-{
-	cooldowns.clear();
-}
diff --git a/BBGE/StateMachine.h b/BBGE/StateMachine.h
index 207846b..b86ba93 100644
--- a/BBGE/StateMachine.h
+++ b/BBGE/StateMachine.h
@@ -23,20 +23,13 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "Base.h"
 
-struct Cooldown
-{
-	int state;
-	Timer timer;
-};
-typedef std::list<Cooldown> Cooldowns;
-
 class StateMachine
 {
 public:
 	StateMachine ();
 	virtual ~StateMachine() {}
 	
-	void setState(int state, float time = -1, bool force = false, void* stateData=0);
+	void setState(int state, float time = -1, bool force = false);
 	void stopState(int state);
 	bool isState(int state);
 	int getState();
@@ -51,15 +44,8 @@ public:
 	};	
 	virtual bool canSetState(int state);
 
-	void addCooldown(int state, float time);
-	void removeCooldown(int state);
-	void updateCooldowns(float dt);
-	bool isCooldown(int state);
-	void clearCooldowns();
 protected:
-	void *currentStateData;
-	void *enqueuedStateData;
-	void perform(int state, float time = -1, void *stateData=0);
+	void perform(int state, float time = -1);
 	virtual void onEnterState(int state);
 	virtual void onExitState(int state);
 
@@ -71,7 +57,6 @@ protected:
 	{ stateCounter = 0; }
 
 private:
-	Cooldowns cooldowns;
 	float stateCounter;
  
 };
diff --git a/BBGE/Texture.cpp b/BBGE/Texture.cpp
index 9f04a4c..f9b898c 100644
--- a/BBGE/Texture.cpp
+++ b/BBGE/Texture.cpp
@@ -54,9 +54,8 @@ bool Texture::useMipMaps = true;
 #endif
 */
 
-TexErr Texture::textureError = TEXERR_OK;
 
-Texture::Texture() : Resource()
+Texture::Texture()
 {
 #ifdef BBGE_BUILD_OPENGL
 	textures[0] = 0;
@@ -69,7 +68,6 @@ Texture::Texture() : Resource()
 	repeat = false;
 	repeating = false;
 	pngSetStandardOrientation(0);
-
 	ow = oh = -1;
 }
 
@@ -151,7 +149,6 @@ void Texture::write(int tx, int ty, int w, int h, const unsigned char *pixels)
 
 void Texture::unload()
 {
-	Resource::unload();
 #ifdef BBGE_BUILD_OPENGL
 	if (textures[0])
 	{
@@ -166,8 +163,6 @@ void Texture::unload()
 
 		glDeleteTextures(1, &textures[0]);
 		textures[0] = 0;
-
-		//removeRef();
 	}
 #endif
 }
@@ -185,10 +180,7 @@ void Texture::destroy()
 	}
 #endif
 
-	if (!core->isShuttingDown())
-		core->removeTexture(this->name);
-
-//	Resource::destroy();
+	core->removeTexture(this);
 }
 
 int Texture::getPixelWidth()
@@ -255,8 +247,6 @@ int Texture::getPixelHeight()
 
 void Texture::reload()
 {
-	Resource::reload();
-
 	debugLog("RELOADING TEXTURE: " + name + " with loadName " + loadName + "...");
 
 	unload();
@@ -270,15 +260,12 @@ void Texture::reload()
 	debugLog("DONE");
 }
 
-void Texture::load(std::string file)
+bool Texture::load(std::string file)
 {
-	Texture::textureError = TEXERR_OK;
-
 	if (file.size()<4)
 	{
 		errorLog("Texture Name is Empty or Too Short");
-		Texture::textureError = TEXERR_FILENOTFOUND;
-		return;
+		return false;
 	}
 
 	stringToLowerUserData(file);
@@ -332,7 +319,7 @@ void Texture::load(std::string file)
 		{
 
 #ifdef BBGE_BUILD_OPENGL
-			loadPNG(file);
+			return loadPNG(file);
 #endif
 
 #ifdef BBGE_BUILD_DIRECTX
@@ -353,18 +340,15 @@ void Texture::load(std::string file)
 		}
 		else if (post == "zga")
 		{
-			loadZGA(file);
+			return loadZGA(file);
 		}
 		else if (post == "tga")
 		{
-			loadTGA(file);
+			return loadTGA(file);
 		}
 		else
 		{
 			debugLog("unknown image file type: " + file);
-			Texture::textureError = TEXERR_FILENOTFOUND;
-			width = 64;
-			height = 64;
 		}
 	}
 	else
@@ -372,10 +356,8 @@ void Texture::load(std::string file)
 		// load default image / leave white
 		if (core->debugLogTextures)
 			debugLog("***Could not find texture: " + file);
-		Texture::textureError = TEXERR_FILENOTFOUND;
-		width = 64;
-		height = 64;
 	}
+	return false;
 }
 
 void Texture::apply(bool repeatOverride)
@@ -411,18 +393,10 @@ void Texture::unbind()
 {
 }
 
-#ifdef BBGE_BUILD_OPENGL
-
-void Texture::setID(int id)
+bool Texture::loadPNG(const std::string &file)
 {
-	textures[0] = id;
-}
-
-#endif
-
-void Texture::loadPNG(const std::string &file)
-{
-	if (file.empty()) return;
+	if (file.empty()) return false;
+	bool good = false;
 
 #ifdef BBGE_BUILD_OPENGL
 
@@ -430,7 +404,7 @@ void Texture::loadPNG(const std::string &file)
 	pngInfo info;
 
 	int pngType = PNG_ALPHA;
-
+	
 	if (format != 0)
 	{
 		if (format == GL_LUMINANCE_ALPHA)
@@ -455,30 +429,29 @@ void Texture::loadPNG(const std::string &file)
 	{
 		width = info.Width;
 		height = info.Height;
+		good = true;
 	}
 	else
 	{
 		fail:
 
 		debugLog("Can't load PNG file: " + file);
-		width = 64;
-		height = 64;
-		Texture::textureError = TEXERR_FILENOTFOUND;
 	}
 
 	if(memptr)
 		delete [] memptr;
 
 #endif
+	return good;
 }
 
 // internal load functions
-void Texture::loadTGA(const std::string &file)
+bool Texture::loadTGA(const std::string &file)
 {
-	loadTGA(TGAload(file.c_str()));
+	return loadTGA(TGAload(file.c_str()));
 }
 
-void Texture::loadZGA(const std::string &file)
+bool Texture::loadZGA(const std::string &file)
 {
 	unsigned long size = 0;
 	char *buf = readCompressedFile(file, &size);
@@ -486,15 +459,15 @@ void Texture::loadZGA(const std::string &file)
 	if (!tga)
 	{
 		debugLog("Can't load ZGA File: " + file);
-		return;
+		return false;
 	}
-	loadTGA(tga);
+	return loadTGA(tga);
 }
 
-void Texture::loadTGA(ImageTGA *imageTGA)
+bool Texture::loadTGA(ImageTGA *imageTGA)
 {
 	if (!imageTGA)
-		return;
+		return false;
 
 	glGenTextures(1, &textures[0]);
 	glBindTexture(GL_TEXTURE_2D, textures[0]);
@@ -512,6 +485,8 @@ void Texture::loadTGA(ImageTGA *imageTGA)
 	if (imageTGA->data)
 		delete[] (imageTGA->data);
 	free (imageTGA);
+
+	return true;
 }
 
 
diff --git a/BBGE/Texture.h b/BBGE/Texture.h
index 68b43fc..a32a5ee 100644
--- a/BBGE/Texture.h
+++ b/BBGE/Texture.h
@@ -21,7 +21,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 #ifndef __texture__
 #define __texture__
 
-#include "Resource.h"
+#include "Base.h"
+
+enum TextureLoadResult
+{
+	TEX_FAILED  = 0x00,
+	TEX_SUCCESS = 0x01,
+	TEX_LOADED  = 0x02,
+};
 
 struct ImageTGA
 {
@@ -31,24 +38,16 @@ struct ImageTGA
 	unsigned char *data;	// The image pixel data
 };
 
-enum TexErr
-{
-	TEXERR_OK				= 0,
-	TEXERR_FILENOTFOUND		= 1,
-	TEXERR_MAX
-};
-
-class Texture : public Resource
+class Texture : public Refcounted
 {
 public:
 	Texture();
 	~Texture();
 
-	void load(std::string file);
+	bool load(std::string file);
 	void apply(bool repeatOverride=false);
 	void unbind();
 	void unload();
-	void setLayer(int layer);
 
 	int getPixelWidth();
 	int getPixelHeight();
@@ -67,7 +66,6 @@ public:
 #ifdef BBGE_BUILD_OPENGL
 	static GLint filter;
 	static GLint format;
-	void setID (int id);
 	GLuint textures[1];
 #endif
 #ifdef BBGE_BUILD_DIRECTX
@@ -76,26 +74,26 @@ public:
 
 	void reload();
 
-	static TexErr textureError;
-
 	void write(int tx, int ty, int w, int h, const unsigned char *pixels);
 	void read(int tx, int ty, int w, int h, unsigned char *pixels);
 
 	unsigned char *getBufferAndSize(int *w, int *h, unsigned int *size); // returned memory must be free()'d
 
+	std::string name;
+
 protected:
 	std::string loadName;
 
 	// internal load functions
-	void loadPNG(const std::string &file);
-	void loadTGA(const std::string &file);
-	void loadZGA(const std::string &file);
-	void loadTGA(ImageTGA *tga);
+	bool loadPNG(const std::string &file);
+	bool loadTGA(const std::string &file);
+	bool loadZGA(const std::string &file);
+	bool loadTGA(ImageTGA *tga);
 
 	int ow, oh;
 	
 };
 
-#define UNREFTEX(x) if (x) {x->removeRef(); x=0;}
+#define UNREFTEX(x) if (x) {x = NULL;}
 
 #endif
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7170fc0..07dca08 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -31,6 +31,7 @@ OPTION(AQUARIA_DEMO_BUILD "Demo Build?" FALSE)
 OPTION(AQUARIA_USE_VFS "Use Virtual File System? Required for some additional features." TRUE)
 
 OPTION(AQUARIA_USE_SDL2 "Use SDL2" FALSE)
+OPTION(AQUARIA_USE_GLM "Use GLM for matrix math" TRUE)
 
 # No Steamworks SDK for Linux at the moment. Roll our own achievements.
 ADD_DEFINITIONS(-DBBGE_BUILD_ACHIEVEMENTS_INTERNAL=1)
@@ -303,6 +304,10 @@ IF(AQUARIA_USE_SDL2)
     ADD_DEFINITIONS(-DBBGE_BUILD_SDL2=1)
 ENDIF(AQUARIA_USE_SDL2)
 
+IF(AQUARIA_USE_GLM)
+    ADD_DEFINITIONS(-DBBGE_USE_GLM=1)
+ENDIF(AQUARIA_USE_GLM)
+
 IF(AQUARIA_DEMO_BUILD)
     message(STATUS "Demo build.")
     ADD_DEFINITIONS(-DAQUARIA_DEMO=1)
@@ -482,7 +487,6 @@ SET(BBGE_SRCS
     ${BBGEDIR}/RenderObject.cpp
     ${BBGEDIR}/RenderObjectLayer.cpp
     ${BBGEDIR}/RenderRect.cpp
-    ${BBGEDIR}/Resource.cpp
     ${BBGEDIR}/RoundedRect.cpp
     ${BBGEDIR}/ScreenTransition.cpp
     ${BBGEDIR}/ScriptObject.cpp
@@ -714,7 +718,7 @@ ENDIF(WIN32)
 IF(MACOSX)
     SET(OPTIONAL_LIBS ${OPTIONAL_LIBS} "-framework Carbon")
     SET(OPTIONAL_LIBS ${OPTIONAL_LIBS} "-framework Cocoa")
-    SET(OPTIONAL_LIBS ${OPTIONAL_LIBS} "-framework OpenAL")
+    #SET(OPTIONAL_LIBS ${OPTIONAL_LIBS} "-framework OpenAL")
 ENDIF(MACOSX)
 
 IF(HAIKU)
diff --git a/ExternalLibs/SDL2/lib/win32/SDL2.lib b/ExternalLibs/SDL2/lib/win32/SDL2.lib
index 83f0a5f..45e87d3 100644
Binary files a/ExternalLibs/SDL2/lib/win32/SDL2.lib and b/ExternalLibs/SDL2/lib/win32/SDL2.lib differ
diff --git a/ExternalLibs/SDL2/lib/win32/SDL2main.lib b/ExternalLibs/SDL2/lib/win32/SDL2main.lib
index 2019eea..f77c1dc 100644
Binary files a/ExternalLibs/SDL2/lib/win32/SDL2main.lib and b/ExternalLibs/SDL2/lib/win32/SDL2main.lib differ
diff --git a/ExternalLibs/glm/CMakeLists.txt b/ExternalLibs/glm/CMakeLists.txt
new file mode 100644
index 0000000..d5ba209
--- /dev/null
+++ b/ExternalLibs/glm/CMakeLists.txt
@@ -0,0 +1,43 @@
+set(NAME glm)
+
+file(GLOB ROOT_SOURCE *.cpp)
+file(GLOB ROOT_INLINE *.inl)
+file(GLOB ROOT_HEADER *.hpp)
+
+file(GLOB_RECURSE CORE_SOURCE ./core/*.cpp)
+file(GLOB_RECURSE CORE_INLINE ./core/*.inl)
+file(GLOB_RECURSE CORE_HEADER ./core/*.hpp)
+
+file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
+file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
+file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
+
+file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
+file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
+file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
+
+file(GLOB_RECURSE VIRTREV_SOURCE ./virtrev/*.cpp)
+file(GLOB_RECURSE VIRTREV_INLINE ./virtrev/*.inl)
+file(GLOB_RECURSE VIRTREV_HEADER ./virtrev/*.hpp)
+
+source_group("Core Files" FILES ${CORE_SOURCE})
+source_group("Core Files" FILES ${CORE_INLINE})
+source_group("Core Files" FILES ${CORE_HEADER})
+source_group("GTC Files" FILES ${GTC_SOURCE})
+source_group("GTC Files" FILES ${GTC_INLINE})
+source_group("GTC Files" FILES ${GTC_HEADER})
+source_group("GTX Files" FILES ${GTX_SOURCE})
+source_group("GTX Files" FILES ${GTX_INLINE})
+source_group("GTX Files" FILES ${GTX_HEADER})
+source_group("VIRTREV Files" FILES ${VIRTREV_SOURCE})
+source_group("VIRTREV Files" FILES ${VIRTREV_INLINE})
+source_group("VIRTREV Files" FILES ${VIRTREV_HEADER})
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+add_executable(${NAME} 
+	${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER} 
+	${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
+	${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER} 
+	${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER} 
+	${VIRTREV_SOURCE} ${VIRTREV_INLINE} ${VIRTREV_HEADER})
diff --git a/ExternalLibs/glm/core/_detail.hpp b/ExternalLibs/glm/core/_detail.hpp
new file mode 100644
index 0000000..8f8a1c5
--- /dev/null
+++ b/ExternalLibs/glm/core/_detail.hpp
@@ -0,0 +1,356 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-07-24
+// Updated : 2008-08-31
+// Licence : This source is under MIT License
+// File    : glm/core/_detail.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_detail
+#define glm_core_detail
+
+#include "setup.hpp"
+#include <cassert>
+
+namespace glm{
+namespace detail
+{
+	class thalf;
+
+#if(__STDC_VERSION__ >= 199901L) // C99 detected, 64 bit types available
+	typedef int64_t								sint64;
+	typedef uint64_t							uint64;
+#elif(GLM_COMPILER & GLM_COMPILER_VC)
+	typedef signed __int64						sint64;
+	typedef unsigned __int64					uint64;
+#elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC | GLM_COMPILER_CLANG))
+	__extension__ typedef signed long long		sint64;
+	__extension__ typedef unsigned long long	uint64;
+#elif(GLM_COMPILER & GLM_COMPILER_BC)
+	typedef Int64								sint64;
+	typedef Uint64								uint64;
+#else//unknown compiler
+	typedef signed long	long					sint64;
+	typedef unsigned long long					uint64;
+#endif//GLM_COMPILER
+
+	template<bool C>
+	struct If
+	{
+		template<typename F, typename T>
+		static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
+		{
+			return functor(val);
+		}
+	};
+
+	template<>
+	struct If<false>
+	{
+		template<typename F, typename T>
+		static GLM_FUNC_QUALIFIER T apply(F, const T& val)
+		{
+			return val;
+		}
+	};
+
+	//template <typename T>
+	//struct traits
+	//{
+	//	static const bool is_signed = false;
+	//	static const bool is_float = false;
+	//	static const bool is_vector = false;
+	//	static const bool is_matrix = false;
+	//	static const bool is_genType = false;
+	//	static const bool is_genIType = false;
+	//	static const bool is_genUType = false;
+	//};
+
+	//template <>
+	//struct traits<half>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <>
+	//struct traits<float>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <>
+	//struct traits<double>
+	//{
+	//	static const bool is_float = true;
+	//	static const bool is_genType = true;
+	//};
+
+	//template <typename genType>
+	//struct desc
+	//{
+	//	typedef genType							type;
+	//	typedef genType *						pointer;
+	//	typedef genType const*					const_pointer;
+	//	typedef genType const *const			const_pointer_const;
+	//	typedef genType *const					pointer_const;
+	//	typedef genType &						reference;
+	//	typedef genType const&					const_reference;
+	//	typedef genType const&					param_type;
+
+	//	typedef typename genType::value_type	value_type;
+	//	typedef typename genType::size_type		size_type;
+	//	static const typename size_type			value_size;
+	//};
+
+	//template <typename genType>
+	//const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
+
+	union uif32
+	{
+		GLM_FUNC_QUALIFIER uif32() :
+			i(0)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(float f) :
+			f(f)
+		{}
+
+		GLM_FUNC_QUALIFIER uif32(unsigned int i) :
+			i(i)
+		{}
+
+		float f;
+		unsigned int i;
+	};
+
+	union uif64
+	{
+		GLM_FUNC_QUALIFIER uif64() :
+			i(0)
+		{}
+
+		GLM_FUNC_QUALIFIER uif64(double f) :
+			f(f)
+		{}
+
+		GLM_FUNC_QUALIFIER uif64(uint64 i) :
+			i(i)
+		{}
+
+		double f;
+		uint64 i;
+	};
+
+	typedef uif32 uif;
+
+	//////////////////
+	// int
+
+	template <typename T>
+	struct is_int
+	{
+		enum is_int_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_INT(T)	\
+	template <>					\
+	struct is_int<T>			\
+	{							\
+		enum is_int_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// uint
+
+	template <typename T>
+	struct is_uint
+	{
+		enum is_uint_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_UINT(T)	\
+	template <>					\
+	struct is_uint<T>			\
+	{							\
+		enum is_uint_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//GLM_DETAIL_IS_UINT(unsigned long long)
+
+	//////////////////
+	// float
+
+	template <typename T>
+	struct is_float
+	{
+		enum is_float_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_FLOAT(T)	\
+	template <>					\
+	struct is_float<T>			\
+	{							\
+		enum is_float_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// bool
+
+	template <typename T>
+	struct is_bool
+	{
+		enum is_bool_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+	
+	template <>
+	struct is_bool<bool>
+	{
+		enum is_bool_enum
+		{
+			_YES = 1,
+			_NO = 0
+		};
+	};
+	
+	//////////////////
+	// vector
+
+	template <typename T>
+	struct is_vector
+	{
+		enum is_vector_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#	define GLM_DETAIL_IS_VECTOR(TYPE) \
+		template <typename T> \
+		struct is_vector<TYPE<T> > \
+		{ \
+			enum is_vector_enum \
+			{ \
+				_YES = 1, \
+				_NO = 0 \
+			}; \
+		}
+
+	//////////////////
+	// matrix
+
+	template <typename T>
+	struct is_matrix
+	{
+		enum is_matrix_enum
+		{
+			_YES = 0,
+			_NO = 1
+		};
+	};
+
+#define GLM_DETAIL_IS_MATRIX(T)	\
+	template <>					\
+	struct is_matrix			\
+	{							\
+		enum is_matrix_enum		\
+		{						\
+			_YES = 1,			\
+			_NO = 0				\
+		};						\
+	}
+
+	//////////////////
+	// type
+
+	template <typename T>
+	struct type
+	{
+		enum type_enum
+		{
+			is_float = is_float<T>::_YES,
+			is_int = is_int<T>::_YES,
+			is_uint = is_uint<T>::_YES,
+			is_bool = is_bool<T>::_YES
+		};
+	};
+
+	//////////////////
+	// type
+
+	typedef signed char							int8;
+	typedef signed short						int16;
+	typedef signed int							int32;
+	typedef detail::sint64						int64;
+
+	typedef unsigned char						uint8;
+	typedef unsigned short						uint16;
+	typedef unsigned int						uint32;
+	typedef detail::uint64						uint64;
+
+	typedef detail::thalf						float16;
+	typedef float								float32;
+	typedef double								float64;
+
+}//namespace detail
+}//namespace glm
+
+#if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
+#	define GLM_DEPRECATED __declspec(deprecated)
+#	define GLM_ALIGN(x) __declspec(align(x)) 
+#	define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct 
+#	define GLM_RESTRICT __declspec(restrict)
+#	define GLM_RESTRICT_VAR __restrict
+#elif((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31))
+#	define GLM_DEPRECATED __attribute__((__deprecated__))
+#	define GLM_ALIGN(x) __attribute__((aligned(x)))
+#	define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
+#	if(GLM_COMPILER >= GLM_COMPILER_GCC33)
+#		define GLM_RESTRICT __restrict__
+#		define GLM_RESTRICT_VAR __restrict__
+#	else
+#		define GLM_RESTRICT
+#		define GLM_RESTRICT_VAR
+#	endif
+#	define GLM_RESTRICT __restrict__
+#	define GLM_RESTRICT_VAR __restrict__
+#else
+#	define GLM_DEPRECATED
+#	define GLM_ALIGN
+#	define GLM_ALIGNED_STRUCT(x) 
+#	define GLM_RESTRICT
+#	define GLM_RESTRICT_VAR
+#endif//GLM_COMPILER
+
+#endif//glm_core_detail
diff --git a/ExternalLibs/glm/core/_fixes.hpp b/ExternalLibs/glm/core/_fixes.hpp
new file mode 100644
index 0000000..ba70800
--- /dev/null
+++ b/ExternalLibs/glm/core/_fixes.hpp
@@ -0,0 +1,18 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-02-21
+// Updated : 2011-02-21
+// Licence : This source is under MIT License
+// File    : glm/core/_fixes.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+//! Workaround for compatibility with other libraries
+#ifdef max
+#undef max
+#endif
+
+//! Workaround for compatibility with other libraries
+#ifdef min
+#undef min
+#endif
diff --git a/ExternalLibs/glm/core/_swizzle.hpp b/ExternalLibs/glm/core/_swizzle.hpp
new file mode 100644
index 0000000..34dabfa
--- /dev/null
+++ b/ExternalLibs/glm/core/_swizzle.hpp
@@ -0,0 +1,1085 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-20
+// Updated : 2008-08-22
+// Licence : This source is under MIT License
+// File    : glm/core/_swizzle.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_swizzle
+#define glm_core_swizzle
+
+namespace glm
+{
+	enum comp
+	{
+		X = 0,
+		R = 0,
+		S = 0,
+		Y = 1,
+		G = 1,
+		T = 1,
+		Z = 2,
+		B = 2,
+		P = 2,
+		W = 3,
+		A = 3,
+		Q = 3
+	};
+}//namespace glm
+
+#if(defined(GLM_SWIZZLE_XYZW) || defined(GLM_SWIZZLE))
+
+#define xx swizzle(glm::X, glm::X)
+#define yx swizzle(glm::Y, glm::X)
+#define zx swizzle(glm::Z, glm::X)
+#define wx swizzle(glm::W, glm::X)
+#define xy swizzle(glm::X, glm::Y)
+#define yy swizzle(glm::Y, glm::Y)
+#define zy swizzle(glm::Z, glm::Y)
+#define wy swizzle(glm::W, glm::Y)
+#define xz swizzle(glm::X, glm::Z)
+#define yz swizzle(glm::Y, glm::Z)
+#define zz swizzle(glm::Z, glm::Z)
+#define wz swizzle(glm::W, glm::Z)
+#define xw swizzle(glm::X, glm::W)
+#define yw swizzle(glm::Y, glm::W)
+#define zw swizzle(glm::Z, glm::W)
+#define ww swizzle(glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_SWIZZLE_RGBA) || defined(GLM_SWIZZLE))
+
+#define rr swizzle(glm::X, glm::X)
+#define gr swizzle(glm::Y, glm::X)
+#define br swizzle(glm::Z, glm::X)
+#define ar swizzle(glm::W, glm::X)
+#define rg swizzle(glm::X, glm::Y)
+#define gg swizzle(glm::Y, glm::Y)
+#define bg swizzle(glm::Z, glm::Y)
+#define ag swizzle(glm::W, glm::Y)
+#define rb swizzle(glm::X, glm::Z)
+#define gb swizzle(glm::Y, glm::Z)
+#define bb swizzle(glm::Z, glm::Z)
+#define ab swizzle(glm::W, glm::Z)
+#define ra swizzle(glm::X, glm::W)
+#define ga swizzle(glm::Y, glm::W)
+#define ba swizzle(glm::Z, glm::W)
+#define aa swizzle(glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_FORCE_SWIZZLE_STPQ) || defined(GLM_SWIZZLE))
+
+#define ss swizzle(glm::X, glm::X)
+#define ts swizzle(glm::Y, glm::X)
+#define ps swizzle(glm::Z, glm::X)
+#define qs swizzle(glm::W, glm::X)
+#define st swizzle(glm::X, glm::Y)
+#define tt swizzle(glm::Y, glm::Y)
+#define pt swizzle(glm::Z, glm::Y)
+#define qt swizzle(glm::W, glm::Y)
+#define sp swizzle(glm::X, glm::Z)
+#define tp swizzle(glm::Y, glm::Z)
+#define pp swizzle(glm::Z, glm::Z)
+#define qp swizzle(glm::W, glm::Z)
+#define sq swizzle(glm::X, glm::W)
+#define tq swizzle(glm::Y, glm::W)
+#define pq swizzle(glm::Z, glm::W)
+#define qq swizzle(glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_SWIZZLE_XYZW) || defined(GLM_SWIZZLE))
+
+#define xxx swizzle(glm::X, glm::X, glm::X)
+#define yxx swizzle(glm::Y, glm::X, glm::X)
+#define zxx swizzle(glm::Z, glm::X, glm::X)
+#define wxx swizzle(glm::W, glm::X, glm::X)
+#define xyx swizzle(glm::X, glm::Y, glm::X)
+#define yyx swizzle(glm::Y, glm::Y, glm::X)
+#define zyx swizzle(glm::Z, glm::Y, glm::X)
+#define wyx swizzle(glm::W, glm::Y, glm::X)
+#define xzx swizzle(glm::X, glm::Z, glm::X)
+#define yzx swizzle(glm::Y, glm::Z, glm::X)
+#define zzx swizzle(glm::Z, glm::Z, glm::X)
+#define wzx swizzle(glm::W, glm::Z, glm::X)
+#define xwx swizzle(glm::X, glm::W, glm::X)
+#define ywx swizzle(glm::Y, glm::W, glm::X)
+#define zwx swizzle(glm::Z, glm::W, glm::X)
+#define wwx swizzle(glm::W, glm::W, glm::X)
+#define xxy swizzle(glm::X, glm::X, glm::Y)
+#define yxy swizzle(glm::Y, glm::X, glm::Y)
+#define zxy swizzle(glm::Z, glm::X, glm::Y)
+#define wxy swizzle(glm::W, glm::X, glm::Y)
+#define xyy swizzle(glm::X, glm::Y, glm::Y)
+#define yyy swizzle(glm::Y, glm::Y, glm::Y)
+#define zyy swizzle(glm::Z, glm::Y, glm::Y)
+#define wyy swizzle(glm::W, glm::Y, glm::Y)
+#define xzy swizzle(glm::X, glm::Z, glm::Y)
+#define yzy swizzle(glm::Y, glm::Z, glm::Y)
+#define zzy swizzle(glm::Z, glm::Z, glm::Y)
+#define wzy swizzle(glm::W, glm::Z, glm::Y)
+#define xwy swizzle(glm::X, glm::W, glm::Y)
+#define ywy swizzle(glm::Y, glm::W, glm::Y)
+#define zwy swizzle(glm::Z, glm::W, glm::Y)
+#define wwy swizzle(glm::W, glm::W, glm::Y)
+#define xxz swizzle(glm::X, glm::X, glm::Z)
+#define yxz swizzle(glm::Y, glm::X, glm::Z)
+#define zxz swizzle(glm::Z, glm::X, glm::Z)
+#define wxz swizzle(glm::W, glm::X, glm::Z)
+#define xyz swizzle(glm::X, glm::Y, glm::Z)
+#define yyz swizzle(glm::Y, glm::Y, glm::Z)
+#define zyz swizzle(glm::Z, glm::Y, glm::Z)
+#define wyz swizzle(glm::W, glm::Y, glm::Z)
+#define xzz swizzle(glm::X, glm::Z, glm::Z)
+#define yzz swizzle(glm::Y, glm::Z, glm::Z)
+#define zzz swizzle(glm::Z, glm::Z, glm::Z)
+#define wzz swizzle(glm::W, glm::Z, glm::Z)
+#define xwz swizzle(glm::X, glm::W, glm::Z)
+#define ywz swizzle(glm::Y, glm::W, glm::Z)
+#define zwz swizzle(glm::Z, glm::W, glm::Z)
+#define wwz swizzle(glm::W, glm::W, glm::Z)
+#define xxw swizzle(glm::X, glm::X, glm::W)
+#define yxw swizzle(glm::Y, glm::X, glm::W)
+#define zxw swizzle(glm::Z, glm::X, glm::W)
+#define wxw swizzle(glm::W, glm::X, glm::W)
+#define xyw swizzle(glm::X, glm::Y, glm::W)
+#define yyw swizzle(glm::Y, glm::Y, glm::W)
+#define zyw swizzle(glm::Z, glm::Y, glm::W)
+#define wyw swizzle(glm::W, glm::Y, glm::W)
+#define xzw swizzle(glm::X, glm::Z, glm::W)
+#define yzw swizzle(glm::Y, glm::Z, glm::W)
+#define zzw swizzle(glm::Z, glm::Z, glm::W)
+#define wzw swizzle(glm::W, glm::Z, glm::W)
+#define xww swizzle(glm::X, glm::W, glm::W)
+#define yww swizzle(glm::Y, glm::W, glm::W)
+#define zww swizzle(glm::Z, glm::W, glm::W)
+#define www swizzle(glm::W, glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_SWIZZLE_RGBA) || defined(GLM_SWIZZLE))
+
+#define rrr swizzle(glm::X, glm::X, glm::X)
+#define grr swizzle(glm::Y, glm::X, glm::X)
+#define brr swizzle(glm::Z, glm::X, glm::X)
+#define arr swizzle(glm::W, glm::X, glm::X)
+#define rgr swizzle(glm::X, glm::Y, glm::X)
+#define ggr swizzle(glm::Y, glm::Y, glm::X)
+#define bgr swizzle(glm::Z, glm::Y, glm::X)
+#define agr swizzle(glm::W, glm::Y, glm::X)
+#define rbr swizzle(glm::X, glm::Z, glm::X)
+#define gbr swizzle(glm::Y, glm::Z, glm::X)
+#define bbr swizzle(glm::Z, glm::Z, glm::X)
+#define abr swizzle(glm::W, glm::Z, glm::X)
+#define rar swizzle(glm::X, glm::W, glm::X)
+#define gar swizzle(glm::Y, glm::W, glm::X)
+#define bar swizzle(glm::Z, glm::W, glm::X)
+#define aar swizzle(glm::W, glm::W, glm::X)
+#define rrg swizzle(glm::X, glm::X, glm::Y)
+#define grg swizzle(glm::Y, glm::X, glm::Y)
+#define brg swizzle(glm::Z, glm::X, glm::Y)
+#define arg swizzle(glm::W, glm::X, glm::Y)
+#define rgg swizzle(glm::X, glm::Y, glm::Y)
+#define ggg swizzle(glm::Y, glm::Y, glm::Y)
+#define bgg swizzle(glm::Z, glm::Y, glm::Y)
+#define agg swizzle(glm::W, glm::Y, glm::Y)
+#define rbg swizzle(glm::X, glm::Z, glm::Y)
+#define gbg swizzle(glm::Y, glm::Z, glm::Y)
+#define bbg swizzle(glm::Z, glm::Z, glm::Y)
+#define abg swizzle(glm::W, glm::Z, glm::Y)
+#define rag swizzle(glm::X, glm::W, glm::Y)
+#define gag swizzle(glm::Y, glm::W, glm::Y)
+#define bag swizzle(glm::Z, glm::W, glm::Y)
+#define aag swizzle(glm::W, glm::W, glm::Y)
+#define rrb swizzle(glm::X, glm::X, glm::Z)
+#define grb swizzle(glm::Y, glm::X, glm::Z)
+#define brb swizzle(glm::Z, glm::X, glm::Z)
+#define arb swizzle(glm::W, glm::X, glm::Z)
+#define rgb swizzle(glm::X, glm::Y, glm::Z)
+#define ggb swizzle(glm::Y, glm::Y, glm::Z)
+#define bgb swizzle(glm::Z, glm::Y, glm::Z)
+#define agb swizzle(glm::W, glm::Y, glm::Z)
+#define rbb swizzle(glm::X, glm::Z, glm::Z)
+#define gbb swizzle(glm::Y, glm::Z, glm::Z)
+#define bbb swizzle(glm::Z, glm::Z, glm::Z)
+#define abb swizzle(glm::W, glm::Z, glm::Z)
+#define rab swizzle(glm::X, glm::W, glm::Z)
+#define gab swizzle(glm::Y, glm::W, glm::Z)
+#define bab swizzle(glm::Z, glm::W, glm::Z)
+#define aab swizzle(glm::W, glm::W, glm::Z)
+#define rra swizzle(glm::X, glm::X, glm::W)
+#define gra swizzle(glm::Y, glm::X, glm::W)
+#define bra swizzle(glm::Z, glm::X, glm::W)
+#define ara swizzle(glm::W, glm::X, glm::W)
+#define rga swizzle(glm::X, glm::Y, glm::W)
+#define gga swizzle(glm::Y, glm::Y, glm::W)
+#define bga swizzle(glm::Z, glm::Y, glm::W)
+#define aga swizzle(glm::W, glm::Y, glm::W)
+#define rba swizzle(glm::X, glm::Z, glm::W)
+#define gba swizzle(glm::Y, glm::Z, glm::W)
+#define bba swizzle(glm::Z, glm::Z, glm::W)
+#define aba swizzle(glm::W, glm::Z, glm::W)
+#define raa swizzle(glm::X, glm::W, glm::W)
+#define gaa swizzle(glm::Y, glm::W, glm::W)
+#define baa swizzle(glm::Z, glm::W, glm::W)
+#define aaa swizzle(glm::W, glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_FORCE_SWIZZLE_STPQ) || defined(GLM_SWIZZLE))
+
+#define sss swizzle(glm::X, glm::X, glm::X)
+#define tss swizzle(glm::Y, glm::X, glm::X)
+#define pss swizzle(glm::Z, glm::X, glm::X)
+#define qss swizzle(glm::W, glm::X, glm::X)
+#define sts swizzle(glm::X, glm::Y, glm::X)
+#define tts swizzle(glm::Y, glm::Y, glm::X)
+#define pts swizzle(glm::Z, glm::Y, glm::X)
+#define qts swizzle(glm::W, glm::Y, glm::X)
+#define sps swizzle(glm::X, glm::Z, glm::X)
+#define tps swizzle(glm::Y, glm::Z, glm::X)
+#define pps swizzle(glm::Z, glm::Z, glm::X)
+#define qps swizzle(glm::W, glm::Z, glm::X)
+#define sqs swizzle(glm::X, glm::W, glm::X)
+#define tqs swizzle(glm::Y, glm::W, glm::X)
+#define pqs swizzle(glm::Z, glm::W, glm::X)
+#define qqs swizzle(glm::W, glm::W, glm::X)
+#define sst swizzle(glm::X, glm::X, glm::Y)
+#define tst swizzle(glm::Y, glm::X, glm::Y)
+#define pst swizzle(glm::Z, glm::X, glm::Y)
+#define qst swizzle(glm::W, glm::X, glm::Y)
+#define stt swizzle(glm::X, glm::Y, glm::Y)
+#define ttt swizzle(glm::Y, glm::Y, glm::Y)
+#define ptt swizzle(glm::Z, glm::Y, glm::Y)
+#define qtt swizzle(glm::W, glm::Y, glm::Y)
+#define spt swizzle(glm::X, glm::Z, glm::Y)
+#define tpt swizzle(glm::Y, glm::Z, glm::Y)
+#define ppt swizzle(glm::Z, glm::Z, glm::Y)
+#define qpt swizzle(glm::W, glm::Z, glm::Y)
+#define sqt swizzle(glm::X, glm::W, glm::Y)
+#define tqt swizzle(glm::Y, glm::W, glm::Y)
+#define pqt swizzle(glm::Z, glm::W, glm::Y)
+#define qqt swizzle(glm::W, glm::W, glm::Y)
+#define ssp swizzle(glm::X, glm::X, glm::Z)
+#define tsp swizzle(glm::Y, glm::X, glm::Z)
+#define psp swizzle(glm::Z, glm::X, glm::Z)
+#define qsp swizzle(glm::W, glm::X, glm::Z)
+#define stp swizzle(glm::X, glm::Y, glm::Z)
+#define ttp swizzle(glm::Y, glm::Y, glm::Z)
+#define ptp swizzle(glm::Z, glm::Y, glm::Z)
+#define qtp swizzle(glm::W, glm::Y, glm::Z)
+#define spp swizzle(glm::X, glm::Z, glm::Z)
+#define tpp swizzle(glm::Y, glm::Z, glm::Z)
+#define ppp swizzle(glm::Z, glm::Z, glm::Z)
+#define qpp swizzle(glm::W, glm::Z, glm::Z)
+#define sqp swizzle(glm::X, glm::W, glm::Z)
+#define tqp swizzle(glm::Y, glm::W, glm::Z)
+#define pqp swizzle(glm::Z, glm::W, glm::Z)
+#define qqp swizzle(glm::W, glm::W, glm::Z)
+#define ssq swizzle(glm::X, glm::X, glm::W)
+#define tsq swizzle(glm::Y, glm::X, glm::W)
+#define psq swizzle(glm::Z, glm::X, glm::W)
+#define qsq swizzle(glm::W, glm::X, glm::W)
+#define stq swizzle(glm::X, glm::Y, glm::W)
+#define ttq swizzle(glm::Y, glm::Y, glm::W)
+#define ptq swizzle(glm::Z, glm::Y, glm::W)
+#define qtq swizzle(glm::W, glm::Y, glm::W)
+#define spq swizzle(glm::X, glm::Z, glm::W)
+#define tpq swizzle(glm::Y, glm::Z, glm::W)
+#define ppq swizzle(glm::Z, glm::Z, glm::W)
+#define qpq swizzle(glm::W, glm::Z, glm::W)
+#define sqq swizzle(glm::X, glm::W, glm::W)
+#define tqq swizzle(glm::Y, glm::W, glm::W)
+#define pqq swizzle(glm::Z, glm::W, glm::W)
+#define qqq swizzle(glm::W, glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_SWIZZLE_XYZW) || defined(GLM_SWIZZLE))
+
+#define xxxx swizzle(glm::X, glm::X, glm::X, glm::X)
+#define yxxx swizzle(glm::Y, glm::X, glm::X, glm::X)
+#define zxxx swizzle(glm::Z, glm::X, glm::X, glm::X)
+#define wxxx swizzle(glm::W, glm::X, glm::X, glm::X)
+#define xyxx swizzle(glm::X, glm::Y, glm::X, glm::X)
+#define yyxx swizzle(glm::Y, glm::Y, glm::X, glm::X)
+#define zyxx swizzle(glm::Z, glm::Y, glm::X, glm::X)
+#define wyxx swizzle(glm::W, glm::Y, glm::X, glm::X)
+#define xzxx swizzle(glm::X, glm::Z, glm::X, glm::X)
+#define yzxx swizzle(glm::Y, glm::Z, glm::X, glm::X)
+#define zzxx swizzle(glm::Z, glm::Z, glm::X, glm::X)
+#define wzxx swizzle(glm::W, glm::Z, glm::X, glm::X)
+#define xwxx swizzle(glm::X, glm::W, glm::X, glm::X)
+#define ywxx swizzle(glm::Y, glm::W, glm::X, glm::X)
+#define zwxx swizzle(glm::Z, glm::W, glm::X, glm::X)
+#define wwxx swizzle(glm::W, glm::W, glm::X, glm::X)
+#define xxyx swizzle(glm::X, glm::X, glm::Y, glm::X)
+#define yxyx swizzle(glm::Y, glm::X, glm::Y, glm::X)
+#define zxyx swizzle(glm::Z, glm::X, glm::Y, glm::X)
+#define wxyx swizzle(glm::W, glm::X, glm::Y, glm::X)
+#define xyyx swizzle(glm::X, glm::Y, glm::Y, glm::X)
+#define yyyx swizzle(glm::Y, glm::Y, glm::Y, glm::X)
+#define zyyx swizzle(glm::Z, glm::Y, glm::Y, glm::X)
+#define wyyx swizzle(glm::W, glm::Y, glm::Y, glm::X)
+#define xzyx swizzle(glm::X, glm::Z, glm::Y, glm::X)
+#define yzyx swizzle(glm::Y, glm::Z, glm::Y, glm::X)
+#define zzyx swizzle(glm::Z, glm::Z, glm::Y, glm::X)
+#define wzyx swizzle(glm::W, glm::Z, glm::Y, glm::X)
+#define xwyx swizzle(glm::X, glm::W, glm::Y, glm::X)
+#define ywyx swizzle(glm::Y, glm::W, glm::Y, glm::X)
+#define zwyx swizzle(glm::Z, glm::W, glm::Y, glm::X)
+#define wwyx swizzle(glm::W, glm::W, glm::Y, glm::X)
+#define xxzx swizzle(glm::X, glm::X, glm::Z, glm::X)
+#define yxzx swizzle(glm::Y, glm::X, glm::Z, glm::X)
+#define zxzx swizzle(glm::Z, glm::X, glm::Z, glm::X)
+#define wxzx swizzle(glm::W, glm::X, glm::Z, glm::X)
+#define xyzx swizzle(glm::X, glm::Y, glm::Z, glm::X)
+#define yyzx swizzle(glm::Y, glm::Y, glm::Z, glm::X)
+#define zyzx swizzle(glm::Z, glm::Y, glm::Z, glm::X)
+#define wyzx swizzle(glm::W, glm::Y, glm::Z, glm::X)
+#define xzzx swizzle(glm::X, glm::Z, glm::Z, glm::X)
+#define yzzx swizzle(glm::Y, glm::Z, glm::Z, glm::X)
+#define zzzx swizzle(glm::Z, glm::Z, glm::Z, glm::X)
+#define wzzx swizzle(glm::W, glm::Z, glm::Z, glm::X)
+#define xwzx swizzle(glm::X, glm::W, glm::Z, glm::X)
+#define ywzx swizzle(glm::Y, glm::W, glm::Z, glm::X)
+#define zwzx swizzle(glm::Z, glm::W, glm::Z, glm::X)
+#define wwzx swizzle(glm::W, glm::W, glm::Z, glm::X)
+#define xxwx swizzle(glm::X, glm::X, glm::W, glm::X)
+#define yxwx swizzle(glm::Y, glm::X, glm::W, glm::X)
+#define zxwx swizzle(glm::Z, glm::X, glm::W, glm::X)
+#define wxwx swizzle(glm::W, glm::X, glm::W, glm::X)
+#define xywx swizzle(glm::X, glm::Y, glm::W, glm::X)
+#define yywx swizzle(glm::Y, glm::Y, glm::W, glm::X)
+#define zywx swizzle(glm::Z, glm::Y, glm::W, glm::X)
+#define wywx swizzle(glm::W, glm::Y, glm::W, glm::X)
+#define xzwx swizzle(glm::X, glm::Z, glm::W, glm::X)
+#define yzwx swizzle(glm::Y, glm::Z, glm::W, glm::X)
+#define zzwx swizzle(glm::Z, glm::Z, glm::W, glm::X)
+#define wzwx swizzle(glm::W, glm::Z, glm::W, glm::X)
+#define xwwx swizzle(glm::X, glm::W, glm::W, glm::X)
+#define ywwx swizzle(glm::Y, glm::W, glm::W, glm::X)
+#define zwwx swizzle(glm::Z, glm::W, glm::W, glm::X)
+#define wwwx swizzle(glm::W, glm::W, glm::W, glm::X)
+#define xxxy swizzle(glm::X, glm::X, glm::X, glm::Y)
+#define yxxy swizzle(glm::Y, glm::X, glm::X, glm::Y)
+#define zxxy swizzle(glm::Z, glm::X, glm::X, glm::Y)
+#define wxxy swizzle(glm::W, glm::X, glm::X, glm::Y)
+#define xyxy swizzle(glm::X, glm::Y, glm::X, glm::Y)
+#define yyxy swizzle(glm::Y, glm::Y, glm::X, glm::Y)
+#define zyxy swizzle(glm::Z, glm::Y, glm::X, glm::Y)
+#define wyxy swizzle(glm::W, glm::Y, glm::X, glm::Y)
+#define xzxy swizzle(glm::X, glm::Z, glm::X, glm::Y)
+#define yzxy swizzle(glm::Y, glm::Z, glm::X, glm::Y)
+#define zzxy swizzle(glm::Z, glm::Z, glm::X, glm::Y)
+#define wzxy swizzle(glm::W, glm::Z, glm::X, glm::Y)
+#define xwxy swizzle(glm::X, glm::W, glm::X, glm::Y)
+#define ywxy swizzle(glm::Y, glm::W, glm::X, glm::Y)
+#define zwxy swizzle(glm::Z, glm::W, glm::X, glm::Y)
+#define wwxy swizzle(glm::W, glm::W, glm::X, glm::Y)
+#define xxyy swizzle(glm::X, glm::X, glm::Y, glm::Y)
+#define yxyy swizzle(glm::Y, glm::X, glm::Y, glm::Y)
+#define zxyy swizzle(glm::Z, glm::X, glm::Y, glm::Y)
+#define wxyy swizzle(glm::W, glm::X, glm::Y, glm::Y)
+#define xyyy swizzle(glm::X, glm::Y, glm::Y, glm::Y)
+#define yyyy swizzle(glm::Y, glm::Y, glm::Y, glm::Y)
+#define zyyy swizzle(glm::Z, glm::Y, glm::Y, glm::Y)
+#define wyyy swizzle(glm::W, glm::Y, glm::Y, glm::Y)
+#define xzyy swizzle(glm::X, glm::Z, glm::Y, glm::Y)
+#define yzyy swizzle(glm::Y, glm::Z, glm::Y, glm::Y)
+#define zzyy swizzle(glm::Z, glm::Z, glm::Y, glm::Y)
+#define wzyy swizzle(glm::W, glm::Z, glm::Y, glm::Y)
+#define xwyy swizzle(glm::X, glm::W, glm::Y, glm::Y)
+#define ywyy swizzle(glm::Y, glm::W, glm::Y, glm::Y)
+#define zwyy swizzle(glm::Z, glm::W, glm::Y, glm::Y)
+#define wwyy swizzle(glm::W, glm::W, glm::Y, glm::Y)
+#define xxzy swizzle(glm::X, glm::X, glm::Z, glm::Y)
+#define yxzy swizzle(glm::Y, glm::X, glm::Z, glm::Y)
+#define zxzy swizzle(glm::Z, glm::X, glm::Z, glm::Y)
+#define wxzy swizzle(glm::W, glm::X, glm::Z, glm::Y)
+#define xyzy swizzle(glm::X, glm::Y, glm::Z, glm::Y)
+#define yyzy swizzle(glm::Y, glm::Y, glm::Z, glm::Y)
+#define zyzy swizzle(glm::Z, glm::Y, glm::Z, glm::Y)
+#define wyzy swizzle(glm::W, glm::Y, glm::Z, glm::Y)
+#define xzzy swizzle(glm::X, glm::Z, glm::Z, glm::Y)
+#define yzzy swizzle(glm::Y, glm::Z, glm::Z, glm::Y)
+#define zzzy swizzle(glm::Z, glm::Z, glm::Z, glm::Y)
+#define wzzy swizzle(glm::W, glm::Z, glm::Z, glm::Y)
+#define xwzy swizzle(glm::X, glm::W, glm::Z, glm::Y)
+#define ywzy swizzle(glm::Y, glm::W, glm::Z, glm::Y)
+#define zwzy swizzle(glm::Z, glm::W, glm::Z, glm::Y)
+#define wwzy swizzle(glm::W, glm::W, glm::Z, glm::Y)
+#define xxwy swizzle(glm::X, glm::X, glm::W, glm::Y)
+#define yxwy swizzle(glm::Y, glm::X, glm::W, glm::Y)
+#define zxwy swizzle(glm::Z, glm::X, glm::W, glm::Y)
+#define wxwy swizzle(glm::W, glm::X, glm::W, glm::Y)
+#define xywy swizzle(glm::X, glm::Y, glm::W, glm::Y)
+#define yywy swizzle(glm::Y, glm::Y, glm::W, glm::Y)
+#define zywy swizzle(glm::Z, glm::Y, glm::W, glm::Y)
+#define wywy swizzle(glm::W, glm::Y, glm::W, glm::Y)
+#define xzwy swizzle(glm::X, glm::Z, glm::W, glm::Y)
+#define yzwy swizzle(glm::Y, glm::Z, glm::W, glm::Y)
+#define zzwy swizzle(glm::Z, glm::Z, glm::W, glm::Y)
+#define wzwy swizzle(glm::W, glm::Z, glm::W, glm::Y)
+#define xwwy swizzle(glm::X, glm::W, glm::W, glm::Y)
+#define ywwy swizzle(glm::Y, glm::W, glm::W, glm::Y)
+#define zwwy swizzle(glm::Z, glm::W, glm::W, glm::Y)
+#define wwwy swizzle(glm::W, glm::W, glm::W, glm::Y)
+#define xxxz swizzle(glm::X, glm::X, glm::X, glm::Z)
+#define yxxz swizzle(glm::Y, glm::X, glm::X, glm::Z)
+#define zxxz swizzle(glm::Z, glm::X, glm::X, glm::Z)
+#define wxxz swizzle(glm::W, glm::X, glm::X, glm::Z)
+#define xyxz swizzle(glm::X, glm::Y, glm::X, glm::Z)
+#define yyxz swizzle(glm::Y, glm::Y, glm::X, glm::Z)
+#define zyxz swizzle(glm::Z, glm::Y, glm::X, glm::Z)
+#define wyxz swizzle(glm::W, glm::Y, glm::X, glm::Z)
+#define xzxz swizzle(glm::X, glm::Z, glm::X, glm::Z)
+#define yzxz swizzle(glm::Y, glm::Z, glm::X, glm::Z)
+#define zzxz swizzle(glm::Z, glm::Z, glm::X, glm::Z)
+#define wzxz swizzle(glm::W, glm::Z, glm::X, glm::Z)
+#define xwxz swizzle(glm::X, glm::W, glm::X, glm::Z)
+#define ywxz swizzle(glm::Y, glm::W, glm::X, glm::Z)
+#define zwxz swizzle(glm::Z, glm::W, glm::X, glm::Z)
+#define wwxz swizzle(glm::W, glm::W, glm::X, glm::Z)
+#define xxyz swizzle(glm::X, glm::X, glm::Y, glm::Z)
+#define yxyz swizzle(glm::Y, glm::X, glm::Y, glm::Z)
+#define zxyz swizzle(glm::Z, glm::X, glm::Y, glm::Z)
+#define wxyz swizzle(glm::W, glm::X, glm::Y, glm::Z)
+#define xyyz swizzle(glm::X, glm::Y, glm::Y, glm::Z)
+#define yyyz swizzle(glm::Y, glm::Y, glm::Y, glm::Z)
+#define zyyz swizzle(glm::Z, glm::Y, glm::Y, glm::Z)
+#define wyyz swizzle(glm::W, glm::Y, glm::Y, glm::Z)
+#define xzyz swizzle(glm::X, glm::Z, glm::Y, glm::Z)
+#define yzyz swizzle(glm::Y, glm::Z, glm::Y, glm::Z)
+#define zzyz swizzle(glm::Z, glm::Z, glm::Y, glm::Z)
+#define wzyz swizzle(glm::W, glm::Z, glm::Y, glm::Z)
+#define xwyz swizzle(glm::X, glm::W, glm::Y, glm::Z)
+#define ywyz swizzle(glm::Y, glm::W, glm::Y, glm::Z)
+#define zwyz swizzle(glm::Z, glm::W, glm::Y, glm::Z)
+#define wwyz swizzle(glm::W, glm::W, glm::Y, glm::Z)
+#define xxzz swizzle(glm::X, glm::X, glm::Z, glm::Z)
+#define yxzz swizzle(glm::Y, glm::X, glm::Z, glm::Z)
+#define zxzz swizzle(glm::Z, glm::X, glm::Z, glm::Z)
+#define wxzz swizzle(glm::W, glm::X, glm::Z, glm::Z)
+#define xyzz swizzle(glm::X, glm::Y, glm::Z, glm::Z)
+#define yyzz swizzle(glm::Y, glm::Y, glm::Z, glm::Z)
+#define zyzz swizzle(glm::Z, glm::Y, glm::Z, glm::Z)
+#define wyzz swizzle(glm::W, glm::Y, glm::Z, glm::Z)
+#define xzzz swizzle(glm::X, glm::Z, glm::Z, glm::Z)
+#define yzzz swizzle(glm::Y, glm::Z, glm::Z, glm::Z)
+#define zzzz swizzle(glm::Z, glm::Z, glm::Z, glm::Z)
+#define wzzz swizzle(glm::W, glm::Z, glm::Z, glm::Z)
+#define xwzz swizzle(glm::X, glm::W, glm::Z, glm::Z)
+#define ywzz swizzle(glm::Y, glm::W, glm::Z, glm::Z)
+#define zwzz swizzle(glm::Z, glm::W, glm::Z, glm::Z)
+#define wwzz swizzle(glm::W, glm::W, glm::Z, glm::Z)
+#define xxwz swizzle(glm::X, glm::X, glm::W, glm::Z)
+#define yxwz swizzle(glm::Y, glm::X, glm::W, glm::Z)
+#define zxwz swizzle(glm::Z, glm::X, glm::W, glm::Z)
+#define wxwz swizzle(glm::W, glm::X, glm::W, glm::Z)
+#define xywz swizzle(glm::X, glm::Y, glm::W, glm::Z)
+#define yywz swizzle(glm::Y, glm::Y, glm::W, glm::Z)
+#define zywz swizzle(glm::Z, glm::Y, glm::W, glm::Z)
+#define wywz swizzle(glm::W, glm::Y, glm::W, glm::Z)
+#define xzwz swizzle(glm::X, glm::Z, glm::W, glm::Z)
+#define yzwz swizzle(glm::Y, glm::Z, glm::W, glm::Z)
+#define zzwz swizzle(glm::Z, glm::Z, glm::W, glm::Z)
+#define wzwz swizzle(glm::W, glm::Z, glm::W, glm::Z)
+#define xwwz swizzle(glm::X, glm::W, glm::W, glm::Z)
+#define ywwz swizzle(glm::Y, glm::W, glm::W, glm::Z)
+#define zwwz swizzle(glm::Z, glm::W, glm::W, glm::Z)
+#define wwwz swizzle(glm::W, glm::W, glm::W, glm::Z)
+#define xxxw swizzle(glm::X, glm::X, glm::X, glm::W)
+#define yxxw swizzle(glm::Y, glm::X, glm::X, glm::W)
+#define zxxw swizzle(glm::Z, glm::X, glm::X, glm::W)
+#define wxxw swizzle(glm::W, glm::X, glm::X, glm::W)
+#define xyxw swizzle(glm::X, glm::Y, glm::X, glm::W)
+#define yyxw swizzle(glm::Y, glm::Y, glm::X, glm::W)
+#define zyxw swizzle(glm::Z, glm::Y, glm::X, glm::W)
+#define wyxw swizzle(glm::W, glm::Y, glm::X, glm::W)
+#define xzxw swizzle(glm::X, glm::Z, glm::X, glm::W)
+#define yzxw swizzle(glm::Y, glm::Z, glm::X, glm::W)
+#define zzxw swizzle(glm::Z, glm::Z, glm::X, glm::W)
+#define wzxw swizzle(glm::W, glm::Z, glm::X, glm::W)
+#define xwxw swizzle(glm::X, glm::W, glm::X, glm::W)
+#define ywxw swizzle(glm::Y, glm::W, glm::X, glm::W)
+#define zwxw swizzle(glm::Z, glm::W, glm::X, glm::W)
+#define wwxw swizzle(glm::W, glm::W, glm::X, glm::W)
+#define xxyw swizzle(glm::X, glm::X, glm::Y, glm::W)
+#define yxyw swizzle(glm::Y, glm::X, glm::Y, glm::W)
+#define zxyw swizzle(glm::Z, glm::X, glm::Y, glm::W)
+#define wxyw swizzle(glm::W, glm::X, glm::Y, glm::W)
+#define xyyw swizzle(glm::X, glm::Y, glm::Y, glm::W)
+#define yyyw swizzle(glm::Y, glm::Y, glm::Y, glm::W)
+#define zyyw swizzle(glm::Z, glm::Y, glm::Y, glm::W)
+#define wyyw swizzle(glm::W, glm::Y, glm::Y, glm::W)
+#define xzyw swizzle(glm::X, glm::Z, glm::Y, glm::W)
+#define yzyw swizzle(glm::Y, glm::Z, glm::Y, glm::W)
+#define zzyw swizzle(glm::Z, glm::Z, glm::Y, glm::W)
+#define wzyw swizzle(glm::W, glm::Z, glm::Y, glm::W)
+#define xwyw swizzle(glm::X, glm::W, glm::Y, glm::W)
+#define ywyw swizzle(glm::Y, glm::W, glm::Y, glm::W)
+#define zwyw swizzle(glm::Z, glm::W, glm::Y, glm::W)
+#define wwyw swizzle(glm::W, glm::W, glm::Y, glm::W)
+#define xxzw swizzle(glm::X, glm::X, glm::Z, glm::W)
+#define yxzw swizzle(glm::Y, glm::X, glm::Z, glm::W)
+#define zxzw swizzle(glm::Z, glm::X, glm::Z, glm::W)
+#define wxzw swizzle(glm::W, glm::X, glm::Z, glm::W)
+#define xyzw swizzle(glm::X, glm::Y, glm::Z, glm::W)
+#define yyzw swizzle(glm::Y, glm::Y, glm::Z, glm::W)
+#define zyzw swizzle(glm::Z, glm::Y, glm::Z, glm::W)
+#define wyzw swizzle(glm::W, glm::Y, glm::Z, glm::W)
+#define xzzw swizzle(glm::X, glm::Z, glm::Z, glm::W)
+#define yzzw swizzle(glm::Y, glm::Z, glm::Z, glm::W)
+#define zzzw swizzle(glm::Z, glm::Z, glm::Z, glm::W)
+#define wzzw swizzle(glm::W, glm::Z, glm::Z, glm::W)
+#define xwzw swizzle(glm::X, glm::W, glm::Z, glm::W)
+#define ywzw swizzle(glm::Y, glm::W, glm::Z, glm::W)
+#define zwzw swizzle(glm::Z, glm::W, glm::Z, glm::W)
+#define wwzw swizzle(glm::W, glm::W, glm::Z, glm::W)
+#define xxww swizzle(glm::X, glm::X, glm::W, glm::W)
+#define yxww swizzle(glm::Y, glm::X, glm::W, glm::W)
+#define zxww swizzle(glm::Z, glm::X, glm::W, glm::W)
+#define wxww swizzle(glm::W, glm::X, glm::W, glm::W)
+#define xyww swizzle(glm::X, glm::Y, glm::W, glm::W)
+#define yyww swizzle(glm::Y, glm::Y, glm::W, glm::W)
+#define zyww swizzle(glm::Z, glm::Y, glm::W, glm::W)
+#define wyww swizzle(glm::W, glm::Y, glm::W, glm::W)
+#define xzww swizzle(glm::X, glm::Z, glm::W, glm::W)
+#define yzww swizzle(glm::Y, glm::Z, glm::W, glm::W)
+#define zzww swizzle(glm::Z, glm::Z, glm::W, glm::W)
+#define wzww swizzle(glm::W, glm::Z, glm::W, glm::W)
+#define xwww swizzle(glm::X, glm::W, glm::W, glm::W)
+#define ywww swizzle(glm::Y, glm::W, glm::W, glm::W)
+#define zwww swizzle(glm::Z, glm::W, glm::W, glm::W)
+#define wwww swizzle(glm::W, glm::W, glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_SWIZZLE_RGBA) || defined(GLM_SWIZZLE))
+
+#define rrrr swizzle(glm::X, glm::X, glm::X, glm::X)
+#define grrr swizzle(glm::Y, glm::X, glm::X, glm::X)
+#define brrr swizzle(glm::Z, glm::X, glm::X, glm::X)
+#define arrr swizzle(glm::W, glm::X, glm::X, glm::X)
+#define rgrr swizzle(glm::X, glm::Y, glm::X, glm::X)
+#define ggrr swizzle(glm::Y, glm::Y, glm::X, glm::X)
+#define bgrr swizzle(glm::Z, glm::Y, glm::X, glm::X)
+#define agrr swizzle(glm::W, glm::Y, glm::X, glm::X)
+#define rbrr swizzle(glm::X, glm::Z, glm::X, glm::X)
+#define gbrr swizzle(glm::Y, glm::Z, glm::X, glm::X)
+#define bbrr swizzle(glm::Z, glm::Z, glm::X, glm::X)
+#define abrr swizzle(glm::W, glm::Z, glm::X, glm::X)
+#define rarr swizzle(glm::X, glm::W, glm::X, glm::X)
+#define garr swizzle(glm::Y, glm::W, glm::X, glm::X)
+#define barr swizzle(glm::Z, glm::W, glm::X, glm::X)
+#define aarr swizzle(glm::W, glm::W, glm::X, glm::X)
+#define rrgr swizzle(glm::X, glm::X, glm::Y, glm::X)
+#define grgr swizzle(glm::Y, glm::X, glm::Y, glm::X)
+#define brgr swizzle(glm::Z, glm::X, glm::Y, glm::X)
+#define argr swizzle(glm::W, glm::X, glm::Y, glm::X)
+#define rggr swizzle(glm::X, glm::Y, glm::Y, glm::X)
+#define gggr swizzle(glm::Y, glm::Y, glm::Y, glm::X)
+#define bggr swizzle(glm::Z, glm::Y, glm::Y, glm::X)
+#define aggr swizzle(glm::W, glm::Y, glm::Y, glm::X)
+#define rbgr swizzle(glm::X, glm::Z, glm::Y, glm::X)
+#define gbgr swizzle(glm::Y, glm::Z, glm::Y, glm::X)
+#define bbgr swizzle(glm::Z, glm::Z, glm::Y, glm::X)
+#define abgr swizzle(glm::W, glm::Z, glm::Y, glm::X)
+#define ragr swizzle(glm::X, glm::W, glm::Y, glm::X)
+#define gagr swizzle(glm::Y, glm::W, glm::Y, glm::X)
+#define bagr swizzle(glm::Z, glm::W, glm::Y, glm::X)
+#define aagr swizzle(glm::W, glm::W, glm::Y, glm::X)
+#define rrbr swizzle(glm::X, glm::X, glm::Z, glm::X)
+#define grbr swizzle(glm::Y, glm::X, glm::Z, glm::X)
+#define brbr swizzle(glm::Z, glm::X, glm::Z, glm::X)
+#define arbr swizzle(glm::W, glm::X, glm::Z, glm::X)
+#define rgbr swizzle(glm::X, glm::Y, glm::Z, glm::X)
+#define ggbr swizzle(glm::Y, glm::Y, glm::Z, glm::X)
+#define bgbr swizzle(glm::Z, glm::Y, glm::Z, glm::X)
+#define agbr swizzle(glm::W, glm::Y, glm::Z, glm::X)
+#define rbbr swizzle(glm::X, glm::Z, glm::Z, glm::X)
+#define gbbr swizzle(glm::Y, glm::Z, glm::Z, glm::X)
+#define bbbr swizzle(glm::Z, glm::Z, glm::Z, glm::X)
+#define abbr swizzle(glm::W, glm::Z, glm::Z, glm::X)
+#define rabr swizzle(glm::X, glm::W, glm::Z, glm::X)
+#define gabr swizzle(glm::Y, glm::W, glm::Z, glm::X)
+#define babr swizzle(glm::Z, glm::W, glm::Z, glm::X)
+#define aabr swizzle(glm::W, glm::W, glm::Z, glm::X)
+#define rrar swizzle(glm::X, glm::X, glm::W, glm::X)
+#define grar swizzle(glm::Y, glm::X, glm::W, glm::X)
+#define brar swizzle(glm::Z, glm::X, glm::W, glm::X)
+#define arar swizzle(glm::W, glm::X, glm::W, glm::X)
+#define rgar swizzle(glm::X, glm::Y, glm::W, glm::X)
+#define ggar swizzle(glm::Y, glm::Y, glm::W, glm::X)
+#define bgar swizzle(glm::Z, glm::Y, glm::W, glm::X)
+#define agar swizzle(glm::W, glm::Y, glm::W, glm::X)
+#define rbar swizzle(glm::X, glm::Z, glm::W, glm::X)
+#define gbar swizzle(glm::Y, glm::Z, glm::W, glm::X)
+#define bbar swizzle(glm::Z, glm::Z, glm::W, glm::X)
+#define abar swizzle(glm::W, glm::Z, glm::W, glm::X)
+#define raar swizzle(glm::X, glm::W, glm::W, glm::X)
+#define gaar swizzle(glm::Y, glm::W, glm::W, glm::X)
+#define baar swizzle(glm::Z, glm::W, glm::W, glm::X)
+#define aaar swizzle(glm::W, glm::W, glm::W, glm::X)
+#define rrrg swizzle(glm::X, glm::X, glm::X, glm::Y)
+#define grrg swizzle(glm::Y, glm::X, glm::X, glm::Y)
+#define brrg swizzle(glm::Z, glm::X, glm::X, glm::Y)
+#define arrg swizzle(glm::W, glm::X, glm::X, glm::Y)
+#define rgrg swizzle(glm::X, glm::Y, glm::X, glm::Y)
+#define ggrg swizzle(glm::Y, glm::Y, glm::X, glm::Y)
+#define bgrg swizzle(glm::Z, glm::Y, glm::X, glm::Y)
+#define agrg swizzle(glm::W, glm::Y, glm::X, glm::Y)
+#define rbrg swizzle(glm::X, glm::Z, glm::X, glm::Y)
+#define gbrg swizzle(glm::Y, glm::Z, glm::X, glm::Y)
+#define bbrg swizzle(glm::Z, glm::Z, glm::X, glm::Y)
+#define abrg swizzle(glm::W, glm::Z, glm::X, glm::Y)
+#define rarg swizzle(glm::X, glm::W, glm::X, glm::Y)
+#define garg swizzle(glm::Y, glm::W, glm::X, glm::Y)
+#define barg swizzle(glm::Z, glm::W, glm::X, glm::Y)
+#define aarg swizzle(glm::W, glm::W, glm::X, glm::Y)
+#define rrgg swizzle(glm::X, glm::X, glm::Y, glm::Y)
+#define grgg swizzle(glm::Y, glm::X, glm::Y, glm::Y)
+#define brgg swizzle(glm::Z, glm::X, glm::Y, glm::Y)
+#define argg swizzle(glm::W, glm::X, glm::Y, glm::Y)
+#define rggg swizzle(glm::X, glm::Y, glm::Y, glm::Y)
+#define gggg swizzle(glm::Y, glm::Y, glm::Y, glm::Y)
+#define bggg swizzle(glm::Z, glm::Y, glm::Y, glm::Y)
+#define aggg swizzle(glm::W, glm::Y, glm::Y, glm::Y)
+#define rbgg swizzle(glm::X, glm::Z, glm::Y, glm::Y)
+#define gbgg swizzle(glm::Y, glm::Z, glm::Y, glm::Y)
+#define bbgg swizzle(glm::Z, glm::Z, glm::Y, glm::Y)
+#define abgg swizzle(glm::W, glm::Z, glm::Y, glm::Y)
+#define ragg swizzle(glm::X, glm::W, glm::Y, glm::Y)
+#define gagg swizzle(glm::Y, glm::W, glm::Y, glm::Y)
+#define bagg swizzle(glm::Z, glm::W, glm::Y, glm::Y)
+#define aagg swizzle(glm::W, glm::W, glm::Y, glm::Y)
+#define rrbg swizzle(glm::X, glm::X, glm::Z, glm::Y)
+#define grbg swizzle(glm::Y, glm::X, glm::Z, glm::Y)
+#define brbg swizzle(glm::Z, glm::X, glm::Z, glm::Y)
+#define arbg swizzle(glm::W, glm::X, glm::Z, glm::Y)
+#define rgbg swizzle(glm::X, glm::Y, glm::Z, glm::Y)
+#define ggbg swizzle(glm::Y, glm::Y, glm::Z, glm::Y)
+#define bgbg swizzle(glm::Z, glm::Y, glm::Z, glm::Y)
+#define agbg swizzle(glm::W, glm::Y, glm::Z, glm::Y)
+#define rbbg swizzle(glm::X, glm::Z, glm::Z, glm::Y)
+#define gbbg swizzle(glm::Y, glm::Z, glm::Z, glm::Y)
+#define bbbg swizzle(glm::Z, glm::Z, glm::Z, glm::Y)
+#define abbg swizzle(glm::W, glm::Z, glm::Z, glm::Y)
+#define rabg swizzle(glm::X, glm::W, glm::Z, glm::Y)
+#define gabg swizzle(glm::Y, glm::W, glm::Z, glm::Y)
+#define babg swizzle(glm::Z, glm::W, glm::Z, glm::Y)
+#define aabg swizzle(glm::W, glm::W, glm::Z, glm::Y)
+#define rrag swizzle(glm::X, glm::X, glm::W, glm::Y)
+#define grag swizzle(glm::Y, glm::X, glm::W, glm::Y)
+#define brag swizzle(glm::Z, glm::X, glm::W, glm::Y)
+#define arag swizzle(glm::W, glm::X, glm::W, glm::Y)
+#define rgag swizzle(glm::X, glm::Y, glm::W, glm::Y)
+#define ggag swizzle(glm::Y, glm::Y, glm::W, glm::Y)
+#define bgag swizzle(glm::Z, glm::Y, glm::W, glm::Y)
+#define agag swizzle(glm::W, glm::Y, glm::W, glm::Y)
+#define rbag swizzle(glm::X, glm::Z, glm::W, glm::Y)
+#define gbag swizzle(glm::Y, glm::Z, glm::W, glm::Y)
+#define bbag swizzle(glm::Z, glm::Z, glm::W, glm::Y)
+#define abag swizzle(glm::W, glm::Z, glm::W, glm::Y)
+#define raag swizzle(glm::X, glm::W, glm::W, glm::Y)
+#define gaag swizzle(glm::Y, glm::W, glm::W, glm::Y)
+#define baag swizzle(glm::Z, glm::W, glm::W, glm::Y)
+#define aaag swizzle(glm::W, glm::W, glm::W, glm::Y)
+#define rrrb swizzle(glm::X, glm::X, glm::X, glm::Z)
+#define grrb swizzle(glm::Y, glm::X, glm::X, glm::Z)
+#define brrb swizzle(glm::Z, glm::X, glm::X, glm::Z)
+#define arrb swizzle(glm::W, glm::X, glm::X, glm::Z)
+#define rgrb swizzle(glm::X, glm::Y, glm::X, glm::Z)
+#define ggrb swizzle(glm::Y, glm::Y, glm::X, glm::Z)
+#define bgrb swizzle(glm::Z, glm::Y, glm::X, glm::Z)
+#define agrb swizzle(glm::W, glm::Y, glm::X, glm::Z)
+#define rbrb swizzle(glm::X, glm::Z, glm::X, glm::Z)
+#define gbrb swizzle(glm::Y, glm::Z, glm::X, glm::Z)
+#define bbrb swizzle(glm::Z, glm::Z, glm::X, glm::Z)
+#define abrb swizzle(glm::W, glm::Z, glm::X, glm::Z)
+#define rarb swizzle(glm::X, glm::W, glm::X, glm::Z)
+#define garb swizzle(glm::Y, glm::W, glm::X, glm::Z)
+#define barb swizzle(glm::Z, glm::W, glm::X, glm::Z)
+#define aarb swizzle(glm::W, glm::W, glm::X, glm::Z)
+#define rrgb swizzle(glm::X, glm::X, glm::Y, glm::Z)
+#define grgb swizzle(glm::Y, glm::X, glm::Y, glm::Z)
+#define brgb swizzle(glm::Z, glm::X, glm::Y, glm::Z)
+#define argb swizzle(glm::W, glm::X, glm::Y, glm::Z)
+#define rggb swizzle(glm::X, glm::Y, glm::Y, glm::Z)
+#define gggb swizzle(glm::Y, glm::Y, glm::Y, glm::Z)
+#define bggb swizzle(glm::Z, glm::Y, glm::Y, glm::Z)
+#define aggb swizzle(glm::W, glm::Y, glm::Y, glm::Z)
+#define rbgb swizzle(glm::X, glm::Z, glm::Y, glm::Z)
+#define gbgb swizzle(glm::Y, glm::Z, glm::Y, glm::Z)
+#define bbgb swizzle(glm::Z, glm::Z, glm::Y, glm::Z)
+#define abgb swizzle(glm::W, glm::Z, glm::Y, glm::Z)
+#define ragb swizzle(glm::X, glm::W, glm::Y, glm::Z)
+#define gagb swizzle(glm::Y, glm::W, glm::Y, glm::Z)
+#define bagb swizzle(glm::Z, glm::W, glm::Y, glm::Z)
+#define aagb swizzle(glm::W, glm::W, glm::Y, glm::Z)
+#define rrbb swizzle(glm::X, glm::X, glm::Z, glm::Z)
+#define grbb swizzle(glm::Y, glm::X, glm::Z, glm::Z)
+#define brbb swizzle(glm::Z, glm::X, glm::Z, glm::Z)
+#define arbb swizzle(glm::W, glm::X, glm::Z, glm::Z)
+#define rgbb swizzle(glm::X, glm::Y, glm::Z, glm::Z)
+#define ggbb swizzle(glm::Y, glm::Y, glm::Z, glm::Z)
+#define bgbb swizzle(glm::Z, glm::Y, glm::Z, glm::Z)
+#define agbb swizzle(glm::W, glm::Y, glm::Z, glm::Z)
+#define rbbb swizzle(glm::X, glm::Z, glm::Z, glm::Z)
+#define gbbb swizzle(glm::Y, glm::Z, glm::Z, glm::Z)
+#define bbbb swizzle(glm::Z, glm::Z, glm::Z, glm::Z)
+#define abbb swizzle(glm::W, glm::Z, glm::Z, glm::Z)
+#define rabb swizzle(glm::X, glm::W, glm::Z, glm::Z)
+#define gabb swizzle(glm::Y, glm::W, glm::Z, glm::Z)
+#define babb swizzle(glm::Z, glm::W, glm::Z, glm::Z)
+#define aabb swizzle(glm::W, glm::W, glm::Z, glm::Z)
+#define rrab swizzle(glm::X, glm::X, glm::W, glm::Z)
+#define grab swizzle(glm::Y, glm::X, glm::W, glm::Z)
+#define brab swizzle(glm::Z, glm::X, glm::W, glm::Z)
+#define arab swizzle(glm::W, glm::X, glm::W, glm::Z)
+#define rgab swizzle(glm::X, glm::Y, glm::W, glm::Z)
+#define ggab swizzle(glm::Y, glm::Y, glm::W, glm::Z)
+#define bgab swizzle(glm::Z, glm::Y, glm::W, glm::Z)
+#define agab swizzle(glm::W, glm::Y, glm::W, glm::Z)
+#define rbab swizzle(glm::X, glm::Z, glm::W, glm::Z)
+#define gbab swizzle(glm::Y, glm::Z, glm::W, glm::Z)
+#define bbab swizzle(glm::Z, glm::Z, glm::W, glm::Z)
+#define abab swizzle(glm::W, glm::Z, glm::W, glm::Z)
+#define raab swizzle(glm::X, glm::W, glm::W, glm::Z)
+#define gaab swizzle(glm::Y, glm::W, glm::W, glm::Z)
+#define baab swizzle(glm::Z, glm::W, glm::W, glm::Z)
+#define aaab swizzle(glm::W, glm::W, glm::W, glm::Z)
+#define rrra swizzle(glm::X, glm::X, glm::X, glm::W)
+#define grra swizzle(glm::Y, glm::X, glm::X, glm::W)
+#define brra swizzle(glm::Z, glm::X, glm::X, glm::W)
+#define arra swizzle(glm::W, glm::X, glm::X, glm::W)
+#define rgra swizzle(glm::X, glm::Y, glm::X, glm::W)
+#define ggra swizzle(glm::Y, glm::Y, glm::X, glm::W)
+#define bgra swizzle(glm::Z, glm::Y, glm::X, glm::W)
+#define agra swizzle(glm::W, glm::Y, glm::X, glm::W)
+#define rbra swizzle(glm::X, glm::Z, glm::X, glm::W)
+#define gbra swizzle(glm::Y, glm::Z, glm::X, glm::W)
+#define bbra swizzle(glm::Z, glm::Z, glm::X, glm::W)
+#define abra swizzle(glm::W, glm::Z, glm::X, glm::W)
+#define rara swizzle(glm::X, glm::W, glm::X, glm::W)
+#define gara swizzle(glm::Y, glm::W, glm::X, glm::W)
+#define bara swizzle(glm::Z, glm::W, glm::X, glm::W)
+#define aara swizzle(glm::W, glm::W, glm::X, glm::W)
+#define rrga swizzle(glm::X, glm::X, glm::Y, glm::W)
+#define grga swizzle(glm::Y, glm::X, glm::Y, glm::W)
+#define brga swizzle(glm::Z, glm::X, glm::Y, glm::W)
+#define arga swizzle(glm::W, glm::X, glm::Y, glm::W)
+#define rgga swizzle(glm::X, glm::Y, glm::Y, glm::W)
+#define ggga swizzle(glm::Y, glm::Y, glm::Y, glm::W)
+#define bgga swizzle(glm::Z, glm::Y, glm::Y, glm::W)
+#define agga swizzle(glm::W, glm::Y, glm::Y, glm::W)
+#define rbga swizzle(glm::X, glm::Z, glm::Y, glm::W)
+#define gbga swizzle(glm::Y, glm::Z, glm::Y, glm::W)
+#define bbga swizzle(glm::Z, glm::Z, glm::Y, glm::W)
+#define abga swizzle(glm::W, glm::Z, glm::Y, glm::W)
+#define raga swizzle(glm::X, glm::W, glm::Y, glm::W)
+#define gaga swizzle(glm::Y, glm::W, glm::Y, glm::W)
+#define baga swizzle(glm::Z, glm::W, glm::Y, glm::W)
+#define aaga swizzle(glm::W, glm::W, glm::Y, glm::W)
+#define rrba swizzle(glm::X, glm::X, glm::Z, glm::W)
+#define grba swizzle(glm::Y, glm::X, glm::Z, glm::W)
+#define brba swizzle(glm::Z, glm::X, glm::Z, glm::W)
+#define arba swizzle(glm::W, glm::X, glm::Z, glm::W)
+#define rgba swizzle(glm::X, glm::Y, glm::Z, glm::W)
+#define ggba swizzle(glm::Y, glm::Y, glm::Z, glm::W)
+#define bgba swizzle(glm::Z, glm::Y, glm::Z, glm::W)
+#define agba swizzle(glm::W, glm::Y, glm::Z, glm::W)
+#define rbba swizzle(glm::X, glm::Z, glm::Z, glm::W)
+#define gbba swizzle(glm::Y, glm::Z, glm::Z, glm::W)
+#define bbba swizzle(glm::Z, glm::Z, glm::Z, glm::W)
+#define abba swizzle(glm::W, glm::Z, glm::Z, glm::W)
+#define raba swizzle(glm::X, glm::W, glm::Z, glm::W)
+#define gaba swizzle(glm::Y, glm::W, glm::Z, glm::W)
+#define baba swizzle(glm::Z, glm::W, glm::Z, glm::W)
+#define aaba swizzle(glm::W, glm::W, glm::Z, glm::W)
+#define rraa swizzle(glm::X, glm::X, glm::W, glm::W)
+#define graa swizzle(glm::Y, glm::X, glm::W, glm::W)
+#define braa swizzle(glm::Z, glm::X, glm::W, glm::W)
+#define araa swizzle(glm::W, glm::X, glm::W, glm::W)
+#define rgaa swizzle(glm::X, glm::Y, glm::W, glm::W)
+#define ggaa swizzle(glm::Y, glm::Y, glm::W, glm::W)
+#define bgaa swizzle(glm::Z, glm::Y, glm::W, glm::W)
+#define agaa swizzle(glm::W, glm::Y, glm::W, glm::W)
+#define rbaa swizzle(glm::X, glm::Z, glm::W, glm::W)
+#define gbaa swizzle(glm::Y, glm::Z, glm::W, glm::W)
+#define bbaa swizzle(glm::Z, glm::Z, glm::W, glm::W)
+#define abaa swizzle(glm::W, glm::Z, glm::W, glm::W)
+#define raaa swizzle(glm::X, glm::W, glm::W, glm::W)
+#define gaaa swizzle(glm::Y, glm::W, glm::W, glm::W)
+#define baaa swizzle(glm::Z, glm::W, glm::W, glm::W)
+#define aaaa swizzle(glm::W, glm::W, glm::W, glm::W)
+
+#endif
+
+#if(defined(GLM_FORCE_SWIZZLE_STPQ) || defined(GLM_SWIZZLE))
+
+#define ssss swizzle(glm::X, glm::X, glm::X, glm::X)
+#define tsss swizzle(glm::Y, glm::X, glm::X, glm::X)
+#define psss swizzle(glm::Z, glm::X, glm::X, glm::X)
+#define qsss swizzle(glm::W, glm::X, glm::X, glm::X)
+#define stss swizzle(glm::X, glm::Y, glm::X, glm::X)
+#define ttss swizzle(glm::Y, glm::Y, glm::X, glm::X)
+#define ptss swizzle(glm::Z, glm::Y, glm::X, glm::X)
+#define qtss swizzle(glm::W, glm::Y, glm::X, glm::X)
+#define spss swizzle(glm::X, glm::Z, glm::X, glm::X)
+#define tpss swizzle(glm::Y, glm::Z, glm::X, glm::X)
+#define ppss swizzle(glm::Z, glm::Z, glm::X, glm::X)
+#define qpss swizzle(glm::W, glm::Z, glm::X, glm::X)
+#define sqss swizzle(glm::X, glm::W, glm::X, glm::X)
+#define tqss swizzle(glm::Y, glm::W, glm::X, glm::X)
+#define pqss swizzle(glm::Z, glm::W, glm::X, glm::X)
+#define qqss swizzle(glm::W, glm::W, glm::X, glm::X)
+#define ssts swizzle(glm::X, glm::X, glm::Y, glm::X)
+#define tsts swizzle(glm::Y, glm::X, glm::Y, glm::X)
+#define psts swizzle(glm::Z, glm::X, glm::Y, glm::X)
+#define qsts swizzle(glm::W, glm::X, glm::Y, glm::X)
+#define stts swizzle(glm::X, glm::Y, glm::Y, glm::X)
+#define ttts swizzle(glm::Y, glm::Y, glm::Y, glm::X)
+#define ptts swizzle(glm::Z, glm::Y, glm::Y, glm::X)
+#define qtts swizzle(glm::W, glm::Y, glm::Y, glm::X)
+#define spts swizzle(glm::X, glm::Z, glm::Y, glm::X)
+#define tpts swizzle(glm::Y, glm::Z, glm::Y, glm::X)
+#define ppts swizzle(glm::Z, glm::Z, glm::Y, glm::X)
+#define qpts swizzle(glm::W, glm::Z, glm::Y, glm::X)
+#define sqts swizzle(glm::X, glm::W, glm::Y, glm::X)
+#define tqts swizzle(glm::Y, glm::W, glm::Y, glm::X)
+#define pqts swizzle(glm::Z, glm::W, glm::Y, glm::X)
+#define qqts swizzle(glm::W, glm::W, glm::Y, glm::X)
+#define ssps swizzle(glm::X, glm::X, glm::Z, glm::X)
+#define tsps swizzle(glm::Y, glm::X, glm::Z, glm::X)
+#define psps swizzle(glm::Z, glm::X, glm::Z, glm::X)
+#define qsps swizzle(glm::W, glm::X, glm::Z, glm::X)
+#define stps swizzle(glm::X, glm::Y, glm::Z, glm::X)
+#define ttps swizzle(glm::Y, glm::Y, glm::Z, glm::X)
+#define ptps swizzle(glm::Z, glm::Y, glm::Z, glm::X)
+#define qtps swizzle(glm::W, glm::Y, glm::Z, glm::X)
+#define spps swizzle(glm::X, glm::Z, glm::Z, glm::X)
+#define tpps swizzle(glm::Y, glm::Z, glm::Z, glm::X)
+#define ppps swizzle(glm::Z, glm::Z, glm::Z, glm::X)
+#define qpps swizzle(glm::W, glm::Z, glm::Z, glm::X)
+#define sqps swizzle(glm::X, glm::W, glm::Z, glm::X)
+#define tqps swizzle(glm::Y, glm::W, glm::Z, glm::X)
+#define pqps swizzle(glm::Z, glm::W, glm::Z, glm::X)
+#define qqps swizzle(glm::W, glm::W, glm::Z, glm::X)
+#define ssqs swizzle(glm::X, glm::X, glm::W, glm::X)
+#define tsqs swizzle(glm::Y, glm::X, glm::W, glm::X)
+#define psqs swizzle(glm::Z, glm::X, glm::W, glm::X)
+#define qsqs swizzle(glm::W, glm::X, glm::W, glm::X)
+#define stqs swizzle(glm::X, glm::Y, glm::W, glm::X)
+#define ttqs swizzle(glm::Y, glm::Y, glm::W, glm::X)
+#define ptqs swizzle(glm::Z, glm::Y, glm::W, glm::X)
+#define qtqs swizzle(glm::W, glm::Y, glm::W, glm::X)
+#define spqs swizzle(glm::X, glm::Z, glm::W, glm::X)
+#define tpqs swizzle(glm::Y, glm::Z, glm::W, glm::X)
+#define ppqs swizzle(glm::Z, glm::Z, glm::W, glm::X)
+#define qpqs swizzle(glm::W, glm::Z, glm::W, glm::X)
+#define sqqs swizzle(glm::X, glm::W, glm::W, glm::X)
+#define tqqs swizzle(glm::Y, glm::W, glm::W, glm::X)
+#define pqqs swizzle(glm::Z, glm::W, glm::W, glm::X)
+#define qqqs swizzle(glm::W, glm::W, glm::W, glm::X)
+#define ssst swizzle(glm::X, glm::X, glm::X, glm::Y)
+#define tsst swizzle(glm::Y, glm::X, glm::X, glm::Y)
+#define psst swizzle(glm::Z, glm::X, glm::X, glm::Y)
+#define qsst swizzle(glm::W, glm::X, glm::X, glm::Y)
+#define stst swizzle(glm::X, glm::Y, glm::X, glm::Y)
+#define ttst swizzle(glm::Y, glm::Y, glm::X, glm::Y)
+#define ptst swizzle(glm::Z, glm::Y, glm::X, glm::Y)
+#define qtst swizzle(glm::W, glm::Y, glm::X, glm::Y)
+#define spst swizzle(glm::X, glm::Z, glm::X, glm::Y)
+#define tpst swizzle(glm::Y, glm::Z, glm::X, glm::Y)
+#define ppst swizzle(glm::Z, glm::Z, glm::X, glm::Y)
+#define qpst swizzle(glm::W, glm::Z, glm::X, glm::Y)
+#define sqst swizzle(glm::X, glm::W, glm::X, glm::Y)
+#define tqst swizzle(glm::Y, glm::W, glm::X, glm::Y)
+#define pqst swizzle(glm::Z, glm::W, glm::X, glm::Y)
+#define qqst swizzle(glm::W, glm::W, glm::X, glm::Y)
+#define sstt swizzle(glm::X, glm::X, glm::Y, glm::Y)
+#define tstt swizzle(glm::Y, glm::X, glm::Y, glm::Y)
+#define pstt swizzle(glm::Z, glm::X, glm::Y, glm::Y)
+#define qstt swizzle(glm::W, glm::X, glm::Y, glm::Y)
+#define sttt swizzle(glm::X, glm::Y, glm::Y, glm::Y)
+#define tttt swizzle(glm::Y, glm::Y, glm::Y, glm::Y)
+#define pttt swizzle(glm::Z, glm::Y, glm::Y, glm::Y)
+#define qttt swizzle(glm::W, glm::Y, glm::Y, glm::Y)
+#define sptt swizzle(glm::X, glm::Z, glm::Y, glm::Y)
+#define tptt swizzle(glm::Y, glm::Z, glm::Y, glm::Y)
+#define pptt swizzle(glm::Z, glm::Z, glm::Y, glm::Y)
+#define qptt swizzle(glm::W, glm::Z, glm::Y, glm::Y)
+#define sqtt swizzle(glm::X, glm::W, glm::Y, glm::Y)
+#define tqtt swizzle(glm::Y, glm::W, glm::Y, glm::Y)
+#define pqtt swizzle(glm::Z, glm::W, glm::Y, glm::Y)
+#define qqtt swizzle(glm::W, glm::W, glm::Y, glm::Y)
+#define sspt swizzle(glm::X, glm::X, glm::Z, glm::Y)
+#define tspt swizzle(glm::Y, glm::X, glm::Z, glm::Y)
+#define pspt swizzle(glm::Z, glm::X, glm::Z, glm::Y)
+#define qspt swizzle(glm::W, glm::X, glm::Z, glm::Y)
+#define stpt swizzle(glm::X, glm::Y, glm::Z, glm::Y)
+#define ttpt swizzle(glm::Y, glm::Y, glm::Z, glm::Y)
+#define ptpt swizzle(glm::Z, glm::Y, glm::Z, glm::Y)
+#define qtpt swizzle(glm::W, glm::Y, glm::Z, glm::Y)
+#define sppt swizzle(glm::X, glm::Z, glm::Z, glm::Y)
+#define tppt swizzle(glm::Y, glm::Z, glm::Z, glm::Y)
+#define pppt swizzle(glm::Z, glm::Z, glm::Z, glm::Y)
+#define qppt swizzle(glm::W, glm::Z, glm::Z, glm::Y)
+#define sqpt swizzle(glm::X, glm::W, glm::Z, glm::Y)
+#define tqpt swizzle(glm::Y, glm::W, glm::Z, glm::Y)
+#define pqpt swizzle(glm::Z, glm::W, glm::Z, glm::Y)
+#define qqpt swizzle(glm::W, glm::W, glm::Z, glm::Y)
+#define ssqt swizzle(glm::X, glm::X, glm::W, glm::Y)
+#define tsqt swizzle(glm::Y, glm::X, glm::W, glm::Y)
+#define psqt swizzle(glm::Z, glm::X, glm::W, glm::Y)
+#define qsqt swizzle(glm::W, glm::X, glm::W, glm::Y)
+#define stqt swizzle(glm::X, glm::Y, glm::W, glm::Y)
+#define ttqt swizzle(glm::Y, glm::Y, glm::W, glm::Y)
+#define ptqt swizzle(glm::Z, glm::Y, glm::W, glm::Y)
+#define qtqt swizzle(glm::W, glm::Y, glm::W, glm::Y)
+#define spqt swizzle(glm::X, glm::Z, glm::W, glm::Y)
+#define tpqt swizzle(glm::Y, glm::Z, glm::W, glm::Y)
+#define ppqt swizzle(glm::Z, glm::Z, glm::W, glm::Y)
+#define qpqt swizzle(glm::W, glm::Z, glm::W, glm::Y)
+#define sqqt swizzle(glm::X, glm::W, glm::W, glm::Y)
+#define tqqt swizzle(glm::Y, glm::W, glm::W, glm::Y)
+#define pqqt swizzle(glm::Z, glm::W, glm::W, glm::Y)
+#define qqqt swizzle(glm::W, glm::W, glm::W, glm::Y)
+#define sssp swizzle(glm::X, glm::X, glm::X, glm::Z)
+#define tssp swizzle(glm::Y, glm::X, glm::X, glm::Z)
+#define pssp swizzle(glm::Z, glm::X, glm::X, glm::Z)
+#define qssp swizzle(glm::W, glm::X, glm::X, glm::Z)
+#define stsp swizzle(glm::X, glm::Y, glm::X, glm::Z)
+#define ttsp swizzle(glm::Y, glm::Y, glm::X, glm::Z)
+#define ptsp swizzle(glm::Z, glm::Y, glm::X, glm::Z)
+#define qtsp swizzle(glm::W, glm::Y, glm::X, glm::Z)
+#define spsp swizzle(glm::X, glm::Z, glm::X, glm::Z)
+#define tpsp swizzle(glm::Y, glm::Z, glm::X, glm::Z)
+#define ppsp swizzle(glm::Z, glm::Z, glm::X, glm::Z)
+#define qpsp swizzle(glm::W, glm::Z, glm::X, glm::Z)
+#define sqsp swizzle(glm::X, glm::W, glm::X, glm::Z)
+#define tqsp swizzle(glm::Y, glm::W, glm::X, glm::Z)
+#define pqsp swizzle(glm::Z, glm::W, glm::X, glm::Z)
+#define qqsp swizzle(glm::W, glm::W, glm::X, glm::Z)
+#define sstp swizzle(glm::X, glm::X, glm::Y, glm::Z)
+#define tstp swizzle(glm::Y, glm::X, glm::Y, glm::Z)
+#define pstp swizzle(glm::Z, glm::X, glm::Y, glm::Z)
+#define qstp swizzle(glm::W, glm::X, glm::Y, glm::Z)
+#define sttp swizzle(glm::X, glm::Y, glm::Y, glm::Z)
+#define tttp swizzle(glm::Y, glm::Y, glm::Y, glm::Z)
+#define pttp swizzle(glm::Z, glm::Y, glm::Y, glm::Z)
+#define qttp swizzle(glm::W, glm::Y, glm::Y, glm::Z)
+#define sptp swizzle(glm::X, glm::Z, glm::Y, glm::Z)
+#define tptp swizzle(glm::Y, glm::Z, glm::Y, glm::Z)
+#define pptp swizzle(glm::Z, glm::Z, glm::Y, glm::Z)
+#define qptp swizzle(glm::W, glm::Z, glm::Y, glm::Z)
+#define sqtp swizzle(glm::X, glm::W, glm::Y, glm::Z)
+#define tqtp swizzle(glm::Y, glm::W, glm::Y, glm::Z)
+#define pqtp swizzle(glm::Z, glm::W, glm::Y, glm::Z)
+#define qqtp swizzle(glm::W, glm::W, glm::Y, glm::Z)
+#define sspp swizzle(glm::X, glm::X, glm::Z, glm::Z)
+#define tspp swizzle(glm::Y, glm::X, glm::Z, glm::Z)
+#define pspp swizzle(glm::Z, glm::X, glm::Z, glm::Z)
+#define qspp swizzle(glm::W, glm::X, glm::Z, glm::Z)
+#define stpp swizzle(glm::X, glm::Y, glm::Z, glm::Z)
+#define ttpp swizzle(glm::Y, glm::Y, glm::Z, glm::Z)
+#define ptpp swizzle(glm::Z, glm::Y, glm::Z, glm::Z)
+#define qtpp swizzle(glm::W, glm::Y, glm::Z, glm::Z)
+#define sppp swizzle(glm::X, glm::Z, glm::Z, glm::Z)
+#define tppp swizzle(glm::Y, glm::Z, glm::Z, glm::Z)
+#define pppp swizzle(glm::Z, glm::Z, glm::Z, glm::Z)
+#define qppp swizzle(glm::W, glm::Z, glm::Z, glm::Z)
+#define sqpp swizzle(glm::X, glm::W, glm::Z, glm::Z)
+#define tqpp swizzle(glm::Y, glm::W, glm::Z, glm::Z)
+#define pqpp swizzle(glm::Z, glm::W, glm::Z, glm::Z)
+#define qqpp swizzle(glm::W, glm::W, glm::Z, glm::Z)
+#define ssqp swizzle(glm::X, glm::X, glm::W, glm::Z)
+#define tsqp swizzle(glm::Y, glm::X, glm::W, glm::Z)
+#define psqp swizzle(glm::Z, glm::X, glm::W, glm::Z)
+#define qsqp swizzle(glm::W, glm::X, glm::W, glm::Z)
+#define stqp swizzle(glm::X, glm::Y, glm::W, glm::Z)
+#define ttqp swizzle(glm::Y, glm::Y, glm::W, glm::Z)
+#define ptqp swizzle(glm::Z, glm::Y, glm::W, glm::Z)
+#define qtqp swizzle(glm::W, glm::Y, glm::W, glm::Z)
+#define spqp swizzle(glm::X, glm::Z, glm::W, glm::Z)
+#define tpqp swizzle(glm::Y, glm::Z, glm::W, glm::Z)
+#define ppqp swizzle(glm::Z, glm::Z, glm::W, glm::Z)
+#define qpqp swizzle(glm::W, glm::Z, glm::W, glm::Z)
+#define sqqp swizzle(glm::X, glm::W, glm::W, glm::Z)
+#define tqqp swizzle(glm::Y, glm::W, glm::W, glm::Z)
+#define pqqp swizzle(glm::Z, glm::W, glm::W, glm::Z)
+#define qqqp swizzle(glm::W, glm::W, glm::W, glm::Z)
+#define sssq swizzle(glm::X, glm::X, glm::X, glm::W)
+#define tssq swizzle(glm::Y, glm::X, glm::X, glm::W)
+#define pssq swizzle(glm::Z, glm::X, glm::X, glm::W)
+#define qssq swizzle(glm::W, glm::X, glm::X, glm::W)
+#define stsq swizzle(glm::X, glm::Y, glm::X, glm::W)
+#define ttsq swizzle(glm::Y, glm::Y, glm::X, glm::W)
+#define ptsq swizzle(glm::Z, glm::Y, glm::X, glm::W)
+#define qtsq swizzle(glm::W, glm::Y, glm::X, glm::W)
+#define spsq swizzle(glm::X, glm::Z, glm::X, glm::W)
+#define tpsq swizzle(glm::Y, glm::Z, glm::X, glm::W)
+#define ppsq swizzle(glm::Z, glm::Z, glm::X, glm::W)
+#define qpsq swizzle(glm::W, glm::Z, glm::X, glm::W)
+#define sqsq swizzle(glm::X, glm::W, glm::X, glm::W)
+#define tqsq swizzle(glm::Y, glm::W, glm::X, glm::W)
+#define pqsq swizzle(glm::Z, glm::W, glm::X, glm::W)
+#define qqsq swizzle(glm::W, glm::W, glm::X, glm::W)
+#define sstq swizzle(glm::X, glm::X, glm::Y, glm::W)
+#define tstq swizzle(glm::Y, glm::X, glm::Y, glm::W)
+#define pstq swizzle(glm::Z, glm::X, glm::Y, glm::W)
+#define qstq swizzle(glm::W, glm::X, glm::Y, glm::W)
+#define sttq swizzle(glm::X, glm::Y, glm::Y, glm::W)
+#define tttq swizzle(glm::Y, glm::Y, glm::Y, glm::W)
+#define pttq swizzle(glm::Z, glm::Y, glm::Y, glm::W)
+#define qttq swizzle(glm::W, glm::Y, glm::Y, glm::W)
+#define sptq swizzle(glm::X, glm::Z, glm::Y, glm::W)
+#define tptq swizzle(glm::Y, glm::Z, glm::Y, glm::W)
+#define pptq swizzle(glm::Z, glm::Z, glm::Y, glm::W)
+#define qptq swizzle(glm::W, glm::Z, glm::Y, glm::W)
+#define sqtq swizzle(glm::X, glm::W, glm::Y, glm::W)
+#define tqtq swizzle(glm::Y, glm::W, glm::Y, glm::W)
+#define pqtq swizzle(glm::Z, glm::W, glm::Y, glm::W)
+#define qqtq swizzle(glm::W, glm::W, glm::Y, glm::W)
+#define sspq swizzle(glm::X, glm::X, glm::Z, glm::W)
+#define tspq swizzle(glm::Y, glm::X, glm::Z, glm::W)
+#define pspq swizzle(glm::Z, glm::X, glm::Z, glm::W)
+#define qspq swizzle(glm::W, glm::X, glm::Z, glm::W)
+#define stpq swizzle(glm::X, glm::Y, glm::Z, glm::W)
+#define ttpq swizzle(glm::Y, glm::Y, glm::Z, glm::W)
+#define ptpq swizzle(glm::Z, glm::Y, glm::Z, glm::W)
+#define qtpq swizzle(glm::W, glm::Y, glm::Z, glm::W)
+#define sppq swizzle(glm::X, glm::Z, glm::Z, glm::W)
+#define tppq swizzle(glm::Y, glm::Z, glm::Z, glm::W)
+#define pppq swizzle(glm::Z, glm::Z, glm::Z, glm::W)
+#define qppq swizzle(glm::W, glm::Z, glm::Z, glm::W)
+#define sqpq swizzle(glm::X, glm::W, glm::Z, glm::W)
+#define tqpq swizzle(glm::Y, glm::W, glm::Z, glm::W)
+#define pqpq swizzle(glm::Z, glm::W, glm::Z, glm::W)
+#define qqpq swizzle(glm::W, glm::W, glm::Z, glm::W)
+#define ssqq swizzle(glm::X, glm::X, glm::W, glm::W)
+#define tsqq swizzle(glm::Y, glm::X, glm::W, glm::W)
+#define psqq swizzle(glm::Z, glm::X, glm::W, glm::W)
+#define qsqq swizzle(glm::W, glm::X, glm::W, glm::W)
+#define stqq swizzle(glm::X, glm::Y, glm::W, glm::W)
+#define ttqq swizzle(glm::Y, glm::Y, glm::W, glm::W)
+#define ptqq swizzle(glm::Z, glm::Y, glm::W, glm::W)
+#define qtqq swizzle(glm::W, glm::Y, glm::W, glm::W)
+#define spqq swizzle(glm::X, glm::Z, glm::W, glm::W)
+#define tpqq swizzle(glm::Y, glm::Z, glm::W, glm::W)
+#define ppqq swizzle(glm::Z, glm::Z, glm::W, glm::W)
+#define qpqq swizzle(glm::W, glm::Z, glm::W, glm::W)
+#define sqqq swizzle(glm::X, glm::W, glm::W, glm::W)
+#define tqqq swizzle(glm::Y, glm::W, glm::W, glm::W)
+#define pqqq swizzle(glm::Z, glm::W, glm::W, glm::W)
+#define qqqq swizzle(glm::W, glm::W, glm::W, glm::W)
+
+#endif
+
+#endif//glm_core_swizzle
diff --git a/ExternalLibs/glm/core/_swizzle.inl b/ExternalLibs/glm/core/_swizzle.inl
new file mode 100644
index 0000000..8502d9e
--- /dev/null
+++ b/ExternalLibs/glm/core/_swizzle.inl
@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-27
+// Updated : 2006-04-27
+// Licence : This source is under MIT License
+// File    : _swizzle.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef __swizzle_inl__
+#define __swizzle_inl__
+
+#include "./_swizzle.h"
+
+namespace glm
+{
+
+}
+
+#endif//__swizzle_inl__
diff --git a/ExternalLibs/glm/core/dummy.cpp b/ExternalLibs/glm/core/dummy.cpp
new file mode 100644
index 0000000..3c603ff
--- /dev/null
+++ b/ExternalLibs/glm/core/dummy.cpp
@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-01-19
+// Updated : 2011-01-19
+// Licence : This source is under MIT License
+// File    : glm/setup.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// GLM is a header only library. There is nothing to compile. 
+// dummy.cpp exist only a wordaround for CMake file.
+
+#include "../glm.hpp"
+#include "../ext.hpp"
+
+//#error "GLM is a header only library"
+
+int main()
+{
+
+}
diff --git a/ExternalLibs/glm/core/func_common.hpp b/ExternalLibs/glm/core/func_common.hpp
new file mode 100644
index 0000000..ec564bf
--- /dev/null
+++ b/ExternalLibs/glm/core/func_common.hpp
@@ -0,0 +1,343 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-03-08
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/func_common.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_common
+#define glm_core_func_common
+
+#include "_fixes.hpp"
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_common();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace common{
+
+	/// \addtogroup core_funcs
+	///@{
+
+	//! Returns x if x >= 0; otherwise, it returns -x. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/abs.xml">GLSL abs man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genFIType> 
+	genFIType abs(genFIType const & x);
+
+	//! Returns 1.0 if x > 0, 0.0 if x == 0, or -1.0 if x < 0. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sign.xml">GLSL sign man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genFIType> 
+	genFIType sign(genFIType const & x);
+
+    //! Returns a value equal to the nearest integer that is less then or equal to x. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floor.xml">GLSL floor man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType floor(genType const & x);
+
+	//! Returns a value equal to the nearest integer to x 
+	//! whose absolute value is not larger than the absolute value of x. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/trunc.xml">GLSL trunc man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType trunc(genType const & x);
+
+	//! Returns a value equal to the nearest integer to x. 
+	//! The fraction 0.5 will round in a direction chosen by the 
+	//! implementation, presumably the direction that is fastest. 
+	//! This includes the possibility that round(x) returns the 
+	//! same value as roundEven(x) for all values of x. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/round.xml">GLSL round man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType round(genType const & x);
+
+	//! Returns a value equal to the nearest integer to x.
+	//! A fractional part of 0.5 will round toward the nearest even
+	//! integer. (Both 3.5 and 4.5 for x will return 4.0.) 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/roundEven.xml">GLSL roundEven man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType roundEven(genType const & x);
+
+	//! Returns a value equal to the nearest integer 
+	//! that is greater than or equal to x. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ceil.xml">GLSL ceil man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+    template <typename genType> 
+	genType ceil(genType const & x);
+
+	//! Return x - floor(x).
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fract.xml">GLSL fract man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+    template <typename genType> 
+	genType fract(genType const & x);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+    template <typename genType> 
+	genType mod(
+		genType const & x, 
+		genType const & y);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mod.xml">GLSL mod man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+    template <typename genType> 
+	genType mod(
+		genType const & x, 
+		typename genType::value_type const & y);
+
+	//! Returns the fractional part of x and sets i to the integer
+	//! part (as a whole number floating point value). Both the
+	//! return value and the output parameter will have the same
+	//! sign as x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/modf.xml">GLSL modf man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType modf(
+		genType const & x, 
+		genType & i);
+
+    //! Returns y if y < x; otherwise, it returns x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/min.xml">GLSL min man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType min(
+		genType const & x, 
+		genType const & y);
+
+	template <typename genType> 
+	genType min(
+		genType const & x, 
+		typename genType::value_type const & y);
+
+    //! Returns y if x < y; otherwise, it returns x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/max.xml">GLSL max man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType max(
+		genType const & x, 
+		genType const & y);
+
+	template <typename genType> 
+	genType max(
+		genType const & x, 
+		typename genType::value_type const & y);
+
+    //! Returns min(max(x, minVal), maxVal) for each component in x 
+	//! using the floating-point values minVal and maxVal.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/clamp.xml">GLSL clamp man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType clamp(
+		genType const & x, 
+		genType const & minVal, 
+		genType const & maxVal); 
+
+	template <typename genType> 
+	genType clamp(
+		genType const & x, 
+		typename genType::value_type const & minVal, 
+		typename genType::value_type const & maxVal); 
+
+	//! \return If genTypeU is a floating scalar or vector: 
+	//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
+	//! x and y using the floating-point value a. 
+	//! The value for a is not restricted to the range [0, 1].
+	//!
+	//! \return If genTypeU is a boolean scalar or vector: 
+	//! Selects which vector each returned component comes
+	//! from. For a component of a that is false, the
+	//! corresponding component of x is returned. For a
+	//! component of a that is true, the corresponding
+	//! component of y is returned. Components of x and y that
+	//! are not selected are allowed to be invalid floating point
+	//! values and will have no effect on the results. Thus, this
+	//! provides different functionality than
+	//! genType mix(genType x, genType y, genType(a))
+	//! where a is a Boolean vector.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/mix.xml">GLSL mix man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	//! 
+	//! \param[in]  x Floating point scalar or vector.
+	//! \param[in]  y Floating point scalar or vector.
+	//! \param[in]  a Floating point or boolean scalar or vector.
+	//!
+	// \todo Test when 'a' is a boolean.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT mix(genTypeT const & x, genTypeT const & y, genTypeU const & a);
+
+	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/step.xml">GLSL step man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType step(
+		genType const & edge, 
+		genType const & x);
+
+	template <typename genType> 
+	genType step(
+		typename genType::value_type const & edge, 
+		genType const & x);
+
+	//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	//! performs smooth Hermite interpolation between 0 and 1
+	//! when edge0 < x < edge1. This is useful in cases where
+	//! you would want a threshold function with a smooth
+	//! transition. This is equivalent to:
+	//! genType t;
+	//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
+	//! return t * t * (3 – 2 * t);
+	//! Results are undefined if edge0 >= edge1.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/smoothstep.xml">GLSL smoothstep man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	genType smoothstep(
+		genType const & edge0, 
+		genType const & edge1, 
+		genType const & x);
+
+	template <typename genType> 
+	genType smoothstep(
+		typename genType::value_type const & edge0, 
+		typename genType::value_type const & edge1, 
+		genType const & x);
+
+	//! Returns true if x holds a NaN (not a number)
+	//! representation in the underlying implementation's set of
+	//! floating point representations. Returns false otherwise,
+	//! including for implementations with no NaN
+	//! representations.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isnan.xml">GLSL isnan man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	typename genType::bool_type isnan(genType const & x);
+
+	//! Returns true if x holds a positive infinity or negative
+	//! infinity representation in the underlying implementation's
+	//! set of floating point representations. Returns false
+	//! otherwise, including for implementations with no infinity
+	//! representations.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/isinf.xml">GLSL isinf man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.3
+	template <typename genType> 
+	typename genType::bool_type isinf(genType const & x);
+
+	//! Returns a signed integer value representing
+	//! the encoding of a floating-point value. The floatingpoint
+	//! value's bit-level representation is preserved.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToInt.xml">GLSL floatBitsToInt man page</a>
+	//! \li GLSL 4.00.08 specification, section 8.3
+	template <typename genType, typename genIType>
+	genIType floatBitsToInt(genType const & value);
+
+	//! Returns a unsigned integer value representing
+	//! the encoding of a floating-point value. The floatingpoint
+	//! value's bit-level representation is preserved.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/floatBitsToUint.xml">GLSL floatBitsToUint man page</a>
+    //! \li GLSL 4.00.08 specification, section 8.3
+	template <typename genType, typename genUType>
+	genUType floatBitsToUint(genType const & value);
+
+	//! Returns a floating-point value corresponding to a signed
+	//! integer encoding of a floating-point value.
+	//! If an inf or NaN is passed in, it will not signal, and the
+	//! resulting floating point value is unspecified. Otherwise,
+	//! the bit-level representation is preserved.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/intBitsToFloat.xml">GLSL intBitsToFloat man page</a>
+    //! \li GLSL 4.00.08 specification, section 8.3
+	template <typename genType, typename genIType>
+	genType intBitsToFloat(genIType const & value);
+        
+    //! Returns a floating-point value corresponding to a
+    //! unsigned integer encoding of a floating-point value.
+    //! If an inf or NaN is passed in, it will not signal, and the
+    //! resulting floating point value is unspecified. Otherwise,
+    //! the bit-level representation is preserved.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uintBitsToFloat.xml">GLSL uintBitsToFloat man page</a>
+    //! \li GLSL 4.00.08 specification, section 8.3
+    template <typename genType, typename genUType>
+    genType uintBitsToFloat(genUType const & value);
+        
+	//! Computes and returns a * b + c.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/fma.xml">GLSL fma man page</a>
+    //! \li GLSL 4.00.08 specification, section 8.3
+	template <typename genType>
+	genType fma(genType const & a, genType const & b, genType const & c);
+
+	//! Splits x into a floating-point significand in the range
+	//! [0.5, 1.0) and an integral exponent of two, such that:
+	//! x = significand * exp(2, exponent)
+	//! 
+	//! The significand is returned by the function and the
+	//! exponent is returned in the parameter exp. For a
+	//! floating-point value of zero, the significant and exponent
+	//! are both zero. For a floating-point value that is an
+	//! infinity or is not a number, the results are undefined.
+	//! 
+	//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/frexp.xml">GLSL frexp man page</a>
+	//! \li GLSL 4.00.08 specification, section 8.3
+	template <typename genType, typename genIType>
+	genType frexp(genType const & x, genIType & exp);
+
+	//! Builds a floating-point number from x and the
+	//! corresponding integral exponent of two in exp, returning:
+	//! significand * exp(2, exponent)
+	//! 
+	//! If this product is too large to be represented in the
+	//! floating-point type, the result is undefined.
+	//! 
+	//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/ldexp.xml">GLSL ldexp man page</a>; 
+	//! \li GLSL 4.00.08 specification, section 8.3
+	template <typename genType, typename genIType>
+	genType ldexp(genType const & x, genIType const & exp);
+
+	///@}
+
+	}//namespace common
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::common;
+}//namespace glm
+
+#include "func_common.inl"
+
+#endif//glm_core_func_common
diff --git a/ExternalLibs/glm/core/func_common.inl b/ExternalLibs/glm/core/func_common.inl
new file mode 100644
index 0000000..df572cf
--- /dev/null
+++ b/ExternalLibs/glm/core/func_common.inl
@@ -0,0 +1,1577 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/func_common.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		template <typename genFIType, bool /*signed*/>
+		struct Abs_
+		{
+		};
+
+		template <typename genFIType>
+		struct Abs_<genFIType, true>
+		{
+			static genFIType get(genFIType const & x)
+			{
+				GLM_STATIC_ASSERT(
+					detail::type<genFIType>::is_float || 
+					detail::type<genFIType>::is_int, "'abs' only accept floating-point and integer inputs");
+				return x >= genFIType(0) ? x : -x;
+			}
+		};
+
+		template <typename genFIType>
+		struct Abs_<genFIType, false>
+		{
+			static genFIType get(genFIType const & x)
+			{
+				GLM_STATIC_ASSERT(
+					detail::type<genFIType>::is_uint, "'abs' only accept floating-point and integer inputs");
+
+				return x;
+			}
+		};
+	}//namespace detail
+
+	namespace core{
+	namespace function{
+	namespace common{
+
+	// abs
+	template <typename genFIType>
+    GLM_FUNC_QUALIFIER genFIType abs(
+		genFIType const & x)
+    {
+		return detail::Abs_<genFIType, std::numeric_limits<genFIType>::is_signed>::get(x);
+    }
+
+	//template <typename T> 
+	//GLM_FUNC_QUALIFIER detail::tvec1<T> abs(
+	//	detail::tvec1<T> const & v)
+	//{
+	//	return detail::tvec1<T>(
+	//		abs(v.x));	
+	//}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> abs(
+		detail::tvec2<T> const & v)
+    {
+        return detail::tvec2<T>(
+            abs(v.x),
+            abs(v.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> abs(
+		detail::tvec3<T> const & v)
+    {
+        return detail::tvec3<T>(
+            abs(v.x),
+            abs(v.y),
+            abs(v.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> abs(
+		detail::tvec4<T> const & v)
+    {
+        return detail::tvec4<T>(
+            abs(v.x),
+            abs(v.y),
+            abs(v.z),
+            abs(v.w));
+    }
+
+    // sign
+
+	//Try something like based on x >> 31 to get the sign bit
+    template <typename genFIType> 
+	GLM_FUNC_QUALIFIER genFIType sign(
+		genFIType const & x)
+	{
+		GLM_STATIC_ASSERT(
+			detail::type<genFIType>::is_float || 
+			detail::type<genFIType>::is_int, "'sign' only accept signed inputs");
+        
+		genFIType result;
+		if(x > genFIType(0))
+            result = genFIType(1);
+        else if(x < genFIType(0))
+            result = genFIType(-1);
+        else
+            result = genFIType(0);
+        return result;
+	}
+	
+    template <typename valFIType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valFIType> sign(
+		detail::tvec2<valFIType> const & x)
+    {
+        return detail::tvec2<valFIType>(
+            sign(x.x),
+            sign(x.y));
+    }
+
+    template <typename valFIType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valFIType> sign(
+		detail::tvec3<valFIType> const & x)
+    {
+        return detail::tvec3<valFIType>(
+            sign(x.x),
+            sign(x.y),
+            sign(x.z));
+    }
+
+    template <typename valFIType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valFIType> sign(
+		detail::tvec4<valFIType> const & x)
+    {
+        return detail::tvec4<valFIType>(
+            sign(x.x),
+            sign(x.y),
+            sign(x.z),
+            sign(x.w));
+    }
+
+    // floor
+    template <>
+	GLM_FUNC_QUALIFIER detail::thalf floor<detail::thalf>(detail::thalf const& x)
+    {
+        return detail::thalf(::std::floor(float(x)));
+    }
+
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType floor(genType const& x)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'floor' only accept floating-point inputs");
+
+        return ::std::floor(x);
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> floor(detail::tvec2<valType> const& x)
+    {
+        return detail::tvec2<valType>(
+            floor(x.x),
+            floor(x.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> floor(detail::tvec3<valType> const& x)
+    {
+        return detail::tvec3<valType>(
+            floor(x.x),
+            floor(x.y),
+            floor(x.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> floor(detail::tvec4<valType> const& x)
+    {
+        return detail::tvec4<valType>(
+            floor(x.x),
+            floor(x.y),
+            floor(x.z),
+            floor(x.w));
+    }
+
+    // trunc
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType trunc(genType const & x)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'trunc' only accept floating-point inputs");
+        return x < 0 ? -floor(-x) : floor(x);
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> trunc(detail::tvec2<valType> const & x)
+    {
+        return detail::tvec2<valType>(
+            trunc(x.x),
+            trunc(x.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> trunc(detail::tvec3<valType> const & x)
+    {
+        return detail::tvec3<valType>(
+            trunc(x.x),
+            trunc(x.y),
+            trunc(x.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> trunc(detail::tvec4<valType> const & x)
+    {
+        return detail::tvec4<valType>(
+            trunc(x.x),
+            trunc(x.y),
+            trunc(x.z),
+            trunc(x.w));
+    }
+
+    // round
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType round(genType const& x)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'round' only accept floating-point inputs");
+
+        return genType(int(x + genType(0.5)));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> round(detail::tvec2<valType> const& x)
+    {
+        return detail::tvec2<valType>(
+            round(x.x),
+            round(x.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> round(detail::tvec3<valType> const& x)
+    {
+        return detail::tvec3<valType>(
+            round(x.x),
+            round(x.y),
+            round(x.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> round(detail::tvec4<valType> const& x)
+    {
+        return detail::tvec4<valType>(
+            round(x.x),
+            round(x.y),
+            round(x.z),
+            round(x.w));
+    }
+
+    // roundEven
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType roundEven(genType const& x)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'roundEven' only accept floating-point inputs");
+
+		return genType(int(x + genType(int(x) % 2)));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> roundEven(detail::tvec2<valType> const& x)
+    {
+        return detail::tvec2<valType>(
+            roundEven(x.x),
+            roundEven(x.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> roundEven(detail::tvec3<valType> const& x)
+    {
+        return detail::tvec3<valType>(
+            roundEven(x.x),
+            roundEven(x.y),
+            roundEven(x.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> roundEven(detail::tvec4<valType> const& x)
+    {
+        return detail::tvec4<valType>(
+            roundEven(x.x),
+            roundEven(x.y),
+            roundEven(x.z),
+            roundEven(x.w));
+    }
+
+    // ceil
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType ceil(genType const & x)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'ceil' only accept floating-point inputs");
+
+        return ::std::ceil(x);
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> ceil(detail::tvec2<valType> const & x)
+    {
+        return detail::tvec2<valType>(
+            ceil(x.x),
+            ceil(x.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> ceil(detail::tvec3<valType> const & x)
+    {
+        return detail::tvec3<valType>(
+            ceil(x.x),
+            ceil(x.y),
+            ceil(x.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> ceil(detail::tvec4<valType> const & x)
+    {
+        return detail::tvec4<valType>(
+            ceil(x.x),
+            ceil(x.y),
+            ceil(x.z),
+            ceil(x.w));
+    }
+
+    // fract
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType fract
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'fract' only accept floating-point inputs");
+
+        return x - ::std::floor(x);
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> fract
+	(
+		detail::tvec2<valType> const & x
+	)
+    {
+        return detail::tvec2<valType>(
+            fract(x.x),
+            fract(x.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> fract
+	(
+		detail::tvec3<valType> const & x
+	)
+    {
+        return detail::tvec3<valType>(
+            fract(x.x),
+            fract(x.y),
+            fract(x.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> fract
+	(
+		detail::tvec4<valType> const & x
+	)
+    {
+        return detail::tvec4<valType>(
+            fract(x.x),
+            fract(x.y),
+            fract(x.z),
+            fract(x.w));
+    }
+
+    // mod
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType mod
+	(
+		genType const & x, 
+		genType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mod' only accept floating-point inputs");
+
+        return x - y * floor(x / y);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> mod
+	(
+		detail::tvec2<T> const & x, 
+		typename detail::tvec2<T>::value_type const & y
+	)
+    {
+        return detail::tvec2<T>(
+            mod(x.x, y),
+            mod(x.y, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> mod
+	(
+		detail::tvec3<T> const & x, 
+		typename detail::tvec3<T>::value_type const & y
+	)
+    {
+        return detail::tvec3<T>(
+            mod(x.x, y),
+            mod(x.y, y),
+            mod(x.z, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> mod
+	(
+		detail::tvec4<T> const & x, 
+		typename detail::tvec4<T>::value_type const & y
+	)
+    {
+        return detail::tvec4<T>(
+            mod(x.x, y),
+            mod(x.y, y),
+            mod(x.z, y),
+            mod(x.w, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> mod
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+        return detail::tvec2<T>(
+            mod(x.x, y.x),
+            mod(x.y, y.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> mod
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+        return detail::tvec3<T>(
+            mod(x.x, y.x),
+            mod(x.y, y.y),
+            mod(x.z, y.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> mod
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+        return detail::tvec4<T>(
+            mod(x.x, y.x),
+            mod(x.y, y.y),
+            mod(x.z, y.z),
+            mod(x.w, y.w));
+    }
+
+    // modf
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType modf
+	(
+		genType const & x, 
+		genType & i
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'modf' only accept floating-point inputs");
+
+		i = glm::floor(x);
+
+        return x - i;
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> modf
+	(
+		detail::tvec2<valType> const & x, 
+		detail::tvec2<valType> const & y
+	)
+    {
+        return detail::tvec2<valType>(
+            modf(x.x, y.x),
+            modf(x.y, y.y));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> modf
+	(
+		detail::tvec3<valType> const & x, 
+		detail::tvec3<valType> const & y
+	)
+    {
+        return detail::tvec3<valType>(
+            modf(x.x, y.x),
+            modf(x.y, y.y),
+            modf(x.z, y.z));
+    }
+
+    template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> modf
+	(
+		detail::tvec4<valType> const & x, 
+		detail::tvec4<valType> const & y
+	)
+    {
+        return detail::tvec4<valType>(
+            modf(x.x, y.x),
+            modf(x.y, y.y),
+            modf(x.z, y.z),
+            modf(x.w, y.w));
+    }
+
+	//// Only valid if (INT_MIN <= x-y <= INT_MAX)
+	//// min(x,y)
+	//r = y + ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT – 1)));
+	//// max(x,y)
+	//r = x - ((x - y) & ((x - y) >> (sizeof(int) *
+	//CHAR_BIT - 1)));
+
+    // min
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType min
+	(
+		genType const & x, 
+		genType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(
+			detail::type<genType>::is_float || 
+			detail::type<genType>::is_int ||
+			detail::type<genType>::is_uint, "'min' only accept numbers");
+
+        return x < y ? x : y;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> min
+	(
+		detail::tvec2<T> const & x, 
+		typename detail::tvec2<T>::value_type const & y
+	)
+    {
+        return detail::tvec2<T>(
+            min(x.x, y),
+            min(x.y, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> min
+	(
+		detail::tvec3<T> const & x, 
+		typename detail::tvec3<T>::value_type const & y
+	)
+    {
+        return detail::tvec3<T>(
+            min(x.x, y),
+            min(x.y, y),
+            min(x.z, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> min
+	(
+		detail::tvec4<T> const & x, 
+		typename detail::tvec4<T>::value_type const & y
+	)
+    {
+        return detail::tvec4<T>(
+            min(x.x, y),
+            min(x.y, y),
+            min(x.z, y),
+            min(x.w, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> min
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+        return detail::tvec2<T>(
+            min(x.x, y.x),
+            min(x.y, y.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> min
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+        return detail::tvec3<T>(
+            min(x.x, y.x),
+            min(x.y, y.y),
+            min(x.z, y.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> min
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+        return detail::tvec4<T>(
+            min(x.x, y.x),
+            min(x.y, y.y),
+            min(x.z, y.z),
+            min(x.w, y.w));
+    }
+
+    // max
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType max
+	(
+		genType const & x, 
+		genType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(
+			detail::type<genType>::is_float || 
+			detail::type<genType>::is_int ||
+			detail::type<genType>::is_uint, "'max' only accept numbers");
+
+		return x > y ? x : y;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> max
+	(
+		detail::tvec2<T> const & x, 
+		typename detail::tvec2<T>::value_type y
+	)
+    {
+        return detail::tvec2<T>(
+            max(x.x, y),
+            max(x.y, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> max
+	(
+		detail::tvec3<T> const & x, 
+		typename detail::tvec3<T>::value_type y
+	)
+    {
+        return detail::tvec3<T>(
+            max(x.x, y),
+            max(x.y, y),
+            max(x.z, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> max
+	(
+		detail::tvec4<T> const & x, 
+		typename detail::tvec4<T>::value_type y
+	)
+    {
+        return detail::tvec4<T>(
+            max(x.x, y),
+            max(x.y, y),
+            max(x.z, y),
+            max(x.w, y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> max
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+        return detail::tvec2<T>(
+            max(x.x, y.x),
+            max(x.y, y.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> max
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+        return detail::tvec3<T>(
+            max(x.x, y.x),
+            max(x.y, y.y),
+            max(x.z, y.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> max
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y)
+    {
+        return detail::tvec4<T>(
+            max(x.x, y.x),
+            max(x.y, y.y),
+            max(x.z, y.z),
+            max(x.w, y.w));
+    }
+
+    // clamp
+    template <typename valType>
+    GLM_FUNC_QUALIFIER valType clamp
+	(
+		valType const & x, 
+		valType const & minVal, 
+		valType const & maxVal
+	)
+    {
+		GLM_STATIC_ASSERT(
+			detail::type<valType>::is_float || 
+			detail::type<valType>::is_int ||
+			detail::type<valType>::is_uint, "'clamp' only accept numbers");
+		
+		// Old implementation, less predictable branching
+		//if(x >= maxVal) return maxVal; 
+        //if(x <= minVal) return minVal;
+	    //return x;
+		return glm::max(glm::min(x, maxVal), minVal);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
+	(
+		detail::tvec2<T> const & x, 
+		typename detail::tvec2<T>::value_type const & minVal, 
+		typename detail::tvec2<T>::value_type const & maxVal
+	)
+    {
+        return detail::tvec2<T>(
+            clamp(x.x, minVal, maxVal),
+            clamp(x.y, minVal, maxVal));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
+	(
+		detail::tvec3<T> const & x, 
+		typename detail::tvec3<T>::value_type const & minVal, 
+		typename detail::tvec3<T>::value_type const & maxVal
+	)
+    {
+        return detail::tvec3<T>(
+            clamp(x.x, minVal, maxVal),
+            clamp(x.y, minVal, maxVal),
+            clamp(x.z, minVal, maxVal));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
+	(
+		detail::tvec4<T> const & x, 
+		typename detail::tvec4<T>::value_type const & minVal, 
+		typename detail::tvec4<T>::value_type const & maxVal
+	)
+    {
+        return detail::tvec4<T>(
+            clamp(x.x, minVal, maxVal),
+            clamp(x.y, minVal, maxVal),
+            clamp(x.z, minVal, maxVal),
+            clamp(x.w, minVal, maxVal));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & minVal, 
+		detail::tvec2<T> const & maxVal
+	)
+    {
+        return detail::tvec2<T>(
+            clamp(x.x, minVal.x, maxVal.x),
+            clamp(x.y, minVal.y, maxVal.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & minVal, 
+		detail::tvec3<T> const & maxVal
+	)
+    {
+        return detail::tvec3<T>(
+            clamp(x.x, minVal.x, maxVal.x),
+            clamp(x.y, minVal.y, maxVal.y),
+            clamp(x.z, minVal.z, maxVal.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & minVal, 
+		detail::tvec4<T> const & maxVal
+	)
+    {
+        return detail::tvec4<T>(
+            clamp(x.x, minVal.x, maxVal.x),
+            clamp(x.y, minVal.y, maxVal.y),
+            clamp(x.z, minVal.z, maxVal.z),
+            clamp(x.w, minVal.w, maxVal.w));
+    }
+
+	// mix
+	template <typename genTypeT, typename genTypeU>
+	GLM_FUNC_QUALIFIER genTypeT mix
+	(
+		genTypeT const & x, 
+		genTypeT const & y, 
+		genTypeU const & a
+	)
+	{
+		// It could be a vector too
+		//GLM_STATIC_ASSERT(
+		//	detail::type<genTypeT>::is_float && 
+		//	detail::type<genTypeU>::is_float);
+
+		//return x + a * (y - x);
+		return genTypeT(genTypeU(x) + a * genTypeU(y - x));
+	}
+
+	template <typename valTypeA, typename valTypeB>
+	GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix
+	(
+		detail::tvec2<valTypeA> const & x, 
+		detail::tvec2<valTypeA> const & y, 
+		valTypeB const & a
+	)
+	{
+		return detail::tvec2<valTypeA>(
+			detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x));
+	}
+
+	template <typename valTypeA, typename valTypeB>
+	GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix
+	(
+		detail::tvec3<valTypeA> const & x, 
+		detail::tvec3<valTypeA> const & y, 
+		valTypeB const & a
+	)
+	{
+		return detail::tvec3<valTypeA>(
+			detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x));
+	}
+
+	template <typename valTypeA, typename valTypeB>
+	GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix
+	(
+		detail::tvec4<valTypeA> const & x, 
+		detail::tvec4<valTypeA> const & y, 
+		valTypeB const & a
+	)
+	{
+		return detail::tvec4<valTypeA>(
+			detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x));
+	}
+
+	template <typename valTypeA, typename valTypeB>
+	GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix
+	(
+		detail::tvec2<valTypeA> const & x, 
+		detail::tvec2<valTypeA> const & y, 
+		detail::tvec2<valTypeB> const & a
+	)
+	{
+		return detail::tvec2<valTypeA>(
+			detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x));
+	}
+
+	template <typename valTypeA, typename valTypeB>
+	GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix
+	(
+		detail::tvec3<valTypeA> const & x, 
+		detail::tvec3<valTypeA> const & y, 
+		detail::tvec3<valTypeB> const & a
+	)
+	{
+		return detail::tvec3<valTypeA>(
+			detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x));
+	}
+
+	template <typename valTypeA, typename valTypeB>
+	GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix
+	(
+		detail::tvec4<valTypeA> const & x, 
+		detail::tvec4<valTypeA> const & y, 
+		detail::tvec4<valTypeB> const & a
+	)
+	{
+		return detail::tvec4<valTypeA>(
+			detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x));
+	}
+
+	//template <typename genTypeT>
+	//GLM_FUNC_QUALIFIER genTypeT mix
+	//(
+	//	genTypeT const & x, 
+	//	genTypeT const & y, 
+	//	float const & a
+	//)
+	//{
+	//	// It could be a vector too
+	//	//GLM_STATIC_ASSERT(
+	//	//	detail::type<genTypeT>::is_float && 
+	//	//	detail::type<genTypeU>::is_float);
+
+	//	return x + a * (y - x);
+	//}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType mix
+	(
+		genType const & x, 
+		genType const & y, 
+		bool a
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
+
+		return a ? x : y;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> mix
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y, 
+		typename detail::tvec2<T>::bool_type a
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
+
+		detail::tvec2<T> result;
+		for
+		(
+			typename detail::tvec2<T>::size_type i = 0; 
+			i < detail::tvec2<T>::value_size(); 
+			++i
+		)
+		{
+			result[i] = a[i] ? x[i] : y[i];
+		}
+		return result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> mix
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y, 
+		typename detail::tvec3<T>::bool_type a
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
+
+		detail::tvec3<T> result;
+		for
+		(
+			typename detail::tvec3<T>::size_type i = 0; 
+			i < detail::tvec3<T>::value_size(); 
+			++i
+		)
+		{
+			result[i] = a[i] ? x[i] : y[i];
+		}
+		return result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> mix
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y, 
+		typename detail::tvec4<T>::bool_type a
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
+
+		detail::tvec4<T> result;
+		for
+		(
+			typename detail::tvec4<T>::size_type i = 0; 
+			i < detail::tvec4<T>::value_size(); 
+			++i
+		)
+		{
+			result[i] = a[i] ? x[i] : y[i];
+		}
+		return result;
+	}
+
+	// step
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType step
+	(
+		genType const & edge, 
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
+
+        return x <= edge ? genType(0) : genType(1);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> step
+	(
+		typename detail::tvec2<T>::value_type const & edge, 
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            x.x <= edge ? T(0) : T(1),
+            x.y <= edge ? T(0) : T(1));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> step
+	(
+		typename detail::tvec3<T>::value_type const & edge, 
+		detail::tvec3<T> const & x
+	)
+    {
+		return detail::tvec3<T>(
+			x.x <= edge ? T(0) : T(1),
+			x.y <= edge ? T(0) : T(1),
+			x.z <= edge ? T(0) : T(1));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> step
+	(
+		typename detail::tvec4<T>::value_type const & edge, 
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            x.x <= edge ? T(0) : T(1),
+            x.y <= edge ? T(0) : T(1),
+            x.z <= edge ? T(0) : T(1),
+            x.w <= edge ? T(0) : T(1));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> step
+	(
+		detail::tvec2<T> const & edge, 
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            x.x <= edge.x ? T(0) : T(1),
+            x.y <= edge.y ? T(0) : T(1));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> step
+	(
+		detail::tvec3<T> const & edge, 
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            x.x <= edge.x ? T(0) : T(1),
+            x.y <= edge.y ? T(0) : T(1),
+            x.z <= edge.z ? T(0) : T(1));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> step
+	(
+		detail::tvec4<T> const & edge, 
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            x.x <= edge.x ? T(0) : T(1),
+            x.y <= edge.y ? T(0) : T(1),
+            x.z <= edge.z ? T(0) : T(1),
+            x.w <= edge.w ? T(0) : T(1));
+    }
+
+    // smoothstep
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType smoothstep
+	(
+		genType const & edge0, 
+		genType const & edge1, 
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
+
+        genType tmp = clamp((x - edge0) / (edge1 - edge0), genType(0), genType(1));
+        return tmp * tmp * (genType(3) - genType(2) * tmp);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep
+	(
+		typename detail::tvec2<T>::value_type const & edge0, 
+		typename detail::tvec2<T>::value_type const & edge1, 
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            smoothstep(edge0, edge1, x.x),
+            smoothstep(edge0, edge1, x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep
+	(
+		typename detail::tvec3<T>::value_type const & edge0, 
+		typename detail::tvec3<T>::value_type const & edge1, 
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            smoothstep(edge0, edge1, x.x),
+            smoothstep(edge0, edge1, x.y),
+            smoothstep(edge0, edge1, x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep
+	(
+		typename detail::tvec4<T>::value_type const & edge0, 
+		typename detail::tvec4<T>::value_type const & edge1, 
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            smoothstep(edge0, edge1, x.x),
+            smoothstep(edge0, edge1, x.y),
+            smoothstep(edge0, edge1, x.z),
+            smoothstep(edge0, edge1, x.w));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> smoothstep
+	(
+		detail::tvec2<T> const & edge0, 
+		detail::tvec2<T> const & edge1, 
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            smoothstep(edge0.x, edge1.x, x.x),
+            smoothstep(edge0.y, edge1.y, x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> smoothstep
+	(
+		detail::tvec3<T> const & edge0, 
+		detail::tvec3<T> const & edge1, 
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            smoothstep(edge0.x, edge1.x, x.x),
+            smoothstep(edge0.y, edge1.y, x.y),
+            smoothstep(edge0.z, edge1.z, x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> smoothstep
+	(
+		detail::tvec4<T> const & edge0, 
+		detail::tvec4<T> const & edge1, 
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            smoothstep(edge0.x, edge1.x, x.x),
+            smoothstep(edge0.y, edge1.y, x.y),
+            smoothstep(edge0.z, edge1.z, x.z),
+            smoothstep(edge0.w, edge1.w, x.w));
+    }
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER typename genType::bool_type isnan
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+		return typename genType::bool_type(_isnan(x));
+#else
+		return typename genType::bool_type(std::isnan(x));
+#endif
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isnan
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return typename detail::tvec2<T>::bool_type(
+            isnan(x.x),
+            isnan(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isnan
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return typename detail::tvec3<T>::bool_type(
+            isnan(x.x),
+            isnan(x.y),
+            isnan(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isnan
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return typename detail::tvec4<T>::bool_type(
+            isnan(x.x),
+            isnan(x.y),
+            isnan(x.z),
+            isnan(x.w));
+    }
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER typename genType::bool_type isinf
+	(
+		genType const & x
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isinf' only accept floating-point inputs");
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+		return typename genType::bool_type(_fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF);
+#else
+		return typename genType::bool_type(std::isinf(x));
+#endif
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec2<T>::bool_type isinf
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return typename detail::tvec2<T>::bool_type(
+            isnan(x.x),
+            isnan(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::bool_type isinf
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return typename detail::tvec3<T>::bool_type(
+            isnan(x.x),
+            isnan(x.y),
+            isnan(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::bool_type isinf
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return typename detail::tvec4<T>::bool_type(
+            isnan(x.x),
+            isnan(x.y),
+            isnan(x.z),
+            isnan(x.w));
+    }
+
+	GLM_FUNC_QUALIFIER int floatBitsToInt(float const & value)
+	{
+		union
+		{
+			float f;
+			int i;
+		} fi;
+
+		fi.f = value;
+		return fi.i;
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<int> floatBitsToInt
+	(
+		detail::tvec2<T> const & value
+	)
+    {
+        return detail::tvec2<T>(
+            floatBitsToInt(value.x),
+            floatBitsToInt(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<int> floatBitsToInt
+	(
+		detail::tvec3<T> const & value
+	)
+    {
+        return detail::tvec3<T>(
+            floatBitsToInt(value.x),
+            floatBitsToInt(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<int> floatBitsToInt
+	(
+		detail::tvec4<T> const & value
+	)
+    {
+        return detail::tvec4<T>(
+            floatBitsToInt(value.x),
+            floatBitsToInt(value.y));
+    }
+
+	GLM_FUNC_QUALIFIER uint floatBitsToUint(float const & value)
+	{
+		union
+		{
+			float f;
+			uint u;
+		} fu;
+
+		fu.f = value;
+		return fu.u;
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<uint> floatBitsToUint
+	(
+		detail::tvec2<T> const & value
+	)
+    {
+        return detail::tvec2<T>(
+            floatBitsToUint(value.x),
+            floatBitsToUint(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<uint> floatBitsToUint
+	(
+		detail::tvec3<T> const & value
+	)
+    {
+        return detail::tvec3<T>(
+            floatBitsToUint(value.x),
+            floatBitsToUint(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<uint> floatBitsToUint
+	(
+		detail::tvec4<T> const & value
+	)
+    {
+        return detail::tvec4<T>(
+            floatBitsToUint(value.x),
+            floatBitsToUint(value.y));
+    }
+
+	GLM_FUNC_QUALIFIER float intBitsToFloat(int const & value)
+	{
+		union
+		{
+			float f;
+			int i;
+		} fi;
+
+		fi.i = value;
+		return fi.f;
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<float> intBitsToFloat
+	(
+		detail::tvec2<T> const & value
+	)
+    {
+        return detail::tvec2<T>(
+            intBitsToFloat(value.x),
+            intBitsToFloat(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<float> intBitsToFloat
+	(
+		detail::tvec3<T> const & value
+	)
+    {
+        return detail::tvec3<T>(
+            intBitsToFloat(value.x),
+            intBitsToFloat(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<float> intBitsToFloat
+	(
+		detail::tvec4<T> const & value
+	)
+    {
+        return detail::tvec4<T>(
+            intBitsToFloat(value.x),
+            intBitsToFloat(value.y));
+    }
+
+    GLM_FUNC_QUALIFIER float uintBitsToFloat(uint const & value)
+    {
+        union
+        {
+            float f;
+            uint u;
+        } fu;
+
+        fu.u = value;
+        return fu.f;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<float> uintBitsToFloat
+	(
+		detail::tvec2<T> const & value
+	)
+    {
+        return detail::tvec2<T>(
+            uintBitsToFloat(value.x),
+            uintBitsToFloat(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<float> uintBitsToFloat
+	(
+		detail::tvec3<T> const & value
+	)
+    {
+        return detail::tvec3<T>(
+            uintBitsToFloat(value.x),
+            uintBitsToFloat(value.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<float> uintBitsToFloat
+	(
+		detail::tvec4<T> const & value
+	)
+    {
+        return detail::tvec4<T>(
+            uintBitsToFloat(value.x),
+            uintBitsToFloat(value.y));
+    }
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType fma
+	(
+		genType const & a, 
+		genType const & b, 
+		genType const & c
+	)
+	{
+		return a * b + c;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType frexp
+	(
+		genType const & x, 
+		int & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> frexp
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<int> & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> frexp
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<int> & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> frexp
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<int> & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType ldexp
+	(
+		genType const & x, 
+		int const & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> ldexp
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<int> const & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> ldexp
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<int> const & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> ldexp
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<int> const & exp
+	)
+	{
+		return std::frexp(x, exp);
+	}
+
+	}//namespace common
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_exponential.hpp b/ExternalLibs/glm/core/func_exponential.hpp
new file mode 100644
index 0000000..7871397
--- /dev/null
+++ b/ExternalLibs/glm/core/func_exponential.hpp
@@ -0,0 +1,90 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-08
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_exponential.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_exponential
+#define glm_core_func_exponential
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_exponential();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace exponential{
+
+	/// \addtogroup core_funcs
+	///@{
+
+	//! Returns x raised to the y power. 
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/pow.xml">GLSL pow man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType pow(genType const & x, genType const & y);
+
+	//! Returns the natural exponentiation of x, i.e., e^x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType exp(genType const & x);
+
+	//! Returns the natural logarithm of x, i.e., 
+	//! returns the value y which satisfies the equation x = e^y. 
+	//! Results are undefined if x <= 0.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType log(genType const & x);
+
+	//! Returns 2 raised to the x power.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType exp2(genType const & x);
+
+	//! Returns the base 2 log of x, i.e., returns the value y, 
+	//! which satisfies the equation x = 2 ^ y.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType log2(genType const & x);
+
+	//! Returns the positive square root of x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType sqrt(genType const & x);
+    
+	//! Returns the reciprocal of the positive square root of x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.2
+	template <typename genType> 
+	genType inversesqrt(genType const & x);
+
+	///@}
+
+	}//namespace exponential
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::exponential;
+}//namespace glm
+
+#include "func_exponential.inl"
+
+#endif//glm_core_func_exponential
diff --git a/ExternalLibs/glm/core/func_exponential.inl b/ExternalLibs/glm/core/func_exponential.inl
new file mode 100644
index 0000000..d3bc59e
--- /dev/null
+++ b/ExternalLibs/glm/core/func_exponential.inl
@@ -0,0 +1,358 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_exponential.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace exponential{
+
+    // pow
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType pow
+	(
+		genType const & x, 
+		genType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'pow' only accept floating-point input");
+
+        return ::std::pow(x, y);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> pow
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+        return detail::tvec2<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> pow
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+        return detail::tvec3<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y),
+            pow(x.z, y.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> pow
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+        return detail::tvec4<T>(
+            pow(x.x, y.x),
+            pow(x.y, y.y),
+            pow(x.z, y.z),
+            pow(x.w, y.w));
+    }
+
+    // exp
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType exp
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp' only accept floating-point input");
+
+        return ::std::exp(x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> exp
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            exp(x.x),
+            exp(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> exp
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            exp(x.x),
+            exp(x.y),
+            exp(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> exp
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            exp(x.x),
+            exp(x.y),
+            exp(x.z),
+            exp(x.w));
+    }
+
+    // log
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType log
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log' only accept floating-point input");
+
+        return ::std::log(x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> log
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            log(x.x),
+            log(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> log
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            log(x.x),
+            log(x.y),
+            log(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> log
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            log(x.x),
+            log(x.y),
+            log(x.z),
+            log(x.w));
+    }
+
+    //exp2, ln2 = 0.69314718055994530941723212145818f
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType exp2
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'exp2' only accept floating-point input");
+
+        return ::std::exp(genType(0.69314718055994530941723212145818) * x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> exp2
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            exp2(x.x),
+            exp2(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> exp2
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            exp2(x.x),
+            exp2(x.y),
+            exp2(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> exp2
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            exp2(x.x),
+            exp2(x.y),
+            exp2(x.z),
+            exp2(x.w));
+    }
+
+    // log2, ln2 = 0.69314718055994530941723212145818f
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType log2
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'log2' only accept floating-point input");
+
+        return ::std::log(x) / genType(0.69314718055994530941723212145818);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> log2
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            log2(x.x),
+            log2(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> log2
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            log2(x.x),
+            log2(x.y),
+            log2(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> log2
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            log2(x.x),
+            log2(x.y),
+            log2(x.z),
+            log2(x.w));
+    }
+
+    // sqrt
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType sqrt
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sqrt' only accept floating-point input");
+
+        return genType(::std::sqrt(x));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> sqrt
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            sqrt(x.x),
+            sqrt(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> sqrt
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            sqrt(x.x),
+            sqrt(x.y),
+            sqrt(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> sqrt
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            sqrt(x.x),
+            sqrt(x.y),
+            sqrt(x.z),
+            sqrt(x.w));
+    }
+
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType inversesqrt
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'inversesqrt' only accept floating-point input");
+
+        return genType(1) / ::std::sqrt(x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> inversesqrt
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            inversesqrt(x.x),
+            inversesqrt(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> inversesqrt
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            inversesqrt(x.x),
+            inversesqrt(x.y),
+            inversesqrt(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> inversesqrt
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            inversesqrt(x.x),
+            inversesqrt(x.y),
+            inversesqrt(x.z),
+            inversesqrt(x.w));
+    }
+
+	}//namespace exponential
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_geometric.hpp b/ExternalLibs/glm/core/func_geometric.hpp
new file mode 100644
index 0000000..c82d104
--- /dev/null
+++ b/ExternalLibs/glm/core/func_geometric.hpp
@@ -0,0 +1,113 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_geometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_geometric
+#define glm_core_func_geometric
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_geometric();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace geometric{
+
+	/// \addtogroup core_funcs
+	///@{
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/length.xml">GLSL length man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+	template <typename genType> 
+	typename genType::value_type length(
+		genType const & x); 
+
+	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/distance.xml">GLSL distance man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+	template <typename genType> 
+	typename genType::value_type distance(
+		genType const & p0, 
+		genType const & p1);
+
+	//! Returns the dot product of x and y, i.e., result = x * y.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/dot.xml">GLSL dot man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+    template <typename genType> 
+	typename genType::value_type dot(
+		genType const & x, 
+		genType const & y);
+
+	//! Returns the cross product of x and y.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cross.xml">GLSL cross man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+    template <typename T> 
+	detail::tvec3<T> cross(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y);
+
+	//! Returns a vector in the same direction as x but with length of 1.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/normalize.xml">GLSL normalize man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+	template <typename genType> 
+	genType normalize(
+		genType const & x);
+
+	//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/faceforward.xml">GLSL faceforward man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+    template <typename genType> 
+	genType faceforward(
+		genType const & N, 
+		genType const & I, 
+		genType const & Nref);
+  
+	//! For the incident vector I and surface orientation N, 
+	//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/reflect.xml">GLSL reflect man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+    template <typename genType> 
+	genType reflect(
+		genType const & I, 
+		genType const & N);
+  
+	//! For the incident vector I and surface normal N, 
+	//! and the ratio of indices of refraction eta, 
+	//! return the refraction vector.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/refract.xml">GLSL refract man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.4
+    template <typename genType> 
+	genType refract(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta);
+
+	///@}
+
+	}//namespace geometric
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::geometric;
+}//namespace glm
+
+#include "func_geometric.inl"
+
+#endif//glm_core_func_geometric
diff --git a/ExternalLibs/glm/core/func_geometric.inl b/ExternalLibs/glm/core/func_geometric.inl
new file mode 100644
index 0000000..086b522
--- /dev/null
+++ b/ExternalLibs/glm/core/func_geometric.inl
@@ -0,0 +1,290 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_geometric.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace geometric{
+
+    // length
+    template <typename genType>
+	GLM_FUNC_QUALIFIER genType length
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'length' only accept floating-point inputs");
+
+        genType sqr = x * x;
+        return sqrt(sqr);
+    }
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type length
+	(
+		detail::tvec2<T> const & v
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
+
+        typename detail::tvec2<T>::value_type sqr = v.x * v.x + v.y * v.y;
+        return sqrt(sqr);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type length
+	(
+		detail::tvec3<T> const & v
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
+
+        typename detail::tvec3<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z;
+        return sqrt(sqr);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type length
+	(
+		detail::tvec4<T> const & v
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'length' only accept floating-point inputs");
+
+        typename detail::tvec4<T>::value_type sqr = v.x * v.x + v.y * v.y + v.z * v.z + v.w * v.w;
+        return sqrt(sqr);
+    }
+
+    // distance
+	template <typename genType>
+    GLM_FUNC_QUALIFIER genType distance
+	(
+		genType const & p0, 
+		genType const & p1
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+    }
+ 
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type distance
+	(
+		detail::tvec2<T> const & p0,
+		detail::tvec2<T> const & p1
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
+
+        return length(p1 - p0);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec3<T>::value_type distance
+	(
+		detail::tvec3<T> const & p0,
+		detail::tvec3<T> const & p1
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename detail::tvec4<T>::value_type distance
+	(
+		detail::tvec4<T> const & p0,
+		detail::tvec4<T> const & p1
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'distance' only accept floating-point inputs");
+
+		return length(p1 - p0);
+    }
+
+	// dot
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType dot
+	(
+		genType const & x, 
+		genType const & y
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'dot' only accept floating-point inputs");
+
+		return x * y;
+	}
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tvec2<T>::value_type dot
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
+
+		return x.x * y.x + x.y * y.y;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T dot
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
+
+		return x.x * y.x + x.y * y.y + x.z * y.z;
+    }
+/* // SSE3
+    GLM_FUNC_QUALIFIER float dot(const tvec4<float>& x, const tvec4<float>& y)
+    {
+	    float Result;
+	    __asm
+        {
+		    mov		esi, x
+		    mov		edi, y
+		    movaps	xmm0, [esi]
+		    mulps	xmm0, [edi]
+		    haddps(	_xmm0, _xmm0 )
+		    haddps(	_xmm0, _xmm0 )
+		    movss	Result, xmm0
+	    }
+	    return Result;
+    }
+*/
+    template <typename T>
+    GLM_FUNC_QUALIFIER T dot
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'dot' only accept floating-point inputs");
+
+        return x.x * y.x + x.y * y.y + x.z * y.z + x.w * y.w;
+    }
+
+    // cross
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> cross
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'cross' only accept floating-point inputs");
+
+        return detail::tvec3<T>(
+            x.y * y.z - y.y * x.z,
+            x.z * y.x - y.z * x.x,
+            x.x * y.y - y.x * x.y);
+    }
+
+    // normalize
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType normalize
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'normalize' only accept floating-point inputs");
+
+        return x < genType(0) ? genType(-1) : genType(1);
+    }
+
+    // According to issue 10 GLSL 1.10 specification, if length(x) == 0 then result is undefine and generate an error
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> normalize
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
+		
+		typename detail::tvec2<T>::value_type sqr = x.x * x.x + x.y * x.y;
+	    return x * inversesqrt(sqr);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> normalize
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
+
+		typename detail::tvec3<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+	    return x * inversesqrt(sqr);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> normalize
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<T>::is_float, "'normalize' only accept floating-point inputs");
+		
+		typename detail::tvec4<T>::value_type sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+	    return x * inversesqrt(sqr);
+    }
+
+    // faceforward
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType faceforward
+	(
+		genType const & N, 
+		genType const & I, 
+		genType const & Nref
+	)
+	{
+		return dot(Nref, I) < 0 ? N : -N;
+	}
+
+	// reflect
+	template <typename genType>
+	genType reflect
+	(
+		genType const & I, 
+		genType const & N
+	)
+	{
+		return I - N * dot(N, I) * float(2);
+	}
+
+    // refract
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType refract
+	(
+		genType const & I, 
+		genType const & N, 
+		typename genType::value_type const & eta
+	)
+    {
+		//It could be a vector
+		//GLM_STATIC_ASSERT(detail::type<genType>::is_float);
+
+        typename genType::value_type dotValue = dot(N, I);
+        typename genType::value_type k = typename genType::value_type(1) - eta * eta * (typename genType::value_type(1) - dotValue * dotValue);
+        if(k < typename genType::value_type(0))
+            return genType(0);
+        else
+            return eta * I - (eta * dotValue + sqrt(k)) * N;
+    }
+
+	}//namespace geometric
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_integer.hpp b/ExternalLibs/glm/core/func_integer.hpp
new file mode 100644
index 0000000..b411b58
--- /dev/null
+++ b/ExternalLibs/glm/core/func_integer.hpp
@@ -0,0 +1,162 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-31
+// Licence : This source is under MIT License
+// File    : glm/core/func_integer.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_integer
+#define glm_core_func_integer
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_integer();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification. 
+	namespace integer{
+
+		/// \addtogroup core_funcs
+		///@{
+
+		//! Adds 32-bit unsigned integer x and y, returning the sum
+		//! modulo pow(2, 32). The value carry is set to 0 if the sum was
+		//! less than pow(2, 32), or to 1 otherwise.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genUType>
+		genUType uaddCarry(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & carry);
+
+		//! Subtracts the 32-bit unsigned integer y from x, returning
+		//! the difference if non-negative, or pow(2, 32) plus the difference
+		//! otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genUType>
+		genUType usubBorrow(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & borrow);
+		
+		//! Multiplies 32-bit integers x and y, producing a 64-bit
+		//! result. The 32 least-significant bits are returned in lsb.
+		//! The 32 most-significant bits are returned in msb.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genUType>
+		void umulExtended(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & msb, 
+			genUType & lsb);
+		
+		//! Multiplies 32-bit integers x and y, producing a 64-bit
+		//! result. The 32 least-significant bits are returned in lsb.
+		//! The 32 most-significant bits are returned in msb.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genIType>
+		void imulExtended(
+			genIType const & x, 
+			genIType const & y, 
+			genIType & msb, 
+			genIType & lsb);
+
+		//! Extracts bits [offset, offset + bits - 1] from value,
+		//! returning them in the least significant bits of the result.
+		//! For unsigned data types, the most significant bits of the
+		//! result will be set to zero. For signed data types, the
+		//! most significant bits will be set to the value of bit offset + base – 1.
+		//!
+		//! If bits is zero, the result will be zero. The result will be
+		//! undefined if offset or bits is negative, or if the sum of
+		//! offset and bits is greater than the number of bits used
+		//! to store the operand.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genIUType>
+		genIUType bitfieldExtract(
+			genIUType const & Value, 
+			int const & Offset, 
+			int const & Bits);
+
+		//! Returns the insertion the bits least-significant bits of insert into base.
+		//!
+		//! The result will have bits [offset, offset + bits - 1] taken
+		//! from bits [0, bits – 1] of insert, and all other bits taken
+		//! directly from the corresponding bits of base. If bits is
+		//! zero, the result will simply be base. The result will be
+		//! undefined if offset or bits is negative, or if the sum of
+		//! offset and bits is greater than the number of bits used to
+		//! store the operand.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genIUType>
+		genIUType bitfieldInsert(
+			genIUType const & Base, 
+			genIUType const & Insert, 
+			int const & Offset, 
+			int const & Bits);
+
+		//! Returns the reversal of the bits of value. 
+		//! The bit numbered n of the result will be taken from bit (bits - 1) - n of value, 
+		//! where bits is the total number of bits used to represent value.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename genIUType>
+		genIUType bitfieldReverse(genIUType const & value);
+		
+		//! Returns the number of bits set to 1 in the binary representation of value.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename T, template <typename> class C>
+		typename C<T>::signed_type bitCount(C<T> const & Value);
+
+		//! Returns the bit number of the least significant bit set to
+		//! 1 in the binary representation of value. 
+		//! If value is zero, -1 will be returned.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename T, template <typename> class C>
+		typename C<T>::signed_type findLSB(C<T> const & Value);
+
+		//! Returns the bit number of the most significant bit in the binary representation of value.
+		//! For positive integers, the result will be the bit number of the most significant bit set to 1. 
+		//! For negative integers, the result will be the bit number of the most significant
+		//! bit set to 0. For a value of zero or negative one, -1 will be returned.
+		//!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.8
+		template <typename T, template <typename> class C>
+		typename C<T>::signed_type findMSB(C<T> const & Value);
+
+		///@}
+
+	}//namespace integer
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::integer;
+}//namespace glm
+
+#include "func_integer.inl"
+
+#endif//glm_core_func_integer
+
diff --git a/ExternalLibs/glm/core/func_integer.inl b/ExternalLibs/glm/core/func_integer.inl
new file mode 100644
index 0000000..0e30aa2
--- /dev/null
+++ b/ExternalLibs/glm/core/func_integer.inl
@@ -0,0 +1,597 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-31
+// Licence : This source is under MIT License
+// File    : glm/core/func_integer.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		
+	}//namespace detail
+
+	namespace core{
+	namespace function{
+	namespace integer
+	{
+		// uaddCarry
+		template <typename genUType>
+		GLM_FUNC_QUALIFIER genUType uaddCarry
+		(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & Carry
+		)
+		{
+			detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
+			genUType Result = genUType(Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
+			Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32))) > 1 ? 1 : 0;
+			return Result;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> uaddCarry
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & Carry
+		)
+		{
+			return detail::tvec2<T>(
+				uaddCarry(x[0], y[0], Carry[0]),
+				uaddCarry(x[1], y[1], Carry[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> uaddCarry
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & Carry
+		)
+		{
+			return detail::tvec3<T>(
+				uaddCarry(x[0], y[0], Carry[0]),
+				uaddCarry(x[1], y[1], Carry[1]),
+				uaddCarry(x[2], y[2], Carry[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> uaddCarry
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & Carry
+		)
+		{
+			return detail::tvec4<T>(
+				uaddCarry(x[0], y[0], Carry[0]),
+				uaddCarry(x[1], y[1], Carry[1]),
+				uaddCarry(x[2], y[2], Carry[2]),
+				uaddCarry(x[3], y[3], Carry[3]));
+		}
+
+		// usubBorrow
+		template <typename genUType>
+		GLM_FUNC_QUALIFIER genUType usubBorrow
+		(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & Borrow
+		)
+		{
+			Borrow = x >= y ? 0 : 1;
+			if(x > y)
+				return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
+			else
+				return genUType(detail::highp_int_t(1) << detail::highp_int_t(32) + detail::highp_int_t(x) - detail::highp_int_t(y));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> usubBorrow
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & Borrow
+		)
+		{
+			return detail::tvec2<T>(
+				usubBorrow(x[0], y[0], Borrow[0]),
+				usubBorrow(x[1], y[1], Borrow[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> usubBorrow
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & Borrow
+		)
+		{
+			return detail::tvec3<T>(
+				usubBorrow(x[0], y[0], Borrow[0]),
+				usubBorrow(x[1], y[1], Borrow[1]),
+				usubBorrow(x[2], y[2], Borrow[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> usubBorrow
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & Borrow
+		)
+		{
+			return detail::tvec4<T>(
+				usubBorrow(x[0], y[0], Borrow[0]),
+				usubBorrow(x[1], y[1], Borrow[1]),
+				usubBorrow(x[2], y[2], Borrow[2]),
+				usubBorrow(x[3], y[3], Borrow[3]));
+		}
+
+		// umulExtended
+		template <typename genUType>
+		GLM_FUNC_QUALIFIER void umulExtended
+		(
+			genUType const & x, 
+			genUType const & y, 
+			genUType & msb, 
+			genUType & lsb
+		)
+		{
+			detail::highp_uint_t ValueX64 = x;
+			detail::highp_uint_t ValueY64 = y;
+			detail::highp_uint_t Value64 = ValueX64 * ValueY64;
+			msb = *(genUType*)&genUType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
+			lsb = *(genUType*)&genUType(Value64 >> detail::highp_uint_t(32));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> umulExtended
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & msb, 
+			detail::tvec2<T> & lsb
+		)
+		{
+			return detail::tvec2<T>(
+				umulExtended(x[0], y[0], msb, lsb),
+				umulExtended(x[1], y[1], msb, lsb));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> umulExtended
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & msb, 
+			detail::tvec3<T> & lsb
+		)
+		{
+			return detail::tvec3<T>(
+				umulExtended(x[0], y[0], msb, lsb),
+				umulExtended(x[1], y[1], msb, lsb),
+				umulExtended(x[2], y[2], msb, lsb));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> umulExtended
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & msb, 
+			detail::tvec4<T> & lsb
+		)
+		{
+			return detail::tvec4<T>(
+				umulExtended(x[0], y[0], msb, lsb),
+				umulExtended(x[1], y[1], msb, lsb),
+				umulExtended(x[2], y[2], msb, lsb),
+				umulExtended(x[3], y[3], msb, lsb));
+		}
+
+		// imulExtended
+		template <typename genIType>
+		GLM_FUNC_QUALIFIER void imulExtended
+		(
+			genIType const & x, 
+			genIType const & y, 
+			genIType & msb, 
+			genIType & lsb
+		)
+		{
+			detail::highp_int_t ValueX64 = x;
+			detail::highp_int_t ValueY64 = y;
+			detail::highp_int_t Value64 = ValueX64 * ValueY64;
+			msb = *(genIType*)&genIType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
+			lsb = *(genIType*)&genIType(Value64 >> detail::highp_uint_t(32));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> imulExtended
+		(
+			detail::tvec2<T> const & x, 
+			detail::tvec2<T> const & y, 
+			detail::tvec2<T> & msb, 
+			detail::tvec2<T> & lsb
+		)
+		{
+			return detail::tvec2<T>(
+				imulExtended(x[0], y[0], msb, lsb),
+				imulExtended(x[1], y[1], msb, lsb));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> imulExtended
+		(
+			detail::tvec3<T> const & x, 
+			detail::tvec3<T> const & y, 
+			detail::tvec3<T> & msb, 
+			detail::tvec3<T> & lsb
+		)
+		{
+			return detail::tvec3<T>(
+				imulExtended(x[0], y[0], msb, lsb),
+				imulExtended(x[1], y[1], msb, lsb),
+				imulExtended(x[2], y[2], msb, lsb));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> imulExtended
+		(
+			detail::tvec4<T> const & x, 
+			detail::tvec4<T> const & y, 
+			detail::tvec4<T> & msb, 
+			detail::tvec4<T> & lsb
+		)
+		{
+			return detail::tvec4<T>(
+				imulExtended(x[0], y[0], msb, lsb),
+				imulExtended(x[1], y[1], msb, lsb),
+				imulExtended(x[2], y[2], msb, lsb),
+				imulExtended(x[3], y[3], msb, lsb));
+		}
+
+		// bitfieldExtract
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER genIUType bitfieldExtract
+		(
+			genIUType const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			int GenSize = int(sizeof(genIUType)) << int(3);
+
+			assert(Offset + Bits <= GenSize);
+
+			genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
+			genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
+
+			return ShiftBack;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldExtract
+		(
+			detail::tvec2<T> const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec2<T>(
+				bitfieldExtract(Value[0]),
+				bitfieldExtract(Value[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldExtract
+		(
+			detail::tvec3<T> const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec3<T>(
+				bitfieldExtract(Value[0]),
+				bitfieldExtract(Value[1]),
+				bitfieldExtract(Value[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldExtract
+		(
+			detail::tvec4<T> const & Value, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec4<T>(
+				bitfieldExtract(Value[0]),
+				bitfieldExtract(Value[1]),
+				bitfieldExtract(Value[2]),
+				bitfieldExtract(Value[3]));
+		}
+
+		// bitfieldInsert
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER genIUType bitfieldInsert
+		(
+			genIUType const & Base, 
+			genIUType const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+			assert(Offset + Bits <= sizeof(genIUType));
+
+			if(Bits == 0)
+				return Base;
+
+			genIUType Mask = 0;
+			for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
+				Mask |= (1 << Bit);
+
+			return (Base & ~Mask) | (Insert & Mask);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldInsert
+		(
+			detail::tvec2<T> const & Base, 
+			detail::tvec2<T> const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec2<T>(
+				bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+				bitfieldInsert(Base[1], Insert[1], Offset, Bits));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldInsert
+		(
+			detail::tvec3<T> const & Base, 
+			detail::tvec3<T> const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec3<T>(
+				bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+				bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+				bitfieldInsert(Base[2], Insert[2], Offset, Bits));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldInsert
+		(
+			detail::tvec4<T> const & Base, 
+			detail::tvec4<T> const & Insert, 
+			int const & Offset, 
+			int const & Bits
+		)
+		{
+			return detail::tvec4<T>(
+				bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+				bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+				bitfieldInsert(Base[2], Insert[2], Offset, Bits),
+				bitfieldInsert(Base[3], Insert[3], Offset, Bits));
+		}
+
+		// bitfieldReverse
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+
+			genIUType Out = 0;
+			std::size_t BitSize = sizeof(genIUType) * 8;
+			for(std::size_t i = 0; i < BitSize; ++i)
+				if(Value & (genIUType(1) << i))
+					Out |= genIUType(1) << (BitSize - 1 - i);
+			return Out;
+		}	
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldReverse
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<T>(
+				bitfieldReverse(value[0]),
+				bitfieldReverse(value[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldReverse
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<T>(
+				bitfieldReverse(value[0]),
+				bitfieldReverse(value[1]),
+				bitfieldReverse(value[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldReverse
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<T>(
+				bitfieldReverse(value[0]),
+				bitfieldReverse(value[1]),
+				bitfieldReverse(value[2]),
+				bitfieldReverse(value[3]));
+		}
+
+		// bitCount
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+
+			int Count = 0;
+			for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
+			{
+				if(Value & (1 << i))
+					++Count;
+			}
+			return Count;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<int> bitCount
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<int>(
+				bitCount(value[0]),
+				bitCount(value[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<int> bitCount
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<int>(
+				bitCount(value[0]),
+				bitCount(value[1]),
+				bitCount(value[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<int> bitCount
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<int>(
+				bitCount(value[0]),
+				bitCount(value[1]),
+				bitCount(value[2]),
+				bitCount(value[3]));
+		}
+
+		// findLSB
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int findLSB
+		(
+			genIUType const & Value
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+			if(Value == 0)
+				return -1;
+
+			genIUType Bit;
+			for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
+			return Bit;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<int> findLSB
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<int>(
+				findLSB(value[0]),
+				findLSB(value[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<int> findLSB
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<int>(
+				findLSB(value[0]),
+				findLSB(value[1]),
+				findLSB(value[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<int> findLSB
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<int>(
+				findLSB(value[0]),
+				findLSB(value[1]),
+				findLSB(value[2]),
+				findLSB(value[3]));
+		}
+
+		// findMSB
+		template <typename genIUType>
+		GLM_FUNC_QUALIFIER int findMSB
+		(
+			genIUType const & Value
+		)
+		{
+			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+			if(Value == 0)
+				return -1;
+
+			genIUType bit = genIUType(-1);
+			for(genIUType tmp = Value; tmp; tmp >>= 1, ++bit){}
+			return bit;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
+		(
+			detail::tvec2<T> const & value
+		)
+		{
+			return detail::tvec2<int>(
+				findMSB(value[0]),
+				findMSB(value[1]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec3<int> findMSB
+		(
+			detail::tvec3<T> const & value
+		)
+		{
+			return detail::tvec3<int>(
+				findMSB(value[0]),
+				findMSB(value[1]),
+				findMSB(value[2]));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER detail::tvec4<int> findMSB
+		(
+			detail::tvec4<T> const & value
+		)
+		{
+			return detail::tvec4<int>(
+				findMSB(value[0]),
+				findMSB(value[1]),
+				findMSB(value[2]),
+				findMSB(value[3]));
+		}
+
+	}//namespace integer
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_matrix.hpp b/ExternalLibs/glm/core/func_matrix.hpp
new file mode 100644
index 0000000..6a60b47
--- /dev/null
+++ b/ExternalLibs/glm/core/func_matrix.hpp
@@ -0,0 +1,115 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_matrix.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_matrix
+#define glm_core_func_matrix
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_matrix();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace matrix{
+
+	/// \addtogroup core_funcs
+	///@{
+
+	//! Multiply matrix x by matrix y component-wise, i.e., 
+	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/matrixCompMult.xml">GLSL matrixCompMult man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.5
+	template <typename matType> 
+	matType matrixCompMult(
+		matType const & x, 
+		matType const & y);
+
+	//! Treats the first parameter c as a column vector 
+	//! and the second parameter r as a row vector
+	//! and does a linear algebraic matrix multiply c * r.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.5	
+    template <typename vecType, typename matType> 
+	matType outerProduct(
+		vecType const & c, 
+		vecType const & r);
+
+	//! Returns the transposed matrix of x
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/transpose.xml">GLSL transpose man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.5	
+    template <typename matType> 
+	typename matType::transpose_type transpose(
+		matType const & x);
+	
+	//! Return the determinant of a mat2 matrix. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.5	
+	template <typename T> 
+	typename detail::tmat2x2<T>::value_type determinant(
+		detail::tmat2x2<T> const & m);
+
+	//! Return the determinant of a mat3 matrix. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.5	
+	template <typename T> 
+	typename detail::tmat3x3<T>::value_type determinant(
+		detail::tmat3x3<T> const & m);
+
+	//! Return the determinant of a mat4 matrix. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/determinant.xml">GLSL determinant man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.5		
+    template <typename T> 
+	typename detail::tmat4x4<T>::value_type determinant(
+		detail::tmat4x4<T> const & m);
+
+	//! Return the inverse of a mat2 matrix. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+    //! \li GLSL 1.40.07 specification, section 8.5	 
+	template <typename T> 
+	detail::tmat2x2<T> inverse(
+		detail::tmat2x2<T> const & m);
+
+	//! Return the inverse of a mat3 matrix. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+    //! \li GLSL 1.40.07 specification, section 8.5 
+	template <typename T> 
+	detail::tmat3x3<T> inverse(
+		detail::tmat3x3<T> const & m);
+
+	//! Return the inverse of a mat4 matrix. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inverse.xml">GLSL inverse man page</a>
+    //! \li GLSL 1.40.07 specification, section 8.5
+	template <typename T> 
+	detail::tmat4x4<T> inverse(
+		detail::tmat4x4<T> const & m);
+
+	///@}
+
+	}//namespace matrix
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::matrix;
+}//namespace glm
+
+#include "func_matrix.inl"
+
+#endif//glm_core_func_matrix
diff --git a/ExternalLibs/glm/core/func_matrix.inl b/ExternalLibs/glm/core/func_matrix.inl
new file mode 100644
index 0000000..d775d96
--- /dev/null
+++ b/ExternalLibs/glm/core/func_matrix.inl
@@ -0,0 +1,571 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-03-08
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/func_matrix.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace matrix{
+
+    // matrixCompMult
+    template <typename matType>
+    GLM_FUNC_QUALIFIER matType matrixCompMult
+	(
+		matType const & x, 
+		matType const & y
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float, "'matrixCompMult' only accept floating-point inputs");
+
+        matType result(matType::null);
+		for(typename matType::size_type i = 0; i < matType::col_size(); ++i)
+			result[i] = x[i] * y[i];
+        return result;
+    }
+
+	// outerProduct
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat2x2<T> outerProduct
+	(
+		detail::tvec2<T> const & c, 
+		detail::tvec2<T> const & r
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat2x2<T> m(detail::tmat2x2<T>::null);
+		m[0][0] = c[0] * r[0];
+		m[0][1] = c[1] * r[0];
+		m[1][0] = c[0] * r[1];
+		m[1][1] = c[1] * r[1];
+        return m;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> outerProduct
+	(
+		detail::tvec3<T> const & c, 
+		detail::tvec3<T> const & r
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
+		for(typename detail::tmat3x3<T>::size_type i = 0; i < detail::tmat3x3<T>::col_size(); ++i)
+			m[i] = c * r[i];
+        return m;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> outerProduct
+	(
+		detail::tvec4<T> const & c, 
+		detail::tvec4<T> const & r
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
+		for(typename detail::tmat4x4<T>::size_type i = 0; i < detail::tmat4x4<T>::col_size(); ++i)
+			m[i] = c * r[i];
+        return m;
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x3<T> outerProduct
+	(
+		detail::tvec3<T> const & c, 
+		detail::tvec2<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat2x3<T> m(detail::tmat2x3<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		return m;
+	}
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x2<T> outerProduct
+	(
+		detail::tvec2<T> const & c, 
+		detail::tvec3<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat3x2<T> m(detail::tmat3x2<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		return m;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x4<T> outerProduct
+	(
+		detail::tvec2<T> const & c, 
+		detail::tvec4<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat2x4<T> m(detail::tmat2x4<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[0][3] = c.w * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		m[1][3] = c.w * r.y;
+		return m;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x2<T> outerProduct
+	(
+		detail::tvec4<T> const & c, 
+		detail::tvec2<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat4x2<T> m(detail::tmat4x2<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		m[3][0] = c.x * r.w;
+		m[3][1] = c.y * r.w;
+		return m;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x4<T> outerProduct
+	(
+		detail::tvec4<T> const & c, 
+		detail::tvec3<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat3x4<T> m(detail::tmat3x4<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[0][3] = c.w * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		m[1][3] = c.w * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		m[2][2] = c.z * r.z;
+		m[2][3] = c.w * r.z;
+		return m;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x3<T> outerProduct
+	(
+		detail::tvec3<T> const & c, 
+		detail::tvec4<T> const & r
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
+
+		detail::tmat4x3<T> m(detail::tmat4x3<T>::null);
+		m[0][0] = c.x * r.x;
+		m[0][1] = c.y * r.x;
+		m[0][2] = c.z * r.x;
+		m[1][0] = c.x * r.y;
+		m[1][1] = c.y * r.y;
+		m[1][2] = c.z * r.y;
+		m[2][0] = c.x * r.z;
+		m[2][1] = c.y * r.z;
+		m[2][2] = c.z * r.z;
+		m[3][0] = c.x * r.w;
+		m[3][1] = c.y * r.w;
+		m[3][2] = c.z * r.w;
+		return m;
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat2x2<T> transpose
+	(
+		detail::tmat2x2<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        return result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> transpose
+	(
+		detail::tmat3x3<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[0][2] = m[2][0];
+
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[1][2] = m[2][1];
+
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        result[2][2] = m[2][2];
+        return result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> transpose
+	(
+		detail::tmat4x4<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[0][2] = m[2][0];
+        result[0][3] = m[3][0];
+
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[1][2] = m[2][1];
+        result[1][3] = m[3][1];
+
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        result[2][2] = m[2][2];
+        result[2][3] = m[3][2];
+
+        result[3][0] = m[0][3];
+        result[3][1] = m[1][3];
+        result[3][2] = m[2][3];
+        result[3][3] = m[3][3];
+        return result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat2x3<T> transpose
+	(
+		detail::tmat3x2<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+        return result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x2<T> transpose
+	(
+		detail::tmat2x3<T> const & m
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        return result;
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x4<T> transpose
+	(
+		detail::tmat4x2<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+		detail::tmat2x4<T> result(detail::tmat2x4<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+		result[0][3] = m[3][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+		result[1][3] = m[3][1];
+		return result;
+	}
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x2<T> transpose
+	(
+		detail::tmat2x4<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+        result[3][0] = m[0][3];
+        result[3][1] = m[1][3];
+        return result;
+	}
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x4<T> transpose
+	(
+		detail::tmat4x3<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+		detail::tmat3x4<T> result(detail::tmat3x4<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+		result[0][3] = m[3][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+		result[1][3] = m[3][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+		result[2][2] = m[2][2];
+		result[2][3] = m[3][2];
+		return result;
+	}
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x3<T> transpose
+	(
+		detail::tmat3x4<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
+
+        detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
+        result[0][0] = m[0][0];
+        result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+        result[1][0] = m[0][1];
+        result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+        result[2][0] = m[0][2];
+        result[2][1] = m[1][2];
+		result[2][2] = m[2][2];
+        result[3][0] = m[0][3];
+        result[3][1] = m[1][3];
+		result[3][2] = m[2][3];
+        return result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tmat2x2<T>::value_type determinant
+	(
+		detail::tmat2x2<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
+
+		return m[0][0] * m[1][1] - m[1][0] * m[0][1];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tmat3x3<T>::value_type determinant
+	(
+		detail::tmat3x3<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
+
+		return 
+			+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+			- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+			+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename detail::tmat4x4<T>::value_type determinant
+	(
+		detail::tmat4x4<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'determinant' only accept floating-point inputs");
+
+		T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+		detail::tvec4<T> DetCof(
+			+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+			- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+			+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+			- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+		return m[0][0] * DetCof[0]
+			 + m[0][1] * DetCof[1]
+			 + m[0][2] * DetCof[2]
+			 + m[0][3] * DetCof[3];
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> inverse
+	(
+		detail::tmat2x2<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
+			
+		//valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
+		T Determinant = determinant(m);
+
+		detail::tmat2x2<T> Inverse(
+			+ m[1][1] / Determinant,
+			- m[0][1] / Determinant, 
+			- m[1][0] / Determinant,
+			+ m[0][0] / Determinant);
+
+		return Inverse;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> inverse
+	(
+		detail::tmat3x3<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
+
+		//valType Determinant = m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
+		//					- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
+		//					+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+
+		T Determinant = determinant(m);
+
+		detail::tmat3x3<T> Inverse(detail::tmat3x3<T>::null);
+		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
+		Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
+		Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
+		Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
+		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
+		Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
+		Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
+		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
+		Inverse /= Determinant;
+
+		return Inverse;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> inverse
+	(
+		detail::tmat4x4<T> const & m
+	)
+	{
+		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'inverse' only accept floating-point inputs");
+
+		T Coef00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		T Coef02 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		T Coef03 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		T Coef04 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		T Coef06 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		T Coef07 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		T Coef08 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		T Coef10 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		T Coef11 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		T Coef12 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		T Coef14 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		T Coef15 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		T Coef16 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		T Coef18 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		T Coef19 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		T Coef20 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		T Coef22 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		T Coef23 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		detail::tvec4<T> const SignA(+1, -1, +1, -1);
+		detail::tvec4<T> const SignB(-1, +1, -1, +1);
+
+		detail::tvec4<T> Fac0(Coef00, Coef00, Coef02, Coef03);
+		detail::tvec4<T> Fac1(Coef04, Coef04, Coef06, Coef07);
+		detail::tvec4<T> Fac2(Coef08, Coef08, Coef10, Coef11);
+		detail::tvec4<T> Fac3(Coef12, Coef12, Coef14, Coef15);
+		detail::tvec4<T> Fac4(Coef16, Coef16, Coef18, Coef19);
+		detail::tvec4<T> Fac5(Coef20, Coef20, Coef22, Coef23);
+
+		detail::tvec4<T> Vec0(m[1][0], m[0][0], m[0][0], m[0][0]);
+		detail::tvec4<T> Vec1(m[1][1], m[0][1], m[0][1], m[0][1]);
+		detail::tvec4<T> Vec2(m[1][2], m[0][2], m[0][2], m[0][2]);
+		detail::tvec4<T> Vec3(m[1][3], m[0][3], m[0][3], m[0][3]);
+
+		detail::tvec4<T> Inv0 = SignA * (Vec1 * Fac0 - Vec2 * Fac1 + Vec3 * Fac2);
+		detail::tvec4<T> Inv1 = SignB * (Vec0 * Fac0 - Vec2 * Fac3 + Vec3 * Fac4);
+		detail::tvec4<T> Inv2 = SignA * (Vec0 * Fac1 - Vec1 * Fac3 + Vec3 * Fac5);
+		detail::tvec4<T> Inv3 = SignB * (Vec0 * Fac2 - Vec1 * Fac4 + Vec2 * Fac5);
+
+		detail::tmat4x4<T> Inverse(Inv0, Inv1, Inv2, Inv3);
+
+		detail::tvec4<T> Row0(Inverse[0][0], Inverse[1][0], Inverse[2][0], Inverse[3][0]);
+
+		T Determinant = glm::dot(m[0], Row0);
+
+		Inverse /= Determinant;
+	    
+		return Inverse;
+	}
+
+	}//namespace matrix
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_noise.hpp b/ExternalLibs/glm/core/func_noise.hpp
new file mode 100644
index 0000000..b76ec4b
--- /dev/null
+++ b/ExternalLibs/glm/core/func_noise.hpp
@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-01
+// Updated : 2008-09-10
+// Licence : This source is under MIT License
+// File    : glm/core/func_noise.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_noise
+#define glm_core_func_noise
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_noise();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
+	namespace noise{
+
+	/// \addtogroup core_funcs
+	///@{
+
+	//! Returns a 1D noise value based on the input value x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise1.xml">GLSL noise1 man page</a>
+	//! \li GLSL 1.30.08 specification, section 8.9
+	template <typename genType>
+	typename genType::value_type noise1(genType const & x);
+
+	//! Returns a 2D noise value based on the input value x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise2.xml">GLSL noise2 man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.9
+	template <typename genType>
+	detail::tvec2<typename genType::value_type> noise2(genType const & x);
+
+	//! Returns a 3D noise value based on the input value x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise3.xml">GLSL noise3 man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.9
+	template <typename genType>
+	detail::tvec3<typename genType::value_type> noise3(genType const & x);
+
+	//! Returns a 4D noise value based on the input value x.
+    //! 
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/noise4.xml">GLSL noise4 man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.9
+	template <typename genType>
+	detail::tvec4<typename genType::value_type> noise4(genType const & x);
+
+	///@}
+
+	}//namespace noise
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::noise;
+}//namespace glm
+
+#include "func_noise.inl"
+
+#endif//glm_core_func_noise
diff --git a/ExternalLibs/glm/core/func_noise.inl b/ExternalLibs/glm/core/func_noise.inl
new file mode 100644
index 0000000..8e00964
--- /dev/null
+++ b/ExternalLibs/glm/core/func_noise.inl
@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-01
+// Updated : 2011-04-14
+// Licence : This source is under MIT License
+// File    : glm/core/func_noise.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace noise{
+
+
+
+	}//namespace noise
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_packing.hpp b/ExternalLibs/glm/core/func_packing.hpp
new file mode 100644
index 0000000..3b42778
--- /dev/null
+++ b/ExternalLibs/glm/core/func_packing.hpp
@@ -0,0 +1,136 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-17
+// Licence : This source is under MIT License
+// File    : glm/core/func_packing.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_packing
+#define glm_core_func_packing
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_packing();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
+	namespace packing
+	{
+		/// \addtogroup core_funcs
+		///@{
+
+        //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+        //! Then, the results are packed into the returned 32-bit unsigned integer.
+        //! 
+        //! The conversion for component c of v to fixed point is done as follows:
+        //! packUnorm2x16: round(clamp(c, 0, +1) * 65535.0) 
+        //! 
+        //! The first component of the vector will be written to the least significant bits of the output; 
+        //! the last component will be written to the most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
+        
+        //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+        //! Then, the results are packed into the returned 32-bit unsigned integer.
+        //! 
+        //! The conversion for component c of v to fixed point is done as follows:
+        //! packUnorm4x8:	round(clamp(c, 0, +1) * 255.0)
+        //! 
+        //! The first component of the vector will be written to the least significant bits of the output; 
+        //! the last component will be written to the most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
+        
+        //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
+        //! Then, the results are packed into the returned 32-bit unsigned integer.
+        //! 
+        //! The conversion for component c of v to fixed point is done as follows:
+        //! packSnorm4x8:	round(clamp(c, -1, +1) * 127.0) 
+        //! 
+        //! The first component of the vector will be written to the least significant bits of the output; 
+        //! the last component will be written to the most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
+
+        //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+        //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+        //! 
+        //! The conversion for unpacked fixed-point value f to floating point is done as follows:
+        //! unpackUnorm2x16: f / 65535.0 
+        //! 
+        //! The first component of the returned vector will be extracted from the least significant bits of the input; 
+        //! the last component will be extracted from the most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p);
+
+        //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+        //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+        //! 
+        //! The conversion for unpacked fixed-point value f to floating point is done as follows:
+        //! unpackUnorm4x8: f / 255.0
+        //! 
+        //! The first component of the returned vector will be extracted from the least significant bits of the input; 
+        //! the last component will be extracted from the most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+        detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p);
+        
+        //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
+        //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
+        //! 
+        //! The conversion for unpacked fixed-point value f to floating point is done as follows:
+        //! unpackSnorm4x8: clamp(f / 127.0, -1, +1)
+        //! 
+        //! The first component of the returned vector will be extracted from the least significant bits of the input; 
+        //! the last component will be extracted from the most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p);
+
+        //! Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
+        //! If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
+        //! Otherwise, the bit- level representation of v is preserved. 
+        //! The first vector component specifies the 32 least significant bits; 
+        //! the second component specifies the 32 most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		double packDouble2x32(detail::tvec2<detail::uint32> const & v);
+        
+        //! Returns a two-component unsigned integer vector representation of v. 
+        //! The bit-level representation of v is preserved. 
+        //! The first component of the vector contains the 32 least significant bits of the double; 
+        //! the second component consists the 32 most significant bits.
+        //! 
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
+        //! \li GLSL 4.00.08 specification, section 8.4
+		detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
+
+		///@}
+
+	}//namespace packing
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::packing;
+}//namespace glm
+
+#include "func_packing.inl"
+
+#endif//glm_core_func_packing
+
diff --git a/ExternalLibs/glm/core/func_packing.inl b/ExternalLibs/glm/core/func_packing.inl
new file mode 100644
index 0000000..672e67b
--- /dev/null
+++ b/ExternalLibs/glm/core/func_packing.inl
@@ -0,0 +1,94 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-03-17
+// Updated : 2010-03-17
+// Licence : This source is under MIT License
+// File    : glm/core/func_packing.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		
+	}//namespace detail
+
+	namespace core{
+	namespace function{
+	namespace packing
+	{
+		GLM_FUNC_QUALIFIER detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v)
+		{
+			detail::uint16 A((detail::uint16)round(clamp(v.x, 0.0f, 1.0f) * 65535.0f));
+			detail::uint16 B((detail::uint16)round(clamp(v.y, 0.0f, 1.0f) * 65535.0f));
+			return detail::uint32((B << 16) | A);
+		}
+
+		GLM_FUNC_QUALIFIER detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v)
+		{
+			 detail::uint8 A((detail::uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
+			 detail::uint8 B((detail::uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
+			 detail::uint8 C((detail::uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
+			 detail::uint8 D((detail::uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
+			 return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
+		}
+
+		GLM_FUNC_QUALIFIER detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v)
+		{
+			 detail::uint8 A((detail::uint8)round(clamp(v.x,-1.0f, 1.0f) * 255.0f));
+			 detail::uint8 B((detail::uint8)round(clamp(v.y,-1.0f, 1.0f) * 255.0f));
+			 detail::uint8 C((detail::uint8)round(clamp(v.z,-1.0f, 1.0f) * 255.0f));
+			 detail::uint8 D((detail::uint8)round(clamp(v.w,-1.0f, 1.0f) * 255.0f));
+			 return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
+		}
+
+		GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p)
+		{
+			detail::uint16 A(detail::uint16(p >> 0));
+			detail::uint16 B(detail::uint16(p >> 16));
+			return detail::tvec2<detail::float32>(
+				A * 1.0f / 65535.0f, 
+				B * 1.0f / 65535.0f);
+		}
+
+		GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
+		{
+			detail::uint8 A(detail::uint8(p >> 0));
+			detail::uint8 B(detail::uint8(p >> 8));
+			detail::uint8 C(detail::uint8(p >> 16));
+			detail::uint8 D(detail::uint8(p >> 24));
+			return detail::tvec4<detail::float32>(
+				A * 1.0f / 255.0f, 
+				B * 1.0f / 255.0f,
+				C * 1.0f / 255.0f,
+				D * 1.0f / 255.0f);
+		}
+
+		GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p)
+		{
+			detail::uint8 A(detail::uint8(p >> 0));
+			detail::uint8 B(detail::uint8(p >> 8));
+			detail::uint8 C(detail::uint8(p >> 16));
+			detail::uint8 D(detail::uint8(p >> 24));
+			return clamp(detail::tvec4<detail::float32>(
+				A * 1.0f / 127.0f, 
+				B * 1.0f / 127.0f,
+				C * 1.0f / 127.0f,
+				D * 1.0f / 127.0f), -1.0f, 1.0f);
+		}
+
+		GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v)
+		{
+			return *(double*)&v;
+		}
+
+		GLM_FUNC_QUALIFIER detail::tvec2<detail::uint32> unpackDouble2x32(double const & v)
+		{
+			return *(detail::tvec2<detail::uint32>*)&v;
+		}
+
+	}//namespace packing
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_trigonometric.hpp b/ExternalLibs/glm/core/func_trigonometric.hpp
new file mode 100644
index 0000000..34e6257
--- /dev/null
+++ b/ExternalLibs/glm/core/func_trigonometric.hpp
@@ -0,0 +1,160 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-01
+// Updated : 2008-09-10
+// Licence : This source is under MIT License
+// File    : glm/core/func_trigonometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_trigonometric
+#define glm_core_func_trigonometric
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_trigonometric();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define Angle and trigonometry functions 
+	//! from Section 8.1 of GLSL 1.30.8 specification. 
+	//! Included in glm namespace.
+	namespace trigonometric{
+
+	/// \addtogroup core_funcs
+	///@{
+
+	//! Converts degrees to radians and returns the result.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/radians.xml">GLSL radians man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType radians(genType const & degrees);
+
+	//! Converts radians to degrees and returns the result.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/degrees.xml">GLSL degrees man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType degrees(genType const & radians);
+
+	//! The standard trigonometric sine function. 
+	//! The values returned by this function will range from [-1, 1].
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sin.xml">GLSL sin man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType sin(genType const & angle);
+
+	//! The standard trigonometric cosine function. 
+	//! The values returned by this function will range from [-1, 1].
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cos.xml">GLSL cos man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType cos(genType const & angle);
+
+	//! The standard trigonometric tangent function.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tan.xml">GLSL tan man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType tan(genType const & angle); 
+
+	//! Arc sine. Returns an angle whose sine is x. 
+	//! The range of values returned by this function is [-PI/2, PI/2]. 
+	//! Results are undefined if |x| > 1.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asin.xml">GLSL asin man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType asin(genType const & x);
+
+	//! Arc cosine. Returns an angle whose sine is x. 
+	//! The range of values returned by this function is [0, PI]. 
+	//! Results are undefined if |x| > 1.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acos.xml">GLSL acos man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType acos(genType const & x);
+
+	//! Arc tangent. Returns an angle whose tangent is y/x. 
+	//! The signs of x and y are used to determine what 
+	//! quadrant the angle is in. The range of values returned 
+	//! by this function is [-PI, PI]. Results are undefined 
+	//! if x and y are both 0. 
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType atan(genType const & y, genType const & x);
+
+	//! Arc tangent. Returns an angle whose tangent is y_over_x. 
+	//! The range of values returned by this function is [-PI/2, PI/2].
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atan.xml">GLSL atan man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType atan(genType const & y_over_x);
+
+	//! Returns the hyperbolic sine function, (exp(x) - exp(-x)) / 2
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sinh.xml">GLSL sinh man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType sinh(genType const & angle);
+
+	//! Returns the hyperbolic cosine function, (exp(x) + exp(-x)) / 2
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/cosh.xml">GLSL cosh man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType cosh(genType const & angle);
+
+	//! Returns the hyperbolic tangent function, sinh(angle) / cosh(angle)
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/tanh.xml">GLSL tanh man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType tanh(genType const & angle);
+
+	//! Arc hyperbolic sine; returns the inverse of sinh.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/asinh.xml">GLSL asinh man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType asinh(genType const & x);
+	
+	//! Arc hyperbolic cosine; returns the non-negative inverse
+	//! of cosh. Results are undefined if x < 1.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/acosh.xml">GLSL acosh man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType acosh(genType const & x);
+
+	//! Arc hyperbolic tangent; returns the inverse of tanh.
+	//! Results are undefined if abs(x) >= 1.
+    //!
+    //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/atanh.xml">GLSL atanh man page</a>
+    //! \li GLSL 1.30.08 specification, section 8.1	
+	template <typename genType> 
+	genType atanh(genType const & x);
+
+	///@}
+
+	}//namespace trigonometric
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::trigonometric;
+}//namespace glm
+
+#include "func_trigonometric.inl"
+
+#endif//glm_core_func_trigonometric
+
+
diff --git a/ExternalLibs/glm/core/func_trigonometric.inl b/ExternalLibs/glm/core/func_trigonometric.inl
new file mode 100644
index 0000000..0584601
--- /dev/null
+++ b/ExternalLibs/glm/core/func_trigonometric.inl
@@ -0,0 +1,745 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2008-09-14
+// Licence : This source is under MIT License
+// File    : glm/core/func_trigonometric.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace trigonometric{
+
+    // radians
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType radians
+	(
+		genType const & degrees
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
+
+        const genType pi = genType(3.1415926535897932384626433832795);
+        return degrees * (pi / genType(180));
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> radians
+	(
+		detail::tvec2<T> const & degrees
+	)
+    {
+        return detail::tvec2<T>(
+            radians(degrees.x),
+            radians(degrees.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> radians
+	(
+		detail::tvec3<T> const & degrees
+	)
+    {
+        return detail::tvec3<T>(
+            radians(degrees.x),
+            radians(degrees.y),
+            radians(degrees.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> radians
+	(
+		detail::tvec4<T> const & degrees
+	)
+    {
+        return detail::tvec4<T>(
+            radians(degrees.x),
+            radians(degrees.y),
+            radians(degrees.z),
+            radians(degrees.w));
+    }
+
+    // degrees
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType degrees
+	(
+		genType const & radians
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'degrees' only accept floating-point input");
+
+        const genType pi = genType(3.1415926535897932384626433832795);
+        return radians * (genType(180) / pi);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> degrees
+	(
+		detail::tvec2<T> const & radians
+	)
+    {
+        return detail::tvec2<T>(
+            degrees(radians.x),
+            degrees(radians.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> degrees
+	(	
+		detail::tvec3<T> const & radians
+	)
+    {
+        return detail::tvec3<T>(
+            degrees(radians.x),
+            degrees(radians.y),
+            degrees(radians.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> degrees
+	(
+		detail::tvec4<T> const & radians
+	)
+    {
+        return detail::tvec4<T>(
+            degrees(radians.x),
+            degrees(radians.y),
+            degrees(radians.z),
+            degrees(radians.w));
+    }
+
+    // sin
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType sin
+	(
+		genType const & angle
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sin' only accept floating-point input");
+
+		return ::std::sin(angle);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> sin
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            sin(angle.x),
+            sin(angle.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> sin
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            sin(angle.x),
+            sin(angle.y),
+            sin(angle.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> sin
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            sin(angle.x),
+            sin(angle.y),
+            sin(angle.z),
+            sin(angle.w));
+    }
+
+    // cos
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType cos(genType const & angle)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cos' only accept floating-point input");
+
+        return ::std::cos(angle);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> cos
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            cos(angle.x),
+            cos(angle.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> cos
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            cos(angle.x),
+            cos(angle.y),
+            cos(angle.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> cos
+	(	
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            cos(angle.x),
+            cos(angle.y),
+            cos(angle.z),
+            cos(angle.w));
+    }
+
+    // tan
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType tan
+	(
+		genType const & angle
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tan' only accept floating-point input");
+
+        return ::std::tan(angle);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> tan
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            tan(angle.x),
+            tan(angle.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> tan
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            tan(angle.x),
+            tan(angle.y),
+            tan(angle.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> tan
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            tan(angle.x),
+            tan(angle.y),
+            tan(angle.z),
+            tan(angle.w));
+    }
+
+    // asin
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType asin
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asin' only accept floating-point input");
+
+        return ::std::asin(x);
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> asin
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            asin(x.x),
+            asin(x.y));
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> asin
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            asin(x.x),
+            asin(x.y),
+            asin(x.z));
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> asin
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            asin(x.x),
+            asin(x.y),
+            asin(x.z),
+            asin(x.w));
+    }
+
+    // acos
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType acos
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acos' only accept floating-point input");
+
+        return ::std::acos(x);
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> acos
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            acos(x.x),
+            acos(x.y));
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> acos
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            acos(x.x),
+            acos(x.y),
+            acos(x.z));
+    }
+
+    template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> acos
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            acos(x.x),
+            acos(x.y),
+            acos(x.z),
+            acos(x.w));
+    }
+
+    // atan
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType atan
+	(
+		genType const & y, 
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
+
+        return ::std::atan2(y, x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> atan
+	(
+		detail::tvec2<T> const & y, 
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            atan(y.x, x.x),
+            atan(y.y, x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> atan
+	(
+		detail::tvec3<T> const & y, 
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            atan(y.x, x.x),
+            atan(y.y, x.y),
+            atan(y.z, x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> atan
+	(
+		detail::tvec4<T> const & y, 
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            atan(y.x, x.x),
+            atan(y.y, x.y),
+            atan(y.z, x.z),
+            atan(y.w, x.w));
+    }
+
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType atan
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
+
+        return ::std::atan(x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> atan
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            atan(x.x),
+            atan(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> atan
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            atan(x.x),
+            atan(x.y),
+            atan(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> atan
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            atan(x.x),
+            atan(x.y),
+            atan(x.z),
+            atan(x.w));
+    }
+
+    // sinh
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType sinh
+	(
+		genType const & angle
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sinh' only accept floating-point input");
+
+		return std::sinh(angle);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> sinh
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            sinh(angle.x),
+            sinh(angle.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> sinh
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            sinh(angle.x),
+            sinh(angle.y),
+            sinh(angle.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> sinh
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            sinh(angle.x),
+            sinh(angle.y),
+            sinh(angle.z),
+            sinh(angle.w));
+    }
+
+    // cosh
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType cosh
+	(
+		genType const & angle
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cosh' only accept floating-point input");
+
+		return std::cosh(angle);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> cosh
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            cosh(angle.x),
+            cosh(angle.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> cosh
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            cosh(angle.x),
+            cosh(angle.y),
+            cosh(angle.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> cosh
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            cosh(angle.x),
+            cosh(angle.y),
+            cosh(angle.z),
+            cosh(angle.w));
+    }
+
+    // tanh
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType tanh
+	(
+		genType const & angle
+	)
+    {
+        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tanh' only accept floating-point input");
+
+		return std::tanh(angle);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> tanh
+	(
+		detail::tvec2<T> const & angle
+	)
+    {
+        return detail::tvec2<T>(
+            tanh(angle.x),
+            tanh(angle.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> tanh
+	(
+		detail::tvec3<T> const & angle
+	)
+    {
+        return detail::tvec3<T>(
+            tanh(angle.x),
+            tanh(angle.y),
+            tanh(angle.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> tanh
+	(
+		detail::tvec4<T> const & angle
+	)
+    {
+        return detail::tvec4<T>(
+            tanh(angle.x),
+            tanh(angle.y),
+            tanh(angle.z),
+            tanh(angle.w));
+    }
+
+    // asinh
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType asinh
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asinh' only accept floating-point input");
+		
+		return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> asinh
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            asinh(x.x),
+            asinh(x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> asinh
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            asinh(x.x),
+            asinh(x.y),
+            asinh(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> asinh
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            asinh(x.x),
+            asinh(x.y),
+            asinh(x.z),
+            asinh(x.w));
+    }
+
+    // acosh
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType acosh
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acosh' only accept floating-point input");
+
+		if(x < genType(1))
+			return genType(0);
+		return log(x + sqrt(x * x - genType(1)));
+    }
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec2<T> acosh
+	(
+		detail::tvec2<T> const & x
+	)
+	{
+		return detail::tvec2<T>(
+			acosh(x.x),
+			acosh(x.y));
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> acosh
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            acosh(x.x),
+            acosh(x.y),
+            acosh(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> acosh
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            acosh(x.x),
+            acosh(x.y),
+            acosh(x.z),
+            acosh(x.w));
+    }
+
+    // atanh
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType atanh
+	(
+		genType const & x
+	)
+    {
+		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atanh' only accept floating-point input");
+		
+		if(abs(x) >= genType(1))
+			return 0;
+		return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> atanh
+	(
+		detail::tvec2<T> const & x
+	)
+    {
+        return detail::tvec2<T>(
+            atanh(x.x),
+            atanh(x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> atanh
+	(
+		detail::tvec3<T> const & x
+	)
+    {
+        return detail::tvec3<T>(
+            atanh(x.x),
+            atanh(x.y),
+            atanh(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> atanh
+	(
+		detail::tvec4<T> const & x
+	)
+    {
+        return detail::tvec4<T>(
+            atanh(x.x),
+            atanh(x.y),
+            atanh(x.z),
+            atanh(x.w));
+    }
+
+	}//namespace trigonometric
+	}//namespace function
+	}//namespace core
+}//namespace glm
diff --git a/ExternalLibs/glm/core/func_vector_relational.hpp b/ExternalLibs/glm/core/func_vector_relational.hpp
new file mode 100644
index 0000000..d290def
--- /dev/null
+++ b/ExternalLibs/glm/core/func_vector_relational.hpp
@@ -0,0 +1,219 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2008-09-09
+// Licence : This source is under MIT License
+// File    : glm/core/func_vector_relational.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_func_vector_relational
+#define glm_core_func_vector_relational
+
+#include "_detail.hpp"
+
+namespace glm
+{
+	namespace test{
+		void main_core_func_vector_relational();
+	}//namespace test
+
+	namespace core{
+	namespace function{
+	//! Define vector relational functions from Section 8.6 of GLSL 1.30.8 specification. 
+	//! Included in glm namespace.
+	namespace vector_relational
+	{
+		/// \addtogroup core_funcs
+		///@{
+
+		//! Returns the component-wise comparison result of x < y.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+        template <typename T, template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThan
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
+				"Invalid template instantiation of 'lessThan', GLM vector types required");
+			GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
+				"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] < y[i];
+
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x <= y.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <typename T, template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThanEqual
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
+				"Invalid template instantiation of 'lessThanEqual', GLM vector types required");
+			GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
+				"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] <= y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x > y.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <typename T, template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThan
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
+				"Invalid template instantiation of 'greaterThan', GLM vector types required");
+			GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
+				"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] > y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x >= y.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <typename T, template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThanEqual
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
+				"Invalid template instantiation of 'greaterThanEqual', GLM vector types required");
+			GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, 
+				"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] >= y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x == y.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <typename T, template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
+				"Invalid template instantiation of 'equal', GLM vector types required");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] == y[i];
+			return Result;
+		}
+
+		//! Returns the component-wise comparison of result x != y.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <typename T, template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER typename vecType<T>::bool_type notEqual
+		(
+			vecType<T> const & x, 
+			vecType<T> const & y
+		)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, 
+				"Invalid template instantiation of 'notEqual', GLM vector types required");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = x[i] != y[i];
+			return Result;
+		}
+
+		//! Returns true if any component of x is true.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER bool any(vecType<bool> const & v)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
+				"Invalid template instantiation of 'any', GLM boolean vector types required");
+
+			bool Result = false;
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result = Result || v[i];
+			return Result;
+		}
+
+		//! Returns true if all components of x are true.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER bool all(vecType<bool> const & v)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
+				"Invalid template instantiation of 'all', GLM boolean vector types required");
+
+			bool Result = true;
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result = Result && v[i];
+			return Result;
+		}
+
+		//! Returns the component-wise logical complement of x.
+        //! /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
+        //!
+        //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
+        //! \li GLSL 1.30.08 specification, section 8.6
+		template <template <typename> class vecType> 
+		GLM_FUNC_QUALIFIER vecType<bool> not_(vecType<bool> const & v)
+		{
+			GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, 
+				"Invalid template instantiation of 'not_', GLM vector types required");
+
+			typename vecType<bool>::bool_type Result(vecType<bool>::null);
+			for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
+				Result[i] = !v[i];
+			return Result;
+		}
+
+		///@}
+
+	}//namespace vector_relational
+	}//namespace function
+	}//namespace core
+
+	using namespace core::function::vector_relational;
+}//namespace glm
+
+#include "func_vector_relational.inl"
+
+#endif//glm_core_func_vector_relational
diff --git a/ExternalLibs/glm/core/func_vector_relational.inl b/ExternalLibs/glm/core/func_vector_relational.inl
new file mode 100644
index 0000000..728c804
--- /dev/null
+++ b/ExternalLibs/glm/core/func_vector_relational.inl
@@ -0,0 +1,20 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-03
+// Updated : 2008-09-14
+// Licence : This source is under MIT License
+// File    : glm/core/func_vector_relational.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace core{
+	namespace function{
+	namespace vector_relational{
+
+	}//namespace vector_relational
+	}//namespace function
+	}//namespace core
+}//namespace glm
+
diff --git a/ExternalLibs/glm/core/hint.hpp b/ExternalLibs/glm/core/hint.hpp
new file mode 100644
index 0000000..d7efd58
--- /dev/null
+++ b/ExternalLibs/glm/core/hint.hpp
@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-14
+// Updated : 2008-08-14
+// Licence : This source is under MIT License
+// File    : glm/core/hint.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type
+#define glm_core_type
+
+namespace glm
+{
+	// Use dont_care, nicest and fastest to optimize implementations.
+	class dont_care {};
+	class nicest {};
+	class fastest {};
+};
+
+#endif//glm_core_type
diff --git a/ExternalLibs/glm/core/intrinsic_common.hpp b/ExternalLibs/glm/core/intrinsic_common.hpp
new file mode 100644
index 0000000..f50d04f
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_common.hpp
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-11
+// Updated : 2009-05-11
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_detail_intrinsic_common
+#define glm_detail_intrinsic_common
+
+#include "setup.hpp"
+
+#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+	__m128 sse_abs_ps(__m128 x);
+
+	__m128 sse_sgn_ps(__m128 x);
+
+	//floor
+	__m128 sse_flr_ps(__m128 v);
+
+	//trunc
+	__m128 sse_trc_ps(__m128 v);
+
+	//round
+	__m128 sse_nd_ps(__m128 v);
+
+	//roundEven
+	__m128 sse_rde_ps(__m128 v);
+
+	__m128 sse_rnd_ps(__m128 x);
+
+	__m128 sse_ceil_ps(__m128 v);
+
+	__m128 sse_frc_ps(__m128 x);
+
+	__m128 sse_mod_ps(__m128 x, __m128 y);
+
+	__m128 sse_modf_ps(__m128 x, __m128i & i);
+
+	//GLM_FUNC_QUALIFIER __m128 sse_min_ps(__m128 x, __m128 y)
+
+	//GLM_FUNC_QUALIFIER __m128 sse_max_ps(__m128 x, __m128 y)
+
+	__m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal);
+
+	__m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a);
+
+	__m128 sse_stp_ps(__m128 edge, __m128 x);
+
+	__m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x);
+
+	__m128 sse_nan_ps(__m128 x);
+
+	__m128 sse_inf_ps(__m128 x);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_common.inl"
+
+#endif//GLM_ARCH
+#endif//glm_detail_intrinsic_common
diff --git a/ExternalLibs/glm/core/intrinsic_common.inl b/ExternalLibs/glm/core/intrinsic_common.inl
new file mode 100644
index 0000000..82c940a
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_common.inl
@@ -0,0 +1,277 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-08
+// Updated : 2009-05-08
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+	union ieee754_QNAN
+	{
+	   const float f;
+	   struct i
+	   {
+		  const unsigned int mantissa:23, exp:8, sign:1;
+	   };
+	   
+	   ieee754_QNAN() : f(0.0)/*, mantissa(0x7FFFFF), exp(0xFF), sign(0x0)*/ {}
+	};
+
+	static const __m128 zero = _mm_setzero_ps();
+	static const __m128 one = _mm_set_ps1(1.0f);
+	static const __m128 minus_one = _mm_set_ps1(-1.0f);
+	static const __m128 two = _mm_set_ps1(2.0f);
+	static const __m128 three = _mm_set_ps1(3.0f);
+	static const __m128 pi = _mm_set_ps1(3.1415926535897932384626433832795f);
+	static const __m128 hundred_eighty = _mm_set_ps1(180.f);
+	static const __m128 pi_over_hundred_eighty = _mm_set_ps1(0.017453292519943295769236907684886f);
+	static const __m128 hundred_eighty_over_pi = _mm_set_ps1(57.295779513082320876798154814105f);
+
+	static const ieee754_QNAN absMask;
+	static const __m128 abs4Mask = _mm_set_ps1(absMask.f);
+
+	static const __m128 _epi32_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x80000000));
+        //static const __m128 _epi32_inv_sign_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7FFFFFFF));
+        //static const __m128 _epi32_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
+        //static const __m128 _epi32_inv_mant_mask = _mm_castsi128_ps(_mm_set1_epi32(0x807FFFFF));
+        //static const __m128 _epi32_min_norm_pos = _mm_castsi128_ps(_mm_set1_epi32(0x00800000));
+	static const __m128 _epi32_0 = _mm_set_ps1(0);
+	static const __m128 _epi32_1 = _mm_set_ps1(1);
+	static const __m128 _epi32_2 = _mm_set_ps1(2);
+	static const __m128 _epi32_3 = _mm_set_ps1(3);
+	static const __m128 _epi32_4 = _mm_set_ps1(4);
+	static const __m128 _epi32_5 = _mm_set_ps1(5);
+	static const __m128 _epi32_6 = _mm_set_ps1(6);
+	static const __m128 _epi32_7 = _mm_set_ps1(7);
+	static const __m128 _epi32_8 = _mm_set_ps1(8);
+	static const __m128 _epi32_9 = _mm_set_ps1(9);
+	static const __m128 _epi32_127 = _mm_set_ps1(127);
+        //static const __m128 _epi32_ninf = _mm_castsi128_ps(_mm_set1_epi32(0xFF800000));
+        //static const __m128 _epi32_pinf = _mm_castsi128_ps(_mm_set1_epi32(0x7F800000));
+
+	static const __m128 _ps_1_3 = _mm_set_ps1(0.33333333333333333333333333333333f);
+	static const __m128 _ps_0p5 = _mm_set_ps1(0.5f);
+	static const __m128 _ps_1 = _mm_set_ps1(1.0f);
+	static const __m128 _ps_m1 = _mm_set_ps1(-1.0f);
+	static const __m128 _ps_2 = _mm_set_ps1(2.0f);
+	static const __m128 _ps_3 = _mm_set_ps1(3.0f);
+	static const __m128 _ps_127 = _mm_set_ps1(127.0f);
+	static const __m128 _ps_255 = _mm_set_ps1(255.0f);
+	static const __m128 _ps_2pow23 = _mm_set_ps1(8388608.0f);
+
+	static const __m128 _ps_1_0_0_0 = _mm_set_ps(1.0f, 0.0f, 0.0f, 0.0f);
+	static const __m128 _ps_0_1_0_0 = _mm_set_ps(0.0f, 1.0f, 0.0f, 0.0f);
+	static const __m128 _ps_0_0_1_0 = _mm_set_ps(0.0f, 0.0f, 1.0f, 0.0f);
+	static const __m128 _ps_0_0_0_1 = _mm_set_ps(0.0f, 0.0f, 0.0f, 1.0f);
+
+	static const __m128 _ps_pi = _mm_set_ps1(3.1415926535897932384626433832795f);
+	static const __m128 _ps_pi2 = _mm_set_ps1(6.283185307179586476925286766560f);
+	static const __m128 _ps_2_pi = _mm_set_ps1(0.63661977236758134307553505349006f);
+	static const __m128 _ps_pi_2 = _mm_set_ps1(1.5707963267948966192313216916398f);
+	static const __m128 _ps_4_pi = _mm_set_ps1(1.2732395447351626861510701069801f);
+	static const __m128 _ps_pi_4 = _mm_set_ps1(0.78539816339744830961566084581988f);
+
+	static const __m128 _ps_sincos_p0 = _mm_set_ps1(0.15707963267948963959e1f);
+	static const __m128 _ps_sincos_p1 = _mm_set_ps1(-0.64596409750621907082e0f);
+	static const __m128 _ps_sincos_p2 = _mm_set_ps1(0.7969262624561800806e-1f);
+	static const __m128 _ps_sincos_p3 = _mm_set_ps1(-0.468175413106023168e-2f);
+	static const __m128 _ps_tan_p0 = _mm_set_ps1(-1.79565251976484877988e7f);
+	static const __m128 _ps_tan_p1 = _mm_set_ps1(1.15351664838587416140e6f);
+	static const __m128 _ps_tan_p2 = _mm_set_ps1(-1.30936939181383777646e4f);
+	static const __m128 _ps_tan_q0 = _mm_set_ps1(-5.38695755929454629881e7f);
+	static const __m128 _ps_tan_q1 = _mm_set_ps1(2.50083801823357915839e7f);
+	static const __m128 _ps_tan_q2 = _mm_set_ps1(-1.32089234440210967447e6f);
+	static const __m128 _ps_tan_q3 = _mm_set_ps1(1.36812963470692954678e4f);
+	static const __m128 _ps_tan_poleval = _mm_set_ps1(3.68935e19f);
+	static const __m128 _ps_atan_t0 = _mm_set_ps1(-0.91646118527267623468e-1f);
+	static const __m128 _ps_atan_t1 = _mm_set_ps1(-0.13956945682312098640e1f);
+	static const __m128 _ps_atan_t2 = _mm_set_ps1(-0.94393926122725531747e2f);
+	static const __m128 _ps_atan_t3 = _mm_set_ps1(0.12888383034157279340e2f);
+	static const __m128 _ps_atan_s0 = _mm_set_ps1(0.12797564625607904396e1f);
+	static const __m128 _ps_atan_s1 = _mm_set_ps1(0.21972168858277355914e1f);
+	static const __m128 _ps_atan_s2 = _mm_set_ps1(0.68193064729268275701e1f);
+	static const __m128 _ps_atan_s3 = _mm_set_ps1(0.28205206687035841409e2f);
+
+	static const __m128 _ps_exp_hi = _mm_set_ps1(88.3762626647949f);
+	static const __m128 _ps_exp_lo = _mm_set_ps1(-88.3762626647949f);
+	static const __m128 _ps_exp_rln2 = _mm_set_ps1(1.4426950408889634073599f);
+	static const __m128 _ps_exp_p0 = _mm_set_ps1(1.26177193074810590878e-4f);
+	static const __m128 _ps_exp_p1 = _mm_set_ps1(3.02994407707441961300e-2f);
+	static const __m128 _ps_exp_q0 = _mm_set_ps1(3.00198505138664455042e-6f);
+	static const __m128 _ps_exp_q1 = _mm_set_ps1(2.52448340349684104192e-3f);
+	static const __m128 _ps_exp_q2 = _mm_set_ps1(2.27265548208155028766e-1f);
+	static const __m128 _ps_exp_q3 = _mm_set_ps1(2.00000000000000000009e0f);
+	static const __m128 _ps_exp_c1 = _mm_set_ps1(6.93145751953125e-1f);
+	static const __m128 _ps_exp_c2 = _mm_set_ps1(1.42860682030941723212e-6f);
+	static const __m128 _ps_exp2_hi = _mm_set_ps1(127.4999961853f);
+	static const __m128 _ps_exp2_lo = _mm_set_ps1(-127.4999961853f);
+	static const __m128 _ps_exp2_p0 = _mm_set_ps1(2.30933477057345225087e-2f);
+	static const __m128 _ps_exp2_p1 = _mm_set_ps1(2.02020656693165307700e1f);
+	static const __m128 _ps_exp2_p2 = _mm_set_ps1(1.51390680115615096133e3f);
+	static const __m128 _ps_exp2_q0 = _mm_set_ps1(2.33184211722314911771e2f);
+	static const __m128 _ps_exp2_q1 = _mm_set_ps1(4.36821166879210612817e3f);
+	static const __m128 _ps_log_p0 = _mm_set_ps1(-7.89580278884799154124e-1f);
+	static const __m128 _ps_log_p1 = _mm_set_ps1(1.63866645699558079767e1f);
+	static const __m128 _ps_log_p2 = _mm_set_ps1(-6.41409952958715622951e1f);
+	static const __m128 _ps_log_q0 = _mm_set_ps1(-3.56722798256324312549e1f);
+	static const __m128 _ps_log_q1 = _mm_set_ps1(3.12093766372244180303e2f);
+	static const __m128 _ps_log_q2 = _mm_set_ps1(-7.69691943550460008604e2f);
+	static const __m128 _ps_log_c0 = _mm_set_ps1(0.693147180559945f);
+	static const __m128 _ps_log2_c0 = _mm_set_ps1(1.44269504088896340735992f);
+
+GLM_FUNC_QUALIFIER __m128 sse_abs_ps(__m128 x)
+{
+	return _mm_and_ps(glm::detail::abs4Mask, x);
+} 
+
+GLM_FUNC_QUALIFIER __m128 sse_sgn_ps(__m128 x)
+{
+	__m128 Neg = _mm_set1_ps(-1.0f);
+	__m128 Pos = _mm_set1_ps(1.0f);
+
+	__m128 Cmp0 = _mm_cmplt_ps(x, zero);
+	__m128 Cmp1 = _mm_cmpgt_ps(x, zero);
+
+	__m128 And0 = _mm_and_ps(Cmp0, Neg);
+	__m128 And1 = _mm_and_ps(Cmp1, Pos);
+
+	return _mm_or_ps(And0, And1);
+}
+
+//floor
+GLM_FUNC_QUALIFIER __m128 sse_flr_ps(__m128 x)
+{
+	__m128 rnd0 = sse_rnd_ps(x);
+	__m128 cmp0 = _mm_cmplt_ps(x, rnd0);
+	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
+	__m128 sub0 = _mm_sub_ps(rnd0, and0);
+	return sub0;
+}
+
+//trunc
+/*
+GLM_FUNC_QUALIFIER __m128 _mm_trc_ps(__m128 v)
+{
+	return __m128();
+}
+*/
+//round
+GLM_FUNC_QUALIFIER __m128 sse_rnd_ps(__m128 x)
+{
+	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
+	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
+	__m128 add0 = _mm_add_ps(x, or0);
+	__m128 sub0 = _mm_sub_ps(add0, or0);
+	return sub0;
+}
+
+//roundEven
+GLM_FUNC_QUALIFIER __m128 sse_rde_ps(__m128 x)
+{
+	__m128 and0 = _mm_and_ps(glm::detail::_epi32_sign_mask, x);
+	__m128 or0 = _mm_or_ps(and0, glm::detail::_ps_2pow23);
+	__m128 add0 = _mm_add_ps(x, or0);
+	__m128 sub0 = _mm_sub_ps(add0, or0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_ceil_ps(__m128 x)
+{
+	__m128 rnd0 = sse_rnd_ps(x);
+	__m128 cmp0 = _mm_cmpgt_ps(x, rnd0);
+	__m128 and0 = _mm_and_ps(cmp0, glm::detail::_ps_1);
+	__m128 add0 = _mm_add_ps(rnd0, and0);
+	return add0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_frc_ps(__m128 x)
+{
+	__m128 flr0 = sse_flr_ps(x);
+	__m128 sub0 = _mm_sub_ps(x, flr0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_mod_ps(__m128 x, __m128 y)
+{
+	__m128 div0 = _mm_div_ps(x, y);
+	__m128 flr0 = sse_flr_ps(div0);
+	__m128 mul0 = _mm_mul_ps(y, flr0);
+	__m128 sub0 = _mm_sub_ps(x, mul0);
+	return sub0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_modf_ps(__m128 x, __m128i & i)
+{
+
+}
+
+//GLM_FUNC_QUALIFIER __m128 _mm_min_ps(__m128 x, __m128 y)
+
+//GLM_FUNC_QUALIFIER __m128 _mm_max_ps(__m128 x, __m128 y)
+
+GLM_FUNC_QUALIFIER __m128 sse_clp_ps(__m128 v, __m128 minVal, __m128 maxVal)
+{
+	__m128 min0 = _mm_min_ps(v, maxVal);
+	__m128 max0 = _mm_max_ps(min0, minVal);
+	return max0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_mix_ps(__m128 v1, __m128 v2, __m128 a)
+{
+	__m128 sub0 = _mm_sub_ps(glm::detail::one, a);
+	__m128 mul0 = _mm_mul_ps(v1, sub0);
+	__m128 mul1 = _mm_mul_ps(v2, a);
+	__m128 add0 = _mm_add_ps(mul0, mul1);
+	return add0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_stp_ps(__m128 edge, __m128 x)
+{
+	__m128 cmp = _mm_cmple_ps(x, edge);
+	if(_mm_movemask_ps(cmp) == 0)
+		return glm::detail::one;
+	else
+		return glm::detail::zero;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_ssp_ps(__m128 edge0, __m128 edge1, __m128 x)
+{
+	__m128 sub0 = _mm_sub_ps(x, edge0);
+	__m128 sub1 = _mm_sub_ps(edge1, edge0);
+	__m128 div0 = _mm_sub_ps(sub0, sub1);
+	__m128 clp0 = sse_clp_ps(div0, glm::detail::zero, glm::detail::one);
+	__m128 mul0 = _mm_mul_ps(glm::detail::two, clp0);
+	__m128 sub2 = _mm_sub_ps(glm::detail::three, mul0);
+	__m128 mul1 = _mm_mul_ps(clp0, clp0);
+	__m128 mul2 = _mm_mul_ps(mul1, sub2);
+	return mul2;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_nan_ps(__m128 x)
+{
+
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_inf_ps(__m128 x)
+{
+
+}
+
+// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
+// By Elan Ruskin, http://assemblyrequired.crashworks.org/
+GLM_FUNC_QUALIFIER __m128 sse_sqrt_wip_ss(__m128 const & x)
+{
+	__m128 recip = _mm_rsqrt_ss(x);  // "estimate" opcode
+	const static __m128 three = {3, 3, 3, 3}; // aligned consts for fast load
+	const static __m128 half = {0.5,0.5,0.5,0.5};
+	__m128 halfrecip = _mm_mul_ss(half, recip);
+	__m128 threeminus_xrr = _mm_sub_ss(three, _mm_mul_ss(x, _mm_mul_ss (recip, recip)));
+	return _mm_mul_ss( halfrecip, threeminus_xrr);
+}
+
+}//namespace detail
+}//namespace glms
diff --git a/ExternalLibs/glm/core/intrinsic_exponential.hpp b/ExternalLibs/glm/core/intrinsic_exponential.hpp
new file mode 100644
index 0000000..8d1a579
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_exponential.hpp
@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-11
+// Updated : 2009-05-11
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_exponential.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_detail_intrinsic_exponential
+#define glm_detail_intrinsic_exponential
+
+#include "setup.hpp"
+
+#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+/*
+GLM_FUNC_QUALIFIER __m128 sse_rsqrt_nr_ss(__m128 const x)
+{
+	__m128 recip = _mm_rsqrt_ss( x );  // "estimate" opcode
+	const static __m128 three = { 3, 3, 3, 3 }; // aligned consts for fast load
+	const static __m128 half = { 0.5,0.5,0.5,0.5 };
+	__m128 halfrecip = _mm_mul_ss( half, recip );
+	__m128 threeminus_xrr = _mm_sub_ss( three, _mm_mul_ss( x, _mm_mul_ss ( recip, recip ) ) );
+	return _mm_mul_ss( halfrecip, threeminus_xrr );
+}
+ 
+GLM_FUNC_QUALIFIER __m128 sse_normalize_fast_ps(  float * RESTRICT vOut, float * RESTRICT vIn )
+{
+        __m128 x = _mm_load_ss(&vIn[0]);
+        __m128 y = _mm_load_ss(&vIn[1]);
+        __m128 z = _mm_load_ss(&vIn[2]);
+ 
+        const __m128 l =  // compute x*x + y*y + z*z
+                _mm_add_ss(
+                 _mm_add_ss( _mm_mul_ss(x,x),
+                             _mm_mul_ss(y,y)
+                            ),
+                 _mm_mul_ss( z, z )
+                );
+ 
+ 
+        const __m128 rsqt = _mm_rsqrt_nr_ss( l );
+        _mm_store_ss( &vOut[0] , _mm_mul_ss( rsqt, x ) );
+        _mm_store_ss( &vOut[1] , _mm_mul_ss( rsqt, y ) );
+        _mm_store_ss( &vOut[2] , _mm_mul_ss( rsqt, z ) );
+ 
+        return _mm_mul_ss( l , rsqt );
+}
+*/
+}//namespace detail
+}//namespace glm
+
+#endif//GLM_ARCH
+#endif//glm_detail_intrinsic_exponential
diff --git a/ExternalLibs/glm/core/intrinsic_exponential.inl b/ExternalLibs/glm/core/intrinsic_exponential.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/core/intrinsic_geometric.hpp b/ExternalLibs/glm/core/intrinsic_geometric.hpp
new file mode 100644
index 0000000..d640774
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_geometric.hpp
@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-08
+// Updated : 2009-05-08
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_geometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_intrinsic_geometric
+#define glm_core_intrinsic_geometric
+
+#include "setup.hpp"
+
+#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+#include "intrinsic_common.hpp"
+
+namespace glm{
+namespace detail
+{
+	//length
+	__m128 sse_len_ps(__m128 x);
+
+	//distance
+	__m128 sse_dst_ps(__m128 p0, __m128 p1);
+
+	//dot
+	__m128 sse_dot_ps(__m128 v1, __m128 v2);
+
+	// SSE1
+	__m128 sse_dot_ss(__m128 v1, __m128 v2);
+
+	//cross
+	__m128 sse_xpd_ps(__m128 v1, __m128 v2);
+
+	//normalize
+	__m128 sse_nrm_ps(__m128 v);
+
+	//faceforward
+	__m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref);
+
+	//reflect
+	__m128 sse_rfe_ps(__m128 I, __m128 N);
+
+	//refract
+	__m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_geometric.inl"
+
+#endif//GLM_ARCH
+#endif//glm_core_intrinsic_geometric
diff --git a/ExternalLibs/glm/core/intrinsic_geometric.inl b/ExternalLibs/glm/core/intrinsic_geometric.inl
new file mode 100644
index 0000000..66c396b
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_geometric.inl
@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-08
+// Updated : 2009-05-08
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_geometric.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+//length
+GLM_FUNC_QUALIFIER __m128 sse_len_ps(__m128 x)
+{
+    __m128 dot0 = sse_dot_ps(x, x);
+	__m128 sqt0 = _mm_sqrt_ps(dot0);
+    return sqt0;
+}
+
+//distance
+GLM_FUNC_QUALIFIER __m128 sse_dst_ps(__m128 p0, __m128 p1)
+{
+	__m128 sub0 = _mm_sub_ps(p0, p1);
+    __m128 len0 = sse_len_ps(sub0);
+    return len0;
+}
+
+//dot
+GLM_FUNC_QUALIFIER __m128 sse_dot_ps(__m128 v1, __m128 v2)
+{
+	__m128 mul0 = _mm_mul_ps(v1, v2);
+	__m128 swp0 = _mm_shuffle_ps(mul0, mul0, _MM_SHUFFLE(2, 3, 0, 1));
+	__m128 add0 = _mm_add_ps(mul0, swp0);
+	__m128 swp1 = _mm_shuffle_ps(add0, add0, _MM_SHUFFLE(0, 1, 2, 3));
+	__m128 add1 = _mm_add_ps(add0, swp1);
+	return add1;
+}
+
+// SSE1
+GLM_FUNC_QUALIFIER __m128 sse_dot_ss(__m128 v1, __m128 v2)
+{
+	__m128 mul0 = _mm_mul_ps(v1, v2);
+	__m128 mov0 = _mm_movehl_ps(mul0, mul0);
+	__m128 add0 = _mm_add_ps(mov0, mul0);
+	__m128 swp1 = _mm_shuffle_ps(add0, add0, 1);
+	__m128 add1 = _mm_add_ss(add0, swp1);
+	return add1;
+}
+
+//cross
+GLM_FUNC_QUALIFIER __m128 sse_xpd_ps(__m128 v1, __m128 v2)
+{
+	__m128 swp0 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 swp1 = _mm_shuffle_ps(v1, v1, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 swp2 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 0, 2, 1));
+	__m128 swp3 = _mm_shuffle_ps(v2, v2, _MM_SHUFFLE(3, 1, 0, 2));
+	__m128 mul0 = _mm_mul_ps(swp0, swp3);
+	__m128 mul1 = _mm_mul_ps(swp1, swp2);
+	__m128 sub0 = _mm_sub_ps(mul0, mul1);
+	return sub0;
+}
+
+//normalize
+GLM_FUNC_QUALIFIER __m128 sse_nrm_ps(__m128 v)
+{
+	__m128 dot0 = sse_dot_ps(v, v);
+	__m128 isr0 = _mm_rsqrt_ps(dot0);
+	__m128 mul0 = _mm_mul_ps(v, isr0);
+	return mul0;
+}
+
+//faceforward
+GLM_FUNC_QUALIFIER __m128 sse_ffd_ps(__m128 N, __m128 I, __m128 Nref)
+{
+	//__m128 dot0 = _mm_dot_ps(v, v);
+	//__m128 neg0 = _mm_neg_ps(N);
+	//__m128 sgn0 = _mm_sgn_ps(dot0);
+	//__m128 mix0 = _mm_mix_ps(N, neg0, sgn0);
+	//return mix0;
+
+	__m128 dot0 = sse_dot_ps(Nref, I);
+	__m128 sgn0 = sse_sgn_ps(dot0);
+	__m128 mul0 = _mm_mul_ps(sgn0, glm::detail::minus_one);
+	__m128 mul1 = _mm_mul_ps(N, mul0);
+	return mul1;
+}
+
+//reflect
+GLM_FUNC_QUALIFIER __m128 sse_rfe_ps(__m128 I, __m128 N)
+{
+	__m128 dot0 = sse_dot_ps(N, I);
+	__m128 mul0 = _mm_mul_ps(N, dot0);
+	__m128 mul1 = _mm_mul_ps(mul0, glm::detail::two);
+	__m128 sub0 = _mm_sub_ps(I, mul1);
+	return sub0;
+}
+
+//refract
+GLM_FUNC_QUALIFIER __m128 sse_rfa_ps(__m128 I, __m128 N, __m128 eta)
+{
+	__m128 dot0 = sse_dot_ps(N, I);
+	__m128 mul0 = _mm_mul_ps(eta, eta);
+	__m128 mul1 = _mm_mul_ps(dot0, dot0);
+	__m128 sub0 = _mm_sub_ps(glm::detail::one, mul0);
+	__m128 sub1 = _mm_sub_ps(glm::detail::one, mul1);
+	__m128 mul2 = _mm_mul_ps(sub0, sub1);
+	
+	if(_mm_movemask_ps(_mm_cmplt_ss(mul2, glm::detail::zero)) == 0)
+		return glm::detail::zero;
+
+	__m128 sqt0 = _mm_sqrt_ps(mul2);
+	__m128 mul3 = _mm_mul_ps(eta, dot0);
+	__m128 add0 = _mm_add_ps(mul3, sqt0);
+	__m128 mul4 = _mm_mul_ps(add0, N);
+	__m128 mul5 = _mm_mul_ps(eta, I);
+	__m128 sub2 = _mm_sub_ps(mul5, mul4);
+
+	return sub2;
+}
+
+}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/core/intrinsic_matrix.hpp b/ExternalLibs/glm/core/intrinsic_matrix.hpp
new file mode 100644
index 0000000..7bb4bd1
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_matrix.hpp
@@ -0,0 +1,50 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-05
+// Updated : 2009-06-05
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_detail_intrinsic_matrix
+#define glm_detail_intrinsic_matrix
+
+#include "setup.hpp"
+
+#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+#include "intrinsic_geometric.hpp"
+
+namespace glm{
+namespace detail
+{
+	void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
+
+	void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4]);
+
+	__m128 sse_mul_ps(__m128 m[4], __m128 v);
+
+	__m128 sse_mul_ps(__m128 v, __m128 m[4]);
+
+	void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4]);
+
+	void sse_transpose_ps(__m128 const in[4], __m128 out[4]);
+
+	void sse_inverse_ps(__m128 const in[4], __m128 out[4]);
+
+	void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4]);
+
+	__m128 sse_det_ps(__m128 const m[4]);
+
+	__m128 sse_slow_det_ps(__m128 const m[4]);
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_matrix.inl"
+
+#endif//GLM_ARCH
+#endif//glm_detail_intrinsic_matrix
diff --git a/ExternalLibs/glm/core/intrinsic_matrix.inl b/ExternalLibs/glm/core/intrinsic_matrix.inl
new file mode 100644
index 0000000..326b65b
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_matrix.inl
@@ -0,0 +1,1075 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-05
+// Updated : 2009-06-05
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_common.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+static const __m128 _m128_rad_ps = _mm_set_ps1(3.141592653589793238462643383279f / 180.f);
+static const __m128 _m128_deg_ps = _mm_set_ps1(180.f / 3.141592653589793238462643383279f);
+
+template <typename matType>
+GLM_FUNC_QUALIFIER matType sse_comp_mul_ps
+(
+	__m128 const in1[4],
+	__m128 const in2[4],
+	__m128 out[4]
+)
+{
+	out[0] = _mm_mul_ps(in1[0], in2[0]);
+	out[1] = _mm_mul_ps(in1[1], in2[1]);
+	out[2] = _mm_mul_ps(in1[2], in2[2]);
+	out[3] = _mm_mul_ps(in1[3], in2[3]);
+}
+
+GLM_FUNC_QUALIFIER void sse_add_ps(__m128 in1[4], __m128 in2[4], __m128 out[4])
+{
+	{
+		out[0] = _mm_add_ps(in1[0], in2[0]);
+		out[1] = _mm_add_ps(in1[1], in2[1]);
+		out[2] = _mm_add_ps(in1[2], in2[2]);
+		out[3] = _mm_add_ps(in1[3], in2[3]);
+	}
+}
+
+GLM_FUNC_QUALIFIER void sse_sub_ps(__m128 in1[4], __m128 in2[4], __m128 out[4])
+{
+	{
+		out[0] = _mm_sub_ps(in1[0], in2[0]);
+		out[1] = _mm_sub_ps(in1[1], in2[1]);
+		out[2] = _mm_sub_ps(in1[2], in2[2]);
+		out[3] = _mm_sub_ps(in1[3], in2[3]);
+	}
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 m[4], __m128 v)
+{
+	__m128 v0 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 v1 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 v2 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 v3 = _mm_shuffle_ps(v, v, _MM_SHUFFLE(3, 3, 3, 3));
+
+	__m128 m0 = _mm_mul_ps(m[0], v0);
+	__m128 m1 = _mm_mul_ps(m[1], v1);
+	__m128 m2 = _mm_mul_ps(m[2], v2);
+	__m128 m3 = _mm_mul_ps(m[3], v3);
+
+	__m128 a0 = _mm_add_ps(m0, m1);
+	__m128 a1 = _mm_add_ps(m2, m3);
+	__m128 a2 = _mm_add_ps(a0, a1);
+
+	return a2;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_mul_ps(__m128 v, __m128 m[4])
+{
+	__m128 i0 = m[0];
+	__m128 i1 = m[1];
+	__m128 i2 = m[2];
+	__m128 i3 = m[3];
+
+	__m128 m0 = _mm_mul_ps(v, i0);
+	__m128 m1 = _mm_mul_ps(v, i1);
+	__m128 m2 = _mm_mul_ps(v, i2);
+	__m128 m3 = _mm_mul_ps(v, i3);
+
+	__m128 u0 = _mm_unpacklo_ps(m0, m1);
+	__m128 u1 = _mm_unpackhi_ps(m0, m1);
+	__m128 a0 = _mm_add_ps(u0, u1);
+
+	__m128 u2 = _mm_unpacklo_ps(m2, m3);
+	__m128 u3 = _mm_unpackhi_ps(m2, m3);
+	__m128 a1 = _mm_add_ps(u2, u3);
+
+	__m128 f0 = _mm_movelh_ps(a0, a1);
+	__m128 f1 = _mm_movehl_ps(a1, a0);
+	__m128 f2 = _mm_add_ps(f0, f1);
+
+	return f2;
+}
+
+GLM_FUNC_QUALIFIER void sse_mul_ps(__m128 const in1[4], __m128 const in2[4], __m128 out[4])
+{
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[0], in2[0], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[0] = a2;
+	}
+
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[1], in2[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[1] = a2;
+	}
+
+	{
+		__m128 e0 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[2], in2[2], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[2] = a2;
+	}
+
+	{
+		//(__m128&)_mm_shuffle_epi32(__m128i&)in2[0], _MM_SHUFFLE(3, 3, 3, 3))
+		__m128 e0 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 e1 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 e2 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 e3 = _mm_shuffle_ps(in2[3], in2[3], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 m0 = _mm_mul_ps(in1[0], e0);
+		__m128 m1 = _mm_mul_ps(in1[1], e1);
+		__m128 m2 = _mm_mul_ps(in1[2], e2);
+		__m128 m3 = _mm_mul_ps(in1[3], e3);
+
+		__m128 a0 = _mm_add_ps(m0, m1);
+		__m128 a1 = _mm_add_ps(m2, m3);
+		__m128 a2 = _mm_add_ps(a0, a1);
+
+		out[3] = a2;
+	}
+}
+
+GLM_FUNC_QUALIFIER void sse_transpose_ps(__m128 const in[4], __m128 out[4])
+{
+    __m128 tmp0 = _mm_shuffle_ps(in[0], in[1], 0x44);
+    __m128 tmp2 = _mm_shuffle_ps(in[0], in[1], 0xEE);
+    __m128 tmp1 = _mm_shuffle_ps(in[2], in[3], 0x44);
+    __m128 tmp3 = _mm_shuffle_ps(in[2], in[3], 0xEE);
+
+    out[0] = _mm_shuffle_ps(tmp0, tmp1, 0x88);
+    out[1] = _mm_shuffle_ps(tmp0, tmp1, 0xDD);
+    out[2] = _mm_shuffle_ps(tmp2, tmp3, 0x88);
+    out[3] = _mm_shuffle_ps(tmp2, tmp3, 0xDD);
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_slow_det_ps(__m128 const in[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0]
+	//						+ m[0][1] * Inverse[1][0]
+	//						+ m[0][2] * Inverse[2][0]
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = sse_dot_ps(in[0], Row2);
+	return Det0;
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_detd_ps
+(
+	__m128 const m[4]
+)
+{
+	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(
+
+	//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+	//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+	//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+	//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+	//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+	//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+	// First 2 columns
+ 	__m128 Swp2A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 1, 1, 2)));
+ 	__m128 Swp3A = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(3, 2, 3, 3)));
+	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
+
+	// Second 2 columns
+	__m128 Swp2B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(3, 2, 3, 3)));
+	__m128 Swp3B = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(0, 1, 1, 2)));
+	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
+
+	// Columns subtraction
+	__m128 SubE = _mm_sub_ps(MulA, MulB);
+
+	// Last 2 rows
+	__m128 Swp2C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[2]), _MM_SHUFFLE(0, 0, 1, 2)));
+	__m128 Swp3C = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[3]), _MM_SHUFFLE(1, 2, 0, 0)));
+	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
+	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
+
+	//detail::tvec4<T> DetCof(
+	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+	//	- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+	__m128 SubFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubE), _MM_SHUFFLE(2, 1, 0, 0)));
+	__m128 SwpFacA = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(0, 0, 0, 1)));
+	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
+
+	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
+	__m128 SubFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpB), _MM_SHUFFLE(3, 1, 1, 0)));//SubF[0], SubE[3], SubE[3], SubE[1];
+	__m128 SwpFacB = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(1, 1, 2, 2)));
+	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
+
+	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
+
+	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
+	__m128 SubFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(SubTmpC), _MM_SHUFFLE(3, 3, 2, 0)));
+	__m128 SwpFacC = _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(m[1]), _MM_SHUFFLE(2, 3, 3, 3)));
+	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
+
+	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
+	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
+
+	//return m[0][0] * DetCof[0]
+	//	 + m[0][1] * DetCof[1]
+	//	 + m[0][2] * DetCof[2]
+	//	 + m[0][3] * DetCof[3];
+
+	return sse_dot_ps(m[0], DetCof);
+}
+
+GLM_FUNC_QUALIFIER __m128 sse_det_ps
+(
+	__m128 const m[4]
+)
+{
+	// _mm_castsi128_ps(_mm_shuffle_epi32(_mm_castps_si128(add)
+
+	//T SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+	//T SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+	//T SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+	//T SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+	//T SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+	//T SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+
+	// First 2 columns
+ 	__m128 Swp2A = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 1, 1, 2));
+ 	__m128 Swp3A = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(3, 2, 3, 3));
+	__m128 MulA = _mm_mul_ps(Swp2A, Swp3A);
+
+	// Second 2 columns
+	__m128 Swp2B = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(3, 2, 3, 3));
+	__m128 Swp3B = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(0, 1, 1, 2));
+	__m128 MulB = _mm_mul_ps(Swp2B, Swp3B);
+
+	// Columns subtraction
+	__m128 SubE = _mm_sub_ps(MulA, MulB);
+
+	// Last 2 rows
+	__m128 Swp2C = _mm_shuffle_ps(m[2], m[2], _MM_SHUFFLE(0, 0, 1, 2));
+	__m128 Swp3C = _mm_shuffle_ps(m[3], m[3], _MM_SHUFFLE(1, 2, 0, 0));
+	__m128 MulC = _mm_mul_ps(Swp2C, Swp3C);
+	__m128 SubF = _mm_sub_ps(_mm_movehl_ps(MulC, MulC), MulC);
+
+	//detail::tvec4<T> DetCof(
+	//	+ (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02),
+	//	- (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04),
+	//	+ (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05),
+	//	- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
+
+	__m128 SubFacA = _mm_shuffle_ps(SubE, SubE, _MM_SHUFFLE(2, 1, 0, 0));
+	__m128 SwpFacA = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(0, 0, 0, 1));
+	__m128 MulFacA = _mm_mul_ps(SwpFacA, SubFacA);
+
+	__m128 SubTmpB = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(0, 0, 3, 1));
+	__m128 SubFacB = _mm_shuffle_ps(SubTmpB, SubTmpB, _MM_SHUFFLE(3, 1, 1, 0));//SubF[0], SubE[3], SubE[3], SubE[1];
+	__m128 SwpFacB = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(1, 1, 2, 2));
+	__m128 MulFacB = _mm_mul_ps(SwpFacB, SubFacB);
+
+	__m128 SubRes = _mm_sub_ps(MulFacA, MulFacB);
+
+	__m128 SubTmpC = _mm_shuffle_ps(SubE, SubF, _MM_SHUFFLE(1, 0, 2, 2));
+	__m128 SubFacC = _mm_shuffle_ps(SubTmpC, SubTmpC, _MM_SHUFFLE(3, 3, 2, 0));
+	__m128 SwpFacC = _mm_shuffle_ps(m[1], m[1], _MM_SHUFFLE(2, 3, 3, 3));
+	__m128 MulFacC = _mm_mul_ps(SwpFacC, SubFacC);
+
+	__m128 AddRes = _mm_add_ps(SubRes, MulFacC);
+	__m128 DetCof = _mm_mul_ps(AddRes, _mm_setr_ps( 1.0f,-1.0f, 1.0f,-1.0f));
+
+	//return m[0][0] * DetCof[0]
+	//	 + m[0][1] * DetCof[1]
+	//	 + m[0][2] * DetCof[2]
+	//	 + m[0][3] * DetCof[3];
+
+	return sse_dot_ps(m[0], DetCof);
+}
+
+GLM_FUNC_QUALIFIER void sse_inverse_ps(__m128 const in[4], __m128 out[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0] 
+	//						+ m[0][1] * Inverse[1][0] 
+	//						+ m[0][2] * Inverse[2][0] 
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = sse_dot_ps(in[0], Row2);
+	__m128 Rcp0 = _mm_div_ps(one, Det0);
+	//__m128 Rcp0 = _mm_rcp_ps(Det0);
+
+	//	Inverse /= Determinant;
+	out[0] = _mm_mul_ps(Inv0, Rcp0);
+	out[1] = _mm_mul_ps(Inv1, Rcp0);
+	out[2] = _mm_mul_ps(Inv2, Rcp0);
+	out[3] = _mm_mul_ps(Inv3, Rcp0);
+}
+
+GLM_FUNC_QUALIFIER void sse_inverse_fast_ps(__m128 const in[4], __m128 out[4])
+{
+	__m128 Fac0;
+	{
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		//	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		//	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac0 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac1;
+	{
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		//	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		//	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac1 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+
+	__m128 Fac2;
+	{
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		//	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		//	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac2 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac3;
+	{
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		//	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		//	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(3, 3, 3, 3));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(3, 3, 3, 3));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac3 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac4;
+	{
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		//	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		//	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(2, 2, 2, 2));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac4 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 Fac5;
+	{
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		//	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		//	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		__m128 Swp0a = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Swp0b = _mm_shuffle_ps(in[3], in[2], _MM_SHUFFLE(0, 0, 0, 0));
+
+		__m128 Swp00 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Swp01 = _mm_shuffle_ps(Swp0a, Swp0a, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp02 = _mm_shuffle_ps(Swp0b, Swp0b, _MM_SHUFFLE(2, 0, 0, 0));
+		__m128 Swp03 = _mm_shuffle_ps(in[2], in[1], _MM_SHUFFLE(1, 1, 1, 1));
+
+		__m128 Mul00 = _mm_mul_ps(Swp00, Swp01);
+		__m128 Mul01 = _mm_mul_ps(Swp02, Swp03);
+		Fac5 = _mm_sub_ps(Mul00, Mul01);
+
+		bool stop = true;
+	}
+
+	__m128 SignA = _mm_set_ps( 1.0f,-1.0f, 1.0f,-1.0f);
+	__m128 SignB = _mm_set_ps(-1.0f, 1.0f,-1.0f, 1.0f);
+
+	// m[1][0]
+	// m[0][0]
+	// m[0][0]
+	// m[0][0]
+	__m128 Temp0 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Vec0 = _mm_shuffle_ps(Temp0, Temp0, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][1]
+	// m[0][1]
+	// m[0][1]
+	// m[0][1]
+	__m128 Temp1 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 Vec1 = _mm_shuffle_ps(Temp1, Temp1, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][2]
+	// m[0][2]
+	// m[0][2]
+	// m[0][2]
+	__m128 Temp2 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 Vec2 = _mm_shuffle_ps(Temp2, Temp2, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// m[1][3]
+	// m[0][3]
+	// m[0][3]
+	// m[0][3]
+	__m128 Temp3 = _mm_shuffle_ps(in[1], in[0], _MM_SHUFFLE(3, 3, 3, 3));
+	__m128 Vec3 = _mm_shuffle_ps(Temp3, Temp3, _MM_SHUFFLE(2, 2, 2, 0));
+
+	// col0
+	// + (Vec1[0] * Fac0[0] - Vec2[0] * Fac1[0] + Vec3[0] * Fac2[0]),
+	// - (Vec1[1] * Fac0[1] - Vec2[1] * Fac1[1] + Vec3[1] * Fac2[1]),
+	// + (Vec1[2] * Fac0[2] - Vec2[2] * Fac1[2] + Vec3[2] * Fac2[2]),
+	// - (Vec1[3] * Fac0[3] - Vec2[3] * Fac1[3] + Vec3[3] * Fac2[3]),
+	__m128 Mul00 = _mm_mul_ps(Vec1, Fac0);
+	__m128 Mul01 = _mm_mul_ps(Vec2, Fac1);
+	__m128 Mul02 = _mm_mul_ps(Vec3, Fac2);
+	__m128 Sub00 = _mm_sub_ps(Mul00, Mul01);
+	__m128 Add00 = _mm_add_ps(Sub00, Mul02);
+	__m128 Inv0 = _mm_mul_ps(SignB, Add00);
+
+	// col1
+	// - (Vec0[0] * Fac0[0] - Vec2[0] * Fac3[0] + Vec3[0] * Fac4[0]),
+	// + (Vec0[0] * Fac0[1] - Vec2[1] * Fac3[1] + Vec3[1] * Fac4[1]),
+	// - (Vec0[0] * Fac0[2] - Vec2[2] * Fac3[2] + Vec3[2] * Fac4[2]),
+	// + (Vec0[0] * Fac0[3] - Vec2[3] * Fac3[3] + Vec3[3] * Fac4[3]),
+	__m128 Mul03 = _mm_mul_ps(Vec0, Fac0);
+	__m128 Mul04 = _mm_mul_ps(Vec2, Fac3);
+	__m128 Mul05 = _mm_mul_ps(Vec3, Fac4);
+	__m128 Sub01 = _mm_sub_ps(Mul03, Mul04);
+	__m128 Add01 = _mm_add_ps(Sub01, Mul05);
+	__m128 Inv1 = _mm_mul_ps(SignA, Add01);
+
+	// col2
+	// + (Vec0[0] * Fac1[0] - Vec1[0] * Fac3[0] + Vec3[0] * Fac5[0]),
+	// - (Vec0[0] * Fac1[1] - Vec1[1] * Fac3[1] + Vec3[1] * Fac5[1]),
+	// + (Vec0[0] * Fac1[2] - Vec1[2] * Fac3[2] + Vec3[2] * Fac5[2]),
+	// - (Vec0[0] * Fac1[3] - Vec1[3] * Fac3[3] + Vec3[3] * Fac5[3]),
+	__m128 Mul06 = _mm_mul_ps(Vec0, Fac1);
+	__m128 Mul07 = _mm_mul_ps(Vec1, Fac3);
+	__m128 Mul08 = _mm_mul_ps(Vec3, Fac5);
+	__m128 Sub02 = _mm_sub_ps(Mul06, Mul07);
+	__m128 Add02 = _mm_add_ps(Sub02, Mul08);
+	__m128 Inv2 = _mm_mul_ps(SignB, Add02);
+
+	// col3
+	// - (Vec1[0] * Fac2[0] - Vec1[0] * Fac4[0] + Vec2[0] * Fac5[0]),
+	// + (Vec1[0] * Fac2[1] - Vec1[1] * Fac4[1] + Vec2[1] * Fac5[1]),
+	// - (Vec1[0] * Fac2[2] - Vec1[2] * Fac4[2] + Vec2[2] * Fac5[2]),
+	// + (Vec1[0] * Fac2[3] - Vec1[3] * Fac4[3] + Vec2[3] * Fac5[3]));
+	__m128 Mul09 = _mm_mul_ps(Vec0, Fac2);
+	__m128 Mul10 = _mm_mul_ps(Vec1, Fac4);
+	__m128 Mul11 = _mm_mul_ps(Vec2, Fac5);
+	__m128 Sub03 = _mm_sub_ps(Mul09, Mul10);
+	__m128 Add03 = _mm_add_ps(Sub03, Mul11);
+	__m128 Inv3 = _mm_mul_ps(SignA, Add03);
+
+	__m128 Row0 = _mm_shuffle_ps(Inv0, Inv1, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row1 = _mm_shuffle_ps(Inv2, Inv3, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Row2 = _mm_shuffle_ps(Row0, Row1, _MM_SHUFFLE(2, 0, 2, 0));
+
+	//	valType Determinant = m[0][0] * Inverse[0][0] 
+	//						+ m[0][1] * Inverse[1][0] 
+	//						+ m[0][2] * Inverse[2][0] 
+	//						+ m[0][3] * Inverse[3][0];
+	__m128 Det0 = sse_dot_ps(in[0], Row2);
+	__m128 Rcp0 = _mm_rcp_ps(Det0);
+	//__m128 Rcp0 = _mm_div_ps(one, Det0);
+	//	Inverse /= Determinant;
+	out[0] = _mm_mul_ps(Inv0, Rcp0);
+	out[1] = _mm_mul_ps(Inv1, Rcp0);
+	out[2] = _mm_mul_ps(Inv2, Rcp0);
+	out[3] = _mm_mul_ps(Inv3, Rcp0);
+}
+
+GLM_FUNC_QUALIFIER void sse_rotate_ps(__m128 const in[4], float Angle, float const v[3], __m128 out[4])
+{
+	float a = glm::radians(Angle);
+    float c = cos(a);
+    float s = sin(a);
+
+	glm::vec4 AxisA(v[0], v[1], v[2], float(0));
+	__m128 AxisB = _mm_set_ps(AxisA.w, AxisA.z, AxisA.y, AxisA.x);
+    __m128 AxisC = detail::sse_nrm_ps(AxisB);
+
+	__m128 Cos0 = _mm_set_ss(c);
+	__m128 CosA = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 Sin0 = _mm_set_ss(s);
+	__m128 SinA = _mm_shuffle_ps(Sin0, Sin0, _MM_SHUFFLE(0, 0, 0, 0));
+
+	// detail::tvec3<valType> temp = (valType(1) - c) * axis;
+	__m128 Temp0 = _mm_sub_ps(one, CosA);
+	__m128 Temp1 = _mm_mul_ps(Temp0, AxisC);
+	
+	//Rotate[0][0] = c + temp[0] * axis[0];
+	//Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+	//Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+	__m128 Axis0 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(0, 0, 0, 0));
+	__m128 TmpA0 = _mm_mul_ps(Axis0, AxisC);
+	__m128 CosA0 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 1, 0));
+	__m128 TmpA1 = _mm_add_ps(CosA0, TmpA0);
+	__m128 SinA0 = SinA;//_mm_set_ps(0.0f, s, -s, 0.0f);
+	__m128 TmpA2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 1, 2, 3));
+	__m128 TmpA3 = _mm_mul_ps(SinA0, TmpA2);
+	__m128 TmpA4 = _mm_add_ps(TmpA1, TmpA3);
+
+	//Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+	//Rotate[1][1] = c + temp[1] * axis[1];
+	//Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+	__m128 Axis1 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(1, 1, 1, 1));
+	__m128 TmpB0 = _mm_mul_ps(Axis1, AxisC);
+	__m128 CosA1 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 1, 0, 1));
+	__m128 TmpB1 = _mm_add_ps(CosA1, TmpB0);
+	__m128 SinB0 = SinA;//_mm_set_ps(-s, 0.0f, s, 0.0f);
+	__m128 TmpB2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 0, 3, 2));
+	__m128 TmpB3 = _mm_mul_ps(SinA0, TmpB2);
+	__m128 TmpB4 = _mm_add_ps(TmpB1, TmpB3);
+
+    //Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+    //Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+    //Rotate[2][2] = c + temp[2] * axis[2];
+	__m128 Axis2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(2, 2, 2, 2));
+	__m128 TmpC0 = _mm_mul_ps(Axis2, AxisC);
+	__m128 CosA2 = _mm_shuffle_ps(Cos0, Cos0, _MM_SHUFFLE(1, 0, 1, 1));
+	__m128 TmpC1 = _mm_add_ps(CosA2, TmpC0);
+	__m128 SinC0 = SinA;//_mm_set_ps(s, -s, 0.0f, 0.0f);
+	__m128 TmpC2 = _mm_shuffle_ps(AxisC, AxisC, _MM_SHUFFLE(3, 3, 0, 1));
+	__m128 TmpC3 = _mm_mul_ps(SinA0, TmpC2);
+	__m128 TmpC4 = _mm_add_ps(TmpC1, TmpC3);
+
+	__m128 Result[4];
+	Result[0] = TmpA4;
+	Result[1] = TmpB4;
+	Result[2] = TmpC4;
+	Result[3] = _mm_set_ps(1, 0, 0, 0);
+
+	//detail::tmat4x4<valType> Result(detail::tmat4x4<valType>::null);
+	//Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+	//Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+	//Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+	//Result[3] = m[3];
+	//return Result;
+	sse_mul_ps(in, Result, out);
+}
+
+GLM_FUNC_QUALIFIER void sse_outer_ps(__m128 const & c, __m128 const & r, __m128 out[4])
+{
+	out[0] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(0, 0, 0, 0)));
+	out[1] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(1, 1, 1, 1)));
+	out[2] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(2, 2, 2, 2)));
+	out[3] = _mm_mul_ps(c, _mm_shuffle_ps(r, r, _MM_SHUFFLE(3, 3, 3, 3)));
+}
+
+}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/core/intrinsic_trigonometric.hpp b/ExternalLibs/glm/core/intrinsic_trigonometric.hpp
new file mode 100644
index 0000000..cdd82c4
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_trigonometric.hpp
@@ -0,0 +1,29 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-09
+// Updated : 2009-06-09
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_trigonometric.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_detail_intrinsic_trigonometric
+#define glm_detail_intrinsic_trigonometric
+
+#include "setup.hpp"
+
+#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_trigonometric.inl"
+
+#endif//GLM_ARCH
+#endif//glm_detail_intrinsic_trigonometric
diff --git a/ExternalLibs/glm/core/intrinsic_trigonometric.inl b/ExternalLibs/glm/core/intrinsic_trigonometric.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/core/intrinsic_vector_relational.hpp b/ExternalLibs/glm/core/intrinsic_vector_relational.hpp
new file mode 100644
index 0000000..e53817a
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_vector_relational.hpp
@@ -0,0 +1,29 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-09
+// Updated : 2009-06-09
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_vector_relational.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_detail_intrinsic_vector_relational
+#define glm_detail_intrinsic_vector_relational
+
+#include "setup.hpp"
+
+#if((GLM_ARCH & GLM_ARCH_SSE2) != GLM_ARCH_SSE2)
+#	error "SSE2 instructions not supported or enabled"
+#else
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
+
+#include "intrinsic_vector_relational.inl"
+
+#endif//GLM_ARCH
+#endif//glm_detail_intrinsic_vector_relational
diff --git a/ExternalLibs/glm/core/intrinsic_vector_relational.inl b/ExternalLibs/glm/core/intrinsic_vector_relational.inl
new file mode 100644
index 0000000..78ccae5
--- /dev/null
+++ b/ExternalLibs/glm/core/intrinsic_vector_relational.inl
@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-09
+// Updated : 2009-06-09
+// Licence : This source is under MIT License
+// File    : glm/core/intrinsic_vector_relational.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//// lessThan
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThan
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//    return typename detail::tvec2<bool>::bool_type(x.x < y.x, x.y < y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThan
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec3<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThan
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec4<bool>::bool_type(x.x < y.x, x.y < y.y, x.z < y.z, x.w < y.w);
+//}
+//
+//// lessThanEqual
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type lessThanEqual
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec2<bool>::bool_type(x.x <= y.x, x.y <= y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type lessThanEqual
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec3<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type lessThanEqual
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec4<bool>::bool_type(x.x <= y.x, x.y <= y.y, x.z <= y.z, x.w <= y.w);
+//}
+//
+//// greaterThan
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type greaterThan
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec2<bool>::bool_type(x.x > y.x, x.y > y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThan
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec3<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThan
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//	
+//	return typename detail::tvec4<bool>::bool_type(x.x > y.x, x.y > y.y, x.z > y.z, x.w > y.w);
+//}
+//
+//// greaterThanEqual
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type greaterThanEqual
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec2<bool>::bool_type(x.x >= y.x, x.y >= y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type greaterThanEqual
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec3<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type greaterThanEqual
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint);
+//
+//	return typename detail::tvec4<bool>::bool_type(x.x >= y.x, x.y >= y.y, x.z >= y.z, x.w >= y.w);
+//}
+//
+//// equal
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type equal
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec2<valType>::bool_type(x.x == y.x, x.y == y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type equal
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec3<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type equal
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec4<valType>::bool_type(x.x == y.x, x.y == y.y, x.z == y.z, x.w == y.w);
+//}
+//
+//// notEqual
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec2<valType>::bool_type notEqual
+//(
+//	detail::tvec2<valType> const & x, 
+//	detail::tvec2<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec2<valType>::bool_type(x.x != y.x, x.y != y.y);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec3<valType>::bool_type notEqual
+//(
+//	detail::tvec3<valType> const & x, 
+//	detail::tvec3<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec3<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z);
+//}
+//
+//template <typename valType>
+//GLM_FUNC_QUALIFIER typename detail::tvec4<valType>::bool_type notEqual
+//(
+//	detail::tvec4<valType> const & x, 
+//	detail::tvec4<valType> const & y
+//)
+//{
+//	GLM_STATIC_ASSERT(
+//		detail::type<valType>::is_float || 
+//		detail::type<valType>::is_int || 
+//		detail::type<valType>::is_uint || 
+//		detail::type<valType>::is_bool);
+//
+//	return typename detail::tvec4<valType>::bool_type(x.x != y.x, x.y != y.y, x.z != y.z, x.w != y.w);
+//}
+//
+//// any
+//GLM_FUNC_QUALIFIER bool any(detail::tvec2<bool> const & x)
+//{
+//	return x.x || x.y;
+//}
+//
+//GLM_FUNC_QUALIFIER bool any(detail::tvec3<bool> const & x)
+//{
+//    return x.x || x.y || x.z;
+//}
+//
+//GLM_FUNC_QUALIFIER bool any(detail::tvec4<bool> const & x)
+//{
+//    return x.x || x.y || x.z || x.w;
+//}
+//
+//// all
+//GLM_FUNC_QUALIFIER bool all(const detail::tvec2<bool>& x)
+//{
+//    return x.x && x.y;
+//}
+//
+//GLM_FUNC_QUALIFIER bool all(const detail::tvec3<bool>& x)
+//{
+//    return x.x && x.y && x.z;
+//}
+//
+//GLM_FUNC_QUALIFIER bool all(const detail::tvec4<bool>& x)
+//{
+//    return x.x && x.y && x.z && x.w;
+//}
+//
+//// not
+//GLM_FUNC_QUALIFIER detail::tvec2<bool>::bool_type not_
+//(
+//	detail::tvec2<bool> const & v
+//)
+//{
+//    return detail::tvec2<bool>::bool_type(!v.x, !v.y);
+//}
+//
+//GLM_FUNC_QUALIFIER detail::tvec3<bool>::bool_type not_
+//(
+//	detail::tvec3<bool> const & v
+//)
+//{
+//    return detail::tvec3<bool>::bool_type(!v.x, !v.y, !v.z);
+//}
+//
+//GLM_FUNC_QUALIFIER detail::tvec4<bool>::bool_type not_
+//(
+//	detail::tvec4<bool> const & v
+//)
+//{
+//    return detail::tvec4<bool>::bool_type(!v.x, !v.y, !v.z, !v.w);
+//}
\ No newline at end of file
diff --git a/ExternalLibs/glm/core/setup.hpp b/ExternalLibs/glm/core/setup.hpp
new file mode 100644
index 0000000..38192aa
--- /dev/null
+++ b/ExternalLibs/glm/core/setup.hpp
@@ -0,0 +1,478 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-11-13
+// Updated : 2011-01-26
+// Licence : This source is under MIT License
+// File    : glm/setup.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_setup
+#define glm_setup
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Version
+
+#define GLM_VERSION					92
+#define GLM_VERSION_MAJOR			0
+#define GLM_VERSION_MINOR			9
+#define GLM_VERSION_PATCH			2
+#define GLM_VERSION_REVISION		1
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Compiler
+
+// User defines: GLM_FORCE_COMPILER_UNKNOWN
+// TODO ? __llvm__ 
+
+#define GLM_COMPILER_UNKNOWN		0x00000000
+
+// Visual C++ defines
+#define GLM_COMPILER_VC				0x01000000
+#define GLM_COMPILER_VC2			0x01000010
+#define GLM_COMPILER_VC4			0x01000020
+#define GLM_COMPILER_VC5			0x01000030
+#define GLM_COMPILER_VC6			0x01000040
+#define GLM_COMPILER_VC2002			0x01000050
+#define GLM_COMPILER_VC2003			0x01000060
+#define GLM_COMPILER_VC2005			0x01000070
+#define GLM_COMPILER_VC2008			0x01000080
+#define GLM_COMPILER_VC2010			0x01000090
+#define GLM_COMPILER_VC2011			0x010000A0
+
+// GCC defines
+#define GLM_COMPILER_GCC            0x02000000
+#define GLM_COMPILER_GCC_LLVM       0x02000000
+#define GLM_COMPILER_GCC_CLANG      0x02000000
+#define GLM_COMPILER_GCC30			0x02000010
+#define GLM_COMPILER_GCC31			0x02000020
+#define GLM_COMPILER_GCC32			0x02000030
+#define GLM_COMPILER_GCC33			0x02000040
+#define GLM_COMPILER_GCC34			0x02000050
+#define GLM_COMPILER_GCC35			0x02000060
+#define GLM_COMPILER_GCC40			0x02000070
+#define GLM_COMPILER_GCC41			0x02000080
+#define GLM_COMPILER_GCC42			0x02000090
+#define GLM_COMPILER_GCC43			0x020000A0
+#define GLM_COMPILER_GCC44			0x020000B0
+#define GLM_COMPILER_GCC45			0x020000C0
+#define GLM_COMPILER_GCC46			0x020000D0
+#define GLM_COMPILER_GCC47			0x020000E0
+#define GLM_COMPILER_GCC48			0x020000F0
+#define GLM_COMPILER_GCC49			0x02000100
+#define GLM_COMPILER_GCC50			0x02000200
+
+// G++ command line to display defined
+// echo "" | g++ -E -dM -x c++ - | sort
+
+// Borland C++ defines. How to identify BC?
+#define GLM_COMPILER_BC				0x04000000
+#define GLM_COMPILER_BCB4			0x04000100
+#define GLM_COMPILER_BCB5			0x04000200
+#define GLM_COMPILER_BCB6			0x04000300
+//#define GLM_COMPILER_BCBX			0x04000400 // What's the version value?
+#define GLM_COMPILER_BCB2009		0x04000500
+
+// CodeWarrior
+#define GLM_COMPILER_CODEWARRIOR	0x08000000
+
+// CUDA
+#define GLM_COMPILER_CUDA           0x10000000
+#define GLM_COMPILER_CUDA30			0x10000010
+#define GLM_COMPILER_CUDA31			0x10000020
+#define GLM_COMPILER_CUDA32			0x10000030
+#define GLM_COMPILER_CUDA40			0x10000040
+
+// Clang
+#define GLM_COMPILER_CLANG          0x20000000
+#define GLM_COMPILER_CLANG26		0x20000010
+#define GLM_COMPILER_CLANG27		0x20000020
+#define GLM_COMPILER_CLANG28		0x20000030
+#define GLM_COMPILER_CLANG29		0x20000040
+
+// LLVM GCC
+#define GLM_COMPILER_LLVM_GCC		0x40000000
+
+// Build model
+#define GLM_MODEL_32				0x00000010
+#define GLM_MODEL_64				0x00000020
+
+// Force generic C++ compiler
+#ifdef GLM_FORCE_COMPILER_UNKNOWN
+#		define GLM_COMPILER GLM_COMPILER_UNKNOWN
+
+// CUDA
+#elif defined(__CUDACC__)
+#	define GLM_COMPILER GLM_COMPILER_CUDA
+
+// Visual C++
+#elif defined(_MSC_VER)
+#	if _MSC_VER == 900
+#		define GLM_COMPILER GLM_COMPILER_VC2
+#	elif _MSC_VER == 1000
+#		define GLM_COMPILER GLM_COMPILER_VC4
+#	elif _MSC_VER == 1100
+#		define GLM_COMPILER GLM_COMPILER_VC5
+#	elif _MSC_VER == 1200
+#		define GLM_COMPILER GLM_COMPILER_VC6
+#	elif _MSC_VER == 1300
+#		define GLM_COMPILER GLM_COMPILER_VC2002
+#	elif _MSC_VER == 1310
+#		define GLM_COMPILER GLM_COMPILER_VC2003
+#	elif _MSC_VER == 1400
+#		define GLM_COMPILER GLM_COMPILER_VC2005
+#	elif _MSC_VER == 1500
+#		define GLM_COMPILER GLM_COMPILER_VC2008
+#	elif _MSC_VER == 1600
+#		define GLM_COMPILER GLM_COMPILER_VC2010
+#	elif _MSC_VER == 1700
+#		define GLM_COMPILER GLM_COMPILER_VC2011
+#	else//_MSC_VER
+#		define GLM_COMPILER GLM_COMPILER_VC
+#	endif//_MSC_VER
+
+// G++
+#elif defined(__GNUC__) || defined(__llvm__) || defined(__clang__)
+#   if defined (__llvm__)
+#       pragma message("LLVM")
+#       define GLM_COMPILER_GCC_EXTRA GLM_COMPILER_GCC_LLVM
+#   elif defined (__clang__)
+#       pragma message("CLANG")
+#       define GLM_COMPILER_GCC_EXTRA GLM_COMPILER_GCC_CLANG
+#   else
+#       pragma message("GCC")
+#       define GLM_COMPILER_GCC_EXTRA 0
+#   endif
+#
+#	if   (__GNUC__ == 3) && (__GNUC_MINOR__ == 2)
+#		define GLM_COMPILER GLM_COMPILER_GCC32
+#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 3)
+#		define GLM_COMPILER GLM_COMPILER_GCC33
+#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 4)
+#		define GLM_COMPILER GLM_COMPILER_GCC34
+#	elif (__GNUC__ == 3) && (__GNUC_MINOR__ == 5)
+#		define GLM_COMPILER GLM_COMPILER_GCC35
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 0)
+#		define GLM_COMPILER (GLM_COMPILER_GCC40 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 1)
+#		define GLM_COMPILER (GLM_COMPILER_GCC41 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 2)
+#		define GLM_COMPILER (GLM_COMPILER_GCC42 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
+#		define GLM_COMPILER (GLM_COMPILER_GCC43 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 4)
+#		define GLM_COMPILER (GLM_COMPILER_GCC44 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 5)
+#		define GLM_COMPILER (GLM_COMPILER_GCC45 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 6)
+#		define GLM_COMPILER (GLM_COMPILER_GCC46 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 7)
+#		define GLM_COMPILER (GLM_COMPILER_GCC47 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 8)
+#		define GLM_COMPILER (GLM_COMPILER_GCC48 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 4) && (__GNUC_MINOR__ == 9)
+#		define GLM_COMPILER (GLM_COMPILER_GCC49 | GLM_COMPILER_GCC_EXTRA)
+#	elif (__GNUC__ == 5) && (__GNUC_MINOR__ == 0)
+#		define GLM_COMPILER (GLM_COMPILER_GCC50 | GLM_COMPILER_GCC_EXTRA)
+#	else
+#		define GLM_COMPILER (GLM_COMPILER_GCC | GLM_COMPILER_GCC_EXTRA)
+#	endif
+
+// Borland C++
+#elif defined(_BORLANDC_)
+#	if defined(VER125)
+#		define GLM_COMPILER GLM_COMPILER_BCB4
+#	elif defined(VER130)
+#		define GLM_COMPILER GLM_COMPILER_BCB5
+#	elif defined(VER140)
+#		define GLM_COMPILER GLM_COMPILER_BCB6
+#	elif defined(VER200)
+#		define GLM_COMPILER GLM_COMPILER_BCB2009
+#	else
+#		define GLM_COMPILER GLM_COMPILER_BC
+#	endif
+
+// Codewarrior
+#elif defined(__MWERKS__)
+#	define GLM_COMPILER GLM_COMPILER_CODEWARRIOR
+
+#else
+#	define GLM_COMPILER GLM_COMPILER_UNKNOWN
+#endif
+
+#ifndef GLM_COMPILER
+#error "GLM_COMPILER undefined, your compiler may not be supported by GLM. Add #define GLM_COMPILER 0 to ignore this message."
+#endif//GLM_COMPILER
+
+// Report compiler detection
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED))
+#	define GLM_MESSAGE_COMPILER_DISPLAYED
+#	if(GLM_COMPILER & GLM_COMPILER_CUDA)
+#		pragma message("GLM: CUDA compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_VC)
+#		pragma message("GLM: Visual C++ compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#		pragma message("GLM: Clang compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
+#		pragma message("GLM: LLVM GCC compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_GCC)
+#       if(GLM_COMPILER & GLM_COMPILER_GCC_LLVM)
+#           pragma message("GLM: LLVM GCC compiler detected")
+#       elif(GLM_COMPILER & GLM_COMPILER_GCC_CLANG)
+#           pragma message("GLM: CLANG compiler detected")
+#       else
+#           pragma message("GLM: GCC compiler detected")
+#       endif
+#	elif(GLM_COMPILER & GLM_COMPILER_BC)
+#		pragma message("GLM: Borland compiler detected but not supported")
+#	elif(GLM_COMPILER & GLM_COMPILER_CODEWARRIOR)
+#		pragma message("GLM: Codewarrior compiler detected but not supported")
+#	else
+#		pragma message("GLM: Compiler not detected")
+#	endif
+#endif//GLM_MESSAGE
+
+/////////////////
+// Build model //
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#	if defined(_M_X64)
+#		define GLM_MODEL	GLM_MODEL_64
+#	else
+#		define GLM_MODEL	GLM_MODEL_32
+#	endif//_M_X64
+#elif(GLM_COMPILER & GLM_COMPILER_GCC)
+#	if(defined(__WORDSIZE) && (__WORDSIZE == 64)) || defined(__arch64__) || defined(__LP64__) || defined(__x86_64__)
+#		define GLM_MODEL	GLM_MODEL_64
+#	else
+#		define GLM_MODEL	GLM_MODEL_32
+#	endif//
+#else
+#	define GLM_MODEL	GLM_MODEL_32
+#endif//
+
+#if(!defined(GLM_MODEL) && GLM_COMPILER != 0)
+#error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
+#endif//GLM_MODEL
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED))
+#	define GLM_MESSAGE_MODEL_DISPLAYED
+#	if(GLM_MODEL == GLM_MODEL_64)
+#		pragma message("GLM: 64 bits model")
+#	elif(GLM_MODEL == GLM_MODEL_32)
+#		pragma message("GLM: 32 bits model")
+#	endif//GLM_MODEL
+#endif//GLM_MESSAGE
+
+/////////////////
+// C++ Version //
+
+// User defines: GLM_FORCE_CXX98
+
+#define GLM_LANG_CXX			0
+#define GLM_LANG_CXX98			1
+#define GLM_LANG_CXX0X			2
+#define GLM_LANG_CXXMS			3
+#define GLM_LANG_CXXGNU			4
+
+#if(defined(GLM_FORCE_CXX98))
+#	define GLM_LANG GLM_LANG_CXX98
+#elif(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__GXX_EXPERIMENTAL_CXX0X__)) // -std=c++0x or -std=gnu++0x
+#	define GLM_LANG GLM_LANG_CXX0X
+#elif(GLM_COMPILER == GLM_COMPILER_VC2010) //_MSC_EXTENSIONS for MS language extensions
+#	define GLM_LANG GLM_LANG_CXX0X
+#elif(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__STRICT_ANSI__))
+#	define GLM_LANG GLM_LANG_CXX98
+#elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && !defined(_MSC_EXTENSIONS))
+#	define GLM_LANG GLM_LANG_CXX98
+#else
+#	define GLM_LANG GLM_LANG_CXX
+#endif
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED))
+#	define GLM_MESSAGE_LANG_DISPLAYED
+#	if(GLM_LANG == GLM_LANG_CXX98)
+#		pragma message("GLM: C++98")
+#	elif(GLM_LANG == GLM_LANG_CXX0X)
+#		pragma message("GLM: C++0x")
+#	endif//GLM_MODEL
+#endif//GLM_MESSAGE
+
+/////////////////
+// Platform 
+
+// User defines: GLM_FORCE_PURE GLM_FORCE_SSE2 GLM_FORCE_AVX
+
+#define GLM_ARCH_PURE		0x0000 //(0x0000)
+#define GLM_ARCH_SSE2		0x0001 //(0x0001)
+#define GLM_ARCH_SSE3		0x0003 //(0x0002 | GLM_ARCH_SSE2)
+#define GLM_ARCH_AVX		0x0007 //(0x0004 | GLM_ARCH_SSE3 | GLM_ARCH_SSE2)
+
+#if(defined(GLM_FORCE_PURE))
+#	define GLM_ARCH GLM_ARCH_PURE
+#elif(defined(GLM_FORCE_AVX))
+#	define GLM_ARCH GLM_ARCH_AVX
+#elif(defined(GLM_FORCE_SSE3))
+#	define GLM_ARCH GLM_ARCH_SSE3
+#elif(defined(GLM_FORCE_SSE2))
+#	define GLM_ARCH GLM_ARCH_SSE2
+#elif((GLM_COMPILER & GLM_COMPILER_VC) && (defined(_M_IX86) || defined(_M_X64)))
+#	if(defined(_M_CEE_PURE))
+#		define GLM_ARCH GLM_ARCH_PURE
+#	elif(GLM_COMPILER >= GLM_COMPILER_VC2010)
+#		if(_MSC_FULL_VER >= 160031118) //160031118: VC2010 SP1 beta full version
+#			define GLM_ARCH GLM_ARCH_AVX //GLM_ARCH_AVX (Require SP1)
+#		else
+#			define GLM_ARCH GLM_ARCH_SSE3
+#		endif
+#	elif(GLM_COMPILER >= GLM_COMPILER_VC2008) 
+#		define GLM_ARCH GLM_ARCH_SSE3
+#	elif(GLM_COMPILER >= GLM_COMPILER_VC2005)
+#		define GLM_ARCH GLM_ARCH_SSE2
+#	else
+#		define GLM_ARCH GLM_ARCH_PURE
+#	endif
+#elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
+#	if(defined(__AVX__))
+#		define GLM_ARCH GLM_ARCH_AVX
+#	elif(defined(__SSE3__))
+#		define GLM_ARCH GLM_ARCH_SSE3
+#	elif(defined(__SSE2__))
+#		define GLM_ARCH GLM_ARCH_SSE2
+#	else
+#		define GLM_ARCH GLM_ARCH_PURE
+#	endif
+#elif((GLM_COMPILER & GLM_COMPILER_GCC) && (defined(__i386__) || defined(__x86_64__)))
+#	if(defined(__AVX__))
+#		define GLM_ARCH GLM_ARCH_AVX
+#	elif(defined(__SSE3__))
+#		define GLM_ARCH GLM_ARCH_SSE3
+#	elif(defined(__SSE2__))
+#		define GLM_ARCH GLM_ARCH_SSE2
+#	else
+#		define GLM_ARCH GLM_ARCH_PURE
+#	endif
+#else
+#	define GLM_ARCH GLM_ARCH_PURE
+#endif
+
+#if(GLM_ARCH != GLM_ARCH_PURE)
+#if((GLM_ARCH & GLM_ARCH_AVX) == GLM_ARCH_AVX)
+#	include <immintrin.h>
+#endif//GLM_ARCH
+#if((GLM_ARCH & GLM_ARCH_SSE3) == GLM_ARCH_SSE3)
+#	include <pmmintrin.h>
+#endif//GLM_ARCH
+#if((GLM_ARCH & GLM_ARCH_SSE2) == GLM_ARCH_SSE2)
+#	include <emmintrin.h>
+#endif//GLM_ARCH
+#endif//(GLM_ARCH != GLM_ARCH_PURE)
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED))
+#	define GLM_MESSAGE_ARCH_DISPLAYED
+#	if(GLM_ARCH == GLM_ARCH_PURE)
+#		pragma message("GLM: Platform independent")
+#	elif(GLM_ARCH == GLM_ARCH_SSE2)
+#		pragma message("GLM: SSE2 build platform")
+#	elif(GLM_ARCH == GLM_ARCH_SSE3)
+#		pragma message("GLM: SSE3 build platform")
+#	elif(GLM_ARCH == GLM_ARCH_AVX)
+#		pragma message("GLM: AVX build platform")
+#	endif//GLM_ARCH
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Components
+
+//#define GLM_FORCE_ONLY_XYZW
+#define GLM_COMPONENT_GLSL_NAMES			0 
+#define GLM_COMPONENT_ONLY_XYZW				1 // To disable multiple vector component names access.
+#define GLM_COMPONENT_MS_EXT				2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
+
+#ifndef GLM_FORCE_ONLY_XYZW
+#	if((GLM_COMPILER & GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS))
+#		define GLM_COMPONENT GLM_COMPONENT_MS_EXT
+#	else
+#		define GLM_COMPONENT GLM_COMPONENT_GLSL_NAMES
+#	endif
+#else
+#	define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW
+#endif
+
+#if((GLM_COMPONENT == GLM_COMPONENT_MS_EXT) && !(GLM_COMPILER & GLM_COMPILER_VC))
+#	error "GLM_COMPONENT value is GLM_COMPONENT_MS_EXT but this is not allowed with the current compiler."
+#endif
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
+#	define GLM_MESSAGE_COMPONENT_DISPLAYED
+#	if(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+#		pragma message("GLM: GLSL multiple vector component names")
+#	elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+#		pragma message("GLM: x,y,z,w vector component names only")
+#	elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+#		pragma message("GLM: Multiple vector component names through Visual C++ language extensions")
+#	else
+#		error "GLM_COMPONENT value unknown"
+#	endif//GLM_MESSAGE_COMPONENT_DISPLAYED
+#endif//GLM_MESSAGE
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Static assert
+
+#if(GLM_LANG == GLM_LANG_CXX0X)
+#	define GLM_STATIC_ASSERT(x, message) static_assert(x, message)
+#elif(defined(BOOST_STATIC_ASSERT))
+#	define GLM_STATIC_ASSERT(x, message) BOOST_STATIC_ASSERT(x)
+#elif(GLM_COMPILER & GLM_COMPILER_VC)
+#	define GLM_STATIC_ASSERT(x, message) typedef char __CASSERT__##__LINE__[(x) ? 1 : -1]
+#else
+#	define GLM_STATIC_ASSERT(x, message)
+#	define GLM_STATIC_ASSERT_NULL
+#endif//GLM_LANG
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Qualifiers 
+
+// User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
+
+#if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
+#   define GLM_CUDA_FUNC_DEF __device__ __host__ 
+#	define GLM_CUDA_FUNC_DECL __device__ __host__ 
+#else
+#   define GLM_CUDA_FUNC_DEF
+#	define GLM_CUDA_FUNC_DECL
+#endif
+
+#if(defined(GLM_FORCE_INLINE))
+#   if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
+#       define GLM_INLINE __forceinline
+#   elif((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC34))
+#       define GLM_INLINE __attribute__((always_inline))
+#   else
+#       define GLM_INLINE inline
+#   endif//GLM_COMPILER
+#else
+#   define GLM_INLINE inline
+#endif//defined(GLM_FORCE_INLINE)
+
+#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
+#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Swizzle operators
+
+// User defines: GLM_SWIZZLE_XYZW GLM_SWIZZLE_RGBA GLM_SWIZZLE_STQP GLM_SWIZZLE
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED))
+#	define GLM_MESSAGE_SWIZZLE_DISPLAYED
+#	if(defined(GLM_SWIZZLE))
+#		pragma message("GLM: Full swizzling operator enabled")
+#	elif(!defined(GLM_SWIZZLE_XYZW) && !defined(GLM_SWIZZLE_RGBA) && !defined(GLM_SWIZZLE_STQP) && !defined(GLM_SWIZZLE))
+#		pragma message("GLM: No swizzling operator enabled")
+#	else
+#		pragma message("GLM: Partial swizzling operator enabled")
+#	endif
+#endif//GLM_MESSAGE
+
+#endif//glm_setup
diff --git a/ExternalLibs/glm/core/type.hpp b/ExternalLibs/glm/core/type.hpp
new file mode 100644
index 0000000..0117c3c
--- /dev/null
+++ b/ExternalLibs/glm/core/type.hpp
@@ -0,0 +1,322 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-01-08
+// Updated : 2008-01-08
+// Licence : This source is under MIT License
+// File    : glm/core/type.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type
+#define glm_core_type
+
+#include "type_half.hpp"
+#include "type_float.hpp"
+#include "type_int.hpp"
+
+#include "type_gentype.hpp"
+
+#include "type_vec1.hpp"
+#include "type_vec2.hpp"
+#include "type_vec3.hpp"
+#include "type_vec4.hpp"
+
+#include "type_mat2x2.hpp"
+#include "type_mat2x3.hpp"
+#include "type_mat2x4.hpp"
+#include "type_mat3x2.hpp"
+#include "type_mat3x3.hpp"
+#include "type_mat3x4.hpp"
+#include "type_mat4x2.hpp"
+#include "type_mat4x3.hpp"
+#include "type_mat4x4.hpp"
+
+namespace glm{
+namespace core{
+namespace type
+{
+	//////////////////////////
+	// Float definition
+
+#if(defined(GLM_PRECISION_HIGHP_FLOAT))
+	typedef precision::highp_vec2		vec2;
+	typedef precision::highp_vec3		vec3;
+	typedef precision::highp_vec4		vec4;
+	typedef precision::highp_mat2x2		mat2x2;
+	typedef precision::highp_mat2x3		mat2x3;
+	typedef precision::highp_mat2x4		mat2x4;
+	typedef precision::highp_mat3x2		mat3x2;
+	typedef precision::highp_mat3x3		mat3x3;
+	typedef precision::highp_mat3x4		mat3x4;
+	typedef precision::highp_mat4x2		mat4x2;
+	typedef precision::highp_mat4x3		mat4x3;
+	typedef precision::highp_mat4x4		mat4x4;
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	typedef precision::mediump_vec2		vec2;
+	typedef precision::mediump_vec3		vec3;
+	typedef precision::mediump_vec4		vec4;
+	typedef precision::mediump_mat2x2	mat2x2;
+	typedef precision::mediump_mat2x3	mat2x3;
+	typedef precision::mediump_mat2x4	mat2x4;
+	typedef precision::mediump_mat3x2	mat3x2;
+	typedef precision::mediump_mat3x3	mat3x3;
+	typedef precision::mediump_mat3x4	mat3x4;
+	typedef precision::mediump_mat4x2	mat4x2;
+	typedef precision::mediump_mat4x3	mat4x3;
+	typedef precision::mediump_mat4x4	mat4x4;
+#elif(defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::lowp_vec2			vec2;
+	typedef precision::lowp_vec3			vec3;
+	typedef precision::lowp_vec4			vec4;
+	typedef precision::lowp_mat2x2			mat2x2;
+	typedef precision::lowp_mat2x3			mat2x3;
+	typedef precision::lowp_mat2x4			mat2x4;
+	typedef precision::lowp_mat3x2			mat3x2;
+	typedef precision::lowp_mat3x3			mat3x3;
+	typedef precision::lowp_mat3x4			mat3x4;
+	typedef precision::lowp_mat4x2			mat4x2;
+	typedef precision::lowp_mat4x3			mat4x3;
+	typedef precision::lowp_mat4x4			mat4x4;
+#else
+	//! 2 components vector of floating-point numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_vec2		vec2;
+
+	//! 3 components vector of floating-point numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_vec3		vec3;
+
+	//! 4 components vector of floating-point numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_vec4		vec4;
+
+	//! 2 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat2x2		mat2x2;
+
+	//! 2 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat2x3		mat2x3;
+
+	//! 2 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat2x4		mat2x4;
+
+	//! 3 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat3x2		mat3x2;
+
+	//! 3 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat3x3		mat3x3;
+
+	//! 3 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat3x4		mat3x4;
+
+	//! 4 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat4x2		mat4x2;
+
+	//! 4 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat4x3		mat4x3;
+
+	//! 4 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef precision::mediump_mat4x4		mat4x4;
+
+#endif//GLM_PRECISION
+
+	//! 2 columns of 2 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef mat2x2							mat2;
+
+	//! 3 columns of 3 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef mat3x3							mat3;
+
+	//! 4 columns of 4 components matrix of floating-point numbers. 
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
+	typedef mat4x4							mat4;
+
+	//////////////////////////
+	// Signed integer definition
+
+#if(defined(GLM_PRECISION_HIGHP_INT))
+	typedef precision::highp_ivec2			ivec2;
+	typedef precision::highp_ivec3			ivec3;
+	typedef precision::highp_ivec4			ivec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef precision::mediump_ivec2		ivec2;
+	typedef precision::mediump_ivec3		ivec3;
+	typedef precision::mediump_ivec4		ivec4;
+#elif(defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::lowp_ivec2			ivec2;
+	typedef precision::lowp_ivec3			ivec3;
+	typedef precision::lowp_ivec4			ivec4;
+#else
+	//! 2 components vector of signed integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_ivec2		ivec2;
+
+	//! 3 components vector of signed integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_ivec3		ivec3;
+
+	//! 4 components vector of signed integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_ivec4		ivec4;
+#endif//GLM_PRECISION
+
+	//////////////////////////
+	// Unsigned integer definition
+
+#if(defined(GLM_PRECISION_HIGHP_UINT))
+	typedef precision::highp_uvec2			uvec2;
+	typedef precision::highp_uvec3			uvec3;
+	typedef precision::highp_uvec4			uvec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
+	typedef precision::mediump_uvec2		uvec2;
+	typedef precision::mediump_uvec3		uvec3;
+	typedef precision::mediump_uvec4		uvec4;
+#elif(defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::lowp_uvec2			uvec2;
+	typedef precision::lowp_uvec3			uvec3;
+	typedef precision::lowp_uvec4			uvec4;
+#else
+	//! 2 components vector of unsigned integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_uvec2		uvec2;
+
+	//! 3 components vector of unsigned integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_uvec3		uvec3;
+
+	//! 4 components vector of unsigned integer numbers. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef precision::mediump_uvec4		uvec4;
+#endif//GLM_PRECISION
+
+	//////////////////////////
+	// Boolean definition
+
+	//! 2 components vector of boolean. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef detail::tvec2<bool>		bvec2;
+
+	//! 3 components vector of boolean. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef detail::tvec3<bool>		bvec3;
+
+	//! 4 components vector of boolean. 
+	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
+	typedef detail::tvec4<bool>		bvec4;
+
+	//////////////////////////
+	// Double definition
+
+	//! Vector of 2 double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tvec2<double>	dvec2;
+
+	//! Vector of 3 double-precision floating-point numbers.
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tvec3<double>	dvec3;
+
+	//! Vector of 4 double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tvec4<double>	dvec4;
+
+	//! 2 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat2x2<double>	dmat2;
+
+	//! 3 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat3x3<double>	dmat3;
+
+	//! 4 * 4 matrix of double-precision floating-point numbers.
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat4x4<double>	dmat4;
+
+	//! 2 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat2x2<double>	dmat2x2;
+
+	//! 2 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat2x3<double>	dmat2x3;
+
+	//! 2 * 4 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat2x4<double>	dmat2x4;
+
+	//! 3 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat3x2<double>	dmat3x2;
+
+	//! 3 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat3x3<double>	dmat3x3;
+
+	//! 3 * 4 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat3x4<double>	dmat3x4;
+
+	//! 4 * 2 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat4x2<double>	dmat4x2;
+
+	//! 4 * 3 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat4x3<double>	dmat4x3;
+
+	//! 4 * 4 matrix of double-precision floating-point numbers. 
+	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
+	typedef detail::tmat4x4<double>	dmat4x4;
+
+}//namespace type
+}//namespace core
+}//namespace glm
+
+#endif//glm_core_type
diff --git a/ExternalLibs/glm/core/type_float.hpp b/ExternalLibs/glm/core/type_float.hpp
new file mode 100644
index 0000000..673797a
--- /dev/null
+++ b/ExternalLibs/glm/core/type_float.hpp
@@ -0,0 +1,74 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2010-02-08
+// Licence : This source is under MIT License
+// File    : glm/core/type_float.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_float
+#define glm_core_type_float
+
+#include "type_half.hpp"
+#include "setup.hpp"
+
+namespace glm
+{
+	namespace detail
+	{
+		GLM_DETAIL_IS_FLOAT(detail::thalf);
+		GLM_DETAIL_IS_FLOAT(float);
+		GLM_DETAIL_IS_FLOAT(double);
+		GLM_DETAIL_IS_FLOAT(long double);
+	}
+	//namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+#ifdef GLM_USE_HALF_SCALAR
+		typedef detail::thalf		lowp_float_t;
+#else//GLM_USE_HALF_SCALAR
+		typedef float				lowp_float_t;
+#endif//GLM_USE_HALF_SCALAR
+		typedef float				mediump_float_t;
+		typedef double				highp_float_t;
+
+		//! Low precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
+		typedef lowp_float_t		lowp_float;
+		//! Medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
+		typedef mediump_float_t     mediump_float;
+		//! High precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
+		typedef highp_float_t		highp_float;
+	}
+	//namespace precision
+
+#if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::mediump_float				float_t;
+#elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::highp_float                  float_t;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::mediump_float				float_t;
+#elif(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::lowp_float					float_t;
+#else
+#	error "GLM error: multiple default precision requested for floating-point types"
+#endif
+
+	}//namespace type
+	}//namespace core
+}//namespace glm
+
+#endif//glm_core_type_float
diff --git a/ExternalLibs/glm/core/type_gentype.hpp b/ExternalLibs/glm/core/type_gentype.hpp
new file mode 100644
index 0000000..fce3881
--- /dev/null
+++ b/ExternalLibs/glm/core/type_gentype.hpp
@@ -0,0 +1,150 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-05
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/type_gentype.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_gentype
+#define glm_core_type_gentype
+
+#include "type_size.hpp"
+
+namespace glm
+{
+	enum profile
+	{
+		nice,
+		fast,
+		simd
+	};
+
+namespace detail
+{
+	template
+	<
+		typename VALTYPE, 
+		template <typename> class TYPE
+	>
+	struct genType
+	{
+	public:
+		enum ctor{null};
+
+		typedef VALTYPE value_type;
+		typedef VALTYPE & value_reference;
+		typedef VALTYPE * value_pointer;
+		typedef VALTYPE const * value_const_pointer;
+		typedef TYPE<bool> bool_type;
+
+		typedef sizeType size_type;
+		static bool is_vector();
+		static bool is_matrix();
+		
+		typedef TYPE<VALTYPE> type;
+		typedef TYPE<VALTYPE> * pointer;
+		typedef TYPE<VALTYPE> const * const_pointer;
+		typedef TYPE<VALTYPE> const * const const_pointer_const;
+		typedef TYPE<VALTYPE> * const pointer_const;
+		typedef TYPE<VALTYPE> & reference;
+		typedef TYPE<VALTYPE> const & const_reference;
+		typedef TYPE<VALTYPE> const & param_type;
+
+		//////////////////////////////////////
+		// Address (Implementation details)
+
+		value_const_pointer value_address() const{return value_pointer(this);}
+		value_pointer value_address(){return value_pointer(this);}
+
+	//protected:
+	//	enum kind
+	//	{
+	//		GEN_TYPE,
+	//		VEC_TYPE,
+	//		MAT_TYPE
+	//	};
+
+	//	typedef typename TYPE::kind kind;
+	};
+
+	template
+	<
+		typename VALTYPE, 
+		template <typename> class TYPE
+	>
+	bool genType<VALTYPE, TYPE>::is_vector()
+	{
+		return true;
+	}
+/*
+	template <typename valTypeT, unsigned int colT, unsigned int rowT, profile proT = nice>
+	class base
+	{
+	public:
+		//////////////////////////////////////
+		// Traits
+
+		typedef sizeType							size_type;
+		typedef valTypeT							value_type;
+
+		typedef base<value_type, colT, rowT>		class_type;
+
+		typedef base<bool, colT, rowT>				bool_type;
+		typedef base<value_type, rowT, 1>			col_type;
+		typedef base<value_type, colT, 1>			row_type;
+		typedef base<value_type, rowT, colT>		transpose_type;
+
+		static size_type							col_size();
+		static size_type							row_size();
+		static size_type							value_size();
+		static bool									is_scalar();
+		static bool									is_vector();
+		static bool									is_matrix();
+
+	private:
+		// Data 
+		col_type value[colT];		
+
+	public:
+		//////////////////////////////////////
+		// Constructors
+		base();
+		base(class_type const & m);
+
+		explicit base(value_type const & x);
+		explicit base(value_type const * const x);
+		explicit base(col_type const * const x);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename vU, uint cU, uint rU, profile pU>
+		explicit base(base<vU, cU, rU, pU> const & m);
+
+		//////////////////////////////////////
+		// Accesses
+		col_type& operator[](size_type i);
+		col_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Unary updatable operators
+		class_type& operator=  (class_type const & x);
+		class_type& operator+= (value_type const & x);
+		class_type& operator+= (class_type const & x);
+		class_type& operator-= (value_type const & x);
+		class_type& operator-= (class_type const & x);
+		class_type& operator*= (value_type const & x);
+		class_type& operator*= (class_type const & x);
+		class_type& operator/= (value_type const & x);
+		class_type& operator/= (class_type const & x);
+		class_type& operator++ ();
+		class_type& operator-- ();
+	};
+*/
+	}//namespace detail
+}//namespace glm
+
+//#include "type_gentype.inl"
+
+#endif//glm_core_type_gentype
diff --git a/ExternalLibs/glm/core/type_gentype.inl b/ExternalLibs/glm/core/type_gentype.inl
new file mode 100644
index 0000000..6451278
--- /dev/null
+++ b/ExternalLibs/glm/core/type_gentype.inl
@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-05
+// Updated : 2008-10-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_gentype.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+/////////////////////////////////
+// Static functions
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::col_size()
+{
+	return cT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::row_size()
+{
+	return rT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::size_type base<vT, cT, rT, pT>::value_size()
+{
+	return rT * cT;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_scalar()
+{
+	return rT == 1 && cT == 1;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_vector()
+{
+	return rT == 1;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+bool base<vT, cT, rT, pT>::is_matrix()
+{
+	return rT != 1;
+}
+
+/////////////////////////////////
+// Constructor
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base()
+{
+	memset(&this->value, 0, cT * rT * sizeof(vT));
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::class_type const & m
+)
+{
+	for
+	(
+		typename genType<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = m[i];
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	if(rT == 1) // vector
+	{
+		for
+		(
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+			i < base<vT, cT, rT, pT>::col_size();
+			++i
+		)
+		{
+			this->value[i][rT] = x;
+		}
+	}
+	else // matrix
+	{
+		memset(&this->value, 0, cT * rT * sizeof(vT));
+
+		typename base<vT, cT, rT, pT>::size_type stop = cT < rT ? cT : rT;
+
+		for
+		(
+			typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+			i < stop;
+			++i
+		)
+		{
+			this->value[i][i] = x;
+		}
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::value_type const * const x
+)
+{
+	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+base<vT, cT, rT, pT>::base
+(
+	typename base<vT, cT, rT, pT>::col_type const * const x
+)
+{
+	for
+	(
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = x[i];
+	}
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+template <typename vU, uint cU, uint rU, profile pU>
+base<vT, cT, rT, pT>::base
+(
+	base<vU, cU, rU, pU> const & m
+)
+{
+	for
+	(
+		typename base<vT, cT, rT, pT>::size_type i = typename base<vT, cT, rT, pT>::size_type(0);
+		i < base<vT, cT, rT, pT>::col_size();
+		++i
+	)
+	{
+		this->value[i] = base<vT, cT, rT, pT>(m[i]);
+	}
+}
+
+//////////////////////////////////////
+// Accesses
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::col_type& base<vT, cT, rT, pT>::operator[]
+(
+	typename base<vT, cT, rT, pT>::size_type i
+)
+{
+	return this->value[i];
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::col_type const & base<vT, cT, rT, pT>::operator[]
+(
+	typename base<vT, cT, rT, pT>::size_type i
+) const
+{
+	return this->value[i];
+}
+
+//////////////////////////////////////
+// Unary updatable operators
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	memcpy(&this->value, &x.value, cT * rT * sizeof(vT));
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] += x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator+= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] += x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] -= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] -= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] *= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator*= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] *= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
+(
+	typename base<vT, cT, rT, pT>::value_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] /= x;
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator/= 
+(
+	typename base<vT, cT, rT, pT>::class_type const & x
+)
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = x.col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = x.row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		this->value[j][i] /= x[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator++ ()
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		++this->value[j][i];
+
+	return *this;
+}
+
+template <typename vT, uint cT, uint rT, profile pT>
+typename base<vT, cT, rT, pT>::class_type& base<vT, cT, rT, pT>::operator-- ()
+{
+	typename base<vT, cT, rT, pT>::size_type stop_col = col_size();
+	typename base<vT, cT, rT, pT>::size_type stop_row = row_size();
+
+	for(typename base<vT, cT, rT, pT>::size_type j = 0; j < stop_col; ++j)
+	for(typename base<vT, cT, rT, pT>::size_type i = 0; i < stop_row; ++i)
+		--this->value[j][i];
+
+	return *this;
+}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_half.hpp b/ExternalLibs/glm/core/type_half.hpp
new file mode 100644
index 0000000..00a9015
--- /dev/null
+++ b/ExternalLibs/glm/core/type_half.hpp
@@ -0,0 +1,87 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-17
+// Updated : 2010-02-17
+// Licence : This source is under MIT License
+// File    : glm/core/type_half.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_half
+#define glm_core_type_half
+
+#include <cstdlib>
+
+namespace glm
+{
+	namespace test
+	{
+		bool main_type_half();
+
+	}//namespace test
+
+	namespace detail
+	{
+		typedef short hdata;
+
+		float toFloat32(hdata value);
+		hdata toFloat16(float const & value);
+
+		///16-bit floating point type.
+		/// \ingroup gtc_half_float
+		class thalf
+		{
+		public: 
+			// Constructors
+			GLM_FUNC_DECL thalf();
+			GLM_FUNC_DECL thalf(thalf const & s);
+			
+			template <typename U>
+			GLM_FUNC_DECL explicit thalf(U const & s);
+
+			// Cast
+			//operator float();
+			GLM_FUNC_DECL operator float() const;
+			//operator double();
+			//operator double() const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL thalf& operator= (thalf const & s);
+			GLM_FUNC_DECL thalf& operator+=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator-=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator*=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator/=(thalf const & s);
+			GLM_FUNC_DECL thalf& operator++();
+			GLM_FUNC_DECL thalf& operator--();
+	
+			GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
+
+			GLM_FUNC_DECL hdata _data() const{return data;}
+
+		private:
+			hdata data;
+		};
+
+		thalf operator+ (thalf const & s1, thalf const & s2);
+
+		thalf operator- (thalf const & s1, thalf const & s2);
+
+		thalf operator* (thalf const & s1, thalf const & s2);
+
+		thalf operator/ (thalf const & s1, thalf const & s2);
+
+		// Unary constant operators
+		thalf operator- (thalf const & s);
+
+		thalf operator-- (thalf const & s, int);
+
+		thalf operator++ (thalf const & s, int);
+
+	}//namespace detail
+
+
+}//namespace glm
+
+#include "type_half.inl"
+
+#endif//glm_core_type_half
diff --git a/ExternalLibs/glm/core/type_half.inl b/ExternalLibs/glm/core/type_half.inl
new file mode 100644
index 0000000..8166a75
--- /dev/null
+++ b/ExternalLibs/glm/core/type_half.inl
@@ -0,0 +1,357 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-17
+// Updated : 2009-11-12
+// Licence : This source is under MIT License
+// File    : glm/core/type_half.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright:
+// This half implementation is based on OpenEXR which is Copyright (c) 2002, 
+// Industrial Light & Magic, a division of Lucas Digital Ltd. LLC
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "_detail.hpp"
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER float overflow()
+	{
+		volatile float f = 1e10;
+
+		for(int i = 0; i < 10; ++i)	
+			f *= f;             // this will overflow before
+								// the for­loop terminates
+		return f;
+	}
+
+	GLM_FUNC_QUALIFIER float toFloat32(hdata value)
+	{
+		int s = (value >> 15) & 0x00000001;
+		int e = (value >> 10) & 0x0000001f;
+		int m =  value        & 0x000003ff;
+
+		if(e == 0)
+		{
+			if(m == 0)
+			{
+				//
+				// Plus or minus zero
+				//
+
+				detail::uif result;
+				result.i = s << 31;
+				return result.f;
+			}
+			else
+			{
+				//
+				// Denormalized number -- renormalize it
+				//
+
+				while(!(m & 0x00000400))
+				{
+					m <<= 1;
+					e -=  1;
+				}
+
+				e += 1;
+				m &= ~0x00000400;
+			}
+		}
+		else if(e == 31)
+		{
+			if(m == 0)
+			{
+				//
+				// Positive or negative infinity
+				//
+
+				uif result;
+				result.i = (s << 31) | 0x7f800000;
+				return result.f;
+			}
+			else
+			{
+				//
+				// Nan -- preserve sign and significand bits
+				//
+
+				uif result;
+				result.i = (s << 31) | 0x7f800000 | (m << 13);
+				return result.f;
+			}
+		}
+
+		//
+		// Normalized number
+		//
+
+		e = e + (127 - 15);
+		m = m << 13;
+
+		//
+		// Assemble s, e and m.
+		//
+
+		uif Result;
+		Result.i = (s << 31) | (e << 23) | m;
+		return Result.f;
+	}
+
+	GLM_FUNC_QUALIFIER hdata toFloat16(float const & f)
+	{
+		uif Entry;
+		Entry.f = f;
+		int i = Entry.i;
+
+		//
+		// Our floating point number, f, is represented by the bit
+		// pattern in integer i.  Disassemble that bit pattern into
+		// the sign, s, the exponent, e, and the significand, m.
+		// Shift s into the position where it will go in in the
+		// resulting half number.
+		// Adjust e, accounting for the different exponent bias
+		// of float and half (127 versus 15).
+		//
+
+		register int s =  (i >> 16) & 0x00008000;
+		register int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+		register int m =   i        & 0x007fffff;
+
+		//
+		// Now reassemble s, e and m into a half:
+		//
+
+		if(e <= 0)
+		{
+			if(e < -10)
+			{
+				//
+				// E is less than -10.  The absolute value of f is
+				// less than half_MIN (f may be a small normalized
+				// float, a denormalized float or a zero).
+				//
+				// We convert f to a _halfGTX zero.
+				//
+
+				return 0;
+			}
+
+			//
+			// E is between -10 and 0.  F is a normalized float,
+			// whose magnitude is less than __half_NRM_MIN.
+			//
+			// We convert f to a denormalized _halfGTX.
+			// 
+
+			m = (m | 0x00800000) >> (1 - e);
+
+			//
+			// Round to nearest, round "0.5" up.
+			//
+			// Rounding may cause the significand to overflow and make
+			// our number normalized.  Because of the way a half's bits
+			// are laid out, we don't have to treat this case separately;
+			// the code below will handle it correctly.
+			// 
+
+			if(m & 0x00001000) 
+				m += 0x00002000;
+
+			//
+			// Assemble the _halfGTX from s, e (zero) and m.
+			//
+
+			return hdata(s | (m >> 13));
+		}
+		else if(e == 0xff - (127 - 15))
+		{
+			if(m == 0)
+			{
+				//
+				// F is an infinity; convert f to a half
+				// infinity with the same sign as f.
+				//
+
+				return hdata(s | 0x7c00);
+			}
+			else
+			{
+				//
+				// F is a NAN; we produce a half NAN that preserves
+				// the sign bit and the 10 leftmost bits of the
+				// significand of f, with one exception: If the 10
+				// leftmost bits are all zero, the NAN would turn 
+				// into an infinity, so we have to set at least one
+				// bit in the significand.
+				//
+
+				m >>= 13;
+
+				return hdata(s | 0x7c00 | m | (m == 0));
+			}
+		}
+		else
+		{
+			//
+			// E is greater than zero.  F is a normalized float.
+			// We try to convert f to a normalized half.
+			//
+
+			//
+			// Round to nearest, round "0.5" up
+			//
+
+			if(m &  0x00001000)
+			{
+				m += 0x00002000;
+
+				if(m & 0x00800000)
+				{
+					m =  0;     // overflow in significand,
+					e += 1;     // adjust exponent
+				}
+			}
+
+			//
+			// Handle exponent overflow
+			//
+
+			if (e > 30)
+			{
+				overflow();        // Cause a hardware floating point overflow;
+
+				return hdata(s | 0x7c00);
+				// if this returns, the half becomes an
+			}   // infinity with the same sign as f.
+
+			//
+			// Assemble the half from s, e and m.
+			//
+
+			return hdata(s | (e << 10) | (m >> 13));
+		}
+	}
+
+	GLM_FUNC_QUALIFIER thalf::thalf() :
+		data(0)
+	{}
+
+	GLM_FUNC_QUALIFIER thalf::thalf(thalf const & s) :
+		data(s.data)
+	{}
+
+	template <typename U>
+	GLM_FUNC_QUALIFIER thalf::thalf(U const & s) :
+		data(toFloat16(float(s)))
+	{}
+
+	// Cast
+	//GLM_FUNC_QUALIFIER half::operator float()
+	//{
+	//	return toFloat();
+	//}
+
+	GLM_FUNC_QUALIFIER thalf::operator float() const 
+	{
+		return toFloat32(this->data);
+	}
+
+	//GLM_FUNC_QUALIFIER half::operator double()
+	//{
+	//	return double(toFloat());
+	//}
+
+	//GLM_FUNC_QUALIFIER half::operator double() const
+	//{
+	//	return double(toFloat());
+	//}
+
+	// Unary updatable operators
+	GLM_FUNC_QUALIFIER thalf& thalf::operator= (thalf const & s)
+	{
+		data = s.data;
+		return *this;
+	}
+
+	GLM_FUNC_QUALIFIER thalf& thalf::operator+=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) + toFloat32(s.data));
+		return *this;
+	}
+
+	GLM_FUNC_QUALIFIER thalf& thalf::operator-=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) - toFloat32(s.data));
+		return *this;
+	}
+
+	GLM_FUNC_QUALIFIER thalf& thalf::operator*=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) * toFloat32(s.data));		
+		return *this;
+	}
+
+	GLM_FUNC_QUALIFIER thalf& thalf::operator/=(thalf const & s)
+	{
+		data = toFloat16(toFloat32(data) / toFloat32(s.data));
+		return *this;
+	}
+
+	GLM_FUNC_QUALIFIER thalf& thalf::operator++()
+	{
+		float Casted = toFloat32(data);
+		data = toFloat16(++Casted);
+		return *this;
+	}
+
+	GLM_FUNC_QUALIFIER thalf& thalf::operator--()
+	{
+		float Casted = toFloat32(data);
+		data = toFloat16(--Casted);
+		return *this;
+	}
+
+	//////////////////////////////////////
+	// Binary arithmetic operators
+
+	GLM_FUNC_QUALIFIER detail::thalf operator+ (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) + float(s2));
+	}
+
+	GLM_FUNC_QUALIFIER detail::thalf operator- (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) - float(s2));
+	}
+
+	GLM_FUNC_QUALIFIER detail::thalf operator* (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) * float(s2));
+	}
+
+	GLM_FUNC_QUALIFIER detail::thalf operator/ (detail::thalf const & s1, detail::thalf const & s2)
+	{
+		return detail::thalf(float(s1) / float(s2));
+	}
+
+	// Unary constant operators
+	GLM_FUNC_QUALIFIER detail::thalf operator- (detail::thalf const & s)
+	{
+		return detail::thalf(-float(s));
+	}
+
+	GLM_FUNC_QUALIFIER detail::thalf operator-- (detail::thalf const & s, int)
+	{
+		return detail::thalf(float(s) - 1.0f);
+	}
+
+	GLM_FUNC_QUALIFIER detail::thalf operator++ (detail::thalf const & s, int)
+	{
+		return detail::thalf(float(s) + 1.0f);
+	}
+
+}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/core/type_int.hpp b/ExternalLibs/glm/core/type_int.hpp
new file mode 100644
index 0000000..59abf8a
--- /dev/null
+++ b/ExternalLibs/glm/core/type_int.hpp
@@ -0,0 +1,114 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2008-09-17
+// Licence : This source is under MIT License
+// File    : glm/core/type_int.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_int
+#define glm_core_type_int
+
+#include "setup.hpp"
+#include "_detail.hpp"
+
+namespace glm
+{
+	namespace detail
+	{
+		typedef signed short			lowp_int_t;
+		typedef signed int				mediump_int_t;
+		typedef sint64					highp_int_t;
+
+		typedef unsigned short			lowp_uint_t;
+		typedef unsigned int			mediump_uint_t;
+		typedef uint64					highp_uint_t;
+
+		GLM_DETAIL_IS_INT(signed char);
+		GLM_DETAIL_IS_INT(signed short);
+		GLM_DETAIL_IS_INT(signed int);
+		GLM_DETAIL_IS_INT(signed long);
+		GLM_DETAIL_IS_INT(highp_int_t);
+
+		GLM_DETAIL_IS_UINT(unsigned char);
+		GLM_DETAIL_IS_UINT(unsigned short);
+		GLM_DETAIL_IS_UINT(unsigned int);
+		GLM_DETAIL_IS_UINT(unsigned long);
+		GLM_DETAIL_IS_UINT(highp_uint_t);
+	}
+	//namespace detail
+
+	namespace core{
+	namespace type{
+
+	///namespace for precision stuff.
+	namespace precision
+	{
+		//! Low precision signed integer. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
+		typedef detail::lowp_int_t				lowp_int;
+		//! Medium precision signed integer. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
+		typedef detail::mediump_int_t				mediump_int;
+		//! High precision signed integer.
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
+		typedef detail::highp_int_t				highp_int;
+
+		//! Low precision unsigned integer. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
+		typedef detail::lowp_uint_t				lowp_uint;
+		//! Medium precision unsigned integer. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
+		typedef detail::mediump_uint_t			mediump_uint;
+		//! High precision unsigned integer. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
+		typedef detail::highp_uint_t				highp_uint;
+	}
+	//namespace precision
+
+#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::mediump_int				int_t;
+#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::highp_int					int_t;
+#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::mediump_int				int_t;
+#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::lowp_int					int_t;
+#else
+#	error "GLM error: multiple default precision requested for signed interger types"
+#endif
+
+#if(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::mediump_uint				uint_t;
+#elif(defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::highp_uint					uint_t;
+#elif(!defined(GLM_PRECISION_HIGHP_UINT) && defined(GLM_PRECISION_MEDIUMP_UINT) && !defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::mediump_uint				uint_t;
+#elif(!defined(GLM_PRECISION_HIGHP_UINT) && !defined(GLM_PRECISION_MEDIUMP_UINT) && defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::lowp_uint					uint_t;
+#else
+#	error "GLM error: multiple default precision requested for unsigned interger types"
+#endif
+
+	//! Unsigned integer. 
+	//! From GLSL 1.30.8 specification section 4.1.3 Integers.
+	typedef uint_t								uint;
+
+	}//namespace type
+	}//namespace core
+}//namespace glm
+
+#endif//glm_core_type_int
diff --git a/ExternalLibs/glm/core/type_mat.hpp b/ExternalLibs/glm/core/type_mat.hpp
new file mode 100644
index 0000000..78ff247
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat.hpp
@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-01-26
+// Updated : 2010-01-26
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat
+#define glm_core_type_mat
+
+#include "type_gentype.hpp"
+
+namespace glm{
+namespace detail
+{
+	//template 
+	//<
+	//	typename T, 
+	//	template <typename> class C, 
+	//	template <typename> class R
+	//>
+	//struct matType
+	//{
+	//	enum ctor{null};
+	//	typedef T value_type;
+	//	typedef std::size_t size_type;
+	//	typedef C<T> col_type;
+	//	typedef R<T> row_type;
+	//	static size_type const col_size;
+	//	static size_type const row_size;
+	//};
+
+	//template 
+	//<
+	//	typename T, 
+	//	template <typename> class C, 
+	//	template <typename> class R
+	//>
+	//typename matType<T, C, R>::size_type const 
+	//matType<T, C, R>::col_size = matType<T, C, R>::col_type::value_size;
+
+	//template 
+	//<
+	//	typename T, 
+	//	template <typename> class C, 
+	//	template <typename> class R
+	//>
+	//typename matType<T, C, R>::size_type const 
+	//matType<T, C, R>::row_size = matType<T, C, R>::row_type::value_size;
+
+}//namespace detail
+}//namespace glm
+
+#endif//glm_core_type_mat
diff --git a/ExternalLibs/glm/core/type_mat.inl b/ExternalLibs/glm/core/type_mat.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/core/type_mat2x2.hpp b/ExternalLibs/glm/core/type_mat2x2.hpp
new file mode 100644
index 0000000..aade1ef
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat2x2.hpp
@@ -0,0 +1,251 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-27
+// Updated : 2010-02-11
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat2x2
+#define glm_core_type_mat2x2
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat2x2();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 2 * 2 matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat2x2
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec2<T> col_type;
+			typedef tvec2<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat2x2<T> type;
+			typedef tmat2x2<T> transpose_type;
+
+		public:
+			// Implementation detail
+			GLM_FUNC_DECL tmat2x2<T> _inverse() const;
+
+		private:
+			// Data 
+			col_type value[2];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat2x2();
+			GLM_FUNC_DECL tmat2x2(
+				tmat2x2 const & m);
+
+			GLM_FUNC_DECL explicit tmat2x2(
+				ctor Null);
+			GLM_FUNC_DECL explicit tmat2x2(
+				value_type const & x);
+			GLM_FUNC_DECL explicit tmat2x2(
+				value_type const & x1, value_type const & y1, 
+				value_type const & x2, value_type const & y2);
+			GLM_FUNC_DECL explicit tmat2x2(
+				col_type const & v1, 
+				col_type const & v2);
+
+			// Conversions
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
+
+			//////////////////////////////////////
+			// Accesses
+
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
+			GLM_FUNC_DECL tmat2x2<T> & operator++();
+			GLM_FUNC_DECL tmat2x2<T> & operator--();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat2x2<T> operator+ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator+ (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator+ (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+	    
+		template <typename T> 
+		tmat2x2<T> operator- (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator- (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator- (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			typename tmat2x2<T>::value_type const & s, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		typename tmat2x2<T>::col_type operator* (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat2x2<T>::row_type operator* (
+			typename tmat2x2<T>::col_type const & v, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+
+		template <typename T> 
+		tmat2x2<T> operator/ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x2<T> operator/ (
+			typename tmat2x2<T>::value_type const & s,
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		typename tmat2x2<T>::col_type operator/ (
+			tmat2x2<T> const & m, 
+			typename tmat2x2<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat2x2<T>::row_type operator/ (
+			typename tmat2x2<T>::col_type const & v, 
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator/ (
+			tmat2x2<T> const & m1, 
+			tmat2x2<T> const & m2);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat2x2<T> const operator-  (
+			tmat2x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> const operator-- (
+			tmat2x2<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat2x2<T> const operator++ (
+			tmat2x2<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 2 columns of 2 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
+		//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
+		//! 2 columns of 2 components matrix of high precision floating-point numbers. 
+		//! There is no guarantee on the actual precision. 
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat2x2<highp_float>	highp_mat2x2;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x2.inl"
+#endif
+
+#endif //glm_core_type_mat2x2
diff --git a/ExternalLibs/glm/core/type_mat2x2.inl b/ExternalLibs/glm/core/type_mat2x2.inl
new file mode 100644
index 0000000..7a53a96
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat2x2.inl
@@ -0,0 +1,610 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-16
+// Updated : 2010-02-11
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x2.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::col_size()
+	{
+		return 2;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T>::size_type tmat2x2<T>::row_size()
+	{
+		return 2;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type &
+	tmat2x2<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type const &
+	tmat2x2<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2()
+    {
+		this->value[0] = col_type(1, 0);
+        this->value[1] = col_type(0, 1);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+	GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero);
+        this->value[1] = col_type(Zero, s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		value_type const & x0, value_type const & y0, 
+		value_type const & x1, value_type const & y1
+	)
+    {
+        this->value[0] = col_type(x0, y0);
+        this->value[1] = col_type(x1, y1);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		col_type const & v0, 
+		col_type const & v1
+	)
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // mat2 conversions
+
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat2x2<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+	template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>::tmat2x2
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> tmat2x2<T>::_inverse() const
+    {
+        typename tmat2x2<T>::value_type Determinant = this->value[0][0] * this->value[1][1] - this->value[1][0] * this->value[0][1];
+
+        tmat2x2<T> Inverse(
+            + this->value[1][1] / Determinant,
+            - this->value[1][0] / Determinant,
+            - this->value[0][1] / Determinant, 
+            + this->value[0][0] / Determinant);
+        return Inverse;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // mat3 operators
+
+    // This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
+	(
+		tmat2x2<T> const & m
+	)
+    {
+	    this->value[0] = m[0];
+	    this->value[1] = m[1];
+	    return *this;
+    }
+
+	template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator=
+	(
+		tmat2x2<U> const & m
+	)
+    {
+	    this->value[0] = m[0];
+	    this->value[1] = m[1];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
+	(
+		U const & s
+	)
+    {
+	    this->value[0] += s;
+	    this->value[1] += s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator+=
+	(
+		tmat2x2<U> const & m
+	)
+    {
+	    this->value[0] += m[0];
+	    this->value[1] += m[1];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
+	(
+		U const & s
+	)
+    {
+	    this->value[0] -= s;
+	    this->value[1] -= s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-=
+	(
+		tmat2x2<U> const & m
+	)
+    {
+	    this->value[0] -= m[0];
+	    this->value[1] -= m[1];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+	    this->value[0] *= s;
+	    this->value[1] *= s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator*= 
+	(
+		tmat2x2<U> const & m
+	)
+    {
+        return (*this = *this * m);
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+	    this->value[0] /= s;
+	    this->value[1] /= s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator/= 
+	(
+		tmat2x2<U> const & m
+	)
+    {
+        return (*this = *this / m);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator++ ()
+    {
+	    ++this->value[0];
+	    ++this->value[1];
+	    return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T>& tmat2x2<T>::operator-- ()
+    {
+	    --this->value[0];
+	    --this->value[1];
+	    return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+	// Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
+    {
+        return tmat2x2<T>(
+            m[0] + s,
+            m[1] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
+	(
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
+    {
+        return tmat2x2<T>(
+            m[0] + s,
+            m[1] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator+ 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+    {
+        return tmat2x2<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
+    {
+        return tmat2x2<T>(
+            m[0] - s,
+            m[1] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
+	(
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
+    {
+        return tmat2x2<T>(
+            s - m[0],
+            s - m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator- 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+    {
+        return tmat2x2<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
+    {
+        return tmat2x2<T>(
+            m[0] * s,
+            m[1] * s);
+    }
+
+	//     X
+	//     X
+	// X X
+	// X X
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
+	(	
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
+    {
+        return tmat2x2<T>(
+            m[0] * s,
+            m[1] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator* 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::row_type const & v
+	)
+    {
+        return detail::tvec2<T>(
+            m[0][0] * v.x + m[1][0] * v.y,
+            m[0][1] * v.x + m[1][1] * v.y);
+    }
+
+	//		X X
+	//		X X
+	// X X 
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator* 
+	(
+		typename tmat2x2<T>::col_type const & v, 
+		tmat2x2<T> const & m
+	)
+    {
+        return detail::tvec2<T>(
+            v.x * m[0][0] + v.y * m[0][1],
+            v.x * m[1][0] + v.y * m[1][1]);
+    }
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+	{
+		return tmat2x2<T>(
+			m1[0][0] * m2[0][0] + m1[1][0] * m2[0][1],
+			m1[0][1] * m2[0][0] + m1[1][1] * m2[0][1],
+			m1[0][0] * m2[1][0] + m1[1][0] * m2[1][1],
+			m1[0][1] * m2[1][0] + m1[1][1] * m2[1][1]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s
+	)
+    {
+        return tmat2x2<T>(
+            m[0] / s,
+            m[1] / s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
+	(
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m
+	)
+    {
+        return tmat2x2<T>(
+            s / m[0],
+            s / m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat2x2<T>::col_type operator/ 
+	(
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::row_type & v
+	)
+    {
+        return m._inverse() * v;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat2x2<T>::row_type operator/ 
+	(
+		typename tmat2x2<T>::col_type const & v,
+		tmat2x2<T> const & m
+	)
+    {
+        return v * m._inverse();
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator/ 
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+    {
+        return m1 * m2._inverse();
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> const operator- 
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        return tmat2x2<T>(
+            -m[0], 
+            -m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> const operator++ 
+	(
+		tmat2x2<T> const & m, 
+		int
+	) 
+    {
+        return tmat2x2<T>(
+            m[0] + T(1),
+            m[1] + T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> const operator-- 
+	(
+		tmat2x2<T> const & m, 
+		int
+	) 
+    {
+        return tmat2x2<T>(
+            m[0] - T(1),
+            m[1] - T(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat2x3.hpp b/ExternalLibs/glm/core/type_mat2x3.hpp
new file mode 100644
index 0000000..ed87f9e
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat2x3.hpp
@@ -0,0 +1,218 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-10-01
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x3.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat2x3
+#define glm_core_type_mat2x3
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat2x3();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat2x3
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec3<T> col_type;
+			typedef tvec2<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat2x3<T> type;
+			typedef tmat3x2<T> transpose_type;
+
+		private:
+			// Data 
+			col_type value[2];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat2x3();
+			GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
+
+			GLM_FUNC_DECL explicit tmat2x3(
+				ctor);
+			GLM_FUNC_DECL explicit tmat2x3(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tmat2x3(
+				value_type const & x0, value_type const & y0, value_type const & z0,
+				value_type const & x1, value_type const & y1, value_type const & z1);
+			GLM_FUNC_DECL explicit tmat2x3(
+				col_type const & v0, 
+				col_type const & v1);
+
+			// Conversion
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
+
+			// Accesses
+			col_type & operator[](size_type i);
+			col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
+
+			GLM_FUNC_DECL tmat2x3<T> & operator++ ();
+			GLM_FUNC_DECL tmat2x3<T> & operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat2x3<T> operator+ (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
+	    
+		template <typename T> 
+		tmat2x3<T> operator+ (
+			tmat2x3<T> const & m1, 
+			tmat2x3<T> const & m2);
+	    
+		template <typename T> 
+		tmat2x3<T> operator- (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x3<T> operator- (
+			tmat2x3<T> const & m1, 
+			tmat2x3<T> const & m2);
+
+		template <typename T> 
+		tmat2x3<T> operator* (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x3<T> operator* (
+			typename tmat2x3<T>::value_type const & s, 
+			tmat2x3<T> const & m);
+
+		template <typename T>
+		typename tmat2x3<T>::col_type operator* (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat2x3<T>::row_type operator* (
+			typename tmat2x3<T>::col_type const & v, 
+			tmat2x3<T> const & m);
+
+		template <typename T>
+		tmat3x3<T> operator* (
+			tmat2x3<T> const & m1, 
+			tmat3x2<T> const & m2);
+
+		template <typename T> 
+		tmat2x3<T> operator/ (
+			tmat2x3<T> const & m, 
+			typename tmat2x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x3<T> operator/ (
+			typename tmat2x3<T>::value_type const & s,
+			tmat2x3<T> const & m);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat2x3<T> const operator-  (
+			tmat2x3<T> const & m);
+
+		template <typename T> 
+		tmat2x3<T> const operator-- (
+			tmat2x3<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat2x3<T> const operator++ (
+			tmat2x3<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 2 columns of 3 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat2x3<lowp_float>		lowp_mat2x3;
+		//! 2 columns of 3 components matrix of medium precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat2x3<mediump_float>	mediump_mat2x3;
+		//! 2 columns of 3 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat2x3<highp_float>	highp_mat2x3;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x3.inl"
+#endif
+
+#endif //glm_core_type_mat2x3
diff --git a/ExternalLibs/glm/core/type_mat2x3.inl b/ExternalLibs/glm/core/type_mat2x3.inl
new file mode 100644
index 0000000..83e8b2e
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat2x3.inl
@@ -0,0 +1,541 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x3.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::col_size()
+	{
+		return 3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x3<T>::size_type tmat2x3<T>::row_size()
+	{
+		return 2;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type &
+	tmat2x3<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type const &
+	tmat2x3<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3()
+    {
+        this->value[0] = col_type(T(1), T(0), T(0));
+        this->value[1] = col_type(T(0), T(1), T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		value_type const & s
+	)
+    {
+        this->value[0] = col_type(s, T(0), T(0));
+        this->value[1] = col_type(T(0), s, T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0,
+        value_type const & x1, value_type const & y1, value_type const & z1
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0);
+        this->value[1] = col_type(x1, y1, z1);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+    (
+        col_type const & v0, 
+        col_type const & v1
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+    }
+
+    // Conversion
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat2x3<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>::tmat2x3
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Unary updatable operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator= 
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator= 
+	(
+		tmat2x3<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator+=
+	(
+		tmat2x3<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator-= 
+	(
+		tmat2x3<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T>& tmat2x3<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator*= 
+	(
+		tmat2x3<U> const & m
+	)
+    {
+        return (*this = tmat2x3<U>(*this * m));
+    }
+
+    template <typename T>
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> & tmat2x3<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        return *this;
+    }
+    
+    //////////////////////////////////////////////////////////////
+    // Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator+ 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
+    {
+        return tmat2x3<T>(
+            m[0] + s,
+            m[1] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator+ 
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+    {
+        return tmat2x3<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator- 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
+    {
+        return tmat2x3<T>(
+            m[0] - s,
+            m[1] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator- 
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+    {
+        return tmat2x3<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
+    {
+        return tmat2x3<T>(
+            m[0] * s,
+            m[1] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator* 
+	(
+		typename tmat2x3<T>::value_type const & s, 
+		tmat2x3<T> const & m
+	)
+    {
+        return tmat2x3<T>(
+            m[0] * s,
+            m[1] * s);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename tmat2x3<T>::col_type operator* 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::row_type const & v)
+    {
+        return typename tmat2x3<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y,
+            m[0][1] * v.x + m[1][1] * v.y,
+            m[0][2] * v.x + m[1][2] * v.y);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat2x3<T>::row_type operator* 
+	(
+		typename tmat2x3<T>::col_type const & v, 
+		tmat2x3<T> const & m) 
+    {
+        return typename tmat2x3<T>::row_type(
+            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	(
+		tmat2x3<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+    {
+		typename tmat2x3<T>::value_type SrcA00 = m1[0][0];
+		typename tmat2x3<T>::value_type SrcA01 = m1[0][1];
+		typename tmat2x3<T>::value_type SrcA02 = m1[0][2];
+		typename tmat2x3<T>::value_type SrcA10 = m1[1][0];
+		typename tmat2x3<T>::value_type SrcA11 = m1[1][1];
+		typename tmat2x3<T>::value_type SrcA12 = m1[1][2];
+
+		typename tmat2x3<T>::value_type SrcB00 = m2[0][0];
+		typename tmat2x3<T>::value_type SrcB01 = m2[0][1];
+		typename tmat2x3<T>::value_type SrcB10 = m2[1][0];
+		typename tmat2x3<T>::value_type SrcB11 = m2[1][1];
+		typename tmat2x3<T>::value_type SrcB20 = m2[2][0];
+		typename tmat2x3<T>::value_type SrcB21 = m2[2][1];
+
+		tmat3x3<T> Result(tmat3x3<T>::null);
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+		return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator/ 
+	(
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s
+	)
+    {
+        return tmat2x3<T>(
+            m[0] / s,
+            m[1] / s);        
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> operator/ 
+	(
+		typename tmat2x3<T>::value_type const & s, 
+		tmat2x3<T> const & m
+	)
+    {
+        return tmat2x3<T>(
+            s / m[0],
+            s / m[1]);        
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> const operator- 
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        return tmat2x3<T>(
+            -m[0], 
+            -m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> const operator++ 
+	(
+		tmat2x3<T> const & m, 
+		int
+	) 
+    {
+        return tmat2x3<T>(
+            m[0] + typename tmat2x3<T>::value_type(1),
+            m[1] + typename tmat2x3<T>::value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x3<T> const operator-- 
+	(
+		tmat2x3<T> const & m, 
+		int
+	) 
+    {
+        return tmat2x3<T>(
+            m[0] - typename tmat2x3<T>::value_type(1),
+            m[1] - typename tmat2x3<T>::value_type(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat2x4.hpp b/ExternalLibs/glm/core/type_mat2x4.hpp
new file mode 100644
index 0000000..a14cc03
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat2x4.hpp
@@ -0,0 +1,215 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-02-11
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat2x4
+#define glm_core_type_mat2x4
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat2x4();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! Template for 2 columns and 4 rows matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat2x4
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec4<T> col_type;
+			typedef tvec2<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat2x4<T> type;
+			typedef tmat4x2<T> transpose_type;
+
+		private:
+			// Data 
+			col_type value[2];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat2x4();
+			GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
+
+			GLM_FUNC_DECL explicit tmat2x4(
+				ctor);
+			GLM_FUNC_DECL explicit tmat2x4(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tmat2x4(
+				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
+			GLM_FUNC_DECL explicit tmat2x4(
+				col_type const & v0, 
+				col_type const & v1);
+
+			// Conversion
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
+
+			// Accesses
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
+
+			GLM_FUNC_DECL tmat2x4<T>& operator++ ();
+			GLM_FUNC_DECL tmat2x4<T>& operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat2x4<T> operator+ (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
+	    
+		template <typename T> 
+		tmat2x4<T> operator+ (
+			tmat2x4<T> const & m1, 
+			tmat2x4<T> const & m2);
+	    
+		template <typename T> 
+		tmat2x4<T> operator- (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x4<T> operator- (
+			tmat2x4<T> const & m1, 
+			tmat2x4<T> const & m2);
+
+		template <typename T> 
+		tmat2x4<T> operator* (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x4<T> operator* (
+			typename tmat2x4<T>::value_type const & s, 
+			tmat2x4<T> const & m);
+
+		template <typename T>
+		typename tmat2x4<T>::col_type operator* (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat2x4<T>::row_type operator* (
+			typename tmat2x4<T>::col_type const & v, 
+			tmat2x4<T> const & m);
+
+		template <typename T>
+		tmat2x4<T> operator* (
+			tmat2x4<T> const & m1, 
+			tmat2x4<T> const & m2);
+
+		template <typename T> 
+		tmat2x4<T> operator/ (
+			tmat2x4<T> const & m, 
+			typename tmat2x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat2x4<T> operator/ (
+			typename tmat2x4<T>::value_type const & s, 
+			tmat2x4<T> const & m);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat2x4<T> const operator-  (
+			tmat2x4<T> const & m);
+
+		template <typename T> 
+		tmat2x4<T> const operator-- (
+			tmat2x4<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat2x4<T> const operator++ (
+			tmat2x4<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 2 columns of 4 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat2x4<lowp_float>		lowp_mat2x4;
+		//! 2 columns of 4 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat2x4<mediump_float>	mediump_mat2x4;
+		//! 2 columns of 4 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat2x4<highp_float>	highp_mat2x4;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat2x4.inl"
+#endif
+
+#endif //glm_core_type_mat2x4
diff --git a/ExternalLibs/glm/core/type_mat2x4.inl b/ExternalLibs/glm/core/type_mat2x4.inl
new file mode 100644
index 0000000..b19193f
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat2x4.inl
@@ -0,0 +1,569 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat2x4.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::col_size()
+	{
+		return 4;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x4<T>::size_type tmat2x4<T>::row_size()
+	{
+		return 2;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type &
+	tmat2x4<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type const &
+	tmat2x4<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4()
+    {
+		value_type const Zero(0);
+		value_type const One(1);
+        this->value[0] = col_type(One, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, One, Zero, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, Zero, Zero, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0, w0);
+        this->value[1] = col_type(x1, y1, z1, w1);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+    (
+        col_type const & v0, 
+        col_type const & v1
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+    }
+
+    // Conversion
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat2x4<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>::tmat2x4
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Unary updatable operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator= 
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator= 
+	(
+		tmat2x4<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator+= 
+	(
+		tmat2x4<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-= 
+	(
+		tmat2x4<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator*=
+	(
+		tmat2x4<U> const & m
+	)
+    {
+        return (*this = tmat2x4<T>(*this * m));
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> & tmat2x4<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T>& tmat2x4<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator+
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
+    {
+        return tmat2x4<T>(
+            m[0] + s,
+            m[1] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator+ 
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+    {
+        return tmat2x4<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator- 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
+    {
+        return tmat2x4<T>(
+            m[0] - s,
+            m[1] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator- 
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+    {
+        return tmat2x4<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator* 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
+    {
+        return tmat2x4<T>(
+            m[0] * s,
+            m[1] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator*
+	(
+		typename tmat2x4<T>::value_type const & s, 
+		tmat2x4<T> const & m
+	)
+    {
+        return tmat2x4<T>(
+            m[0] * s,
+            m[1] * s);
+    }
+   
+	//     X
+	//     X
+	// X X
+	// X X
+	// X X
+	// X X
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename tmat2x4<T>::col_type operator* 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::row_type const & v
+	)
+    {
+        return typename tmat2x4<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y,
+            m[0][1] * v.x + m[1][1] * v.y,
+            m[0][2] * v.x + m[1][2] * v.y,
+            m[0][3] * v.x + m[1][3] * v.y);
+    }
+
+	//			X X
+	//			X X
+	//			X X
+	//			X X
+	// X X X X
+	template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat2x4<T>::row_type operator* 
+	(
+		typename tmat2x4<T>::col_type const & v, 
+		tmat2x4<T> const & m
+	) 
+    {
+        return typename tmat2x4<T>::row_type(
+            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
+	(
+		tmat2x4<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+    {
+		typename tmat2x4<T>::value_type SrcA00 = m1[0][0];
+		typename tmat2x4<T>::value_type SrcA01 = m1[0][1];
+		typename tmat2x4<T>::value_type SrcA02 = m1[0][2];
+		typename tmat2x4<T>::value_type SrcA03 = m1[0][3];
+		typename tmat2x4<T>::value_type SrcA10 = m1[1][0];
+		typename tmat2x4<T>::value_type SrcA11 = m1[1][1];
+		typename tmat2x4<T>::value_type SrcA12 = m1[1][2];
+		typename tmat2x4<T>::value_type SrcA13 = m1[1][3];
+
+		typename tmat2x4<T>::value_type SrcB00 = m2[0][0];
+		typename tmat2x4<T>::value_type SrcB01 = m2[0][1];
+		typename tmat2x4<T>::value_type SrcB10 = m2[1][0];
+		typename tmat2x4<T>::value_type SrcB11 = m2[1][1];
+		typename tmat2x4<T>::value_type SrcB20 = m2[2][0];
+		typename tmat2x4<T>::value_type SrcB21 = m2[2][1];
+		typename tmat2x4<T>::value_type SrcB30 = m2[3][0];
+		typename tmat2x4<T>::value_type SrcB31 = m2[3][1];
+
+		tmat4x4<T> Result(tmat4x4<T>::null);
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01;
+		Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11;
+		Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21;
+		Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21;
+		Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31;
+		Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31;
+		Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31;
+		Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31;
+		return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator/ 
+	(
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s
+	)
+    {
+        return tmat2x4<T>(
+            m[0] / s,
+            m[1] / s);        
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> operator/ 
+	(
+		typename tmat2x4<T>::value_type const & s, 
+		tmat2x4<T> const & m
+	)
+    {
+        return tmat2x4<T>(
+            s / m[0],
+            s / m[1]);        
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> const operator- 
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        return tmat2x4<T>(
+            -m[0], 
+            -m[1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> const operator++ 
+	(
+		tmat2x4<T> const & m, 
+		int
+	) 
+    {
+        return tmat2x4<T>(
+            m[0] + typename tmat2x4<T>::value_type(1),
+            m[1] + typename tmat2x4<T>::value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x4<T> const operator-- 
+	(
+		tmat2x4<T> const & m, 
+		int
+	) 
+    {
+        return tmat2x4<T>(
+            m[0] - typename tmat2x4<T>::value_type(1),
+            m[1] - typename tmat2x4<T>::value_type(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat3x2.hpp b/ExternalLibs/glm/core/type_mat3x2.hpp
new file mode 100644
index 0000000..3457b72
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat3x2.hpp
@@ -0,0 +1,217 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-02-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat3x2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat3x2
+#define glm_core_type_mat3x2
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat3x2();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat3x2
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec2<T> col_type;
+			typedef tvec3<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat3x2<T> type;
+			typedef tmat2x3<T> transpose_type;
+
+		private:
+			// Data
+			col_type value[3];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat3x2();
+			GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
+
+			GLM_FUNC_DECL explicit tmat3x2(
+				ctor);
+			GLM_FUNC_DECL explicit tmat3x2(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tmat3x2(
+				value_type const & x0, value_type const & y0,
+				value_type const & x1, value_type const & y1,
+				value_type const & x2, value_type const & y2);
+			GLM_FUNC_DECL explicit tmat3x2(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2);
+
+			// Conversion
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
+
+			// Accesses
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
+
+			GLM_FUNC_DECL tmat3x2<T> & operator++ ();
+			GLM_FUNC_DECL tmat3x2<T> & operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat3x2<T> operator+ (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
+	    
+		template <typename T> 
+		tmat3x2<T> operator+ (
+			tmat3x2<T> const & m1, 
+			tmat3x2<T> const & m2);
+	    
+		template <typename T> 
+		tmat3x2<T> operator- (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x2<T> operator- (
+			tmat3x2<T> const & m1, 
+			tmat3x2<T> const & m2);
+
+		template <typename T> 
+		tmat3x2<T> operator* (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x2<T> operator* (
+			typename tmat3x2<T>::value_type const & s, 
+			tmat3x2<T> const & m);
+
+		template <typename T>
+		typename tmat3x2<T>::col_type operator* (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat3x2<T>::row_type operator* (
+			typename tmat3x2<T>::col_type const & v,
+			tmat3x2<T> const & m);
+
+		template <typename T>
+		tmat2x2<T> operator* (
+			tmat3x2<T> const & m1, 
+			tmat2x3<T> const & m2);
+
+		template <typename T> 
+		tmat3x2<T> operator/ (
+			tmat3x2<T> const & m, 
+			typename tmat3x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x2<T> operator/ (
+			typename tmat3x2<T>::value_type const & s, 
+			tmat3x2<T> const & m);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat3x2<T> const operator-  (
+			tmat3x2<T> const & m);
+
+		template <typename T> 
+		tmat3x2<T> const operator-- (
+			tmat3x2<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat3x2<T> const operator++ (
+			tmat3x2<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 3 columns of 2 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat3x2<lowp_float>		lowp_mat3x2;
+		//! 3 columns of 2 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat3x2<mediump_float>	mediump_mat3x2;
+		//! 3 columns of 2 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat3x2<highp_float>	highp_mat3x2;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x2.inl"
+#endif
+
+#endif //glm_core_type_mat3x2
diff --git a/ExternalLibs/glm/core/type_mat3x2.inl b/ExternalLibs/glm/core/type_mat3x2.inl
new file mode 100644
index 0000000..5fddb4c
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat3x2.inl
@@ -0,0 +1,575 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-01-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat3x2.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::col_size()
+	{
+		return 2;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x2<T>::size_type tmat3x2<T>::row_size()
+	{
+		return 3;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type &
+	tmat3x2<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type const & 
+	tmat3x2<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2()
+    {
+        this->value[0] = col_type(1, 0);
+        this->value[1] = col_type(0, 1);
+        this->value[2] = col_type(0, 0);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+		this->value[2] = m.value[2];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		value_type const & s
+	)
+    {
+        this->value[0] = col_type(s, 0);
+        this->value[1] = col_type(0, s);
+        this->value[2] = col_type(0, 0);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+    (
+        value_type const & x0, value_type const & y0,
+        value_type const & x1, value_type const & y1,
+        value_type const & x2, value_type const & y2
+    )
+    {
+        this->value[0] = col_type(x0, y0);
+        this->value[1] = col_type(x1, y1);
+        this->value[2] = col_type(x2, y2);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+        this->value[2] = v2;
+    }
+
+    // Conversion
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat3x2<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = col_type(T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>::tmat3x2
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Unary updatable operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator= 
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator= 
+	(
+		tmat3x2<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        this->value[2] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator+= 
+	(
+		tmat3x2<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        this->value[2] += m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        this->value[2] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-= 
+	(
+		tmat3x2<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        this->value[2] -= m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        this->value[2] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator*= 
+	(
+		tmat3x2<U> const & m
+	)
+    {
+        return (*this = tmat3x2<T>(*this * m));
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> & tmat3x2<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        this->value[2] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        ++this->value[2];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T>& tmat3x2<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        --this->value[2];
+        return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator+ 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
+    {
+        return tmat3x2<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator+ 
+	(
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+    {
+        return tmat3x2<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1],
+            m1[2] + m2[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator- 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
+    {
+        return tmat3x2<T>(
+            m[0] - s,
+            m[1] - s,
+            m[2] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator- 
+	(	
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+    {
+        return tmat3x2<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1],
+            m1[2] - m2[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
+    {
+        return tmat3x2<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator* 
+	(
+		typename tmat3x2<T>::value_type const & s, 
+		tmat3x2<T> const & m
+	)
+    {
+        return tmat3x2<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s);
+    }
+   
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename tmat3x2<T>::col_type operator* 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::row_type const & v)
+    {
+        return typename tmat3x2<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat3x2<T>::row_type operator* 
+	(
+		typename tmat3x2<T>::col_type const & v, 
+		tmat3x2<T> const & m) 
+    {
+        return typename tmat3x2<T>::row_type(
+            v.x * m[0][0] + v.y * m[0][1],
+            v.x * m[1][0] + v.y * m[1][1],
+            v.x * m[2][0] + v.y * m[2][1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
+	(
+		tmat3x2<T> const & m1, 
+		tmat2x3<T> const & m2
+	)
+    {
+        const T SrcA00 = m1[0][0];
+        const T SrcA01 = m1[0][1];
+        const T SrcA10 = m1[1][0];
+        const T SrcA11 = m1[1][1];
+        const T SrcA20 = m1[2][0];
+        const T SrcA21 = m1[2][1];
+
+        const T SrcB00 = m2[0][0];
+        const T SrcB01 = m2[0][1];
+        const T SrcB02 = m2[0][2];
+        const T SrcB10 = m2[1][0];
+        const T SrcB11 = m2[1][1];
+        const T SrcB12 = m2[1][2];
+
+        tmat2x2<T> Result(tmat2x2<T>::null);
+        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator/ 
+	(
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s
+	)
+    {
+        return tmat3x2<T>(
+            m[0] / s,
+            m[1] / s,
+            m[2] / s);        
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> operator/ 
+	(
+		typename tmat3x2<T>::value_type const & s, 
+		tmat3x2<T> const & m
+	)
+    {
+        return tmat3x2<T>(
+            s / m[0],
+            s / m[1],
+            s / m[2]);        
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> const operator- 
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        return tmat3x2<T>(
+            -m[0], 
+            -m[1],
+            -m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> const operator++ 
+	(
+		tmat3x2<T> const & m, 
+		int
+	) 
+    {
+		typename tmat3x2<T>::value_type One(1);
+        return tmat3x2<T>(
+            m[0] + One,
+            m[1] + One,
+            m[2] + One);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x2<T> const operator-- 
+	(
+		tmat3x2<T> const & m, 
+		int
+	) 
+    {
+		typename tmat3x2<T>::value_type One(1);
+        return tmat3x2<T>(
+            m[0] - One,
+            m[1] - One,
+            m[2] - One);
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat3x3.hpp b/ExternalLibs/glm/core/type_mat3x3.hpp
new file mode 100644
index 0000000..bf18c16
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat3x3.hpp
@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-27
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat3x3.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat3x3
+#define glm_core_type_mat3x3
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat3x3();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 3 * 3 matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat3x3
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec3<T> col_type;
+			typedef tvec3<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat3x3<T> type;
+			typedef tmat3x3<T> transpose_type;
+
+		public:
+			// Implementation detail
+			GLM_FUNC_DECL tmat3x3<T> _inverse() const;
+
+		private:
+			// Data
+			col_type value[3];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat3x3();
+			GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
+
+			GLM_FUNC_DECL explicit tmat3x3(
+				ctor Null);
+			GLM_FUNC_DECL explicit tmat3x3(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tmat3x3(
+				value_type const & x0, value_type const & y0, value_type const & z0,
+				value_type const & x1, value_type const & y1, value_type const & z1,
+				value_type const & x2, value_type const & y2, value_type const & z2);
+			GLM_FUNC_DECL explicit tmat3x3(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2);
+
+			// Conversions
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
+
+			// Accesses
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
+			GLM_FUNC_DECL tmat3x3<T>& operator++ ();
+			GLM_FUNC_DECL tmat3x3<T>& operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat3x3<T> operator+ (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x3<T> operator+ (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		tmat3x3<T> operator+ (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
+	    
+		template <typename T> 
+		tmat3x3<T> operator- (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x3<T> operator- (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		tmat3x3<T> operator- (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
+
+		template <typename T> 
+		tmat3x3<T> operator* (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x3<T> operator* (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		typename tmat3x3<T>::col_type operator* (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat3x3<T>::row_type operator* (
+			typename tmat3x3<T>::col_type const & v, 
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		tmat3x3<T> operator* (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
+
+		template <typename T> 
+		tmat3x3<T> operator/ (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x3<T> operator/ (
+			typename tmat3x3<T>::value_type const & s, 
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		typename tmat3x3<T>::col_type operator/ (
+			tmat3x3<T> const & m, 
+			typename tmat3x3<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat3x3<T>::row_type operator/ (
+			typename tmat3x3<T>::col_type const & v, 
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		tmat3x3<T> operator/ (
+			tmat3x3<T> const & m1, 
+			tmat3x3<T> const & m2);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat3x3<T> const operator-  (
+			tmat3x3<T> const & m);
+
+		template <typename T> 
+		tmat3x3<T> const operator-- (
+			tmat3x3<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat3x3<T> const operator++ (
+			tmat3x3<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 3 columns of 3 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat3x3<lowp_float>		lowp_mat3x3;
+		//! 3 columns of 3 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat3x3<mediump_float>	mediump_mat3x3;
+		//! 3 columns of 3 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat3x3<highp_float>	highp_mat3x3;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x3.inl"
+#endif
+
+#endif //glm_core_type_mat3x3
diff --git a/ExternalLibs/glm/core/type_mat3x3.inl b/ExternalLibs/glm/core/type_mat3x3.inl
new file mode 100644
index 0000000..667f223
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat3x3.inl
@@ -0,0 +1,704 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-27
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat3x3.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::col_size()
+	{
+		return 3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::size_type tmat3x3<T>::row_size()
+	{
+		return 3;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type &
+	tmat3x3<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type const &
+	tmat3x3<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3()
+    {
+		value_type const Zero(0);
+		value_type const One(1);
+        this->value[0] = col_type(One, Zero, Zero);
+        this->value[1] = col_type(Zero, One, Zero);
+        this->value[2] = col_type(Zero, Zero, One);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+        this->value[2] = m.value[2];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero);
+        this->value[1] = col_type(Zero, s, Zero);
+        this->value[2] = col_type(Zero, Zero, s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0, 
+        value_type const & x1, value_type const & y1, value_type const & z1,
+        value_type const & x2, value_type const & y2, value_type const & z2
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0);
+        this->value[1] = col_type(x1, y1, z1);
+        this->value[2] = col_type(x2, y2, z2);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+        this->value[2] = v2;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Conversions
+
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat3x3<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+	template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(m[2], value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(detail::tvec2<T>(0), value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(m[2], value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T>::tmat3x3
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
+	(
+		tmat3x3<T> const & m
+	)
+    {
+	    this->value[0] = m[0];
+	    this->value[1] = m[1];
+        this->value[2] = m[2];
+	    return *this;
+    }
+
+    template <typename T> 
+    template <typename U> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator=
+	(
+		tmat3x3<U> const & m
+	)
+    {
+	    this->value[0] = m[0];
+	    this->value[1] = m[1];
+        this->value[2] = m[2];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+	    this->value[0] += s;
+	    this->value[1] += s;
+        this->value[2] += s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator+=
+	(
+		tmat3x3<U> const & m
+	)
+    {
+	    this->value[0] += m[0];
+	    this->value[1] += m[1];
+        this->value[2] += m[2];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+	    this->value[0] -= s;
+	    this->value[1] -= s;
+        this->value[2] -= s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-= 
+	(
+		tmat3x3<U> const & m
+	)
+    {
+	    this->value[0] -= m[0];
+	    this->value[1] -= m[1];
+        this->value[2] -= m[2];
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+	    this->value[0] *= s;
+	    this->value[1] *= s;
+        this->value[2] *= s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator*= 
+	(
+		tmat3x3<U> const & m
+	)
+    {
+        return (*this = *this * m);
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+	    this->value[0] /= s;
+	    this->value[1] /= s;
+        this->value[2] /= s;
+	    return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator/= 
+	(
+		tmat3x3<U> const & m
+	)
+    {
+        return (*this = *this / m);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator++ ()
+    {
+	    ++this->value[0];
+	    ++this->value[1];
+        ++this->value[2];
+	    return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> & tmat3x3<T>::operator-- ()
+    {
+	    --this->value[0];
+	    --this->value[1];
+        --this->value[2];
+	    return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> tmat3x3<T>::_inverse() const
+    {
+        T S00 = value[0][0];
+        T S01 = value[0][1];
+        T S02 = value[0][2];
+
+        T S10 = value[1][0];
+        T S11 = value[1][1];
+        T S12 = value[1][2];
+
+        T S20 = value[2][0];
+        T S21 = value[2][1];
+        T S22 = value[2][2];
+/*
+        tmat3x3<T> Inverse(
+            + (S11 * S22 - S21 * S12),
+            - (S10 * S22 - S20 * S12),
+            + (S10 * S21 - S20 * S11),
+            - (S01 * S22 - S21 * S02),
+            + (S00 * S22 - S20 * S02),
+            - (S00 * S21 - S20 * S01),
+            + (S01 * S12 - S11 * S02),
+            - (S00 * S12 - S10 * S02),
+            + (S00 * S11 - S10 * S01));
+*/
+        tmat3x3<T> Inverse(
+            S11 * S22 - S21 * S12,
+            S12 * S20 - S22 * S10,
+            S10 * S21 - S20 * S11,
+            S02 * S21 - S01 * S22,
+            S00 * S22 - S02 * S20,
+            S01 * S20 - S00 * S21,
+            S12 * S01 - S11 * S02,
+            S10 * S02 - S12 * S00,
+            S11 * S00 - S10 * S01);
+
+        T Determinant = S00 * (S11 * S22 - S21 * S12)
+                      - S10 * (S01 * S22 - S21 * S02)
+                      + S20 * (S01 * S12 - S11 * S02);
+
+        Inverse /= Determinant;
+        return Inverse;
+    }
+
+    //////////////////////////////////////////////////////////////
+	// Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
+    {
+        return tmat3x3<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
+    {
+        return tmat3x3<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator+ 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+    {
+        return tmat3x3<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1],
+            m1[2] + m2[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
+    {
+        return tmat3x3<T>(
+            m[0] - s,
+            m[1] - s,
+            m[2] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
+    {
+        return tmat3x3<T>(
+            s - m[0],
+            s - m[1],
+            s - m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator- 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+    {
+        return tmat3x3<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1],
+            m1[2] - m2[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
+    {
+        return tmat3x3<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
+    {
+        return tmat3x3<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator* 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::row_type const & v
+	)
+    {
+        return typename tmat3x3<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator* 
+	(
+		typename tmat3x3<T>::col_type const & v, 
+		tmat3x3<T> const & m
+	)
+    {
+        return typename tmat3x3<T>::row_type(
+            m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z,
+            m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z,
+            m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+    {
+		typename tmat3x3<T>::value_type const SrcA00 = m1[0][0];
+		typename tmat3x3<T>::value_type const SrcA01 = m1[0][1];
+		typename tmat3x3<T>::value_type const SrcA02 = m1[0][2];
+		typename tmat3x3<T>::value_type const SrcA10 = m1[1][0];
+		typename tmat3x3<T>::value_type const SrcA11 = m1[1][1];
+		typename tmat3x3<T>::value_type const SrcA12 = m1[1][2];
+		typename tmat3x3<T>::value_type const SrcA20 = m1[2][0];
+		typename tmat3x3<T>::value_type const SrcA21 = m1[2][1];
+		typename tmat3x3<T>::value_type const SrcA22 = m1[2][2];
+
+		typename tmat3x3<T>::value_type const SrcB00 = m2[0][0];
+		typename tmat3x3<T>::value_type const SrcB01 = m2[0][1];
+		typename tmat3x3<T>::value_type const SrcB02 = m2[0][2];
+		typename tmat3x3<T>::value_type const SrcB10 = m2[1][0];
+		typename tmat3x3<T>::value_type const SrcB11 = m2[1][1];
+		typename tmat3x3<T>::value_type const SrcB12 = m2[1][2];
+		typename tmat3x3<T>::value_type const SrcB20 = m2[2][0];
+		typename tmat3x3<T>::value_type const SrcB21 = m2[2][1];
+		typename tmat3x3<T>::value_type const SrcB22 = m2[2][2];
+
+		tmat3x3<T> Result(tmat3x3<T>::null);
+		Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+		Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+		Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+		Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+		Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+		Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+		Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+		Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+		Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+		return Result;
+    }
+
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s
+	)
+    {
+        return tmat3x3<T>(
+            m[0] / s,
+            m[1] / s,
+            m[2] / s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
+	(
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m
+	)
+    {
+        return tmat3x3<T>(
+            s / m[0],
+            s / m[1],
+            s / m[2]);
+    }
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::col_type operator/ 
+	(
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::row_type const & v
+	)
+	{
+		return m._inverse() * v;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER typename tmat3x3<T>::row_type operator/ 
+	(
+		typename tmat3x3<T>::col_type const & v, 
+		tmat3x3<T> const & m
+	)
+	{
+		return v * m._inverse();
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x3<T> operator/ 
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+	{
+		return m1 * m2._inverse();
+	}
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> const operator- 
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        return tmat3x3<T>(
+            -m[0], 
+            -m[1],
+            -m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> const operator++ 
+	(
+		tmat3x3<T> const & m, 
+		int
+	) 
+    {
+        return tmat3x3<T>(
+            m[0] + T(1),
+            m[1] + T(1),
+            m[2] + T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> const operator-- 
+	(
+		tmat3x3<T> const & m, 
+		int
+	) 
+    {
+        return tmat3x3<T>(
+            m[0] - T(1),
+            m[1] - T(1),
+            m[2] - T(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat3x4.hpp b/ExternalLibs/glm/core/type_mat3x4.hpp
new file mode 100644
index 0000000..1f84ec7
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat3x4.hpp
@@ -0,0 +1,217 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-02-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat3x4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat3x4
+#define glm_core_type_mat3x4
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat3x4();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat3x4
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec4<T> col_type;
+			typedef tvec3<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat3x4<T> type;
+			typedef tmat4x3<T> transpose_type;
+
+		private:
+			// Data 
+			col_type value[3];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat3x4();
+			GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
+
+			GLM_FUNC_DECL explicit tmat3x4(
+				ctor Null);
+			GLM_FUNC_DECL explicit tmat3x4(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tmat3x4(
+				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
+			GLM_FUNC_DECL explicit tmat3x4(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2);
+
+			// Conversion
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
+
+			// Accesses
+			col_type & operator[](size_type i);
+			col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
+
+			GLM_FUNC_DECL tmat3x4<T> & operator++ ();
+			GLM_FUNC_DECL tmat3x4<T> & operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat3x4<T> operator+ (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
+	    
+		template <typename T> 
+		tmat3x4<T> operator+ (
+			tmat3x4<T> const & m1, 
+			tmat3x4<T> const & m2);
+	    
+		template <typename T> 
+		tmat3x4<T> operator- (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x4<T> operator- (
+			tmat3x4<T> const & m1, 
+			tmat3x4<T> const & m2);
+
+		template <typename T> 
+		tmat3x4<T> operator* (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x4<T> operator* (
+			typename tmat3x4<T>::value_type const & s, 
+			tmat3x4<T> const & m);
+
+		template <typename T>
+		typename tmat3x4<T>::col_type operator* (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat3x4<T>::row_type operator* (
+			typename tmat3x4<T>::col_type const & v, 
+			tmat3x4<T> const & m);
+
+		template <typename T>
+		tmat4x4<T> operator* (
+			tmat3x4<T> const & m1, 
+			tmat4x3<T> const & m2);
+
+		template <typename T> 
+		tmat3x4<T> operator/ (
+			tmat3x4<T> const & m, 
+			typename tmat3x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat3x4<T> operator/ (
+			typename tmat3x4<T>::value_type const & s, 
+			tmat3x4<T> const & m);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat3x4<T> const operator-  (
+			tmat3x4<T> const & m);
+
+		template <typename T> 
+		tmat3x4<T> const operator-- (
+			tmat3x4<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat3x4<T> const operator++ (
+			tmat3x4<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 3 columns of 4 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat3x4<lowp_float>		lowp_mat3x4;
+		//! 3 columns of 4 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat3x4<mediump_float>	mediump_mat3x4;
+		//! 3 columns of 4 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		typedef detail::tmat3x4<highp_float>	highp_mat3x4;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat3x4.inl"
+#endif
+
+#endif //glm_core_type_mat3x4
diff --git a/ExternalLibs/glm/core/type_mat3x4.inl b/ExternalLibs/glm/core/type_mat3x4.inl
new file mode 100644
index 0000000..3d32271
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat3x4.inl
@@ -0,0 +1,609 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-05
+// Updated : 2010-02-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat3x4.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::col_size()
+	{
+		return 4;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x4<T>::size_type tmat3x4<T>::row_size()
+	{
+		return 3;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type & 
+	tmat3x4<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type const & 
+	tmat3x4<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4()
+    {
+		value_type const Zero(0);
+		value_type const One(1);
+        this->value[0] = col_type(1, 0, 0, 0);
+        this->value[1] = col_type(0, 1, 0, 0);
+        this->value[2] = col_type(0, 0, 1, 0);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+        this->value[2] = m.value[2];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, s, Zero, Zero);
+        this->value[2] = col_type(Zero, Zero, s, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+    (
+		value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+        value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0, w0);
+        this->value[1] = col_type(x1, y1, z1, w1);
+        this->value[2] = col_type(x2, y2, z2, w2);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+        this->value[2] = v2;
+    }
+
+    // Conversion
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat3x4<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+        this->value[2] = col_type(T(0), T(0), T(1), T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+        this->value[2] = col_type(m[2], T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+        this->value[2] = col_type(T(0), T(0), T(1), T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+        this->value[2] = col_type(m[2], T(0), T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(T(0), T(0), T(1), T(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(T(0)));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(T(0)));
+        this->value[2] = col_type(m[2], detail::tvec2<T>(T(1), T(0)));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>::tmat3x4
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+        this->value[2] = col_type(m[2], T(0));
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Unary updatable operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator= 
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator= 
+	(
+		tmat3x4<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        this->value[2] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator+= 
+	(
+		tmat3x4<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        this->value[2] += m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        this->value[2] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-= 
+	(
+		tmat3x4<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        this->value[2] -= m[2];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        this->value[2] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator*= 
+	(
+		tmat3x4<U> const & m
+	)
+    {
+        return (*this = tmat3x4<T>(*this * m));
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> & tmat3x4<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        this->value[2] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        ++this->value[2];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T>& tmat3x4<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        --this->value[2];
+        return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator+ 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
+    {
+        return tmat3x4<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator+ 
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+    {
+        return tmat3x4<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1],
+            m1[2] + m2[2]);
+    }
+
+    template <typename T> 
+	GLM_FUNC_QUALIFIER tmat3x4<T> operator- 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
+    {
+        return tmat3x4<T>(
+            m[0] - s,
+            m[1] - s,
+            m[2] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator- 
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+    {
+        return tmat3x4<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1],
+            m1[2] - m2[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
+    {
+        return tmat3x4<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator* 
+	(
+		typename tmat3x4<T>::value_type const & s, 
+		tmat3x4<T> const & m
+	)
+    {
+        return tmat3x4<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s);
+    }
+   
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename tmat3x4<T>::col_type operator* 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::row_type const & v
+	)
+    {
+        return typename tmat3x4<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z,
+            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z,
+            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z,
+            m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z);
+    }
+
+	//			X X X
+	//			X X X
+	//			X X X
+	//			X X X
+	// X X X X
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat3x4<T>::row_type operator* 
+	(
+		typename tmat3x4<T>::col_type const & v, 
+		tmat3x4<T> const & m
+	)
+    {
+		return typename tmat3x4<T>::row_type(
+            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2] + v.w * m[0][3],
+            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2] + v.w * m[1][3],
+            v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2] + v.w * m[2][3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
+	(
+		tmat3x4<T> const & m1, 
+		tmat4x3<T> const & m2
+	)
+    {
+        const T SrcA00 = m1[0][0];
+        const T SrcA01 = m1[0][1];
+        const T SrcA02 = m1[0][2];
+        const T SrcA03 = m1[0][3];
+        const T SrcA10 = m1[1][0];
+        const T SrcA11 = m1[1][1];
+        const T SrcA12 = m1[1][2];
+        const T SrcA13 = m1[1][3];
+        const T SrcA20 = m1[2][0];
+        const T SrcA21 = m1[2][1];
+        const T SrcA22 = m1[2][2];
+        const T SrcA23 = m1[2][3];
+
+        const T SrcB00 = m2[0][0];
+        const T SrcB01 = m2[0][1];
+        const T SrcB02 = m2[0][2];
+        const T SrcB10 = m2[1][0];
+        const T SrcB11 = m2[1][1];
+        const T SrcB12 = m2[1][2];
+        const T SrcB20 = m2[2][0];
+        const T SrcB21 = m2[2][1];
+        const T SrcB22 = m2[2][2];
+        const T SrcB30 = m2[3][0];
+        const T SrcB31 = m2[3][1];
+        const T SrcB32 = m2[3][2];
+
+        tmat4x4<T> Result(tmat4x4<T>::null);
+        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02;
+        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02;
+        Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02;
+        Result[0][3] = SrcA03 * SrcB00 + SrcA13 * SrcB01 + SrcA23 * SrcB02;
+        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12;
+        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12;
+        Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12;
+        Result[1][3] = SrcA03 * SrcB10 + SrcA13 * SrcB11 + SrcA23 * SrcB12;
+        Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22;
+        Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22;
+        Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22;
+        Result[2][3] = SrcA03 * SrcB20 + SrcA13 * SrcB21 + SrcA23 * SrcB22;
+        Result[3][0] = SrcA00 * SrcB30 + SrcA10 * SrcB31 + SrcA20 * SrcB32;
+        Result[3][1] = SrcA01 * SrcB30 + SrcA11 * SrcB31 + SrcA21 * SrcB32;
+        Result[3][2] = SrcA02 * SrcB30 + SrcA12 * SrcB31 + SrcA22 * SrcB32;
+        Result[3][3] = SrcA03 * SrcB30 + SrcA13 * SrcB31 + SrcA23 * SrcB32;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator/ 
+	(
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s
+	)
+    {
+        return tmat3x4<T>(
+            m[0] / s,
+            m[1] / s,
+            m[2] / s);        
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> operator/
+	(
+		typename tmat3x4<T>::value_type const & s, 
+		tmat3x4<T> const & m
+	)
+    {
+        return tmat3x4<T>(
+            s / m[0],
+            s / m[1],
+            s / m[2]);        
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> const operator- 
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        return tmat3x4<T>(
+            -m[0], 
+            -m[1],
+            -m[2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> const operator++ 
+	(
+		tmat3x4<T> const & m, 
+		int
+	) 
+    {
+        return tmat3x4<T>(
+            m[0] + T(1),
+            m[1] + T(1),
+            m[2] + T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x4<T> const operator-- 
+	(
+		tmat3x4<T> const & m, 
+		int
+	) 
+    {
+        return tmat3x4<T>(
+            m[0] - T(1),
+            m[1] - T(1),
+            m[2] - T(1));
+	}
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat4x2.hpp b/ExternalLibs/glm/core/type_mat4x2.hpp
new file mode 100644
index 0000000..3354ce8
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat4x2.hpp
@@ -0,0 +1,222 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-10-01
+// Updated : 2010-02-11
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat4x2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat4x2
+#define glm_core_type_mat4x2
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat4x2();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat4x2
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec2<T> col_type;
+			typedef tvec4<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat4x2<T> type;
+			typedef tmat2x4<T> transpose_type;
+
+		private:
+			// Data 
+			col_type value[4];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat4x2();
+			GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
+
+			GLM_FUNC_DECL explicit tmat4x2(
+				ctor Null);
+			GLM_FUNC_DECL explicit tmat4x2(
+				value_type const & x);
+			GLM_FUNC_DECL explicit tmat4x2(
+				value_type const & x0, value_type const & y0,
+				value_type const & x1, value_type const & y1,
+				value_type const & x2, value_type const & y2,
+				value_type const & x3, value_type const & y3);
+			GLM_FUNC_DECL explicit tmat4x2(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2,
+				col_type const & v3);
+
+			// Conversions
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
+			
+			GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
+
+			// Accesses
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
+
+			GLM_FUNC_DECL tmat4x2<T>& operator++ ();
+			GLM_FUNC_DECL tmat4x2<T>& operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat4x2<T> operator+ (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
+	    
+		template <typename T> 
+		tmat4x2<T> operator+ (
+			tmat4x2<T> const & m1, 
+			tmat4x2<T> const & m2);
+	    
+		template <typename T> 
+		tmat4x2<T> operator- (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x2<T> operator- (
+			tmat4x2<T> const & m1, 
+			tmat4x2<T> const & m2);
+
+		template <typename T> 
+		tmat4x2<T> operator* (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x2<T> operator* (
+			typename tmat4x2<T>::value_type const & s, 
+			tmat4x2<T> const & m);
+
+		template <typename T>
+		typename tmat4x2<T>::col_type operator* (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat4x2<T>::row_type operator* (
+			typename tmat4x2<T>::col_type const & v, 
+			tmat4x2<T> const & m);
+
+		template <typename T> 
+		tmat2x2<T> operator* (
+			tmat4x2<T> const & m1, 
+			tmat2x4<T> const & m2);
+
+		template <typename T> 
+		tmat4x2<T> operator/ (
+			tmat4x2<T> const & m, 
+			typename tmat4x2<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x2<T> operator/ (
+			typename tmat4x2<T>::value_type const & s, 
+			tmat4x2<T> const & m);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat4x2<T> const operator-  (
+			tmat4x2<T> const & m);
+
+		template <typename T> 
+		tmat4x2<T> const operator-- (
+			tmat4x2<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat4x2<T> const operator++ (
+			tmat4x2<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 4 columns of 2 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x2<lowp_float>		lowp_mat4x2;
+		//! 4 columns of 2 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x2<mediump_float>	mediump_mat4x2;
+		//! 4 columns of 2 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x2<highp_float>	highp_mat4x2;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x2.inl"
+#endif
+
+#endif //glm_core_type_mat4x2
diff --git a/ExternalLibs/glm/core/type_mat4x2.inl b/ExternalLibs/glm/core/type_mat4x2.inl
new file mode 100644
index 0000000..cb30a98
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat4x2.inl
@@ -0,0 +1,618 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-10-01
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat4x2.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::col_size()
+	{
+		return 2;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x2<T>::size_type tmat4x2<T>::row_size()
+	{
+		return 4;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type & 
+	tmat4x2<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type const & 
+	tmat4x2<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2()
+    {
+		value_type const Zero(0);
+		value_type const One(1);
+        this->value[0] = col_type(One, Zero);
+        this->value[1] = col_type(Zero, One);
+        this->value[2] = col_type(Zero, Zero);
+        this->value[3] = col_type(Zero, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+        this->value[2] = m.value[2];
+        this->value[3] = m.value[3];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero);
+        this->value[1] = col_type(Zero, s);
+        this->value[2] = col_type(Zero, Zero);
+        this->value[3] = col_type(Zero, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+    (
+        value_type const & x0, value_type const & y0,
+        value_type const & x1, value_type const & y1,
+        value_type const & x2, value_type const & y2,
+        value_type const & x3, value_type const & y3
+    )
+    {
+        this->value[0] = col_type(x0, y0);
+        this->value[1] = col_type(x1, y1);
+        this->value[2] = col_type(x2, y2);
+        this->value[3] = col_type(x3, y3);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2,
+        col_type const & v3
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+        this->value[2] = v2;
+        this->value[3] = v3;
+    }
+
+    // Conversion
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat4x2<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(m[3]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(value_type(0));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(value_type(0));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(value_type(0));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>::tmat4x2
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(value_type(0));
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Unary updatable operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator= 
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T>& tmat4x2<T>::operator= 
+	(
+		tmat4x2<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        this->value[2] += s;
+        this->value[3] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator+= 
+	(
+		tmat4x2<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        this->value[2] += m[2];
+        this->value[3] += m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        this->value[2] -= s;
+        this->value[3] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-= 
+	(
+		tmat4x2<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        this->value[2] -= m[2];
+        this->value[3] -= m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        this->value[2] *= s;
+        this->value[3] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator*= 
+	(
+		tmat4x2<U> const & m
+	)
+    {
+        return (*this = tmat4x2<T>(*this * m));
+    }
+
+    template <typename T>
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        this->value[2] /= s;
+        this->value[3] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        ++this->value[2];
+        ++this->value[3];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> & tmat4x2<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        --this->value[2];
+        --this->value[3];
+        return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator+ 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
+    {
+        return tmat4x2<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s,
+            m[3] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator+ 
+	(	
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+    {
+        return tmat4x2<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1],
+            m1[2] + m2[2],
+            m1[3] + m2[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator- 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
+    {
+        return tmat4x2<T>(
+            m[0] - s,
+            m[1] - s,
+            m[2] - s,
+            m[3] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator- 
+	(	
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+    {
+        return tmat4x2<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1],
+            m1[2] - m2[2],
+            m1[3] - m2[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
+    {
+        return tmat4x2<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s,
+            m[3] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator* 
+	(
+		typename tmat4x2<T>::value_type const & s, 
+		tmat4x2<T> const & m
+	)
+    {
+        return tmat4x2<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s,
+            m[3] * s);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename tmat4x2<T>::col_type operator* 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::row_type const & v)
+    {
+        return typename tmat4x2<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat4x2<T>::row_type operator* 
+	(
+		typename tmat4x2<T>::col_type const & v, 
+		tmat4x2<T> const & m) 
+    {
+        return typename tmat4x2<T>::row_type(
+            v.x * m[0][0] + v.y * m[0][1],
+            v.x * m[1][0] + v.y * m[1][1],
+            v.x * m[2][0] + v.y * m[2][1],
+            v.x * m[3][0] + v.y * m[3][1]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat2x2<T> operator* 
+	(
+		tmat4x2<T> const & m1, 
+		tmat2x4<T> const & m2
+	)
+    {
+        T const SrcA00 = m1[0][0];
+        T const SrcA01 = m1[0][1];
+        T const SrcA10 = m1[1][0];
+        T const SrcA11 = m1[1][1];
+        T const SrcA20 = m1[2][0];
+        T const SrcA21 = m1[2][1];
+        T const SrcA30 = m1[3][0];
+        T const SrcA31 = m1[3][1];
+
+        T const SrcB00 = m2[0][0];
+        T const SrcB01 = m2[0][1];
+        T const SrcB02 = m2[0][2];
+        T const SrcB03 = m2[0][3];
+        T const SrcB10 = m2[1][0];
+        T const SrcB11 = m2[1][1];
+        T const SrcB12 = m2[1][2];
+        T const SrcB13 = m2[1][3];
+
+        tmat2x2<T> Result(tmat2x2<T>::null);
+        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator/ 
+	(
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s
+	)
+    {
+        return tmat4x2<T>(
+            m[0] / s,
+            m[1] / s,
+            m[2] / s,
+            m[3] / s);        
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> operator/ 
+	(
+		typename tmat4x2<T>::value_type const & s, 
+		tmat4x2<T> const & m
+	)
+    {
+        return tmat4x2<T>(
+            s / m[0],
+            s / m[1],
+            s / m[2],
+            s / m[3]);        
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> const operator- 
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        return tmat4x2<T>(
+            -m[0], 
+            -m[1], 
+            -m[2], 
+            -m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> const operator++ 
+	(
+		tmat4x2<T> const & m, 
+		int
+	) 
+    {
+        return tmat4x2<T>(
+			m[0] + typename tmat4x2<T>::value_type(1),
+            m[1] + typename tmat4x2<T>::value_type(1),
+            m[2] + typename tmat4x2<T>::value_type(1),
+            m[3] + typename tmat4x2<T>::value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x2<T> const operator-- 
+	(
+		tmat4x2<T> const & m, 
+		int
+	) 
+    {
+        return tmat4x2<T>(
+            m[0] - typename tmat4x2<T>::value_type(1),
+            m[1] - typename tmat4x2<T>::value_type(1),
+            m[2] - typename tmat4x2<T>::value_type(1),
+            m[3] - typename tmat4x2<T>::value_type(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_mat4x3.hpp b/ExternalLibs/glm/core/type_mat4x3.hpp
new file mode 100644
index 0000000..b15a3c3
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat4x3.hpp
@@ -0,0 +1,222 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-08-04
+// Updated : 2010-02-11
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat4x3.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat4x3
+#define glm_core_type_mat4x3
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat4x3();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat4x3
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec3<T> col_type;
+			typedef tvec4<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat4x3<T> type;
+			typedef tmat3x4<T> transpose_type;
+
+		private:
+			// Data 
+			col_type value[4];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat4x3();
+			GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
+
+			GLM_FUNC_DECL explicit tmat4x3(
+				ctor Null);
+			GLM_FUNC_DECL explicit tmat4x3(
+				value_type const & x);
+			GLM_FUNC_DECL explicit tmat4x3(
+				value_type const & x0, value_type const & y0, value_type const & z0,
+				value_type const & x1, value_type const & y1, value_type const & z1,
+				value_type const & x2, value_type const & y2, value_type const & z2,
+				value_type const & x3, value_type const & y3, value_type const & z3);
+			GLM_FUNC_DECL explicit tmat4x3(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2,
+				col_type const & v3);
+
+			// Conversion
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
+			
+			GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
+
+			// Accesses
+			col_type & operator[](size_type i);
+			col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<T> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
+			template <typename U> 
+			GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
+
+			GLM_FUNC_DECL tmat4x3<T> & operator++ ();
+			GLM_FUNC_DECL tmat4x3<T> & operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat4x3<T> operator+ (
+			tmat4x3<T> const & m, 
+			typename tmat4x3<T>::value_type const & s);
+	    
+		template <typename T> 
+		tmat4x3<T> operator+ (
+			tmat4x3<T> const & m1, 
+			tmat4x3<T> const & m2);
+	    
+		template <typename T> 
+		tmat4x3<T> operator- (
+			tmat4x3<T> const & m, 
+			typename tmat4x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x3<T> operator- (
+			tmat4x3<T> const & m1, 
+			tmat4x3<T> const & m2);
+
+		template <typename T> 
+		tmat4x3<T> operator* (
+			tmat4x3<T> const & m, 
+			typename tmat4x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x3<T> operator* (
+			typename tmat4x3<T>::value_type const & s, 
+			tmat4x3<T> const & m);
+
+		template <typename T>
+		typename tmat4x3<T>::col_type operator* (
+			tmat4x3<T> const & m, 
+			typename tmat4x3<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat4x3<T>::row_type operator* (
+			typename tmat4x3<T>::col_type const & v, 
+			tmat4x3<T> const & m);
+
+		template <typename T> 
+		tmat3x3<T> operator* (
+			tmat4x3<T> const & m1, 
+			tmat3x4<T> const & m2);
+
+		template <typename T> 
+		tmat4x3<T> operator/ (
+			tmat4x3<T> const & m, 
+			typename tmat4x3<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x3<T> operator/ (
+			typename tmat4x3<T>::value_type const & s, 
+			tmat4x3<T> const & m);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat4x3<T> const operator- (
+			tmat4x3<T> const & m);
+
+		template <typename T> 
+		tmat4x3<T> const operator-- (
+			tmat4x3<T> const & m, 
+			int);
+
+		template <typename T> 
+		tmat4x3<T> const operator++ (
+			tmat4x3<T> const & m, 
+			int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 4 columns of 3 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x3<lowp_float>		lowp_mat4x3;
+		//! 4 columns of 3 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x3<mediump_float>	mediump_mat4x3;
+		//! 4 columns of 3 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x3<highp_float>	highp_mat4x3;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x3.inl"
+#endif
+
+#endif//glm_core_type_mat4x3
diff --git a/ExternalLibs/glm/core/type_mat4x3.inl b/ExternalLibs/glm/core/type_mat4x3.inl
new file mode 100644
index 0000000..b882af2
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat4x3.inl
@@ -0,0 +1,623 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-17
+// Updated : 2010-02-02
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat4x3.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::col_size()
+	{
+		return 3;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x3<T>::size_type tmat4x3<T>::row_size()
+	{
+		return 4;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type & 
+	tmat4x3<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type const & 
+	tmat4x3<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3()
+    {
+		value_type const Zero(0);
+		value_type const One(1);
+        this->value[0] = col_type(One, Zero, Zero);
+        this->value[1] = col_type(Zero, One, Zero);
+        this->value[2] = col_type(Zero, Zero, One);
+        this->value[3] = col_type(Zero, Zero, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+        this->value[2] = m.value[2];
+        this->value[3] = m.value[3];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero);
+        this->value[1] = col_type(Zero, s, Zero);
+        this->value[2] = col_type(Zero, Zero, s);
+        this->value[3] = col_type(Zero, Zero, Zero);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0,
+        value_type const & x1, value_type const & y1, value_type const & z1,
+        value_type const & x2, value_type const & y2, value_type const & z2,
+        value_type const & x3, value_type const & y3, value_type const & z3
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0);
+        this->value[1] = col_type(x1, y1, z1);
+        this->value[2] = col_type(x2, y2, z2);
+        this->value[3] = col_type(x3, y3, z3);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2,
+        col_type const & v3
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+        this->value[2] = v2;
+        this->value[3] = v3;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Conversions
+
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat4x3<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(m[3]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(m[2], value_type(1));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(m[2], value_type(1));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(value_type(0), value_type(0), value_type(1));
+        this->value[3] = col_type(value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(m[2], value_type(1));
+        this->value[3] = col_type(m[3], value_type(0));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>::tmat4x3
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(value_type(0));
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Unary updatable operators
+
+	template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator= 
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T>& tmat4x3<T>::operator= 
+	(
+		tmat4x3<U> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        this->value[2] += s;
+        this->value[3] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator+= 
+	(
+		tmat4x3<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        this->value[2] += m[2];
+        this->value[3] += m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        this->value[2] -= s;
+        this->value[3] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-= 
+	(
+		tmat4x3<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        this->value[2] -= m[2];
+        this->value[3] -= m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        this->value[2] *= s;
+        this->value[3] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator*= 
+	(
+		tmat4x3<U> const & m
+	)
+    {
+        return (*this = tmat4x3<T>(*this * m));
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        this->value[2] /= s;
+        this->value[3] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        ++this->value[2];
+        ++this->value[3];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> & tmat4x3<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        --this->value[2];
+        --this->value[3];
+        return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Binary operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s)
+    {
+        return tmat4x3<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s,
+            m[3] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator+ (
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2)
+    {
+        return tmat4x3<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1],
+            m1[2] + m2[2],
+            m1[3] + m2[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s)
+    {
+        return tmat4x3<T>(
+            m[0] - s,
+            m[1] - s,
+            m[2] - s,
+            m[3] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator- (
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2)
+    {
+        return tmat4x3<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1],
+            m1[2] - m2[2],
+            m1[3] - m2[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s)
+    {
+        return tmat4x3<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s,
+            m[3] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator* (
+		typename tmat4x3<T>::value_type const & s, 
+		tmat4x3<T> const & m)
+    {
+        return tmat4x3<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s,
+            m[3] * s);
+    }
+   
+    template <typename T>
+    GLM_FUNC_QUALIFIER typename tmat4x3<T>::col_type operator* 
+	(
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::row_type const & v)
+    {
+        return typename tmat4x3<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
+            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat4x3<T>::row_type operator* 
+	(
+		typename tmat4x3<T>::col_type const & v, 
+		tmat4x3<T> const & m) 
+    {
+        return typename tmat4x3<T>::row_type(
+            v.x * m[0][0] + v.y * m[0][1] + v.z * m[0][2],
+            v.x * m[1][0] + v.y * m[1][1] + v.z * m[1][2],
+            v.x * m[2][0] + v.y * m[2][1] + v.z * m[2][2],
+            v.x * m[3][0] + v.y * m[3][1] + v.z * m[3][2]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat3x3<T> operator* 
+	(
+		tmat4x3<T> const & m1, 
+		tmat3x4<T> const & m2
+	)
+    {
+        T const SrcA00 = m1[0][0];
+        T const SrcA01 = m1[0][1];
+        T const SrcA02 = m1[0][2];
+        T const SrcA10 = m1[1][0];
+		T const SrcA11 = m1[1][1];
+        T const SrcA12 = m1[1][2];
+        T const SrcA20 = m1[2][0];
+        T const SrcA21 = m1[2][1];
+        T const SrcA22 = m1[2][2];
+        T const SrcA30 = m1[3][0];
+        T const SrcA31 = m1[3][1];
+        T const SrcA32 = m1[3][2];
+
+        T const SrcB00 = m2[0][0];
+        T const SrcB01 = m2[0][1];
+        T const SrcB02 = m2[0][2];
+        T const SrcB03 = m2[0][3];
+        T const SrcB10 = m2[1][0];
+        T const SrcB11 = m2[1][1];
+        T const SrcB12 = m2[1][2];
+        T const SrcB13 = m2[1][3];
+        T const SrcB20 = m2[2][0];
+        T const SrcB21 = m2[2][1];
+        T const SrcB22 = m2[2][2];
+        T const SrcB23 = m2[2][3];
+
+        tmat3x3<T> Result(tmat3x3<T>::null);
+        Result[0][0] = SrcA00 * SrcB00 + SrcA10 * SrcB01 + SrcA20 * SrcB02 + SrcA30 * SrcB03;
+        Result[0][1] = SrcA01 * SrcB00 + SrcA11 * SrcB01 + SrcA21 * SrcB02 + SrcA31 * SrcB03;
+        Result[0][2] = SrcA02 * SrcB00 + SrcA12 * SrcB01 + SrcA22 * SrcB02 + SrcA32 * SrcB03;
+        Result[1][0] = SrcA00 * SrcB10 + SrcA10 * SrcB11 + SrcA20 * SrcB12 + SrcA30 * SrcB13;
+        Result[1][1] = SrcA01 * SrcB10 + SrcA11 * SrcB11 + SrcA21 * SrcB12 + SrcA31 * SrcB13;
+        Result[1][2] = SrcA02 * SrcB10 + SrcA12 * SrcB11 + SrcA22 * SrcB12 + SrcA32 * SrcB13;
+        Result[2][0] = SrcA00 * SrcB20 + SrcA10 * SrcB21 + SrcA20 * SrcB22 + SrcA30 * SrcB23;
+        Result[2][1] = SrcA01 * SrcB20 + SrcA11 * SrcB21 + SrcA21 * SrcB22 + SrcA31 * SrcB23;
+        Result[2][2] = SrcA02 * SrcB20 + SrcA12 * SrcB21 + SrcA22 * SrcB22 + SrcA32 * SrcB23;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator/ 
+	(
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s
+	)
+    {
+        return tmat4x3<T>(
+            m[0] / s,
+            m[1] / s,
+            m[2] / s,
+            m[3] / s);        
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> operator/ 
+	(
+		typename tmat4x3<T>::value_type const & s, 
+		tmat4x3<T> const & m
+	)
+    {
+        return tmat4x3<T>(
+            s / m[0],
+            s / m[1],
+            s / m[2],
+            s / m[3]);        
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> const operator- 
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        return tmat4x3<T>(
+            -m[0], 
+            -m[1],
+            -m[2],
+            -m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> const operator++ 
+	(
+		tmat4x3<T> const & m, 
+		int
+	) 
+    {
+        return tmat4x3<T>(
+            m[0] + T(1),
+            m[1] + T(1),
+            m[2] + T(1),
+            m[3] + T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x3<T> const operator-- 
+	(
+		tmat4x3<T> const & m, 
+		int
+	) 
+    {
+        return tmat4x3<T>(
+            m[0] - T(1),
+            m[1] - T(1),
+            m[2] - T(1),
+            m[3] - T(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+
+} //namespace detail
+} //namespace glm
+
diff --git a/ExternalLibs/glm/core/type_mat4x4.hpp b/ExternalLibs/glm/core/type_mat4x4.hpp
new file mode 100644
index 0000000..6aa1f68
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat4x4.hpp
@@ -0,0 +1,250 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-27
+// Updated : 2008-08-30
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat4x4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_mat4x4
+#define glm_core_type_mat4x4
+
+#include "type_mat.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_mat4x4();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+		template <typename T> struct tmat2x2;
+		template <typename T> struct tmat2x3;
+		template <typename T> struct tmat2x4;
+		template <typename T> struct tmat3x2;
+		template <typename T> struct tmat3x3;
+		template <typename T> struct tmat3x4;
+		template <typename T> struct tmat4x2;
+		template <typename T> struct tmat4x3;
+		template <typename T> struct tmat4x4;
+
+		//! \brief Template for 4 * 4 matrix of floating-point numbers.
+		//! \ingroup core_template
+		template <typename T> 
+		struct tmat4x4
+		{
+			enum ctor{null};
+			typedef T value_type;
+			typedef std::size_t size_type;
+			typedef tvec4<T> col_type;
+			typedef tvec4<T> row_type;
+			static GLM_FUNC_DECL size_type col_size();
+			static GLM_FUNC_DECL size_type row_size();
+
+			typedef tmat4x4<T> type;
+			typedef tmat4x4<T> transpose_type;
+
+		public:
+			// Implementation detail
+			GLM_FUNC_DECL tmat4x4<T> _inverse() const;
+
+		private:
+			// Data 
+			col_type value[4];
+
+		public:
+			// Constructors
+			GLM_FUNC_DECL tmat4x4();
+			GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
+
+			GLM_FUNC_DECL explicit tmat4x4(
+				ctor Null);
+			GLM_FUNC_DECL explicit tmat4x4(
+				value_type const & x);
+			GLM_FUNC_DECL explicit tmat4x4(
+				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
+				value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
+			GLM_FUNC_DECL explicit tmat4x4(
+				col_type const & v0, 
+				col_type const & v1,
+				col_type const & v2,
+				col_type const & v3);
+
+			// Conversions
+			template <typename U> 
+			GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
+
+			GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
+			GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
+
+			// Accesses
+			GLM_FUNC_DECL col_type & operator[](size_type i);
+			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+			// Unary updatable operators
+			GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<T> const & m);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
+			GLM_FUNC_DECL tmat4x4<T> & operator++ ();
+			GLM_FUNC_DECL tmat4x4<T> & operator-- ();
+		};
+
+		// Binary operators
+		template <typename T> 
+		tmat4x4<T> operator+ (
+			tmat4x4<T> const & m, 
+			typename tmat4x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x4<T> operator+ (
+			typename tmat4x4<T>::value_type const & s, 
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		tmat4x4<T> operator+ (
+			tmat4x4<T> const & m1, 
+			tmat4x4<T> const & m2);
+	    
+		template <typename T> 
+		tmat4x4<T> operator- (
+			tmat4x4<T> const & m, 
+			typename tmat4x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x4<T> operator- (
+			typename tmat4x4<T>::value_type const & s, 
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		tmat4x4<T> operator- (
+			tmat4x4<T> const & m1, 
+			tmat4x4<T> const & m2);
+
+		template <typename T> 
+		tmat4x4<T> operator* (
+			tmat4x4<T> const & m, 
+			typename tmat4x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x4<T> operator* (
+			typename tmat4x4<T>::value_type const & s, 
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		typename tmat4x4<T>::col_type operator* (
+			tmat4x4<T> const & m, 
+			typename tmat4x4<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat4x4<T>::row_type operator* (
+			typename tmat4x4<T>::col_type const & v, 
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		tmat4x4<T> operator* (
+			tmat4x4<T> const & m1, 
+			tmat4x4<T> const & m2);
+
+		template <typename T> 
+		tmat4x4<T> operator/ (
+			tmat4x4<T> const & m, 
+			typename tmat4x4<T>::value_type const & s);
+
+		template <typename T> 
+		tmat4x4<T> operator/ (
+			typename tmat4x4<T>::value_type const & s, 
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		typename tmat4x4<T>::col_type operator/ (
+			tmat4x4<T> const & m, 
+			typename tmat4x4<T>::row_type const & v);
+
+		template <typename T> 
+		typename tmat4x4<T>::row_type operator/ (
+			typename tmat4x4<T>::col_type & v, 
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		tmat4x4<T> operator/ (
+			tmat4x4<T> const & m1, 
+			tmat4x4<T> const & m2);
+
+		// Unary constant operators
+		template <typename T> 
+		tmat4x4<T> const operator-  (
+			tmat4x4<T> const & m);
+
+		template <typename T> 
+		tmat4x4<T> const operator-- (
+			tmat4x4<T> const & m, int);
+
+		template <typename T> 
+		tmat4x4<T> const operator++ (
+			tmat4x4<T> const & m, int);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 4 columns of 4 components matrix of low precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x4<lowp_float>		lowp_mat4x4;
+		//! 4 columns of 4 components matrix of medium precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x4<mediump_float>	mediump_mat4x4;
+		//! 4 columns of 4 components matrix of high precision floating-point numbers.
+		//! There is no guarantee on the actual precision.
+		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
+		typedef detail::tmat4x4<highp_float>	highp_mat4x4;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+} //namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_mat4x4.inl"
+#endif
+
+#endif //glm_core_type_mat4x4
diff --git a/ExternalLibs/glm/core/type_mat4x4.inl b/ExternalLibs/glm/core/type_mat4x4.inl
new file mode 100644
index 0000000..8df4b06
--- /dev/null
+++ b/ExternalLibs/glm/core/type_mat4x4.inl
@@ -0,0 +1,759 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-27
+// Updated : 2010-02-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_mat4x4.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::col_size()
+	{
+		return 4;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x4<T>::size_type tmat4x4<T>::row_size()
+	{
+		return 4;
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type & 
+	tmat4x4<T>::operator[]
+	(
+		size_type i
+	)
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type const & 
+	tmat4x4<T>::operator[]
+	(
+		size_type i
+	) const
+	{
+		assert(i < this->row_size());
+		return this->value[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // Constructors
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4()
+    {
+		value_type Zero(0);
+		value_type One(1);
+        this->value[0] = col_type(One, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, One, Zero, Zero);
+        this->value[2] = col_type(Zero, Zero, One, Zero);
+        this->value[3] = col_type(Zero, Zero, Zero, One);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        this->value[0] = m.value[0];
+        this->value[1] = m.value[1];
+        this->value[2] = m.value[2];
+        this->value[3] = m.value[3];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		ctor
+	)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		value_type const & s
+	)
+    {
+		value_type const Zero(0);
+        this->value[0] = col_type(s, Zero, Zero, Zero);
+        this->value[1] = col_type(Zero, s, Zero, Zero);
+        this->value[2] = col_type(Zero, Zero, s, Zero);
+        this->value[3] = col_type(Zero, Zero, Zero, s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+    (
+        value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+        value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+        value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
+        value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3
+    )
+    {
+        this->value[0] = col_type(x0, y0, z0, w0);
+        this->value[1] = col_type(x1, y1, z1, w1);
+        this->value[2] = col_type(x2, y2, z2, w2);
+        this->value[3] = col_type(x3, y3, z3, w3);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+    (
+        col_type const & v0, 
+        col_type const & v1, 
+        col_type const & v2,
+        col_type const & v3
+    )
+    {
+        this->value[0] = v0;
+        this->value[1] = v1;
+        this->value[2] = v2;
+        this->value[3] = v3;
+    }
+
+    template <typename T> 
+    template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat4x4<U> const & m
+	)
+    {
+        this->value[0] = col_type(m[0]);
+        this->value[1] = col_type(m[1]);
+        this->value[2] = col_type(m[2]);
+        this->value[3] = col_type(m[3]);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat2x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+        this->value[2] = col_type(value_type(0));
+        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat3x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(m[2], value_type(0));
+        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
+    }
+
+	template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat2x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], value_type(0));
+        this->value[1] = col_type(m[1], value_type(0));
+        this->value[2] = col_type(value_type(0));
+        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat3x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+        this->value[2] = col_type(m[2], detail::tvec2<T>(0));
+        this->value[3] = col_type(value_type(0), value_type(0), value_type(0), value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat2x4<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = col_type(T(0));
+        this->value[3] = col_type(T(0), T(0), T(0), T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat4x2<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], detail::tvec2<T>(0));
+        this->value[1] = col_type(m[1], detail::tvec2<T>(0));
+        this->value[2] = col_type(T(0));
+        this->value[3] = col_type(T(0), T(0), T(0), T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat3x4<T> const & m
+	)
+    {
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = col_type(T(0), T(0), T(0), T(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>::tmat4x4
+	(
+		tmat4x3<T> const & m
+	)
+    {
+        this->value[0] = col_type(m[0], T(0));
+        this->value[1] = col_type(m[1], T(0));
+        this->value[2] = col_type(m[2], T(0));
+        this->value[3] = col_type(m[3], T(1));
+    }
+
+    //////////////////////////////////////////////////////////////
+    // Operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator= 
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        //memcpy could be faster
+        //memcpy(&this->value, &m.value, 16 * sizeof(valType));
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator= 
+	(
+		tmat4x4<U> const & m
+	)
+    {
+        //memcpy could be faster
+        //memcpy(&this->value, &m.value, 16 * sizeof(valType));
+        this->value[0] = m[0];
+        this->value[1] = m[1];
+        this->value[2] = m[2];
+        this->value[3] = m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] += s;
+        this->value[1] += s;
+        this->value[2] += s;
+        this->value[3] += s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x4<T>& tmat4x4<T>::operator+= 
+	(
+		tmat4x4<U> const & m
+	)
+    {
+        this->value[0] += m[0];
+        this->value[1] += m[1];
+        this->value[2] += m[2];
+        this->value[3] += m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] -= s;
+        this->value[1] -= s;
+        this->value[2] -= s;
+        this->value[3] -= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U>
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-= 
+	(
+		tmat4x4<U> const & m
+	)
+    {
+        this->value[0] -= m[0];
+        this->value[1] -= m[1];
+        this->value[2] -= m[2];
+        this->value[3] -= m[3];
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U>
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] *= s;
+        this->value[1] *= s;
+        this->value[2] *= s;
+        this->value[3] *= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U>
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator*= 
+	(
+		tmat4x4<U> const & m
+	)
+    {
+        return (*this = *this * m);
+    }
+
+    template <typename T> 
+	template <typename U>
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= 
+	(
+		U const & s
+	)
+    {
+        this->value[0] /= s;
+        this->value[1] /= s;
+        this->value[2] /= s;
+        this->value[3] /= s;
+        return *this;
+    }
+
+    template <typename T> 
+	template <typename U>
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator/= 
+	(
+		tmat4x4<U> const & m
+	)
+    {
+        return (*this = *this / m);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator++ ()
+    {
+        ++this->value[0];
+        ++this->value[1];
+        ++this->value[2];
+        ++this->value[3];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> & tmat4x4<T>::operator-- ()
+    {
+        --this->value[0];
+        --this->value[1];
+        --this->value[2];
+        --this->value[3];
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> tmat4x4<T>::_inverse() const
+    {
+        // Calculate all mat2 determinants
+        value_type SubFactor00 = this->value[2][2] * this->value[3][3] - this->value[3][2] * this->value[2][3];
+        value_type SubFactor01 = this->value[2][1] * this->value[3][3] - this->value[3][1] * this->value[2][3];
+        value_type SubFactor02 = this->value[2][1] * this->value[3][2] - this->value[3][1] * this->value[2][2];
+        value_type SubFactor03 = this->value[2][0] * this->value[3][3] - this->value[3][0] * this->value[2][3];
+        value_type SubFactor04 = this->value[2][0] * this->value[3][2] - this->value[3][0] * this->value[2][2];
+        value_type SubFactor05 = this->value[2][0] * this->value[3][1] - this->value[3][0] * this->value[2][1];
+        value_type SubFactor06 = this->value[1][2] * this->value[3][3] - this->value[3][2] * this->value[1][3];
+        value_type SubFactor07 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
+        value_type SubFactor08 = this->value[1][1] * this->value[3][2] - this->value[3][1] * this->value[1][2];
+        value_type SubFactor09 = this->value[1][0] * this->value[3][3] - this->value[3][0] * this->value[1][3];
+        value_type SubFactor10 = this->value[1][0] * this->value[3][2] - this->value[3][0] * this->value[1][2];
+        value_type SubFactor11 = this->value[1][1] * this->value[3][3] - this->value[3][1] * this->value[1][3];
+        value_type SubFactor12 = this->value[1][0] * this->value[3][1] - this->value[3][0] * this->value[1][1];
+        value_type SubFactor13 = this->value[1][2] * this->value[2][3] - this->value[2][2] * this->value[1][3];
+        value_type SubFactor14 = this->value[1][1] * this->value[2][3] - this->value[2][1] * this->value[1][3];
+        value_type SubFactor15 = this->value[1][1] * this->value[2][2] - this->value[2][1] * this->value[1][2];
+        value_type SubFactor16 = this->value[1][0] * this->value[2][3] - this->value[2][0] * this->value[1][3];
+        value_type SubFactor17 = this->value[1][0] * this->value[2][2] - this->value[2][0] * this->value[1][2];
+        value_type SubFactor18 = this->value[1][0] * this->value[2][1] - this->value[2][0] * this->value[1][1];
+/*
+        tmat4x4<T> Inverse(
+            + (this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02),
+            - (this->value[1][0] * SubFactor00 - this->value[1][2] * SubFactor03 + this->value[1][3] * SubFactor04),
+            + (this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05),
+            - (this->value[1][0] * SubFactor02 - this->value[1][1] * SubFactor04 + this->value[1][2] * SubFactor05),
+
+            - (this->value[0][1] * SubFactor00 - this->value[0][2] * SubFactor01 + this->value[0][3] * SubFactor02),
+            + (this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04),
+            - (this->value[0][0] * SubFactor01 - this->value[0][1] * SubFactor03 + this->value[0][3] * SubFactor05),
+            + (this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05),
+
+            + (this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08),
+            - (this->value[0][0] * SubFactor06 - this->value[0][2] * SubFactor09 + this->value[0][3] * SubFactor10),
+            + (this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12),
+            - (this->value[0][0] * SubFactor08 - this->value[0][1] * SubFactor10 + this->value[0][2] * SubFactor12),
+
+            - (this->value[0][1] * SubFactor13 - this->value[0][2] * SubFactor14 + this->value[0][3] * SubFactor15),
+            + (this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17),
+            - (this->value[0][0] * SubFactor14 - this->value[0][1] * SubFactor16 + this->value[0][3] * SubFactor18),
+            + (this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18));
+*/
+        tmat4x4<T> Inverse(
+            + this->value[1][1] * SubFactor00 - this->value[1][2] * SubFactor01 + this->value[1][3] * SubFactor02,
+            - this->value[1][0] * SubFactor00 + this->value[1][2] * SubFactor03 - this->value[1][3] * SubFactor04,
+            + this->value[1][0] * SubFactor01 - this->value[1][1] * SubFactor03 + this->value[1][3] * SubFactor05,
+            - this->value[1][0] * SubFactor02 + this->value[1][1] * SubFactor04 - this->value[1][2] * SubFactor05,
+
+            - this->value[0][1] * SubFactor00 + this->value[0][2] * SubFactor01 - this->value[0][3] * SubFactor02,
+            + this->value[0][0] * SubFactor00 - this->value[0][2] * SubFactor03 + this->value[0][3] * SubFactor04,
+            - this->value[0][0] * SubFactor01 + this->value[0][1] * SubFactor03 - this->value[0][3] * SubFactor05,
+            + this->value[0][0] * SubFactor02 - this->value[0][1] * SubFactor04 + this->value[0][2] * SubFactor05,
+
+            + this->value[0][1] * SubFactor06 - this->value[0][2] * SubFactor07 + this->value[0][3] * SubFactor08,
+            - this->value[0][0] * SubFactor06 + this->value[0][2] * SubFactor09 - this->value[0][3] * SubFactor10,
+            + this->value[0][0] * SubFactor11 - this->value[0][1] * SubFactor09 + this->value[0][3] * SubFactor12,
+            - this->value[0][0] * SubFactor08 + this->value[0][1] * SubFactor10 - this->value[0][2] * SubFactor12,
+
+            - this->value[0][1] * SubFactor13 + this->value[0][2] * SubFactor14 - this->value[0][3] * SubFactor15,
+            + this->value[0][0] * SubFactor13 - this->value[0][2] * SubFactor16 + this->value[0][3] * SubFactor17,
+            - this->value[0][0] * SubFactor14 + this->value[0][1] * SubFactor16 - this->value[0][3] * SubFactor18,
+            + this->value[0][0] * SubFactor15 - this->value[0][1] * SubFactor17 + this->value[0][2] * SubFactor18);
+
+        value_type Determinant = 
+			+ this->value[0][0] * Inverse[0][0] 
+			+ this->value[0][1] * Inverse[1][0] 
+			+ this->value[0][2] * Inverse[2][0] 
+			+ this->value[0][3] * Inverse[3][0];
+
+        Inverse /= Determinant;
+        return Inverse;
+    }
+
+	// Binary operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
+	(
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s
+	)
+    {
+        return tmat4x4<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s,
+            m[3] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
+	(
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m
+	)
+    {
+        return tmat4x4<T>(
+            m[0] + s,
+            m[1] + s,
+            m[2] + s,
+            m[3] + s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator+ 
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+    {
+        return tmat4x4<T>(
+            m1[0] + m2[0],
+            m1[1] + m2[1],
+            m1[2] + m2[2],
+            m1[3] + m2[3]);
+    }
+    
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
+	(
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s
+	)
+    {
+        return tmat4x4<T>(
+            m[0] - s,
+            m[1] - s,
+            m[2] - s,
+            m[3] - s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
+	(
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m
+	)
+    {
+        return tmat4x4<T>(
+            s - m[0],
+            s - m[1],
+            s - m[2],
+            s - m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator- 
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+    {
+        return tmat4x4<T>(
+            m1[0] - m2[0],
+            m1[1] - m2[1],
+            m1[2] - m2[2],
+            m1[3] - m2[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
+	(
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const  & s
+	)
+    {
+        return tmat4x4<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s,
+            m[3] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
+	(
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m
+	)
+    {
+        return tmat4x4<T>(
+            m[0] * s,
+            m[1] * s,
+            m[2] * s,
+            m[3] * s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator* 
+	(
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::row_type const & v
+	)
+    {
+        return typename tmat4x4<T>::col_type(
+            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w,
+            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w,
+            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w,
+            m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z + m[3][3] * v.w);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator* 
+	(
+		typename tmat4x4<T>::col_type const & v, 
+		tmat4x4<T> const & m
+	)
+    {
+        return typename tmat4x4<T>::row_type(
+            m[0][0] * v.x + m[0][1] * v.y + m[0][2] * v.z + m[0][3] * v.w,
+            m[1][0] * v.x + m[1][1] * v.y + m[1][2] * v.z + m[1][3] * v.w,
+            m[2][0] * v.x + m[2][1] * v.y + m[2][2] * v.z + m[2][3] * v.w,
+            m[3][0] * v.x + m[3][1] * v.y + m[3][2] * v.z + m[3][3] * v.w);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator* 
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+    {
+		typename tmat4x4<T>::col_type const SrcA0 = m1[0];
+		typename tmat4x4<T>::col_type const SrcA1 = m1[1];
+		typename tmat4x4<T>::col_type const SrcA2 = m1[2];
+		typename tmat4x4<T>::col_type const SrcA3 = m1[3];
+
+		typename tmat4x4<T>::col_type const SrcB0 = m2[0];
+		typename tmat4x4<T>::col_type const SrcB1 = m2[1];
+		typename tmat4x4<T>::col_type const SrcB2 = m2[2];
+		typename tmat4x4<T>::col_type const SrcB3 = m2[3];
+
+        tmat4x4<T> Result(tmat4x4<T>::null);
+		Result[0] = SrcA0 * SrcB0[0] + SrcA1 * SrcB0[1] + SrcA2 * SrcB0[2] + SrcA3 * SrcB0[3];
+		Result[1] = SrcA0 * SrcB1[0] + SrcA1 * SrcB1[1] + SrcA2 * SrcB1[2] + SrcA3 * SrcB1[3];
+		Result[2] = SrcA0 * SrcB2[0] + SrcA1 * SrcB2[1] + SrcA2 * SrcB2[2] + SrcA3 * SrcB2[3];
+		Result[3] = SrcA0 * SrcB3[0] + SrcA1 * SrcB3[1] + SrcA2 * SrcB3[2] + SrcA3 * SrcB3[3];
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
+	(
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s
+	)
+    {
+        return tmat4x4<T>(
+            m[0] / s,
+            m[1] / s,
+            m[2] / s,
+            m[3] / s);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
+	(
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m
+	)
+    {
+        return tmat4x4<T>(
+            s / m[0],
+            s / m[1],
+            s / m[2],
+            s / m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat4x4<T>::col_type operator/ 
+	(
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::row_type const & v
+	)
+    {
+        return m._inverse() * v;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tmat4x4<T>::row_type operator/ 
+	(
+		typename tmat4x4<T>::col_type const & v, 
+		tmat4x4<T> const & m
+	)
+    {
+        return v * m._inverse();
+    }
+ 
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> operator/ 
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+    {
+        return m1 * m2._inverse();
+    }
+
+	// Unary constant operators
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> const operator- 
+	(
+		tmat4x4<T> const & m
+	)
+    {
+        return tmat4x4<T>(
+            -m[0], 
+            -m[1],
+            -m[2],
+            -m[3]);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> const operator++ 
+	(
+		tmat4x4<T> const & m, 
+		int
+	) 
+    {
+        return tmat4x4<T>(
+            m[0] + typename tmat4x4<T>::value_type(1),
+            m[1] + typename tmat4x4<T>::value_type(1),
+            m[2] + typename tmat4x4<T>::value_type(1),
+            m[3] + typename tmat4x4<T>::value_type(1));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tmat4x4<T> const operator-- 
+	(
+		tmat4x4<T> const & m, 
+		int
+	) 
+    {
+        return tmat4x4<T>(
+            m[0] - typename tmat4x4<T>::value_type(1),
+            m[1] - typename tmat4x4<T>::value_type(1),
+            m[2] - typename tmat4x4<T>::value_type(1),
+            m[3] - typename tmat4x4<T>::value_type(1));
+    }
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+	{
+		return (m1[0] == m2[0]) && (m1[1] == m2[1]) && (m1[2] == m2[2]) && (m1[3] == m2[3]);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2
+	)
+	{
+		return (m1[0] != m2[0]) || (m1[1] != m2[1]) || (m1[2] != m2[2]) || (m1[3] != m2[3]);
+	}
+
+} //namespace detail
+} //namespace glm
diff --git a/ExternalLibs/glm/core/type_size.hpp b/ExternalLibs/glm/core/type_size.hpp
new file mode 100644
index 0000000..8c1321c
--- /dev/null
+++ b/ExternalLibs/glm/core/type_size.hpp
@@ -0,0 +1,24 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-05
+// Updated : 2008-10-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_size.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_size
+#define glm_core_type_size
+
+#include <cstdlib>
+
+namespace glm{
+namespace detail
+{
+	//typedef std::size_t size_t;
+	typedef int sizeType;
+
+}//namespace detail
+}//namespace glm
+
+#endif//glm_core_type_size
diff --git a/ExternalLibs/glm/core/type_vec.hpp b/ExternalLibs/glm/core/type_vec.hpp
new file mode 100644
index 0000000..59c7c0b
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec.hpp
@@ -0,0 +1,22 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-01-26
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/type_vec.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_vec
+#define glm_core_type_vec
+
+#include "type_gentype.hpp"
+
+namespace glm{
+namespace detail
+{
+
+}//namespace detail
+}//namespace glm
+
+#endif//glm_core_type_vec
diff --git a/ExternalLibs/glm/core/type_vec.inl b/ExternalLibs/glm/core/type_vec.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/core/type_vec1.hpp b/ExternalLibs/glm/core/type_vec1.hpp
new file mode 100644
index 0000000..ffd8da1
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec1.hpp
@@ -0,0 +1,178 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-25
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/type_vec1.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_gentype1
+#define glm_core_type_gentype1
+
+#include "type_vec.hpp"
+#include "type_float.hpp"
+#include "type_int.hpp"
+#include "type_size.hpp"
+#include "_swizzle.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_vec1();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tref1;
+		template <typename T> struct tref2;
+		template <typename T> struct tref3;
+		template <typename T> struct tref4;
+		template <typename T> struct tvec1;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+
+		template <typename T>
+		struct tvec1
+		{
+			enum ctor{null};
+
+			typedef T value_type;
+			typedef std::size_t size_type;
+			GLM_FUNC_DECL size_type length() const;
+			static GLM_FUNC_DECL size_type value_size();
+
+			typedef tvec1<T> type;
+			typedef tvec1<bool> bool_type;
+
+			//////////////////////////////////////
+			// Data
+
+#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+			value_type x;
+#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+			union {value_type x, r, s;};
+#		endif//GLM_COMPONENT
+
+			//////////////////////////////////////
+			// Accesses
+
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+			//////////////////////////////////////
+			// Implicit basic constructors
+
+			GLM_FUNC_DECL tvec1();
+			GLM_FUNC_DECL tvec1(tvec1<T> const & v);
+
+			//////////////////////////////////////
+			// Explicit basic constructors
+
+			GLM_FUNC_DECL explicit tvec1(
+				ctor);
+			GLM_FUNC_DECL explicit tvec1(
+				value_type const & s);
+
+			//////////////////////////////////////
+			// Swizzle constructors
+
+			GLM_FUNC_DECL tvec1(tref1<T> const & r);
+
+			//////////////////////////////////////
+			// Convertion scalar constructors
+
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec1(U const & s);
+
+			//////////////////////////////////////
+			// Convertion vector constructors
+
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
+
+			//////////////////////////////////////
+			// Unary arithmetic operators
+
+			GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
+
+			GLM_FUNC_DECL tvec1<T> & operator+=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator-=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator*=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator/=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator++();
+			GLM_FUNC_DECL tvec1<T> & operator--();
+
+			//////////////////////////////////////
+			// Unary bit operators
+
+			GLM_FUNC_DECL tvec1<T> & operator%=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator&=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator|=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator^=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator<<=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<T> const & v);
+			GLM_FUNC_DECL tvec1<T> & operator>>=(value_type const & s);
+			GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<T> const & v);
+
+			//////////////////////////////////////
+			// Swizzle operators
+
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref1<T> swizzle(comp X);
+		};
+
+		template <typename T>
+		struct tref1
+		{
+			GLM_FUNC_DECL tref1(T & x);
+			GLM_FUNC_DECL tref1(tref1<T> const & r);
+			GLM_FUNC_DECL tref1(tvec1<T> const & v);
+
+			GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
+			GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
+
+			T& x;
+		};
+
+		GLM_DETAIL_IS_VECTOR(tvec1);
+
+		typedef detail::tvec1<core::type::precision::highp_float>		highp_vec1_t;
+		typedef detail::tvec1<core::type::precision::mediump_float>		mediump_vec1_t;
+		typedef detail::tvec1<core::type::precision::lowp_float>		lowp_vec1_t;
+		typedef detail::tvec1<core::type::precision::highp_int>			highp_ivec1_t;
+		typedef detail::tvec1<core::type::precision::mediump_int>		mediump_ivec1_t;
+		typedef detail::tvec1<core::type::precision::lowp_int>			lowp_ivec1_t;
+		typedef detail::tvec1<core::type::precision::highp_uint>		highp_uvec1_t;
+		typedef detail::tvec1<core::type::precision::mediump_uint>		mediump_uvec1_t;
+		typedef detail::tvec1<core::type::precision::lowp_uint>			lowp_uvec1_t;
+
+	} //namespace detail
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec1.inl"
+#endif
+
+#endif//glm_core_type_gentype1
diff --git a/ExternalLibs/glm/core/type_vec1.inl b/ExternalLibs/glm/core/type_vec1.inl
new file mode 100644
index 0000000..df0d1ad
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec1.inl
@@ -0,0 +1,885 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-25
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/type_vec1.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec1<T>::size_type tvec1<T>::length() const
+		{
+			return 1;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec1<T>::size_type tvec1<T>::value_size()
+		{
+			return 1;
+		}
+
+		//////////////////////////////////////
+		// Accesses
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec1<T>::value_type & tvec1<T>::operator[]
+		(
+			size_type i
+		)
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec1<T>::value_type const & tvec1<T>::operator[]
+		(
+			size_type i
+		) const
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1() :
+			x(value_type(0))
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			ctor
+		)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			tvec1<T> const & v
+		) :
+			x(v.x)
+		{}
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			value_type const & s
+		) :
+			x(s)
+		{}
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			tref1<T> const & r
+		) :
+			x(r.x)
+		{}
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+		
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			U const & s
+		) :
+			x(value_type(s))
+		{}
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			tvec2<U> const & v
+		) :
+			x(value_type(v.x))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			tvec3<U> const & v
+		) :
+			x(value_type(v.x))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec1<T>::tvec1
+		(
+			tvec4<U> const & v
+		) :
+			x(value_type(v.x))
+		{}
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x = v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
+		(
+			value_type const & s
+		)
+		{
+			this->x += s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator+=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x += v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
+		(
+			value_type const & s
+		)
+		{
+			this->x -= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator-=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x -= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
+		(
+			value_type const & s
+		)
+		{
+			this->x *= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator*=
+		(	
+			tvec1<T> const & v
+		)
+		{
+			this->x *= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
+		(
+			value_type const & s
+		)
+		{
+			this->x /= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator/=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x /= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator++()
+		{
+			++this->x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator--()
+		{
+			--this->x;
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator==
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return (v1.x == v2.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator!=
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return (v1.x != v2.x);
+		}
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
+		(
+			value_type const & s
+		)
+		{
+			this->x %= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator%=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x %= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
+		(
+			value_type const & s
+		)
+		{
+			this->x &= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator&=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x &= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
+		(
+			value_type const & s
+		)
+		{
+			this->x |= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator|=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x |= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
+		(
+			value_type const & s
+		)
+		{
+			this->x ^= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator^=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x ^= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
+		(
+			value_type const & s
+		)
+		{
+			this->x <<= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator<<=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x <<= v.x;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
+		(
+			value_type const & s
+		)
+		{
+			this->x >>= s;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> & tvec1<T>::operator>>=
+		(
+			tvec1<T> const & v
+		)
+		{
+			this->x >>= v.x;
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER T 
+		tvec1<T>::swizzle(comp x) const
+		{
+			return (*this)[x];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> 
+		tvec1<T>::swizzle
+		(
+			comp x, 
+			comp y
+		) const
+		{
+			return tvec2<T>(
+				(*this)[x],
+				(*this)[y]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> 
+		tvec1<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z
+		) const
+		{
+			return tvec3<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> 
+		tvec1<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z, 
+			comp w
+		) const
+		{
+			return tvec4<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z],
+				(*this)[w]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tref1<T> 
+		tvec1<T>::swizzle
+		(
+			comp x
+		)
+		{
+			return tref1<T>(
+				(*this)[x]);
+		}
+
+		//////////////////////////////////////
+		// Binary arithmetic operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator+ 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x + s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator+ 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s + v.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator+ 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x + v2.x);
+		}
+
+		//operator-
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator- 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x - s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator- 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s - v.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator- 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x - v2.x);
+		}
+
+		//operator*
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator* 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x * s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator* 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s * v.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator*
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x * v2.x);
+		}
+
+		//operator/
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator/ 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x / s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator/ 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s / v.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator/ 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x / v2.x);
+		}
+
+		// Unary constant operators
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator- 
+		(
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				-v.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator++ 
+		(
+			tvec1<T> const & v, 
+			int
+		)
+		{
+			return tvec1<T>(
+				v.x + T(1));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator-- 
+		(
+			tvec1<T> const & v, 
+			int
+		)
+		{
+			return tvec1<T>(
+				v.x - T(1));
+		}
+
+		//////////////////////////////////////
+		// Binary bit operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator% 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x % s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator% 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s % v.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator% 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x % v2.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator& 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x & s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator& 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s & v.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator& 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x & v2.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator| 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x | s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator| 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s | v.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator| 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x | v2.x);
+		}
+		
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator^ 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x ^ s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator^ 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s ^ v.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator^ 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x ^ v2.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator<< 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x << s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator<< 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s << v.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator<< 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x << v2.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator>> 
+		(
+			tvec1<T> const & v, 
+			typename tvec1<T>::value_type const & s
+		)
+		{
+			return tvec1<T>(
+				v.x >> s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator>> 
+		(
+			typename tvec1<T>::value_type const & s, 
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				s >> v.x);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec1<T> operator>> 
+		(
+			tvec1<T> const & v1, 
+			tvec1<T> const & v2
+		)
+		{
+			return tvec1<T>(
+				v1.x >> v2.x);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec1<T> operator~ 
+		(
+			tvec1<T> const & v
+		)
+		{
+			return tvec1<T>(
+				~v.x);
+		}
+
+		//////////////////////////////////////
+		// tref definition
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref1<T>::tref1
+		(
+			T & x
+		) :
+			x(x)
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref1<T>::tref1
+		(
+			tref1<T> const & r
+		) :
+			x(r.x)
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref1<T>::tref1
+		(
+			tvec1<T> const & v
+		) :
+			x(v.x)
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
+		(
+			tref1<T> const & r
+		)
+		{
+			x = r.x;
+			return *this;
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref1<T> & tref1<T>::operator= 
+		(
+			tvec1<T> const & v
+		)
+		{
+			x = v.x;
+			return *this;
+		}
+
+	}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/core/type_vec2.hpp b/ExternalLibs/glm/core/type_vec2.hpp
new file mode 100644
index 0000000..29d641c
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec2.hpp
@@ -0,0 +1,266 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-18
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/type_tvec2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_gentype2
+#define glm_core_type_gentype2
+
+#include "type_vec.hpp"
+#include "type_float.hpp"
+#include "type_int.hpp"
+#include "type_size.hpp"
+#include "_swizzle.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_vec2();
+	}
+	//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tref2;
+		template <typename T> struct tref3;
+		template <typename T> struct tref4;
+		template <typename T> struct tvec3;
+		template <typename T> struct tvec4;
+
+		//! The basic 2D vector type.
+		//! \ingroup core_template
+		template <typename T>
+		struct tvec2
+		{
+			enum ctor{null};
+
+			typedef T value_type;
+			typedef std::size_t size_type;
+			GLM_FUNC_DECL size_type length() const;
+			static GLM_FUNC_DECL size_type value_size();
+
+			typedef tvec2<T> type;
+			typedef tvec2<bool> bool_type;
+
+			//////////////////////////////////////
+			// Data
+
+#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+			value_type x, y;
+#		elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+			union 
+			{
+				struct{value_type x, y;};
+				struct{value_type r, g;};
+				struct{value_type s, t;};
+			};
+#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+			union {value_type x, r, s;};
+			union {value_type y, g, t;};
+#		endif//GLM_COMPONENT
+
+			//////////////////////////////////////
+			// Accesses
+
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+			//////////////////////////////////////
+			// Implicit basic constructors
+
+			GLM_FUNC_DECL tvec2();
+			GLM_FUNC_DECL tvec2(tvec2<T> const & v);
+
+			//////////////////////////////////////
+			// Explicit basic constructors
+
+			GLM_FUNC_DECL explicit tvec2(
+				ctor);
+			GLM_FUNC_DECL explicit tvec2(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tvec2(
+				value_type const & s1, 
+				value_type const & s2);
+
+			//////////////////////////////////////
+			// Swizzle constructors
+
+			tvec2(tref2<T> const & r);
+
+			//////////////////////////////////////
+			// Convertion scalar constructors
+
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec2(
+				U const & x);
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U, typename V> 
+			GLM_FUNC_DECL explicit tvec2(
+				U const & x, 
+				V const & y);
+
+			//////////////////////////////////////
+			// Convertion vector constructors
+
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
+
+			//////////////////////////////////////
+			// Unary arithmetic operators
+
+			GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
+
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
+			GLM_FUNC_DECL tvec2<T> & operator++();
+			GLM_FUNC_DECL tvec2<T> & operator--();
+
+			//////////////////////////////////////
+			// Unary bit operators
+
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
+
+			//////////////////////////////////////
+			// Swizzle operators
+
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
+		};
+
+		template <typename T>
+		struct tref2
+		{
+			GLM_FUNC_DECL tref2(T & x, T & y);
+			GLM_FUNC_DECL tref2(tref2<T> const & r);
+			GLM_FUNC_DECL tref2(tvec2<T> const & v);
+
+			GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
+			GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
+
+			T& x;
+			T& y;
+		};
+
+		GLM_DETAIL_IS_VECTOR(tvec2);
+
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 2 components vector of high precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<highp_float>		highp_vec2;
+		//! 2 components vector of medium precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<mediump_float>	mediump_vec2;
+		//! 2 components vector of low precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<lowp_float>		lowp_vec2;
+
+		//! 2 components vector of high precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<highp_int>		highp_ivec2;
+		//! 2 components vector of medium precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<mediump_int>		mediump_ivec2;
+		//! 2 components vector of low precision signed integer numbers.
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<lowp_int>			lowp_ivec2;
+	
+		//! 2 components vector of high precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<highp_uint>		highp_uvec2;
+		//! 2 components vector of medium precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<mediump_uint>		mediump_uvec2;
+		//! 2 components vector of low precision unsigned integer numbers.
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec2<lowp_uint>		lowp_uvec2;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec2.inl"
+#endif
+
+#endif//glm_core_type_gentype2
diff --git a/ExternalLibs/glm/core/type_vec2.inl b/ExternalLibs/glm/core/type_vec2.inl
new file mode 100644
index 0000000..b9fc67c
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec2.inl
@@ -0,0 +1,1011 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-18
+// Updated : 2010-10-26
+// Licence : This source is under MIT License
+// File    : glm/core/type_tvec2.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec2<T>::size_type tvec2<T>::length() const
+		{
+			return 2;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec2<T>::size_type tvec2<T>::value_size()
+		{
+			return 2;
+		}
+
+		//////////////////////////////////////
+		// Accesses
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec2<T>::value_type & 
+		tvec2<T>::operator[]
+		(
+			size_type i
+		)
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec2<T>::value_type const & 
+		tvec2<T>::operator[]
+		(
+			size_type i
+		) const
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2() :
+			x(value_type(0)),
+			y(value_type(0))
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			ctor
+		)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			tvec2<T> const & v
+		) :
+			x(v.x),
+			y(v.y)
+		{}
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			value_type const & s
+		) :
+			x(s),
+			y(s)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			value_type const & s1, 
+			value_type const & s2
+		) :
+			x(s1),
+			y(s2)
+		{}
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			tref2<T> const & r
+		) :
+			x(r.x),
+			y(r.y)
+		{}
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+		
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			U const & x
+		) :
+			x(value_type(x)),
+			y(value_type(x))
+		{}
+
+		template <typename T>
+		template <typename U, typename V> 
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			U const & x, 
+			V const & y
+		) :
+			x(value_type(x)),
+			y(value_type(y))
+		{}
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			tvec2<U> const & v
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			tvec3<U> const & v
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T>::tvec2
+		(
+			tvec4<U> const & v
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y))
+		{}
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator= 
+		(
+			tvec2<T> const & v
+		)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator= 
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x = T(v.x);
+			this->y = T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
+		(
+			U const & s
+		)
+		{
+			this->x += T(s);
+			this->y += T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator+=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x += T(v.x);
+			this->y += T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
+		(
+			U const & s
+		)
+		{
+			this->x -= T(s);
+			this->y -= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator-=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x -= T(v.x);
+			this->y -= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
+		(
+			U const & s
+		)
+		{
+			this->x *= T(s);
+			this->y *= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator*=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x *= T(v.x);
+			this->y *= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
+		(
+			U const & s
+		)
+		{
+			this->x /= T(s);
+			this->y /= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator/=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x /= T(v.x);
+			this->y /= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator++()
+		{
+			++this->x;
+			++this->y;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator--()
+		{
+			--this->x;
+			--this->y;
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator==
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return (v1.x == v2.x) && (v1.y == v2.y);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator!=
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return (v1.x != v2.x) || (v1.y != v2.y);
+		}
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
+		(
+			U const & s
+		)
+		{
+			this->x %= T(s);
+			this->y %= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator%=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x %= T(v.x);
+			this->y %= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
+		(
+			U const & s
+		)
+		{
+			this->x &= T(s);
+			this->y &= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator&=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x &= T(v.x);
+			this->y &= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
+		(
+			U const & s
+		)
+		{
+			this->x |= T(s);
+			this->y |= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator|=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x |= T(v.x);
+			this->y |= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
+		(
+			U const & s
+		)
+		{
+			this->x ^= T(s);
+			this->y ^= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator^=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x ^= T(v.x);
+			this->y ^= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
+		(
+			U const & s
+		)
+		{
+			this->x <<= T(s);
+			this->y <<= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator<<=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x <<= T(v.x);
+			this->y <<= T(v.y);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
+		(
+			U const & s
+		)
+		{
+			this->x >>= T(s);
+			this->y >>= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec2<T> & tvec2<T>::operator>>=
+		(
+			tvec2<U> const & v
+		)
+		{
+			this->x >>= T(v.x);
+			this->y >>= T(v.y);
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec2<T>::value_type tvec2<T>::swizzle
+		(
+			comp x
+		) const
+		{
+			return (*this)[x];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> tvec2<T>::swizzle
+		(
+			comp x, 
+			comp y
+		) const
+		{
+			return tvec2<T>(
+				(*this)[x],
+				(*this)[y]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> tvec2<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z
+		) const
+		{
+			return tvec3<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> tvec2<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z, 
+			comp w
+		) const
+		{
+			return tvec4<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z],
+				(*this)[w]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tref2<T> tvec2<T>::swizzle
+		(
+			comp x, 
+			comp y
+		)
+		{
+			return tref2<T>(
+				(*this)[x],
+				(*this)[y]);
+		}
+
+		//////////////////////////////////////
+		// Binary arithmetic operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator+ 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x + T(s),
+				v.y + T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator+ 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) + v.x,
+				T(s) + v.y);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator+ 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x + T(v2.x),
+				v1.y + T(v2.y));
+		}
+
+		//operator-
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator-
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x - T(s),
+				v.y - T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator- 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) - v.x,
+				T(s) - v.y);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator- 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x - T(v2.x),
+				v1.y - T(v2.y));
+		}
+
+		//operator*
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator* 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x * T(s),
+				v.y * T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator* 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) * v.x,
+				T(s) * v.y);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator*
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x * T(v2.x),
+				v1.y * T(v2.y));
+		}
+
+		//operator/
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator/
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x / T(s),
+				v.y / T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator/
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) / v.x,
+				T(s) / v.y);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator/ 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x / T(v2.x),
+				v1.y / T(v2.y));
+		}
+
+		// Unary constant operators
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator- 
+		(
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				-v.x, 
+				-v.y);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator++ 
+		(
+			tvec2<T> const & v, 
+			int
+		)
+		{
+			return tvec2<T>(
+				v.x + T(1), 
+				v.y + T(1));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator-- 
+		(
+			tvec2<T> const & v, 
+			int
+		)
+		{
+			return tvec2<T>(
+				v.x - T(1), 
+				v.y - T(1));
+		}
+
+		//////////////////////////////////////
+		// Binary bit operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator% 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x % T(s),
+				v.y % T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator%
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) % v.x,
+				T(s) % v.y);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator% 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x % T(v2.x),
+				v1.y % T(v2.y));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator& 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x & T(s),
+				v.y & T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator& 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) & v.x,
+				T(s) & v.y);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator& 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x & T(v2.x),
+				v1.y & T(v2.y));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator| 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x | T(s),
+				v.y | T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator| 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) | v.x,
+				T(s) | v.y);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator| 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x | T(v2.x),
+				v1.y | T(v2.y));
+		}
+		
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator^ 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x ^ T(s),
+				v.y ^ T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator^ 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) ^ v.x,
+				T(s) ^ v.y);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator^ 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x ^ T(v2.x),
+				v1.y ^ T(v2.y));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator<< 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x << T(s),
+				v.y << T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator<< 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				s << T(v.x),
+				s << T(v.y));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator<< 
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x << T(v2.x),
+				v1.y << T(v2.y));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator>> 
+		(
+			tvec2<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec2<T>(
+				v.x >> T(s),
+				v.y >> T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator>> 
+		(
+			T const & s, 
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				T(s) >> v.x,
+				T(s) >> v.y);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> operator>>
+		(
+			tvec2<T> const & v1, 
+			tvec2<T> const & v2
+		)
+		{
+			return tvec2<T>(
+				v1.x >> T(v2.x),
+				v1.y >> T(v2.y));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec2<T> operator~ 
+		(
+			tvec2<T> const & v
+		)
+		{
+			return tvec2<T>(
+				~v.x,
+				~v.y);
+		}
+
+		//////////////////////////////////////
+		// tref definition
+
+		template <typename T> 
+		tref2<T>::tref2
+		(
+			T & x, 
+			T & y
+		) :
+			x(x),
+			y(y)
+		{}
+
+		template <typename T> 
+		tref2<T>::tref2
+		(
+			tref2<T> const & r
+		) :
+			x(r.x),
+			y(r.y)
+		{}
+
+		template <typename T> 
+		tref2<T>::tref2
+		(
+			tvec2<T> const & v
+		) :
+			x(v.x),
+			y(v.y)
+		{}
+
+		template <typename T> 
+		tref2<T>& tref2<T>::operator= 
+		(
+			tref2<T> const & r
+		)
+		{
+			x = r.x;
+			y = r.y;
+			return *this;
+		}
+
+		template <typename T> 
+		tref2<T>& tref2<T>::operator= 
+		(
+			tvec2<T> const & v
+		)
+		{
+			x = v.x;
+			y = v.y;
+			return *this;
+		}
+
+	}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/core/type_vec3.hpp b/ExternalLibs/glm/core/type_vec3.hpp
new file mode 100644
index 0000000..1e06a78
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec3.hpp
@@ -0,0 +1,271 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_tvec3.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_gentype3
+#define glm_core_type_gentype3
+
+#include "type_vec.hpp"
+#include "type_float.hpp"
+#include "type_int.hpp"
+#include "type_size.hpp"
+#include "_swizzle.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_vec3();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tref2;
+		template <typename T> struct tref3;
+		template <typename T> struct tref4;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec4;
+
+		//! Basic 3D vector type.
+		//! \ingroup core_template
+		template <typename T>
+		struct tvec3
+		{	
+			enum ctor{null};
+
+			typedef T value_type;
+			typedef std::size_t size_type;
+			GLM_FUNC_DECL size_type length() const;
+			static GLM_FUNC_DECL size_type value_size();
+
+			typedef tvec3<T> type;
+			typedef tvec3<bool> bool_type;
+
+			//////////////////////////////////////
+			// Data
+
+#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+			value_type x, y, z;
+#		elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+			union 
+			{
+				struct{value_type x, y, z;};
+				struct{value_type r, g, b;};
+				struct{value_type s, t, p;};
+			};
+#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+			union {value_type x, r, s;};
+			union {value_type y, g, t;};
+			union {value_type z, b, p;};
+#		endif//GLM_COMPONENT
+
+			//////////////////////////////////////
+			// Accesses
+
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+			//////////////////////////////////////
+			// Implicit basic constructors
+
+			GLM_FUNC_DECL tvec3();
+			GLM_FUNC_DECL tvec3(tvec3<T> const & v);
+
+			//////////////////////////////////////
+			// Explicit basic constructors
+
+			GLM_FUNC_DECL explicit tvec3(
+				ctor);
+			GLM_FUNC_DECL explicit tvec3(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tvec3(
+				value_type const & s1, 
+				value_type const & s2, 
+				value_type const & s3);
+
+			//////////////////////////////////////
+			// Swizzle constructors
+
+			GLM_FUNC_DECL tvec3(tref3<T> const & r);
+
+			//////////////////////////////////////
+			// Convertion scalar constructors
+
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec3(
+				U const & x);
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U, typename V, typename W> 
+			GLM_FUNC_DECL explicit tvec3(
+				U const & x, 
+				V const & y, 
+				W const & z);			
+
+			//////////////////////////////////////
+			// Convertion vector constructors
+
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B> 
+			GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B> 
+			GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
+
+			//////////////////////////////////////
+			// Unary arithmetic operators
+
+			GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
+
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
+			template <typename U> 
+			GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
+			GLM_FUNC_DECL tvec3<T> & operator++();
+			GLM_FUNC_DECL tvec3<T> & operator--();
+
+			//////////////////////////////////////
+			// Unary bit operators
+
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
+
+			//////////////////////////////////////
+			// Swizzle operators
+
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
+		};
+
+		template <typename T>
+		struct tref3
+		{
+			GLM_FUNC_DECL tref3(T & x, T & y, T & z);
+			GLM_FUNC_DECL tref3(tref3<T> const & r);
+			GLM_FUNC_DECL tref3(tvec3<T> const & v);
+
+			GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
+			GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
+
+			T & x;
+			T & y;
+			T & z;
+		};
+
+		GLM_DETAIL_IS_VECTOR(tvec3);
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	namespace precision
+	{
+		//! 3 components vector of high precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<highp_float>		highp_vec3;
+		//! 3 components vector of medium precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<mediump_float>	mediump_vec3;
+		//! 3 components vector of low precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<lowp_float>		lowp_vec3;
+
+		//! 3 components vector of high precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<highp_int>		highp_ivec3;
+		//! 3 components vector of medium precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<mediump_int>		mediump_ivec3;
+		//! 3 components vector of low precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<lowp_int>			lowp_ivec3;
+
+		//! 3 components vector of high precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<highp_uint>		highp_uvec3;
+		//! 3 components vector of medium precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<mediump_uint>		mediump_uvec3;
+		//! 3 components vector of low precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec3<lowp_uint>		lowp_uvec3;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec3.inl"
+#endif
+
+#endif//glm_core_type_gentype3
diff --git a/ExternalLibs/glm/core/type_vec3.inl b/ExternalLibs/glm/core/type_vec3.inl
new file mode 100644
index 0000000..f7e9bfb
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec3.inl
@@ -0,0 +1,1098 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/core/type_tvec3.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec3<T>::size_type tvec3<T>::length() const
+		{
+			return 3;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec3<T>::size_type tvec3<T>::value_size()
+		{
+			return 3;
+		}
+
+		//////////////////////////////////////
+		// Accesses
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec3<T>::value_type & 
+		tvec3<T>::operator[]
+		(
+			size_type i
+		)
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec3<T>::value_type const & 
+		tvec3<T>::operator[]
+		(
+			size_type i
+		) const
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3() :
+			x(value_type(0)),
+			y(value_type(0)),
+			z(value_type(0))
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			ctor
+		)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			tvec3<T> const & v
+		) :
+			x(v.x),
+			y(v.y),
+			z(v.z)
+		{}
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			value_type const & s
+		) :
+			x(s),
+			y(s),
+			z(s)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			value_type const & s0, 
+			value_type const & s1, 
+			value_type const & s2
+		) :
+			x(s0),
+			y(s1),
+			z(s2)
+		{}
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			tref3<T> const & r
+		) :
+			x(r.x),
+			y(r.y),
+			z(r.z)
+		{}
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+		
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			U const & s
+		) :
+			x(value_type(s)),
+			y(value_type(s)),
+			z(value_type(s))
+		{}
+
+		template <typename T>
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			A const & x, 
+			B const & y, 
+			C const & z
+		) :
+			x(value_type(x)),
+			y(value_type(y)),
+			z(value_type(z))
+		{}
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		template <typename T>
+		template <typename A, typename B> 
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			tvec2<A> const & v, 
+			B const & s
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y)),
+			z(value_type(s))
+		{}
+
+		template <typename T>
+		template <typename A, typename B> 
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(	
+			A const & s, 
+			tvec2<B> const & v
+		) :
+			x(value_type(s)),
+			y(value_type(v.x)),
+			z(value_type(v.y))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			tvec3<U> const & v
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y)),
+			z(value_type(v.z))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T>::tvec3
+		(
+			tvec4<U> const & v
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y)),
+			z(value_type(v.z))
+		{}
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T>& tvec3<T>::operator= 
+		(
+			tvec3<T> const & v
+		)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			this->z = v.z;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T>& tvec3<T>::operator= 
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x = T(v.x);
+			this->y = T(v.y);
+			this->z = T(v.z);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=
+		(
+			U const & s
+		)
+		{
+			this->x += T(s);
+			this->y += T(s);
+			this->z += T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator+=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x += T(v.x);
+			this->y += T(v.y);
+			this->z += T(v.z);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=
+		(
+			U const & s
+		)
+		{
+			this->x -= T(s);
+			this->y -= T(s);
+			this->z -= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator-=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x -= T(v.x);
+			this->y -= T(v.y);
+			this->z -= T(v.z);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=
+		(
+			U const & s
+		)
+		{
+			this->x *= T(s);
+			this->y *= T(s);
+			this->z *= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator*=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x *= T(v.x);
+			this->y *= T(v.y);
+			this->z *= T(v.z);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=
+		(
+			U const & s
+		)
+		{
+			this->x /= T(s);
+			this->y /= T(s);
+			this->z /= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator/=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x /= T(v.x);
+			this->y /= T(v.y);
+			this->z /= T(v.z);
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator++()
+		{
+			++this->x;
+			++this->y;
+			++this->z;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator--()
+		{
+			--this->x;
+			--this->y;
+			--this->z;
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator==
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator!=
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z);
+		}
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=
+		(
+			U const & s
+		)
+		{
+			this->x %= s;
+			this->y %= s;
+			this->z %= s;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator%=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x %= v.x;
+			this->y %= v.y;
+			this->z %= v.z;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=
+		(	
+			U const & s
+		)
+		{
+			this->x &= s;
+			this->y &= s;
+			this->z &= s;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator&=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x &= v.x;
+			this->y &= v.y;
+			this->z &= v.z;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=
+		(
+			U const & s
+		)
+		{
+			this->x |= s;
+			this->y |= s;
+			this->z |= s;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator|=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x |= v.x;
+			this->y |= v.y;
+			this->z |= v.z;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=
+		(
+			U const & s
+		)
+		{
+			this->x ^= s;
+			this->y ^= s;
+			this->z ^= s;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator^=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x ^= v.x;
+			this->y ^= v.y;
+			this->z ^= v.z;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=
+		(
+			U const & s
+		)
+		{
+			this->x <<= s;
+			this->y <<= s;
+			this->z <<= s;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator<<=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x <<= T(v.x);
+			this->y <<= T(v.y);
+			this->z <<= T(v.z);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=
+		(
+			U const & s
+		)
+		{
+			this->x >>= T(s);
+			this->y >>= T(s);
+			this->z >>= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec3<T> & tvec3<T>::operator>>=
+		(
+			tvec3<U> const & v
+		)
+		{
+			this->x >>= T(v.x);
+			this->y >>= T(v.y);
+			this->z >>= T(v.z);
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec3<T>::value_type 
+		tvec3<T>::swizzle
+		(
+			comp x
+		) const
+		{
+			return (*this)[x];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> tvec3<T>::swizzle
+		(
+			comp x, 
+			comp y
+		) const
+		{
+			return tvec2<T>(
+				(*this)[x],
+				(*this)[y]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> tvec3<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z
+		) const
+		{
+			return tvec3<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> tvec3<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z, 
+			comp w
+		) const
+		{
+			return tvec4<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z],
+				(*this)[w]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tref3<T> tvec3<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z
+		)
+		{
+			return tref3<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z]);
+		}
+
+		//////////////////////////////////////
+		// Binary arithmetic operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator+
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x + T(s),
+				v.y + T(s),
+				v.z + T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator+ 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) + v.x,
+				T(s) + v.y,
+				T(s) + v.z);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator+ 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x + T(v2.x),
+				v1.y + T(v2.y),
+				v1.z + T(v2.z));
+		}
+
+		//operator-
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator- 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x - T(s),
+				v.y - T(s),
+				v.z - T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator- 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) - v.x,
+				T(s) - v.y,
+				T(s) - v.z);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator- 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x - T(v2.x),
+				v1.y - T(v2.y),
+				v1.z - T(v2.z));
+		}
+
+		//operator*
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator*
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x * T(s),
+				v.y * T(s),
+				v.z * T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator* 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) * v.x,
+				T(s) * v.y,
+				T(s) * v.z);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator* 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x * T(v2.x),
+				v1.y * T(v2.y),
+				v1.z * T(v2.z));
+		}
+
+		//operator/
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator/
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x / T(s),
+				v.y / T(s),
+				v.z / T(s));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator/ 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) / v.x,
+				T(s) / v.y,
+				T(s) / v.z);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator/ 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x / T(v2.x),
+				v1.y / T(v2.y),
+				v1.z / T(v2.z));
+		}
+
+		// Unary constant operators
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator- 
+		(
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				-v.x, 
+				-v.y, 
+				-v.z);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator++ 
+		(
+			tvec3<T> const & v, 
+			int
+		)
+		{
+			return tvec3<T>(
+				v.x + T(1), 
+				v.y + T(1), 
+				v.z + T(1));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator-- 
+		(
+			tvec3<T> const & v, 
+			int
+		)
+		{
+			return tvec3<T>(
+				v.x - T(1), 
+				v.y - T(1), 
+				v.z - T(1));
+		}
+
+		//////////////////////////////////////
+		// Binary bit operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator% 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x % T(s),
+				v.y % T(s),
+				v.z % T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator%
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) % v.x,
+				T(s) % v.y,
+				T(s) % v.z);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator% 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x % T(v2.x),
+				v1.y % T(v2.y),
+				v1.z % T(v2.z));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator& 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x & T(s),
+				v.y & T(s),
+				v.z & T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator& 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) & v.x,
+				T(s) & v.y,
+				T(s) & v.z);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator& 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x & T(v2.x),
+				v1.y & T(v2.y),
+				v1.z & T(v2.z));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator| 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x | T(s),
+				v.y | T(s),
+				v.z | T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator| 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) | v.x,
+				T(s) | v.y,
+				T(s) | v.z);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator| 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x | T(v2.x),
+				v1.y | T(v2.y),
+				v1.z | T(v2.z));
+		}
+		
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator^ 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x ^ T(s),
+				v.y ^ T(s),
+				v.z ^ T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator^ 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) ^ v.x,
+				T(s) ^ v.y,
+				T(s) ^ v.z);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator^ 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x ^ T(v2.x),
+				v1.y ^ T(v2.y),
+				v1.z ^ T(v2.z));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator<< 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x << T(s),
+				v.y << T(s),
+				v.z << T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator<< 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				T(s) << v.x,
+				T(s) << v.y,
+				T(s) << v.z);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator<< 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x << T(v2.x),
+				v1.y << T(v2.y),
+				v1.z << T(v2.z));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator>> 
+		(
+			tvec3<T> const & v, 
+			T const & s
+		)
+		{
+			return tvec3<T>(
+				v.x >> T(s),
+				v.y >> T(s),
+				v.z >> T(s));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator>> 
+		(
+			T const & s, 
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				s >> T(v.x),
+				s >> T(v.y),
+				s >> T(v.z));
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> operator>> 
+		(
+			tvec3<T> const & v1, 
+			tvec3<T> const & v2
+		)
+		{
+			return tvec3<T>(
+				v1.x >> T(v2.x),
+				v1.y >> T(v2.y),
+				v1.z >> T(v2.z));
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec3<T> operator~ 
+		(
+			tvec3<T> const & v
+		)
+		{
+			return tvec3<T>(
+				~v.x,
+				~v.y,
+				~v.z);
+		}
+
+		//////////////////////////////////////
+		// tref definition
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref3<T>::tref3(T & x, T & y, T & z) :
+			x(x),
+			y(y),
+			z(z)
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref3<T>::tref3
+		(
+			tref3<T> const & r
+		) :
+			x(r.x),
+			y(r.y),
+			z(r.z)
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref3<T>::tref3
+		(
+			tvec3<T> const & v
+		) :
+			x(v.x),
+			y(v.y),
+			z(v.z)
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref3<T> & tref3<T>::operator=
+		(
+			tref3<T> const & r
+		)
+		{
+			x = r.x;
+			y = r.y;
+			z = r.z;
+			return *this;
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tref3<T> & tref3<T>::operator=
+		(
+			tvec3<T> const & v
+		)
+		{
+			x = v.x;
+			y = v.y;
+			z = v.z;
+			return *this;
+		}
+
+	}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/core/type_vec4.hpp b/ExternalLibs/glm/core/type_vec4.hpp
new file mode 100644
index 0000000..354cd5b
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec4.hpp
@@ -0,0 +1,290 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-22
+// Updated : 2010-02-03
+// Licence : This source is under MIT License
+// File    : glm/core/type_tvec4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_core_type_gentype4
+#define glm_core_type_gentype4
+
+#include "type_vec.hpp"
+#include "type_float.hpp"
+#include "type_int.hpp"
+#include "type_size.hpp"
+#include "_swizzle.hpp"
+
+namespace glm
+{
+	namespace test
+	{
+		void main_vec4();
+	}//namespace test
+
+	namespace detail
+	{
+		template <typename T> struct tref2;
+		template <typename T> struct tref3;
+		template <typename T> struct tref4;
+		template <typename T> struct tvec2;
+		template <typename T> struct tvec3;
+
+		///Basic 4D vector type.
+		//! \ingroup core_template
+		template <typename T>
+		struct tvec4
+		{
+			enum ctor{null};
+
+			typedef T value_type;
+			typedef std::size_t size_type;
+			GLM_FUNC_DECL size_type length() const;
+			static GLM_FUNC_DECL size_type value_size();
+
+			typedef tvec4<T> type;
+			typedef tvec4<bool> bool_type;
+
+			//////////////////////////////////////
+			// Data
+
+#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+			value_type x, y, z, w;
+#		elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+			union 
+			{
+				struct{value_type x, y, z, w;};
+				struct{value_type r, g, b, a;};
+				struct{value_type s, t, p, q;};
+			};
+#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+			union {value_type x, r, s;};
+			union {value_type y, g, t;};
+			union {value_type z, b, p;};
+			union {value_type w, a, q;};
+#		endif//GLM_COMPONENT
+
+			//////////////////////////////////////
+			// Accesses
+
+			GLM_FUNC_DECL value_type & operator[](size_type i);
+			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+			//////////////////////////////////////
+			// Implicit basic constructors
+
+			GLM_FUNC_DECL tvec4();
+			GLM_FUNC_DECL tvec4(type const & v);
+
+			//////////////////////////////////////
+			// Explicit basic constructors
+
+			GLM_FUNC_DECL explicit tvec4(
+				ctor);
+			GLM_FUNC_DECL explicit tvec4(
+				value_type const & s);
+			GLM_FUNC_DECL explicit tvec4(
+				value_type const & s0, 
+				value_type const & s1, 
+				value_type const & s2, 
+				value_type const & s3);
+
+			//////////////////////////////////////
+			// Swizzle constructors
+
+			GLM_FUNC_DECL tvec4(tref4<T> const & r);
+
+			//////////////////////////////////////
+			// Convertion scalar constructors
+
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec4(
+				U const & x);
+			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B, typename C, typename D> 
+			GLM_FUNC_DECL explicit tvec4(
+				A const & x, 
+				B const & y, 
+				C const & z, 
+				D const & w);			
+
+			//////////////////////////////////////
+			// Convertion vector constructors
+
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B, typename C> 
+			GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B, typename C> 
+			GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B, typename C> 
+			GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B> 
+			GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B> 
+			GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename A, typename B> 
+			GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
+			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+			template <typename U> 
+			GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
+
+			//////////////////////////////////////
+			// Unary arithmetic operators
+
+			GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
+
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
+			GLM_FUNC_DECL tvec4<T> & operator++();
+			GLM_FUNC_DECL tvec4<T> & operator--();
+
+			//////////////////////////////////////
+			// Unary bit operators
+
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
+			template <typename U>
+			GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
+
+			//////////////////////////////////////
+			// Swizzle operators
+
+			GLM_FUNC_DECL value_type swizzle(comp X) const;
+			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+			GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
+		};
+
+		template <typename T>
+		struct tref4
+		{
+			GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
+			GLM_FUNC_DECL tref4(tref4<T> const & r);
+			GLM_FUNC_DECL tref4(tvec4<T> const & v);
+
+			GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
+			GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
+
+			T & x;
+			T & y;
+			T & z;
+			T & w;
+		};
+
+		GLM_DETAIL_IS_VECTOR(tvec4);
+	} //namespace detail
+
+	namespace core{
+	namespace type{
+
+	//////////////////////////
+	// Float definition
+
+	namespace precision
+	{
+		//! 4 components vector of high precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<highp_float>		highp_vec4;
+		//! 4 components vector of medium precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<mediump_float>	mediump_vec4;
+		//! 4 components vector of low precision floating-point numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<lowp_float>		lowp_vec4;
+
+		//! 4 components vector of high precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<highp_int>		highp_ivec4;
+		//! 4 components vector of medium precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<mediump_int>		mediump_ivec4;
+		//! 4 components vector of low precision signed integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<lowp_int>			lowp_ivec4;
+
+		//! 4 components vector of high precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<highp_uint>		highp_uvec4;
+		//! 4 components vector of medium precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<mediump_uint>		mediump_uvec4;
+		//! 4 components vector of low precision unsigned integer numbers. 
+		//! There is no guarantee on the actual precision.
+		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
+		typedef detail::tvec4<lowp_uint>		lowp_uvec4;
+	}
+	//namespace precision
+
+	}//namespace type
+	}//namespace core
+
+	using namespace core::type;
+
+}//namespace glm
+
+#ifndef GLM_EXTERNAL_TEMPLATE
+#include "type_vec4.inl"
+#endif
+
+#endif//glm_core_type_gentype4
diff --git a/ExternalLibs/glm/core/type_vec4.inl b/ExternalLibs/glm/core/type_vec4.inl
new file mode 100644
index 0000000..52e16d8
--- /dev/null
+++ b/ExternalLibs/glm/core/type_vec4.inl
@@ -0,0 +1,1227 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-08-23
+// Updated : 2010-02-05
+// Licence : This source is under MIT License
+// File    : glm/core/type_tvec4.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec4<T>::size_type tvec4<T>::length() const
+		{
+			return 4;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec4<T>::size_type tvec4<T>::value_size()
+		{
+			return 4;
+		}
+
+		//////////////////////////////////////
+		// Accesses
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec4<T>::value_type & 
+		tvec4<T>::operator[]
+		(
+			size_type i
+		)
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec4<T>::value_type const & 
+		tvec4<T>::operator[]
+		(
+			size_type i
+		) const
+		{
+			assert(i < value_size());
+			return (&x)[i];
+		}
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4() :
+			x(value_type(0)),
+			y(value_type(0)),
+			z(value_type(0)),
+			w(value_type(0))
+		{}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			ctor
+		)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			type const & v
+		) :
+			x(v.x),
+			y(v.y),
+			z(v.z),
+			w(v.w)
+		{}
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			value_type const & s
+		) :
+			x(s),
+			y(s),
+			z(s),
+			w(s)
+		{}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			value_type const & s1, 
+			value_type const & s2, 
+			value_type const & s3, 
+			value_type const & s4
+		) :
+			x(s1),
+			y(s2),
+			z(s3),
+			w(s4)
+		{}
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			tref4<T> const & r
+		) :
+			x(r.x),
+			y(r.y),
+			z(r.z),
+			w(r.w)
+		{}
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+		
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			U const & x
+		) :
+			x(value_type(x)),
+			y(value_type(x)),
+			z(value_type(x)),
+			w(value_type(x))
+		{}
+
+		template <typename T>
+		template <typename A, typename B, typename C, typename D> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			A const & x, 
+			B const & y, 
+			C const & z, 
+			D const & w
+		) :
+			x(value_type(x)),
+			y(value_type(y)),
+			z(value_type(z)),
+			w(value_type(w))
+		{}
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		template <typename T>
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			tvec2<A> const & v, 
+			B const & s1, 
+			C const & s2
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y)),
+			z(value_type(s1)),
+			w(value_type(s2))
+		{}
+
+		template <typename T>
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			A const & s1, 
+			tvec2<B> const & v, 
+			C const & s2
+		) :
+			x(value_type(s1)),
+			y(value_type(v.x)),
+			z(value_type(v.y)),
+			w(value_type(s2))
+		{}
+
+		template <typename T>
+		template <typename A, typename B, typename C> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			A const & s1, 
+			B const & s2, 
+			tvec2<C> const & v
+		) :
+			x(value_type(s1)),
+			y(value_type(s2)),
+			z(value_type(v.x)),
+			w(value_type(v.y))
+		{}
+
+		template <typename T>
+		template <typename A, typename B> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			tvec3<A> const & v, 
+			B const & s
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y)),
+			z(value_type(v.z)),
+			w(value_type(s))
+		{}
+
+		template <typename T>
+		template <typename A, typename B> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			A const & s, 
+			tvec3<B> const & v
+		) :
+			x(value_type(s)),
+			y(value_type(v.x)),
+			z(value_type(v.y)),
+			w(value_type(v.z))
+		{}
+
+		template <typename T>
+		template <typename A, typename B> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			tvec2<A> const & v1, 
+			tvec2<B> const & v2
+		) :
+			x(value_type(v1.x)),
+			y(value_type(v1.y)),
+			z(value_type(v2.x)),
+			w(value_type(v2.y))
+		{}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T>::tvec4
+		(
+			tvec4<U> const & v
+		) :
+			x(value_type(v.x)),
+			y(value_type(v.y)),
+			z(value_type(v.z)),
+			w(value_type(v.w))
+		{}
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator= 
+		(
+			tvec4<T> const & v
+		)
+		{
+			this->x = v.x;
+			this->y = v.y;
+			this->z = v.z;
+			this->w = v.w;
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator= 
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x = T(v.x);
+			this->y = T(v.y);
+			this->z = T(v.z);
+			this->w = T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+=
+		(
+			U const & s
+		)
+		{
+			this->x += T(s);
+			this->y += T(s);
+			this->z += T(s);
+			this->w += T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator+=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x += T(v.x);
+			this->y += T(v.y);
+			this->z += T(v.z);
+			this->w += T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-=
+		(
+			U const & s
+		)
+		{
+			this->x -= T(s);
+			this->y -= T(s);
+			this->z -= T(s);
+			this->w -= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator-=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x -= T(v.x);
+			this->y -= T(v.y);
+			this->z -= T(v.z);
+			this->w -= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*=
+		(
+			U const & s
+		)
+		{
+			this->x *= T(s);
+			this->y *= T(s);
+			this->z *= T(s);
+			this->w *= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator*=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x *= T(v.x);
+			this->y *= T(v.y);
+			this->z *= T(v.z);
+			this->w *= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/=
+		(
+			U const & s
+		)
+		{
+			this->x /= T(s);
+			this->y /= T(s);
+			this->z /= T(s);
+			this->w /= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator/=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x /= T(v.x);
+			this->y /= T(v.y);
+			this->z /= T(v.z);
+			this->w /= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator++()
+		{
+			++this->x;
+			++this->y;
+			++this->z;
+			++this->w;
+			return *this;
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator--()
+		{
+			--this->x;
+			--this->y;
+			--this->z;
+			--this->w;
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%=
+		(
+			U const & s
+		)
+		{
+			this->x %= T(s);
+			this->y %= T(s);
+			this->z %= T(s);
+			this->w %= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator%=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x %= T(v.x);
+			this->y %= T(v.y);
+			this->z %= T(v.z);
+			this->w %= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&=
+		(
+			U const & s
+		)
+		{
+			this->x &= T(s);
+			this->y &= T(s);
+			this->z &= T(s);
+			this->w &= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator&=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x &= T(v.x);
+			this->y &= T(v.y);
+			this->z &= T(v.z);
+			this->w &= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|=
+		(
+			U const & s
+		)
+		{
+			this->x |= T(s);
+			this->y |= T(s);
+			this->z |= T(s);
+			this->w |= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator|=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x |= T(v.x);
+			this->y |= T(v.y);
+			this->z |= T(v.z);
+			this->w |= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^=
+		(
+			U const & s
+		)
+		{
+			this->x ^= T(s);
+			this->y ^= T(s);
+			this->z ^= T(s);
+			this->w ^= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator^=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x ^= T(v.x);
+			this->y ^= T(v.y);
+			this->z ^= T(v.z);
+			this->w ^= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<=
+		(
+			U const & s
+		)
+		{
+			this->x <<= T(s);
+			this->y <<= T(s);
+			this->z <<= T(s);
+			this->w <<= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator<<=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x <<= T(v.x);
+			this->y <<= T(v.y);
+			this->z <<= T(v.z);
+			this->w <<= T(v.w);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>=
+		(
+			U const & s
+		)
+		{
+			this->x >>= T(s);
+			this->y >>= T(s);
+			this->z >>= T(s);
+			this->w >>= T(s);
+			return *this;
+		}
+
+		template <typename T>
+		template <typename U> 
+		GLM_FUNC_QUALIFIER tvec4<T> & tvec4<T>::operator>>=
+		(
+			tvec4<U> const & v
+		)
+		{
+			this->x >>= T(v.x);
+			this->y >>= T(v.y);
+			this->z >>= T(v.z);
+			this->w >>= T(v.w);
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER typename tvec4<T>::value_type 
+		tvec4<T>::swizzle
+		(	
+			comp x
+		) const
+		{
+			return (*this)[x];
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec2<T> tvec4<T>::swizzle
+		(
+			comp x, 
+			comp y
+		) const
+		{
+			return tvec2<T>(
+				(*this)[x],
+				(*this)[y]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec3<T> tvec4<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z
+		) const
+		{
+			return tvec3<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> tvec4<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z, 
+			comp w
+		) const
+		{
+			return tvec4<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z],
+				(*this)[w]);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tref4<T> tvec4<T>::swizzle
+		(
+			comp x, 
+			comp y, 
+			comp z, 
+			comp w
+		)
+		{
+			return tref4<T>(
+				(*this)[x],
+				(*this)[y],
+				(*this)[z],
+				(*this)[w]);
+		}
+
+		//////////////////////////////////////
+		// Binary arithmetic operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator+ 
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x + s,
+				v.y + s,
+				v.z + s,
+				v.w + s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator+ 
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s + v.x,
+				s + v.y,
+				s + v.z,
+				s + v.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator+ 
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x + v2.x,
+				v1.y + v2.y,
+				v1.z + v2.z,
+				v1.w + v2.w);
+		}
+
+		//operator-
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator- 
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x - s,
+				v.y - s,
+				v.z - s,
+				v.w - s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator- 
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s - v.x,
+				s - v.y,
+				s - v.z,
+				s - v.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator- 
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x - v2.x,
+				v1.y - v2.y,
+				v1.z - v2.z,
+				v1.w - v2.w);
+		}
+
+		//operator*
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator* 
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x * s,
+				v.y * s,
+				v.z * s,
+				v.w * s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator* 
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s * v.x,
+				s * v.y,
+				s * v.z,
+				s * v.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator*
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x * v2.x,
+				v1.y * v2.y,
+				v1.z * v2.z,
+				v1.w * v2.w);
+		}
+
+		//operator/
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator/ 
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x / s,
+				v.y / s,
+				v.z / s,
+				v.w / s);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator/ 
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s / v.x,
+				s / v.y,
+				s / v.z,
+				s / v.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator/ 
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x / v2.x,
+				v1.y / v2.y,
+				v1.z / v2.z,
+				v1.w / v2.w);
+		}
+
+		// Unary constant operators
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator- 
+		(
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				-v.x, 
+				-v.y, 
+				-v.z, 
+				-v.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator++ 
+		(
+			tvec4<T> const & v, 
+			int
+		)
+		{
+			typename tvec4<T>::value_type One(1);
+			return tvec4<T>(
+				v.x + One, 
+				v.y + One, 
+				v.z + One, 
+				v.w + One);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator-- 
+		(
+			tvec4<T> const & v, 
+			int
+		)
+		{
+			typename tvec4<T>::value_type One(1);
+			return tvec4<T>(
+				v.x - One, 
+				v.y - One, 
+				v.z - One, 
+				v.w - One);
+		}
+
+		//////////////////////////////////////
+		// Boolean operators
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator==
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return (v1.x == v2.x) && (v1.y == v2.y) && (v1.z == v2.z) && (v1.w == v2.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER bool operator!=
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return (v1.x != v2.x) || (v1.y != v2.y) || (v1.z != v2.z) || (v1.w != v2.w);
+		}
+
+		//////////////////////////////////////
+		// Binary bit operators
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator% 
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x % s,
+				v.y % s,
+				v.z % s,
+				v.w % s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator% 
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s % v.x,
+				s % v.y,
+				s % v.z,
+				s % v.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator%
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x % v2.x,
+				v1.y % v2.y,
+				v1.z % v2.z,
+				v1.w % v2.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator& 
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x & s,
+				v.y & s,
+				v.z & s,
+				v.w & s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator& 
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s & v.x,
+				s & v.y,
+				s & v.z,
+				s & v.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator&
+		(
+			tvec4<T> const & v1,
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x & v2.x,
+				v1.y & v2.y,
+				v1.z & v2.z,
+				v1.w & v2.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator|
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x | s,
+				v.y | s,
+				v.z | s,
+				v.w | s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator|
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s | v.x,
+				s | v.y,
+				s | v.z,
+				s | v.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator|
+		(
+			tvec4<T> const & v1, 
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x | v2.x,
+				v1.y | v2.y,
+				v1.z | v2.z,
+				v1.w | v2.w);
+		}
+		
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator^
+		(
+			tvec4<T> const & v, 
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x ^ s,
+				v.y ^ s,
+				v.z ^ s,
+				v.w ^ s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator^
+		(
+			typename tvec4<T>::value_type const & s, 
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s ^ v.x,
+				s ^ v.y,
+				s ^ v.z,
+				s ^ v.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator^
+		(
+			tvec4<T> const & v1,
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x ^ v2.x,
+				v1.y ^ v2.y,
+				v1.z ^ v2.z,
+				v1.w ^ v2.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator<<
+		(
+			tvec4<T> const & v,
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x << s,
+				v.y << s,
+				v.z << s,
+				v.w << s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator<<
+		(
+			typename tvec4<T>::value_type const & s,
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s << v.x,
+				s << v.y,
+				s << v.z,
+				s << v.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator<<
+		(
+			tvec4<T> const & v1,
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x << v2.x,
+				v1.y << v2.y,
+				v1.z << v2.z,
+				v1.w << v2.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator>>
+		(
+			tvec4<T> const & v,
+			typename tvec4<T>::value_type const & s
+		)
+		{
+			return tvec4<T>(
+				v.x >> s,
+				v.y >> s,
+				v.z >> s,
+				v.w >> s);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator>>
+		(
+			typename tvec4<T>::value_type const & s,
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				s >> v.x,
+				s >> v.y,
+				s >> v.z,
+				s >> v.w);
+		}
+
+		template <typename T>
+		GLM_FUNC_QUALIFIER tvec4<T> operator>>
+		(
+			tvec4<T> const & v1,
+			tvec4<T> const & v2
+		)
+		{
+			return tvec4<T>(
+				v1.x >> v2.x,
+				v1.y >> v2.y,
+				v1.z >> v2.z,
+				v1.w >> v2.w);
+		}
+
+		template <typename T> 
+		GLM_FUNC_QUALIFIER tvec4<T> operator~
+		(
+			tvec4<T> const & v
+		)
+		{
+			return tvec4<T>(
+				~v.x,
+				~v.y,
+				~v.z,
+				~v.w);
+		}
+
+		//////////////////////////////////////
+		// tref definition
+
+		template <typename T> 
+		tref4<T>::tref4
+		(
+			T & x, 
+			T & y, 
+			T & z, 
+			T & w
+		) :
+			x(x),
+			y(y),
+			z(z),
+			w(w)
+		{}
+
+		template <typename T> 
+		tref4<T>::tref4
+		(
+			tref4<T> const & r
+		) :
+			x(r.x),
+			y(r.y),
+			z(r.z),
+			w(r.w)
+		{}
+
+		template <typename T> 
+		tref4<T>::tref4
+		(
+			tvec4<T> const & v
+		) :
+			x(v.x),
+			y(v.y),
+			z(v.z),
+			w(v.w)
+		{}
+
+		template <typename T> 
+		tref4<T>& tref4<T>::operator= 
+		(
+			tref4<T> const & r
+		)
+		{
+			x = r.x;
+			y = r.y;
+			z = r.z;
+			w = r.w;
+			return *this;
+		}
+
+		template <typename T> 
+		tref4<T>& tref4<T>::operator= 
+		(
+			tvec4<T> const & v
+		)
+		{
+			x = v.x;
+			y = v.y;
+			z = v.z;
+			w = v.w;
+			return *this;
+		}
+
+	}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/ext.hpp b/ExternalLibs/glm/ext.hpp
new file mode 100644
index 0000000..d925fe6
--- /dev/null
+++ b/ExternalLibs/glm/ext.hpp
@@ -0,0 +1,97 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-01
+// Updated : 2010-12-13
+// Licence : This source is under MIT License
+// File    : glm/ext.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_ext
+#define glm_ext
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED))
+#	define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
+#	pragma message("GLM: All extensions included (not recommanded)")
+#endif//GLM_MESSAGES
+
+#include "./gtc/half_float.hpp"
+#include "./gtc/matrix_access.hpp"
+#include "./gtc/matrix_integer.hpp"
+#include "./gtc/matrix_inverse.hpp"
+#include "./gtc/matrix_transform.hpp"
+#include "./gtc/quaternion.hpp"
+#include "./gtc/swizzle.hpp"
+#include "./gtc/type_precision.hpp"
+#include "./gtc/type_ptr.hpp"
+
+#include "./gtx/associated_min_max.hpp"
+#include "./gtx/bit.hpp"
+#include "./gtx/closest_point.hpp"
+#include "./gtx/color_cast.hpp"
+#include "./gtx/color_space.hpp"
+#include "./gtx/color_space_YCoCg.hpp"
+#include "./gtx/compatibility.hpp"
+#include "./gtx/component_wise.hpp"
+#include "./gtx/epsilon.hpp"
+#include "./gtx/euler_angles.hpp"
+#include "./gtx/extend.hpp"
+#include "./gtx/extented_min_max.hpp"
+#include "./gtx/fast_exponential.hpp"
+#include "./gtx/fast_square_root.hpp"
+#include "./gtx/fast_trigonometry.hpp"
+#include "./gtx/gradient_paint.hpp"
+#include "./gtx/handed_coordinate_space.hpp"
+#include "./gtx/inertia.hpp"
+#include "./gtx/int_10_10_10_2.hpp"
+#include "./gtx/integer.hpp"
+#include "./gtx/intersect.hpp"
+#include "./gtx/log_base.hpp"
+#include "./gtx/matrix_cross_product.hpp"
+#include "./gtx/matrix_interpolation.hpp"
+#include "./gtx/matrix_major_storage.hpp"
+#include "./gtx/matrix_operation.hpp"
+#include "./gtx/matrix_query.hpp"
+#include "./gtx/mixed_product.hpp"
+#include "./gtx/multiple.hpp"
+#include "./gtx/noise.hpp"
+#include "./gtx/norm.hpp"
+#include "./gtx/normal.hpp"
+#include "./gtx/normalize_dot.hpp"
+#include "./gtx/number_precision.hpp"
+#include "./gtx/ocl_type.hpp"
+#include "./gtx/optimum_pow.hpp"
+#include "./gtx/orthonormalize.hpp"
+#include "./gtx/perpendicular.hpp"
+#include "./gtx/polar_coordinates.hpp"
+#include "./gtx/projection.hpp"
+#include "./gtx/quaternion.hpp"
+#include "./gtx/random.hpp"
+#include "./gtx/raw_data.hpp"
+#include "./gtx/reciprocal.hpp"
+#include "./gtx/rotate_vector.hpp"
+#include "./gtx/spline.hpp"
+#include "./gtx/std_based_type.hpp"
+#include "./gtx/string_cast.hpp"
+#include "./gtx/transform.hpp"
+#include "./gtx/transform2.hpp"
+#include "./gtx/ulp.hpp"
+#include "./gtx/unsigned_int.hpp"
+#include "./gtx/vec1.hpp"
+#include "./gtx/vector_access.hpp"
+#include "./gtx/vector_angle.hpp"
+#include "./gtx/vector_query.hpp"
+#include "./gtx/verbose_operator.hpp"
+#include "./gtx/wrap.hpp"
+
+#if(GLM_ARCH & GLM_ARCH_SSE2)
+#	include "./gtx/simd_vec4.hpp"
+#	include "./gtx/simd_mat4.hpp"
+#endif
+
+#include "./virtrev/xstream.hpp"
+
+//const float goldenRatio = 1.618033988749894848f;
+//const float pi = 3.141592653589793238f;
+
+#endif //glm_ext
diff --git a/ExternalLibs/glm/glm.hpp b/ExternalLibs/glm/glm.hpp
new file mode 100644
index 0000000..394ecf4
--- /dev/null
+++ b/ExternalLibs/glm/glm.hpp
@@ -0,0 +1,101 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-01-14
+// Updated : 2011-01-19
+// Licence : This source is under MIT License
+// File    : glm/glm.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "core/_fixes.hpp"
+
+#ifndef glm_glm
+#define glm_glm
+
+#include <cmath>
+#include <climits>
+#include <cfloat>
+#include <limits>
+#include "core/setup.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
+#	define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
+#	pragma message("GLM: Core library included")
+#endif//GLM_MESSAGE
+
+//! GLM namespace, it contains all GLSL based features.
+namespace glm
+{
+	namespace test
+	{
+		bool main_bug();
+		bool main_core();
+	}//namespace test
+
+	//! GLM core. Namespace that includes all the feature define by GLSL 4.10.6 specification. This namespace is included in glm namespace.
+	namespace core
+	{
+		//! Scalar, vectors and matrices 
+		//! from section 4.1.2 Booleans, 4.1.3 Integers section, 4.1.4 Floats section,
+		//! 4.1.5 Vectors and section 4.1.6 Matrices of GLSL 1.30.8 specification. 
+		//! This namespace resolves precision qualifier define in section 4.5 of GLSL 1.30.8 specification.
+		namespace type{}
+
+		//! Some of the functions defined in section 8 Built-in Functions of GLSL 1.30.8 specification.
+		//! Angle and trigonometry, exponential, common, geometric, matrix and vector relational functions.
+		namespace function{}
+	}
+	//namespace core
+
+	//! G-Truc Creation stable extensions.
+	namespace gtc{}
+
+	//! G-Truc Creation experimental extensions. 
+	//! The interface could change between releases.
+	namespace gtx{}
+
+	//! VIRTREV extensions.
+	namespace img{}
+
+} //namespace glm
+
+#include "./core/_detail.hpp"
+#include "./core/type.hpp"
+
+#include "./core/func_trigonometric.hpp"
+#include "./core/func_exponential.hpp"
+#include "./core/func_common.hpp"
+#include "./core/func_packing.hpp"
+#include "./core/func_geometric.hpp"
+#include "./core/func_matrix.hpp"
+#include "./core/func_vector_relational.hpp"
+#include "./core/func_integer.hpp"
+#include "./core/func_noise.hpp"
+#include "./core/_swizzle.hpp"
+
+namespace glm
+{
+ 	using namespace core::type;
+	using namespace core::type::precision;
+	using namespace core::function;
+} //namespace glm
+
+////////////////////
+// check type sizes
+#ifndef GLM_STATIC_ASSERT_NULL
+	GLM_STATIC_ASSERT(sizeof(glm::detail::int8) == 1, "int8 size isn't 1 byte on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::int16) == 2, "int16 size isn't 2 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::int32) == 4, "int32 size isn't 4 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::int64) == 8, "int64 size isn't 8 bytes on this platform");
+
+	GLM_STATIC_ASSERT(sizeof(glm::detail::uint8) == 1, "uint8 size isn't 1 byte on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::uint16) == 2, "uint16 size isn't 2 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::uint32) == 4, "uint32 size isn't 4 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::uint64) == 8, "uint64 size isn't 8 bytes on this platform");
+
+	GLM_STATIC_ASSERT(sizeof(glm::detail::float16) == 2, "float16 size isn't 2 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::float32) == 4, "float32 size isn't 4 bytes on this platform");
+	GLM_STATIC_ASSERT(sizeof(glm::detail::float64) == 8, "float64 size isn't 8 bytes on this platform");
+#endif//GLM_STATIC_ASSERT_NULL
+
+#endif //glm_glm
diff --git a/ExternalLibs/glm/gtc/half_float.hpp b/ExternalLibs/glm/gtc/half_float.hpp
new file mode 100644
index 0000000..ab3a1da
--- /dev/null
+++ b/ExternalLibs/glm/gtc/half_float.hpp
@@ -0,0 +1,365 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-04-29
+// Updated : 2010-02-07
+// Licence : This source is under MIT License
+// File    : glm/gtc/half_float.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_half_float
+#define glm_gtc_half_float
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_half_float extension included")
+#endif
+
+namespace glm{
+namespace detail
+{
+#ifndef _MSC_EXTENSIONS
+	template <>
+	struct tvec2<thalf>
+	{
+		enum ctor{null};
+		typedef thalf value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef tvec2<thalf> type;
+		typedef tvec2<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+		thalf x, y;
+
+		//////////////////////////////////////
+		// Accesses
+
+		thalf & operator[](size_type i);
+		thalf const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		tvec2();
+		tvec2(tvec2<thalf> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit tvec2(ctor);
+		explicit tvec2(
+			thalf const & s);
+		explicit tvec2(
+			thalf const & s1, 
+			thalf const & s2);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec2(tref2<thalf> const & r);
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(U const & x);
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U, typename V> 
+		explicit tvec2(U const & x, V const & y);			
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(tvec2<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(tvec3<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		tvec2<thalf>& operator= (tvec2<thalf> const & v);
+
+		tvec2<thalf>& operator+=(thalf const & s);
+		tvec2<thalf>& operator+=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator-=(thalf const & s);
+		tvec2<thalf>& operator-=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator*=(thalf const & s);
+		tvec2<thalf>& operator*=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator/=(thalf const & s);
+		tvec2<thalf>& operator/=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator++();
+		tvec2<thalf>& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		thalf swizzle(comp X) const;
+		tvec2<thalf> swizzle(comp X, comp Y) const;
+		tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
+		tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
+		tref2<thalf> swizzle(comp X, comp Y);
+	};
+
+	template <>
+	struct tvec3<thalf>
+	{
+		enum ctor{null};
+		typedef thalf value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef tvec3<thalf> type;
+		typedef tvec3<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+		thalf x, y, z;
+
+		//////////////////////////////////////
+		// Accesses
+
+		thalf & operator[](size_type i);
+		thalf const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		tvec3();
+		tvec3(tvec3<thalf> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit tvec3(ctor);
+		explicit tvec3(
+			thalf const & s);
+		explicit tvec3(
+			thalf const & s1, 
+			thalf const & s2, 
+			thalf const & s3);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec3(tref3<thalf> const & r);
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec3(U const & x);
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U, typename V, typename W> 
+		explicit tvec3(U const & x, V const & y, W const & z);			
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec3(tvec2<A> const & v, B const & s);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec3(A const & s, tvec2<B> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec3(tvec3<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec3(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		tvec3<thalf>& operator= (tvec3<thalf> const & v);
+
+		tvec3<thalf>& operator+=(thalf const & s);
+		tvec3<thalf>& operator+=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator-=(thalf const & s);
+		tvec3<thalf>& operator-=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator*=(thalf const & s);
+		tvec3<thalf>& operator*=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator/=(thalf const & s);
+		tvec3<thalf>& operator/=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator++();
+		tvec3<thalf>& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		thalf swizzle(comp X) const;
+		tvec2<thalf> swizzle(comp X, comp Y) const;
+		tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
+		tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
+		tref3<thalf> swizzle(comp X, comp Y, comp Z);
+	};
+
+	template <>
+	struct tvec4<thalf>
+	{
+		enum ctor{null};
+		typedef thalf value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef tvec4<thalf> type;
+		typedef tvec4<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+		thalf x, y, z, w;
+
+		//////////////////////////////////////
+		// Accesses
+
+		thalf & operator[](size_type i);
+		thalf const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		tvec4();
+		tvec4(tvec4<thalf> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit tvec4(ctor);
+		explicit tvec4(
+			thalf const & s);
+		explicit tvec4(
+			thalf const & s0, 
+			thalf const & s1, 
+			thalf const & s2, 
+			thalf const & s3);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec4(tref4<thalf> const & r);
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec4(U const & x);
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C, typename D> 
+		explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C> 
+		explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C> 
+		explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C> 
+		explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec4(tvec3<A> const & v, B const & s);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec4(A const & s, tvec3<B> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec4(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		tvec4<thalf>& operator= (tvec4<thalf> const & v);
+
+		tvec4<thalf>& operator+=(thalf const & s);
+		tvec4<thalf>& operator+=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator-=(thalf const & s);
+		tvec4<thalf>& operator-=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator*=(thalf const & s);
+		tvec4<thalf>& operator*=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator/=(thalf const & s);
+		tvec4<thalf>& operator/=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator++();
+		tvec4<thalf>& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		thalf swizzle(comp X) const;
+		tvec2<thalf> swizzle(comp X, comp Y) const;
+		tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
+		tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
+		tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
+	};
+#endif//_MSC_EXTENSIONS
+}
+//namespace detail
+
+namespace gtc{
+namespace half_float ///< GLM_GTC_half_float extension: Add support for half precision floating-point types
+{
+	/// \addtogroup gtc_half_float
+	///@{
+
+	/// Type for half-precision floating-point numbers. 
+	/// From GLM_GTC_half_float extension.
+	typedef detail::thalf					half;
+
+	/// Vector of 2 half-precision floating-point numbers. 
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tvec2<detail::thalf>	hvec2;
+
+	/// Vector of 3 half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tvec3<detail::thalf>	hvec3;
+
+	/// Vector of 4 half-precision floating-point numbers. 
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tvec4<detail::thalf>	hvec4;
+
+	/// 2 * 2 matrix of half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tmat2x2<detail::thalf>	hmat2;
+
+	/// 3 * 3 matrix of half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tmat3x3<detail::thalf>	hmat3;
+
+	/// 4 * 4 matrix of half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tmat4x4<detail::thalf>	hmat4;
+
+	/// @}
+
+}// namespace half_float
+}// namespace gtc
+}// namespace glm
+
+#include "half_float.inl"
+
+namespace glm{using namespace gtc::half_float;}
+
+#endif//glm_gtc_half_float
diff --git a/ExternalLibs/glm/gtc/half_float.inl b/ExternalLibs/glm/gtc/half_float.inl
new file mode 100644
index 0000000..b3c36a9
--- /dev/null
+++ b/ExternalLibs/glm/gtc/half_float.inl
@@ -0,0 +1,975 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2010-02-07
+// Licence : This source is under MIT licence
+// File    : glm/gtc/half_float.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail{
+
+#ifndef _MSC_EXTENSIONS
+
+//////////////////////////////////////
+// hvec2
+
+GLM_FUNC_QUALIFIER tvec2<thalf>::size_type tvec2<thalf>::value_size()
+{
+	return 2;
+}
+
+//////////////////////////////////////
+// Accesses
+
+GLM_FUNC_QUALIFIER thalf & tvec2<thalf>::operator[](tvec2<thalf>::size_type i)
+{
+	assert(/*i >= tvec2<thalf>::size_type(0) && */i < tvec2<thalf>::value_size());
+	return (&x)[i];
+}
+
+GLM_FUNC_QUALIFIER thalf const & tvec2<thalf>::operator[](tvec2<thalf>::size_type i) const
+{
+	assert(/*i >= tvec2<thalf>::size_type(0) && */i < tvec2<thalf>::value_size());
+	return (&x)[i];
+}
+
+//////////////////////////////////////
+// Implicit basic constructors
+
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2() :
+	x(thalf(0.f)),
+	y(thalf(0.f))
+{}
+
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	tvec2<thalf> const & v
+) :
+	x(v.x),
+	y(v.y)
+{}
+
+//////////////////////////////////////
+// Explicit basic constructors
+
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	thalf const & s
+) :
+	x(s),
+	y(s)
+{}
+
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	thalf const & s1, 
+	thalf const & s2
+) :
+	x(s1),
+	y(s2)
+{}
+
+//////////////////////////////////////
+// Swizzle constructors
+
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	tref2<thalf> const & r
+) :
+	x(r.x),
+	y(r.y)
+{}
+
+//////////////////////////////////////
+// Convertion scalar constructors
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	U const & x
+) :
+	x(thalf(x)),
+	y(thalf(x))
+{}
+
+template <typename U, typename V> 
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	U const & x, 
+	V const & y
+) :
+	x(thalf(x)),
+	y(thalf(y))
+{}
+
+//////////////////////////////////////
+// Convertion vector constructors
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	tvec2<U> const & v
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y))
+{}
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(	
+	tvec3<U> const & v
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y))
+{}
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec2<thalf>::tvec2
+(
+	tvec4<U> const & v
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y))
+{}
+
+//////////////////////////////////////
+// Unary arithmetic operators
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator= 
+(
+	tvec2<thalf> const & v
+)
+{
+	this->x = v.x;
+	this->y = v.y;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator+=
+(
+	thalf const & s
+)
+{
+	this->x += s;
+	this->y += s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator+=
+(
+	tvec2<thalf> const & v
+)
+{
+	this->x += v.x;
+	this->y += v.y;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator-=
+(
+	thalf const & s
+)
+{
+	this->x -= s;
+	this->y -= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator-=
+(
+	tvec2<thalf> const & v
+)
+{
+	this->x -= v.x;
+	this->y -= v.y;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf>& tvec2<thalf>::operator*=
+(
+	thalf const & s
+)
+{
+	this->x *= s;
+	this->y *= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator*=
+(
+	tvec2<thalf> const & v
+)
+{
+	this->x *= v.x;
+	this->y *= v.y;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator/=
+(
+	thalf const & s
+)
+{
+	this->x /= s;
+	this->y /= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator/=
+(
+	tvec2<thalf> const & v
+)
+{
+	this->x /= v.x;
+	this->y /= v.y;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> & tvec2<thalf>::operator++()
+{
+	++this->x;
+	++this->y;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf>& tvec2<thalf>::operator--()
+{
+	--this->x;
+	--this->y;
+	return *this;
+}
+
+//////////////////////////////////////
+// Swizzle operators
+
+GLM_FUNC_QUALIFIER thalf tvec2<thalf>::swizzle(comp x) const
+{
+	return (*this)[x];
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> tvec2<thalf>::swizzle(comp x, comp y) const
+{
+	return tvec2<thalf>(
+		(*this)[x],
+		(*this)[y]);
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> tvec2<thalf>::swizzle(comp x, comp y, comp z) const
+{
+	return tvec3<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z]);
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf> tvec2<thalf>::swizzle(comp x, comp y, comp z, comp w) const
+{
+	return tvec4<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z],
+		(*this)[w]);
+}
+
+GLM_FUNC_QUALIFIER tref2<thalf> tvec2<thalf>::swizzle(comp x, comp y)
+{
+	return tref2<thalf>(
+		(*this)[x],
+		(*this)[y]);
+}
+
+//////////////////////////////////////
+// hvec3
+
+GLM_FUNC_QUALIFIER tvec3<thalf>::size_type tvec3<thalf>::value_size()
+{
+	return 3;
+}
+
+//////////////////////////////////////
+// Accesses
+
+GLM_FUNC_QUALIFIER thalf & tvec3<thalf>::operator[]
+(
+	tvec3<thalf>::size_type i
+)
+{
+	assert(/*i >= tvec3<thalf>::size_type(0) &&*/ i < tvec3<thalf>::value_size());
+
+	return (&x)[i];
+}
+
+GLM_FUNC_QUALIFIER thalf const & tvec3<thalf>::operator[]
+(
+	tvec3<thalf>::size_type i
+) const
+{
+	assert(/*i >= tvec3<thalf>::size_type(0) &&*/ i < tvec3<thalf>::value_size());
+
+	return (&x)[i];
+}
+
+//////////////////////////////////////
+// Implicit basic constructors
+
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3() :
+	x(thalf(0)),
+	y(thalf(0)),
+	z(thalf(0))
+{}
+
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	tvec3<thalf> const & v
+) :
+	x(v.x),
+	y(v.y),
+	z(v.z)
+{}
+
+//////////////////////////////////////
+// Explicit basic constructors
+
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	thalf const & s
+) :
+	x(s),
+	y(s),
+	z(s)
+{}
+
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	thalf const & s0, 
+	thalf const & s1, 
+	thalf const & s2
+) :
+	x(s0),
+	y(s1),
+	z(s2)
+{}
+
+//////////////////////////////////////
+// Swizzle constructors
+
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	tref3<thalf> const & r
+) :
+	x(r.x),
+	y(r.y),
+	z(r.z)
+{}
+
+//////////////////////////////////////
+// Convertion scalar constructors
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	U const & x
+) :
+	x(thalf(x)),
+	y(thalf(x)),
+	z(thalf(x))
+{}
+
+template <typename A, typename B, typename C> 
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	A const & x, 
+	B const & y, 
+	C const & z
+) :
+	x(thalf(x)),
+	y(thalf(y)),
+	z(thalf(z))
+{}
+
+//////////////////////////////////////
+// Convertion vector constructors
+
+template <typename A, typename B> 
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	tvec2<A> const & v, 
+	B const & s
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y)),
+	z(thalf(s))
+{}
+
+template <typename A, typename B> 
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	A const & s, 
+	tvec2<B> const & v
+) :
+	x(thalf(s)),
+	y(thalf(v.x)),
+	z(thalf(v.y))
+{}
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	tvec3<U> const & v
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y)),
+	z(thalf(v.z))
+{}
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec3<thalf>::tvec3
+(
+	tvec4<U> const & v
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y)),
+	z(thalf(v.z))
+{}
+
+//////////////////////////////////////
+// Unary arithmetic operators
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator= 
+(
+	tvec3<thalf> const & v
+)
+{
+	this->x = v.x;
+	this->y = v.y;
+	this->z = v.z;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator+=
+(
+	thalf const & s
+)
+{
+	this->x += s;
+	this->y += s;
+	this->z += s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator+=
+(
+	tvec3<thalf> const & v
+)
+{
+	this->x += v.x;
+	this->y += v.y;
+	this->z += v.z;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator-=
+(
+	thalf const & s
+)
+{
+	this->x -= s;
+	this->y -= s;
+	this->z -= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator-=
+(
+	tvec3<thalf> const & v
+)
+{
+	this->x -= v.x;
+	this->y -= v.y;
+	this->z -= v.z;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator*=
+(
+	thalf const & s
+)
+{
+	this->x *= s;
+	this->y *= s;
+	this->z *= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator*=
+(
+	tvec3<thalf> const & v
+)
+{
+	this->x *= v.x;
+	this->y *= v.y;
+	this->z *= v.z;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator/=
+(
+	thalf const & s
+)
+{
+	this->x /= s;
+	this->y /= s;
+	this->z /= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator/=
+(
+	tvec3<thalf> const & v
+)
+{
+	this->x /= v.x;
+	this->y /= v.y;
+	this->z /= v.z;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator++()
+{
+	++this->x;
+	++this->y;
+	++this->z;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> & tvec3<thalf>::operator--()
+{
+	--this->x;
+	--this->y;
+	--this->z;
+	return *this;
+}
+
+//////////////////////////////////////
+// Swizzle operators
+
+GLM_FUNC_QUALIFIER thalf tvec3<thalf>::swizzle(comp x) const
+{
+	return (*this)[x];
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> tvec3<thalf>::swizzle(comp x, comp y) const
+{
+	return tvec2<thalf>(
+		(*this)[x],
+		(*this)[y]);
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> tvec3<thalf>::swizzle(comp x, comp y, comp z) const
+{
+	return tvec3<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z]);
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf> tvec3<thalf>::swizzle(comp x, comp y, comp z, comp w) const
+{
+	return tvec4<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z],
+		(*this)[w]);
+}
+
+GLM_FUNC_QUALIFIER tref3<thalf> tvec3<thalf>::swizzle(comp x, comp y, comp z)
+{
+	return tref3<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z]);
+}
+
+//////////////////////////////////////
+// hvec4
+
+GLM_FUNC_QUALIFIER tvec4<thalf>::size_type tvec4<thalf>::value_size()
+{
+	return 4;
+}
+
+//////////////////////////////////////
+// Accesses
+
+GLM_FUNC_QUALIFIER thalf & tvec4<thalf>::operator[]
+(
+	tvec4<thalf>::size_type i
+)
+{
+	assert(/*i >= tvec4<thalf>::size_type(0) && */i < tvec4<thalf>::value_size());
+
+	return (&x)[i];
+}
+
+GLM_FUNC_QUALIFIER thalf const & tvec4<thalf>::operator[]
+(
+	tvec4<thalf>::size_type i
+) const
+{
+	assert(/*i >= tvec4<thalf>::size_type(0) && */i < tvec4<thalf>::value_size());
+
+	return (&x)[i];
+}
+
+//////////////////////////////////////
+// Implicit basic constructors
+
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4() :
+	x(thalf(0)),
+	y(thalf(0)),
+	z(thalf(0)),
+	w(thalf(0))
+{}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	tvec4<thalf> const & v
+) :
+	x(v.x),
+	y(v.y),
+	z(v.z),
+	w(v.w)
+{}
+
+//////////////////////////////////////
+// Explicit basic constructors
+
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	thalf const & s
+) :
+	x(s),
+	y(s),
+	z(s),
+	w(s)
+{}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	thalf const & s1, 
+	thalf const & s2, 
+	thalf const & s3, 
+	thalf const & s4
+) :
+	x(s1),
+	y(s2),
+	z(s3),
+	w(s4)
+{}
+
+//////////////////////////////////////
+// Swizzle constructors
+
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	tref4<thalf> const & r
+) :
+	x(r.x),
+	y(r.y),
+	z(r.z),
+	w(r.w)
+{}
+
+//////////////////////////////////////
+// Convertion scalar constructors
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	U const & x
+) :
+	x(thalf(x)),
+	y(thalf(x)),
+	z(thalf(x)),
+	w(thalf(x))
+{}
+
+template <typename A, typename B, typename C, typename D> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	A const & x, 
+	B const & y, 
+	C const & z, 
+	D const & w
+) :
+	x(thalf(x)),
+	y(thalf(y)),
+	z(thalf(z)),
+	w(thalf(w))
+{}
+
+//////////////////////////////////////
+// Convertion vector constructors
+
+template <typename A, typename B, typename C> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	tvec2<A> const & v, 
+	B const & s1, 
+	C const & s2
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y)),
+	z(thalf(s1)),
+	w(thalf(s2))
+{}
+
+template <typename A, typename B, typename C> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	A const & s1, 
+	tvec2<B> const & v, 
+	C const & s2
+) :
+	x(thalf(s1)),
+	y(thalf(v.x)),
+	z(thalf(v.y)),
+	w(thalf(s2))
+{}
+
+template <typename A, typename B, typename C> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	A const & s1, 
+	B const & s2, 
+	tvec2<C> const & v
+) :
+	x(thalf(s1)),
+	y(thalf(s2)),
+	z(thalf(v.x)),
+	w(thalf(v.y))
+{}
+
+template <typename A, typename B> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	tvec3<A> const & v, 
+	B const & s
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y)),
+	z(thalf(v.z)),
+	w(thalf(s))
+{}
+
+template <typename A, typename B> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	A const & s, 
+	tvec3<B> const & v
+) :
+	x(thalf(s)),
+	y(thalf(v.x)),
+	z(thalf(v.y)),
+	w(thalf(v.z))
+{}
+
+template <typename A, typename B> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	tvec2<A> const & v1, 
+	tvec2<B> const & v2
+) :
+	x(thalf(v1.x)),
+	y(thalf(v1.y)),
+	z(thalf(v2.x)),
+	w(thalf(v2.y))
+{}
+
+template <typename U> 
+GLM_FUNC_QUALIFIER tvec4<thalf>::tvec4
+(
+	tvec4<U> const & v
+) :
+	x(thalf(v.x)),
+	y(thalf(v.y)),
+	z(thalf(v.z)),
+	w(thalf(v.w))
+{}
+
+//////////////////////////////////////
+// Unary arithmetic operators
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator= 
+(
+	tvec4<thalf> const & v
+)
+{
+	this->x = v.x;
+	this->y = v.y;
+	this->z = v.z;
+	this->w = v.w;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator+=
+(
+	thalf const & s
+)
+{
+	this->x += s;
+	this->y += s;
+	this->z += s;
+	this->w += s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator+=
+(
+	tvec4<thalf> const & v
+)
+{
+	this->x += v.x;
+	this->y += v.y;
+	this->z += v.z;
+	this->w += v.w;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator-=
+(
+	thalf const & s
+)
+{
+	this->x -= s;
+	this->y -= s;
+	this->z -= s;
+	this->w -= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator-=
+(
+	tvec4<thalf> const & v
+)
+{
+	this->x -= v.x;
+	this->y -= v.y;
+	this->z -= v.z;
+	this->w -= v.w;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator*=
+(
+	thalf const & s
+)
+{
+	this->x *= s;
+	this->y *= s;
+	this->z *= s;
+	this->w *= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator*=
+(
+	tvec4<thalf> const & v
+)
+{
+	this->x *= v.x;
+	this->y *= v.y;
+	this->z *= v.z;
+	this->w *= v.w;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator/=
+(
+	thalf const & s
+)
+{
+	this->x /= s;
+	this->y /= s;
+	this->z /= s;
+	this->w /= s;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator/=
+(
+	tvec4<thalf> const & v
+)
+{
+	this->x /= v.x;
+	this->y /= v.y;
+	this->z /= v.z;
+	this->w /= v.w;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator++()
+{
+	++this->x;
+	++this->y;
+	++this->z;
+	++this->w;
+	return *this;
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf>& tvec4<thalf>::operator--()
+{
+	--this->x;
+	--this->y;
+	--this->z;
+	--this->w;
+	return *this;
+}
+
+//////////////////////////////////////
+// Swizzle operators
+
+GLM_FUNC_QUALIFIER thalf tvec4<thalf>::swizzle(comp x) const
+{
+	return (*this)[x];
+}
+
+GLM_FUNC_QUALIFIER tvec2<thalf> tvec4<thalf>::swizzle(comp x, comp y) const
+{
+	return tvec2<thalf>(
+		(*this)[x],
+		(*this)[y]);
+}
+
+GLM_FUNC_QUALIFIER tvec3<thalf> tvec4<thalf>::swizzle(comp x, comp y, comp z) const
+{
+	return tvec3<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z]);
+}
+
+GLM_FUNC_QUALIFIER tvec4<thalf> tvec4<thalf>::swizzle(comp x, comp y, comp z, comp w) const
+{
+	return tvec4<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z],
+		(*this)[w]);
+}
+
+GLM_FUNC_QUALIFIER tref4<thalf> tvec4<thalf>::swizzle(comp x, comp y, comp z, comp w)
+{
+	return tref4<thalf>(
+		(*this)[x],
+		(*this)[y],
+		(*this)[z],
+		(*this)[w]);
+}
+
+#endif//_MSC_EXTENSIONS
+
+}//namespace detail
+}//namespace glm
diff --git a/ExternalLibs/glm/gtc/matrix_access.hpp b/ExternalLibs/glm/gtc/matrix_access.hpp
new file mode 100644
index 0000000..670fa90
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_access.hpp
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-27
+// Updated : 2010-11-12
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_access.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_matrix_access
+#define glm_gtc_matrix_access
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_matrix_access extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace matrix_access ///< GLM_GTC_matrix_access extension: Set a column or a row of a matrix
+{
+	/// \addtogroup gtc_matrix_access
+	///@{
+
+	//! Get a specific row of a matrix.
+	//! From GLM_GTC_matrix_access extension.
+	template <typename genType> 
+	typename genType::row_type row(
+		genType const & m, 
+		int index);
+
+	//! Set a specific row to a matrix.
+	//! From GLM_GTC_matrix_access extension.
+    template <typename genType> 
+	genType row(
+		genType const & m, 
+		int index, 
+		typename genType::row_type const & x);
+
+	//! Get a specific column of a matrix.
+	//! From GLM_GTC_matrix_access extension.
+	template <typename genType> 
+	typename genType::col_type column(
+		genType const & m, 
+		int index);
+
+	 //! Set a specific column to a matrix.
+	 //! From GLM_GTC_matrix_access extension.
+	template <typename genType> 
+	genType column(
+		genType const & m, 
+		int index, 
+		typename genType::col_type const & x);
+
+	///@}
+
+}//namespace matrix_access
+}//namespace gtc
+}//namespace glm
+
+#include "matrix_access.inl"
+
+namespace glm{using namespace gtc::matrix_access;}
+
+#endif//glm_gtc_matrix_access
diff --git a/ExternalLibs/glm/gtc/matrix_access.inl b/ExternalLibs/glm/gtc/matrix_access.inl
new file mode 100644
index 0000000..fd5cdd7
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_access.inl
@@ -0,0 +1,59 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-27
+// Updated : 2010-11-12
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_access.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtc{
+namespace matrix_access
+{
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType row(
+		genType const & m, 
+		int index, 
+		typename genType::row_type const & x)
+    {
+        genType Result = m;
+        for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
+			Result[i][index] = x[i];
+        return Result;
+    }
+
+    template <typename genType>
+    GLM_FUNC_QUALIFIER typename genType::row_type row(
+		genType const & m, 
+		int index)
+    {
+		typename genType::row_type Result;
+		for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
+			Result[i] = m[i][index];
+		return Result;
+    }
+
+    template <typename genType>
+    GLM_FUNC_QUALIFIER genType column(
+		genType const & m, 
+		int index, 
+		typename genType::col_type const & x)
+    {
+        genType Result = m;
+        Result[index] = x;
+        return Result;
+    }
+
+    template <typename genType>
+    GLM_FUNC_QUALIFIER typename genType::col_type column(
+		genType const & m, 
+		int index)
+    {
+        return m[index];
+    }
+
+}//namespace matrix_access
+}//namespace gtc
+}//namespace glm
+
diff --git a/ExternalLibs/glm/gtc/matrix_integer.hpp b/ExternalLibs/glm/gtc/matrix_integer.hpp
new file mode 100644
index 0000000..63fb6d2
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_integer.hpp
@@ -0,0 +1,204 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-01-20
+// Updated : 2011-01-20
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_integer.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_matrix_integer
+#define glm_gtc_matrix_integer
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_matrix_integer extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices
+{
+	/// \addtogroup gtc_matrix_integer
+	///@{
+
+	typedef detail::tmat2x2<highp_int>				highp_imat2;	//!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_int>				highp_imat3;	//!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_int>				highp_imat4;	//!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<highp_int>				highp_imat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<highp_int>				highp_imat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<highp_int>				highp_imat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<highp_int>				highp_imat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_int>				highp_imat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<highp_int>				highp_imat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<highp_int>				highp_imat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<highp_int>				highp_imat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_int>				highp_imat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_int>			mediump_imat2;	//!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_int>			mediump_imat3;	//!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_int>			mediump_imat4;	//!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_int>			mediump_imat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<mediump_int>			mediump_imat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<mediump_int>			mediump_imat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<mediump_int>			mediump_imat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_int>			mediump_imat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<mediump_int>			mediump_imat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<mediump_int>			mediump_imat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<mediump_int>			mediump_imat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_int>			mediump_imat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_int>				lowp_imat2;	//!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_int>				lowp_imat3;	//!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_int>				lowp_imat4;	//!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_int>				lowp_imat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<lowp_int>				lowp_imat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<lowp_int>				lowp_imat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<lowp_int>				lowp_imat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_int>				lowp_imat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<lowp_int>				lowp_imat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<lowp_int>				lowp_imat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<lowp_int>				lowp_imat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_int>				lowp_imat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<highp_uint>				highp_umat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_uint>				highp_umat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_uint>				highp_umat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<highp_uint>				highp_umat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<highp_uint>				highp_umat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<highp_uint>				highp_umat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<highp_uint>				highp_umat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_uint>				highp_umat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<highp_uint>				highp_umat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<highp_uint>				highp_umat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<highp_uint>				highp_umat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_uint>				highp_umat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_uint>			mediump_umat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_uint>			mediump_umat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_uint>			mediump_umat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_uint>			mediump_umat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<mediump_uint>			mediump_umat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<mediump_uint>			mediump_umat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<mediump_uint>			mediump_umat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_uint>			mediump_umat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<mediump_uint>			mediump_umat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<mediump_uint>			mediump_umat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<mediump_uint>			mediump_umat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_uint>			mediump_umat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_uint>				lowp_umat2;	//!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_uint>				lowp_umat3;	//!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_uint>				lowp_umat4;	//!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_uint>				lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<lowp_uint>				lowp_umat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<lowp_uint>				lowp_umat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<lowp_uint>				lowp_umat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_uint>				lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<lowp_uint>				lowp_umat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<lowp_uint>				lowp_umat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<lowp_uint>				lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_uint>				lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+#if(defined(GLM_PRECISION_HIGHP_INT))
+	typedef highp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+#elif(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_imat2							imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3							imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4							imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_HIGHP_UINT))
+	typedef highp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+#elif(defined(GLM_PRECISION_LOWP_UINT))
+	typedef lowp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
+	typedef mediump_umat2							umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3							umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4							umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+#endif//GLM_PRECISION
+
+	///@}
+
+}//namespace matrix_integer
+}//namespace gtc
+}//namespace glm
+
+namespace glm{using namespace gtc::matrix_integer;}
+
+#endif//glm_gtc_matrix_integer
diff --git a/ExternalLibs/glm/gtc/matrix_inverse.hpp b/ExternalLibs/glm/gtc/matrix_inverse.hpp
new file mode 100644
index 0000000..ac77697
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_inverse.hpp
@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2010-12-13
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_inverse.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_matrix_inverse
+#define glm_gtc_matrix_inverse
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_matrix_inverse extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace matrix_inverse ///< GLM_GTC_matrix_inverse extension: Inverse matrix functions
+{
+	/// \addtogroup gtc_matrix_inverse
+	///@{
+
+	//! Fast matrix inverse for affine matrix.
+	//! From GLM_GTC_matrix_inverse extension.
+	template <typename genType> 
+	genType affineInverse(genType const & m);
+
+	//! Compute the inverse transpose of a matrix.
+	//! From GLM_GTC_matrix_inverse extension.
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER typename genType::value_type inverseTranspose(
+		genType const & m);
+
+	///@}
+
+}//namespace matrix_inverse
+}//namespace gtc
+}//namespace glm
+
+#include "matrix_inverse.inl"
+
+namespace glm{using namespace gtc::matrix_inverse;}
+
+#endif//glm_gtc_matrix_inverse
diff --git a/ExternalLibs/glm/gtc/matrix_inverse.inl b/ExternalLibs/glm/gtc/matrix_inverse.inl
new file mode 100644
index 0000000..86acd18
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_inverse.inl
@@ -0,0 +1,139 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2010-12-13
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_inverse.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtc{
+namespace matrix_inverse
+{
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> affineInverse
+	(
+		detail::tmat3x3<T> const & m
+	)
+	{
+		detail::tmat3x3<T> Result(m);
+		Result[2] = detail::tvec3<T>(0, 0, 1);
+		Result = transpose(Result);
+		detail::tvec3<T> Translation = Result * detail::tvec3<T>(-detail::tvec2<T>(m[2]), m[2][2]);
+		Result[2] = Translation;
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> affineInverse
+	(
+		detail::tmat4x4<T> const & m
+	)
+	{
+		detail::tmat4x4<T> Result(m);
+		Result[3] = detail::tvec4<T>(0, 0, 0, 1);
+		Result = transpose(Result);
+		detail::tvec4<T> Translation = Result * detail::tvec4<T>(-detail::tvec3<T>(m[3]), m[3][3]);
+		Result[3] = Translation;
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> inverseTranspose(
+		detail::tmat2x2<valType> const & m)
+	{
+		valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
+
+		detail::tmat2x2<valType> Inverse(
+			+ m[1][1] / Determinant,
+			- m[0][1] / Determinant,
+			- m[1][0] / Determinant, 
+			+ m[0][0] / Determinant);
+
+		return Inverse;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> inverseTranspose(
+		detail::tmat3x3<valType> const & m)
+	{
+		valType Determinant = 
+			+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
+			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+
+		detail::tmat3x3<valType> Inverse;
+		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
+		Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
+		Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
+		Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
+		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
+		Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
+		Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+		Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
+		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
+		Inverse /= Determinant;
+
+		return Inverse;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> inverseTranspose(
+		detail::tmat4x4<valType> const & m)
+	{
+		valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		valType SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+		valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+		valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+		valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+		valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+		valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+		detail::tmat4x4<valType> Inverse;
+		Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
+		Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
+		Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
+		Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05);
+
+		Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02);
+		Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04);
+		Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
+		Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05);
+
+		Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
+		Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10);
+		Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12);
+		Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12);
+
+		Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15);
+		Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17);
+		Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18);
+		Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18);
+
+		valType Determinant = 
+			+ m[0][0] * Inverse[0][0] 
+			+ m[0][1] * Inverse[0][1] 
+			+ m[0][2] * Inverse[0][2] 
+			+ m[0][3] * Inverse[0][3];
+
+		Inverse /= Determinant;
+    
+		return Inverse;
+	}
+
+}//namespace matrix_inverse
+}//namespace gtc
+}//namespace glm
diff --git a/ExternalLibs/glm/gtc/matrix_transform.hpp b/ExternalLibs/glm/gtc/matrix_transform.hpp
new file mode 100644
index 0000000..ae3aae8
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_transform.hpp
@@ -0,0 +1,158 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-04-29
+// Updated : 2009-04-29
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_transform.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_matrix_operation
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_matrix_transform
+#define glm_gtc_matrix_transform
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_matrix_transform extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace matrix_transform ///< GLM_GTC_matrix_transform extension: Add transformation matrices
+{
+	/// \addtogroup gtc_matrix_transform
+	///@{
+
+	//! Builds a translation 4 * 4 matrix created from a vector of 3 components.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		detail::tmat4x4<T> const & m,
+		detail::tvec3<T> const & v);
+		
+	//! Builds a rotation 4 * 4 matrix created from an axis vector and an angle expressed in degrees. 
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		detail::tmat4x4<T> const & m,
+		T const & angle, 
+		detail::tvec3<T> const & v);
+
+	//! Builds a scale 4 * 4 matrix created from 3 scalars. 
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		detail::tmat4x4<T> const & m,
+		detail::tvec3<T> const & v);
+
+	//! Creates a matrix for an orthographic parallel viewing volume.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> ortho(
+		T const & left, 
+		T const & right, 
+		T const & bottom, 
+		T const & top, 
+		T const & zNear, 
+		T const & zFar);
+
+	//! Creates a matrix for projecting two-dimensional coordinates onto the screen.
+	//! From GLM_GTC_matrix_transform extension.
+    template <typename T> 
+	detail::tmat4x4<T> ortho(
+		T const & left, 
+		T const & right, 
+		T const & bottom, 
+		T const & top);
+
+	//! Creates a frustum matrix.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> frustum(
+		T const & left, 
+		T const & right, 
+		T const & bottom, 
+		T const & top, 
+		T const & nearVal, 
+		T const & farVal);
+
+	//! Creates a matrix for a symetric perspective-view frustum.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> perspective(
+		T const & fovy, 
+		T const & aspect, 
+		T const & zNear, 
+		T const & zFar);
+
+	//! Builds a perspective projection matrix based on a field of view
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> perspectiveFov(
+		valType const & fov, 
+		valType const & width, 
+		valType const & height, 
+		valType const & zNear, 
+		valType const & zFar);
+
+	//! Creates a matrix for a symmetric perspective-view frustum with far plane at infinite .
+	//! From GLM_GTC_matrix_transform extension.
+    template <typename T> 
+	detail::tmat4x4<T> infinitePerspective(
+		T fovy, T aspect, T zNear);
+
+	//! Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
+	//! From GLM_GTC_matrix_transform extension.
+    template <typename T> 
+	detail::tmat4x4<T> tweakedInfinitePerspective(
+		T fovy, T aspect, T zNear);
+
+	//! Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T, typename U> 
+	detail::tvec3<T> project(
+		detail::tvec3<T> const & obj, 
+		detail::tmat4x4<T> const & model, 
+		detail::tmat4x4<T> const & proj, 
+		detail::tvec4<U> const & viewport);
+
+	//! Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T, typename U> 
+	detail::tvec3<T> unProject(
+		detail::tvec3<T> const & win, 
+		detail::tmat4x4<T> const & model, 
+		detail::tmat4x4<T> const & proj, 
+		detail::tvec4<U> const & viewport);
+
+	//! Define a picking region
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T, typename U> 
+	detail::tmat4x4<T> pickMatrix(
+		detail::tvec2<T> const & center, 
+		detail::tvec2<T> const & delta, 
+		detail::tvec4<U> const & viewport);
+
+	//! Build a look at view matrix.
+	//! From GLM_GTC_matrix_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> lookAt(
+		detail::tvec3<T> const & eye, 
+		detail::tvec3<T> const & center, 
+		detail::tvec3<T> const & up);
+
+	///@}
+}//namespace matrix_transform
+}//namespace gtc
+}//namespace glm
+
+#include "matrix_transform.inl"
+
+namespace glm{using namespace gtc::matrix_transform;}
+
+#endif//glm_gtc_matrix_transform
diff --git a/ExternalLibs/glm/gtc/matrix_transform.inl b/ExternalLibs/glm/gtc/matrix_transform.inl
new file mode 100644
index 0000000..525fbff
--- /dev/null
+++ b/ExternalLibs/glm/gtc/matrix_transform.inl
@@ -0,0 +1,397 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-04-29
+// Updated : 2009-04-29
+// Licence : This source is under MIT License
+// File    : glm/gtc/matrix_transform.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtc{
+namespace matrix_transform
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
+	(
+		detail::tmat4x4<T> const & m,
+		detail::tvec3<T> const & v
+	)
+    {
+		detail::tmat4x4<T> Result(m);
+		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
+		return Result;
+    }
+		
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate
+	(
+		detail::tmat4x4<T> const & m,
+		T const & angle, 
+		detail::tvec3<T> const & v
+	)
+    {
+        T a = radians(angle);
+        T c = cos(a);
+        T s = sin(a);
+
+        detail::tvec3<T> axis = normalize(v);
+
+		detail::tvec3<T> temp = (T(1) - c) * axis;
+
+        detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null);
+		Rotate[0][0] = c + temp[0] * axis[0];
+	    Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+	    Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+
+	    Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+	    Rotate[1][1] = c + temp[1] * axis[1];
+	    Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+
+	    Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+	    Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+	    Rotate[2][2] = c + temp[2] * axis[2];
+
+		detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
+		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+		Result[3] = m[3];
+		return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale
+	(
+		detail::tmat4x4<T> const & m,
+		detail::tvec3<T> const & v
+	)
+    {
+        detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
+		Result[0] = m[0] * v[0];
+		Result[1] = m[1] * v[1];
+		Result[2] = m[2] * v[2];
+		Result[3] = m[3];
+		return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow
+	(
+		detail::tmat4x4<T> const & m,
+		detail::tvec3<T> const & v
+	)
+    {
+        detail::tmat4x4<T> Result(T(1));
+        Result[3] = detail::tvec4<T>(v, T(1));
+        return m * Result;
+
+		//detail::tmat4x4<valType> Result(m);
+		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
+		//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
+		//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
+		//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
+		//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
+		//return Result;
+    }
+		
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow
+	(
+		detail::tmat4x4<T> const & m,
+		T const & angle, 
+		detail::tvec3<T> const & v
+	)
+    {
+        T a = radians(angle);
+        T c = cos(a);
+        T s = sin(a);
+        detail::tmat4x4<T> Result;
+
+        detail::tvec3<T> axis = normalize(v);
+
+        Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
+	    Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
+	    Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
+	    Result[0][3] = 0;
+
+	    Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
+	    Result[1][1] = c + (1 - c) * axis.y * axis.y;
+	    Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
+	    Result[1][3] = 0;
+
+	    Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
+	    Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
+	    Result[2][2] = c + (1 - c) * axis.z * axis.z;
+	    Result[2][3] = 0;
+
+        Result[3] = detail::tvec4<T>(0, 0, 0, 1);
+        return m * Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow
+	(
+		detail::tmat4x4<T> const & m,
+		detail::tvec3<T> const & v
+	)
+    {
+        detail::tmat4x4<T> Result(T(1));
+        Result[0][0] = v.x;
+        Result[1][1] = v.y;
+        Result[2][2] = v.z;
+        return m * Result;
+    }
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho
+	(
+		valType const & left, 
+		valType const & right, 
+		valType const & bottom, 
+		valType const & top, 
+		valType const & zNear, 
+		valType const & zFar
+	)
+	{
+		detail::tmat4x4<valType> Result(1);
+		Result[0][0] = valType(2) / (right - left);
+		Result[1][1] = valType(2) / (top - bottom);
+		Result[2][2] = - valType(2) / (zFar - zNear);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho(
+		valType const & left, 
+		valType const & right, 
+		valType const & bottom, 
+		valType const & top)
+	{
+		detail::tmat4x4<valType> Result(1);
+		Result[0][0] = valType(2) / (right - left);
+		Result[1][1] = valType(2) / (top - bottom);
+		Result[2][2] = - valType(1);
+		Result[3][0] = - (right + left) / (right - left);
+		Result[3][1] = - (top + bottom) / (top - bottom);
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum
+	(
+		valType const & left, 
+		valType const & right, 
+		valType const & bottom, 
+		valType const & top, 
+		valType const & nearVal, 
+		valType const & farVal
+	)
+	{
+		detail::tmat4x4<valType> Result(0);
+		Result[0][0] = (valType(2) * nearVal) / (right - left);
+		Result[1][1] = (valType(2) * nearVal) / (top - bottom);
+		Result[2][0] = (right + left) / (right - left);
+		Result[2][1] = (top + bottom) / (top - bottom);
+		Result[2][2] = -(farVal + nearVal) / (farVal - nearVal);
+		Result[2][3] = valType(-1);
+		Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal);
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective
+	(
+		valType const & fovy, 
+		valType const & aspect, 
+		valType const & zNear, 
+		valType const & zFar
+	)
+	{
+		valType range = tan(radians(fovy / valType(2))) * zNear;	
+		valType left = -range * aspect;
+		valType right = range * aspect;
+		valType bottom = -range;
+		valType top = range;
+
+		detail::tmat4x4<valType> Result(valType(0));
+		Result[0][0] = (valType(2) * zNear) / (right - left);
+		Result[1][1] = (valType(2) * zNear) / (top - bottom);
+		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = - valType(1);
+		Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template <typename valType>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov
+	(
+		valType const & fov, 
+		valType const & width, 
+		valType const & height, 
+		valType const & zNear, 
+		valType const & zFar
+	)
+	{
+		valType rad = glm::radians(fov);
+		valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
+		valType w = h * height / width;
+
+		detail::tmat4x4<valType> Result(valType(0));
+		Result[0][0] = w;
+		Result[1][1] = h;
+		Result[2][2] = (zFar + zNear) / (zFar - zNear);
+		Result[2][3] = valType(1);
+		Result[3][2] = -(valType(2) * zFar * zNear) / (zFar - zNear);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective
+	(
+		T fovy, 
+		T aspect, 
+		T zNear
+	)
+	{
+		T range = tan(radians(fovy / T(2))) * zNear;	
+		T left = -range * aspect;
+		T right = range * aspect;
+		T bottom = -range;
+		T top = range;
+
+		detail::tmat4x4<T> Result(T(0));
+		Result[0][0] = (T(2) * zNear) / (right - left);
+		Result[1][1] = (T(2) * zNear) / (top - bottom);
+		Result[2][2] = - T(1);
+		Result[2][3] = - T(1);
+		Result[3][2] = - T(2) * zNear;
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective
+	(
+		T fovy, 
+		T aspect, 
+		T zNear
+	)
+	{
+		T range = tan(radians(fovy / T(2))) * zNear;	
+		T left = -range * aspect;
+		T right = range * aspect;
+		T bottom = -range;
+		T top = range;
+
+		detail::tmat4x4<T> Result(T(0));
+		Result[0][0] = (T(2) * zNear) / (right - left);
+		Result[1][1] = (T(2) * zNear) / (top - bottom);
+		Result[2][2] = T(0.0001) - T(1);
+		Result[2][3] = T(-1);
+		Result[3][2] = - (T(0.0001) - T(2)) * zNear;
+		return Result;
+	}
+
+	template <typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> project
+	(
+		detail::tvec3<T> const & obj, 
+		detail::tmat4x4<T> const & model, 
+		detail::tmat4x4<T> const & proj, 
+		detail::tvec4<U> const & viewport
+	)
+	{
+		detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
+		tmp = model * tmp;
+		tmp = proj * tmp;
+
+		tmp /= tmp.w;
+		tmp = tmp * T(0.5) + T(0.5);
+		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
+		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
+
+		return detail::tvec3<T>(tmp);
+	}
+
+	template <typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> unProject
+	(
+		detail::tvec3<T> const & win, 
+		detail::tmat4x4<T> const & model, 
+		detail::tmat4x4<T> const & proj, 
+		detail::tvec4<U> const & viewport
+	)
+	{
+		detail::tmat4x4<T> inverse = glm::inverse(proj * model);
+
+		detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1));
+		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
+		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
+		tmp = tmp * T(2) - T(1);
+
+		detail::tvec4<T> obj = inverse * tmp;
+		obj /= obj.w;
+
+		return detail::tvec3<T>(obj);
+	}
+
+	template <typename T, typename U> 
+	detail::tmat4x4<T> pickMatrix
+	(
+		detail::tvec2<T> const & center, 
+		detail::tvec2<T> const & delta, 
+		detail::tvec4<U> const & viewport
+	)
+	{
+		assert(delta.x > T(0) && delta.y > T(0));
+		detail::tmat4x4<T> Result(1.0f);
+
+		if(!(delta.x > T(0) && delta.y > T(0))) 
+			return Result; // Error
+
+		detail::tvec3<T> Temp(
+			(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
+			(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
+			T(0));
+
+		// Translate and scale the picked region to the entire window
+		Result = translate(Result, Temp);
+		return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
+	}
+
+    template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
+	(
+		detail::tvec3<T> const & eye,
+		detail::tvec3<T> const & center,
+		detail::tvec3<T> const & up
+	)
+    {
+        detail::tvec3<T> f = normalize(center - eye);
+        detail::tvec3<T> u = normalize(up);
+        detail::tvec3<T> s = normalize(cross(f, u));
+        u = cross(s, f);
+
+        detail::tmat4x4<T> Result(1);
+        Result[0][0] = s.x;
+        Result[1][0] = s.y;
+        Result[2][0] = s.z;
+        Result[0][1] = u.x;
+        Result[1][1] = u.y;
+        Result[2][1] = u.z;
+        Result[0][2] =-f.x;
+        Result[1][2] =-f.y;
+        Result[2][2] =-f.z;
+    /*  Test this instead of translate3D
+        Result[3][0] =-dot(s, eye);
+        Result[3][1] =-dot(y, eye);
+        Result[3][2] = dot(f, eye);
+    */  
+		return gtc::matrix_transform::translate(Result, -eye);
+    }
+}//namespace matrix_transform
+}//namespace gtc
+}//namespace glm
diff --git a/ExternalLibs/glm/gtc/quaternion.hpp b/ExternalLibs/glm/gtc/quaternion.hpp
new file mode 100644
index 0000000..a859eed
--- /dev/null
+++ b/ExternalLibs/glm/gtc/quaternion.hpp
@@ -0,0 +1,229 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-21
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/gtc/quaternion.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// ToDo:
+// - Study constructors with angles and axis
+// - Study constructors with vec3 that are the imaginary component of quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_quaternion
+#define glm_gtc_quaternion
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_quaternion extension included")
+#endif
+
+namespace glm{
+namespace detail
+{
+	//! \brief Template for quaternion. 
+	//! From GLM_GTC_quaternion extension.
+	/// \ingroup gtc_quaternion
+	template <typename T> 
+	struct tquat// : public genType<T, tquat>
+	{
+		typedef T value_type;
+
+	public:
+		value_type x, y, z, w;
+
+		// Constructors
+		tquat();
+		explicit tquat(
+			value_type const & s, 
+			tvec3<T> const & v);
+		explicit tquat(
+			value_type const & w, 
+			value_type const & x, 
+			value_type const & y, 
+			value_type const & z);
+
+		// Convertions
+		//explicit tquat(valType const & pitch, valType const & yaw, valType const & roll);
+		//! pitch, yaw, roll
+		explicit tquat(
+			tvec3<T> const & eulerAngles);
+		explicit tquat(
+			tmat3x3<T> const & m);
+		explicit tquat(
+			tmat4x4<T> const & m);
+
+		// Accesses
+		value_type & operator[](int i);
+		value_type const & operator[](int i) const;
+
+		// Operators
+		tquat<T> & operator*=(value_type const & s);
+		tquat<T> & operator/=(value_type const & s);
+	};
+
+	template <typename T> 
+	detail::tquat<T> operator- (
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tquat<T> operator* ( 
+		detail::tquat<T> const & q, 
+		detail::tquat<T> const & p); 
+
+	template <typename T> 
+	detail::tvec3<T> operator* (
+		detail::tquat<T> const & q, 
+		detail::tvec3<T> const & v);
+
+	template <typename T> 
+	detail::tvec3<T> operator* (
+		detail::tvec3<T> const & v,
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tvec4<T> operator* (
+		detail::tquat<T> const & q, 
+		detail::tvec4<T> const & v);
+
+	template <typename T> 
+	detail::tvec4<T> operator* (
+		detail::tvec4<T> const & v,
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tquat<T> operator* (
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & s);
+
+	template <typename T> 
+	detail::tquat<T> operator* (
+		typename detail::tquat<T>::value_type const & s,
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tquat<T> operator/ (
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & s);
+
+} //namespace detail
+
+namespace gtc{
+namespace quaternion ///< GLM_GTC_quaternion extension: Quaternion types and functions
+{
+	/// \addtogroup gtc_quaternion
+	///@{
+
+	//! Returns the length of the quaternion x. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	typename detail::tquat<T>::value_type length(
+		detail::tquat<T> const & q);
+
+    //! Returns the normalized quaternion of from x. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> normalize(
+		detail::tquat<T> const & q);
+		
+    //! Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	typename detail::tquat<T>::value_type dot(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2);
+
+    //! Returns the cross product of q1 and q2. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	GLM_DEPRECATED detail::tquat<T> cross(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2);
+		
+	//! Returns a SLERP interpolated quaternion of x and y according a. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> mix(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		typename detail::tquat<T>::value_type const & a);
+		
+	//! Returns the q conjugate. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	detail::tquat<T> conjugate(
+		detail::tquat<T> const & q);
+
+	//! Returns the q inverse. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	detail::tquat<T> inverse(
+		detail::tquat<T> const & q);
+
+	//! Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> rotate(
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & angle, 
+		detail::tvec3<T> const & v);
+
+	//! Converts a quaternion to a 3 * 3 matrix. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	detail::tmat3x3<T> mat3_cast(
+		detail::tquat<T> const & x);
+
+	//! Converts a quaternion to a 4 * 4 matrix. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tmat4x4<T> mat4_cast(
+		detail::tquat<T> const & x);
+
+	//! Converts a 3 * 3 matrix to a quaternion. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> quat_cast(
+		detail::tmat3x3<T> const & x);
+
+	//! Converts a 4 * 4 matrix to a quaternion. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> quat_cast(
+		detail::tmat4x4<T> const & x);
+
+	//! Quaternion of floating-point numbers. 
+	//! From GLM_GTC_quaternion extension.
+    typedef detail::tquat<float> quat;
+
+	//! Quaternion of half-precision floating-point numbers.
+	//! From GLM_GTC_quaternion extension.
+	typedef detail::tquat<detail::thalf>	hquat;
+
+	//! Quaternion of single-precision floating-point numbers. 
+	//! From GLM_GTC_quaternion extension.
+	typedef detail::tquat<float>	fquat;
+
+	//! Quaternion of double-precision floating-point numbers. 
+	//! From GLM_GTC_quaternion extension.
+	typedef detail::tquat<double>	dquat;
+
+	///@}
+
+} //namespace quaternion
+} //namespace gtc
+} //namespace glm
+
+#include "quaternion.inl"
+
+namespace glm{using namespace gtc::quaternion;}
+
+#endif//glm_gtc_quaternion
diff --git a/ExternalLibs/glm/gtc/quaternion.inl b/ExternalLibs/glm/gtc/quaternion.inl
new file mode 100644
index 0000000..742fbde
--- /dev/null
+++ b/ExternalLibs/glm/gtc/quaternion.inl
@@ -0,0 +1,570 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-21
+// Updated : 2010-02-04
+// Licence : This source is under MIT License
+// File    : glm/gtc/quaternion.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <limits>
+
+namespace glm{
+namespace detail{
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T>::tquat() : 
+        x(0),
+        y(0),
+        z(0),
+        w(1)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T>::tquat
+	(
+		value_type const & s, 
+		tvec3<T> const & v
+	) : 
+        x(v.x),
+        y(v.y),
+        z(v.z),
+        w(s)
+    {}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T>::tquat
+	(
+		value_type const & w, 
+		value_type const & x, 
+		value_type const & y, 
+		value_type const & z
+	) :
+        x(x),
+        y(y),
+        z(z),
+        w(w)
+    {}
+
+    //////////////////////////////////////////////////////////////
+    // tquat conversions
+
+	//template <typename valType> 
+	//GLM_FUNC_QUALIFIER tquat<valType>::tquat
+	//(
+	//	valType const & pitch, 
+	//	valType const & yaw, 
+	//	valType const & roll
+	//)
+	//{
+	//	tvec3<valType> eulerAngle(pitch * valType(0.5), yaw * valType(0.5), roll * valType(0.5));
+	//	tvec3<valType> c = glm::cos(eulerAngle * valType(0.5));
+	//	tvec3<valType> s = glm::sin(eulerAngle * valType(0.5));
+	//	
+	//	this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+	//	this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+	//	this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+	//	this->z = c.x * c.y * s.z - s.x * s.y * c.z;
+	//}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER tquat<T>::tquat
+	(
+		tvec3<T> const & eulerAngle
+	)
+	{
+		tvec3<T> c = glm::cos(eulerAngle * value_type(0.5));
+		tvec3<T> s = glm::sin(eulerAngle * value_type(0.5));
+		
+		this->w = c.x * c.y * c.z + s.x * s.y * s.z;
+		this->x = s.x * c.y * c.z - c.x * s.y * s.z;
+		this->y = c.x * s.y * c.z + s.x * c.y * s.z;
+		this->z = c.x * c.y * s.z - s.x * s.y * c.z;		
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T>::tquat
+	(
+		tmat3x3<T> const & m
+	)
+    {
+		*this = toQuat(m);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T>::tquat
+	(
+		tmat4x4<T> const & m
+	)
+    {
+		*this = toQuat(m);
+    }
+
+    //////////////////////////////////////////////////////////////
+    // tquat<T> accesses
+
+    template <typename T> 
+	GLM_FUNC_QUALIFIER typename tquat<T>::value_type & tquat<T>::operator [] (int i)
+    {
+        return (&x)[i];
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename tquat<T>::value_type const & tquat<T>::operator [] (int i) const
+    {
+        return (&x)[i];
+    }
+
+    //////////////////////////////////////////////////////////////
+    // tquat<valType> operators
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T> & tquat<T>::operator *=
+	(
+		value_type const & s
+	)
+    {
+        this->w *= s;
+        this->x *= s;
+        this->y *= s;
+        this->z *= s;
+        return *this;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER tquat<T> & tquat<T>::operator /=
+	(
+		value_type const & s
+	)
+    {
+        this->w /= s;
+        this->x /= s;
+        this->y /= s;
+        this->z /= s;
+        return *this;
+    }
+
+    //////////////////////////////////////////////////////////////
+    // tquat<valType> external operators
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tquat<T> operator- 
+	(
+		detail::tquat<T> const & q
+	)
+	{
+		return detail::tquat<T>(-q.w, -q.x, -q.y, -q.z);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tquat<T> operator*
+	( 
+		detail::tquat<T> const & q, 
+		detail::tquat<T> const & p
+	) 
+	{ 
+        return detail::tquat<T>(
+            q.w * p.w - q.x * p.x - q.y * p.y - q.z * p.z,
+	        q.w * p.x + q.x * p.w + q.y * p.z - q.z * p.y,
+	        q.w * p.y + q.y * p.w + q.z * p.x - q.x * p.z,
+	        q.w * p.z + q.z * p.w + q.x * p.y - q.y * p.x);
+	} 
+
+	// Transformation
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> operator* 
+	(
+		detail::tquat<T> const & q, 
+		detail::tvec3<T> const & v
+	)
+	{
+		typename detail::tquat<T>::value_type Two(2);
+
+		detail::tvec3<T> uv, uuv;
+		detail::tvec3<T> QuatVector(q.x, q.y, q.z);
+		uv = glm::cross(QuatVector, v);
+		uuv = glm::cross(QuatVector, uv);
+		uv *= (Two * q.w); 
+		uuv *= Two; 
+
+		return v + uv + uuv;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> operator* 
+	(
+		detail::tvec3<T> const & v,
+		detail::tquat<T> const & q 
+	)
+	{
+		return gtc::quaternion::inverse(q) * v;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> operator* 
+	(
+		detail::tquat<T> const & q, 
+		detail::tvec4<T> const & v
+	)
+	{
+		return detail::tvec4<T>(q * detail::tvec3<T>(v), v.w);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> operator* 
+	(
+		detail::tvec4<T> const & v,
+		detail::tquat<T> const & q 
+	)
+	{
+		return gtc::quaternion::inverse(q) * v;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tquat<T> operator* 
+	(
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & s
+	)
+	{
+		return detail::tquat<T>(
+			q.w * s, q.x * s, q.y * s, q.z * s);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tquat<T> operator* 
+	(
+		typename detail::tquat<T>::value_type const & s,
+		detail::tquat<T> const & q
+	)
+	{
+		return q * s;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tquat<T> operator/ 
+	(
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & s
+	)
+	{
+		return detail::tquat<T>(
+			q.w / s, q.x / s, q.y / s, q.z / s);
+	}
+
+	//////////////////////////////////////
+	// Boolean operators
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator==
+	(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2
+	)
+	{
+		return (q1.x == q2.x) && (q1.y == q2.y) && (q1.z == q2.z) && (q1.w == q2.w);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER bool operator!=
+	(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2
+	)
+	{
+		return (q1.x != q2.x) || (q1.y != q2.y) || (q1.z != q2.z) || (q1.w != q2.w);
+	}
+
+}//namespace detail
+
+namespace gtc{
+namespace quaternion{
+
+	////////////////////////////////////////////////////////
+    template <typename T> 
+	GLM_FUNC_QUALIFIER typename detail::tquat<T>::value_type length
+	(
+		detail::tquat<T> const & q
+	)
+    {
+		return glm::sqrt(dot(q, q));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> normalize
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        typename detail::tquat<T>::value_type len = length(q);
+        if(len <= typename detail::tquat<T>::value_type(0)) // Problem
+            return detail::tquat<T>(1, 0, 0, 0);
+        typename detail::tquat<T>::value_type oneOverLen = typename detail::tquat<T>::value_type(1) / len;
+        return detail::tquat<T>(q.w * oneOverLen, q.x * oneOverLen, q.y * oneOverLen, q.z * oneOverLen);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER typename detail::tquat<T>::value_type dot
+	(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2
+	)
+    {
+        return q1.x * q2.x + q1.y * q2.y + q1.z * q2.z + q1.w * q2.w;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> cross
+	(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2
+	)
+    {
+        return detail::tquat<T>(
+            q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
+	        q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
+	        q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
+	        q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x);
+    }
+/*
+	// (x * sin(1 - a) * angle / sin(angle)) + (y * sin(a) * angle / sin(angle))
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tquat<T> mix
+	(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		typename detail::tquat<T>::value_type const & a
+	)
+    {
+        if(a <= typename detail::tquat<T>::value_type(0)) return x;
+        if(a >= typename detail::tquat<T>::value_type(1)) return y;
+
+        float fCos = dot(x, y);
+        detail::tquat<T> y2(y); //BUG!!! tquat<T> y2;
+        if(fCos < typename detail::tquat<T>::value_type(0))
+        {
+            y2 = -y;
+            fCos = -fCos;
+        }
+
+        //if(fCos > 1.0f) // problem
+        float k0, k1;
+        if(fCos > typename detail::tquat<T>::value_type(0.9999))
+        {
+            k0 = typename detail::tquat<T>::value_type(1) - a;
+            k1 = typename detail::tquat<T>::value_type(0) + a; //BUG!!! 1.0f + a;
+        }
+        else
+        {
+            typename detail::tquat<T>::value_type fSin = sqrt(T(1) - fCos * fCos);
+            typename detail::tquat<T>::value_type fAngle = atan(fSin, fCos);
+            typename detail::tquat<T>::value_type fOneOverSin = T(1) / fSin;
+            k0 = sin((typename detail::tquat<T>::value_type(1) - a) * fAngle) * fOneOverSin;
+            k1 = sin((typename detail::tquat<T>::value_type(0) + a) * fAngle) * fOneOverSin;
+        }
+
+        return detail::tquat<T>(
+            k0 * x.w + k1 * y2.w,
+            k0 * x.x + k1 * y2.x,
+            k0 * x.y + k1 * y2.y,
+            k0 * x.z + k1 * y2.z);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tquat<T> mix2
+	(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a
+	)
+    {
+        bool flip = false;
+		if(a <= T(0)) return x;
+        if(a >= T(1)) return y;
+
+        T cos_t = dot(x, y);
+		if(cos_t < T(0))
+		{
+			cos_t = -cos_t;
+			flip = true;
+		}
+
+		T alpha(0), beta(0);
+
+		if(T(1) - cos_t < 1e-7)
+			beta = T(1) - alpha;
+		else
+		{
+			T theta = acos(cos_t);
+			T sin_t = sin(theta);
+			beta = sin(theta * (T(1) - alpha)) / sin_t;
+			alpha = sin(alpha * theta) / sin_t;
+		}
+
+		if(flip)
+			alpha = -alpha;
+		
+        return normalize(beta * x + alpha * y);
+    }
+*/
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tquat<T> mix
+	(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a
+	)
+    {
+		T angle = acos(dot(x, y));
+		return (sin((1 - a) * angle) * x + sin(a * angle) * y) / sin(angle);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> conjugate
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        return detail::tquat<T>(q.w, -q.x, -q.y, -q.z);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> inverse
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        return gtc::quaternion::conjugate(q) / gtc::quaternion::dot(q, q);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> rotate
+	(
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & angle, 
+		detail::tvec3<T> const & v
+	)
+    {
+		detail::tvec3<T> Tmp = v;
+
+        // Axis of rotation must be normalised
+        typename detail::tquat<T>::value_type len = glm::core::function::geometric::length(Tmp);
+        if(abs(len - typename detail::tquat<T>::value_type(1)) > typename detail::tquat<T>::value_type(0.001))
+        {
+            T oneOverLen = T(1) / len;
+            Tmp.x *= oneOverLen;
+            Tmp.y *= oneOverLen;
+            Tmp.z *= oneOverLen;
+        }
+
+        typename detail::tquat<T>::value_type AngleRad = radians(angle);
+        typename detail::tquat<T>::value_type fSin = sin(AngleRad * T(0.5));
+
+        return gtc::quaternion::cross(q, detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> mat3_cast
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        detail::tmat3x3<T> Result(typename detail::tquat<T>::value_type(1));
+        Result[0][0] = 1 - 2 * q.y * q.y - 2 * q.z * q.z;
+        Result[0][1] = 2 * q.x * q.y + 2 * q.w * q.z;
+        Result[0][2] = 2 * q.x * q.z - 2 * q.w * q.y;
+
+        Result[1][0] = 2 * q.x * q.y - 2 * q.w * q.z;
+        Result[1][1] = 1 - 2 * q.x * q.x - 2 * q.z * q.z;
+        Result[1][2] = 2 * q.y * q.z + 2 * q.w * q.x;
+
+        Result[2][0] = 2 * q.x * q.z + 2 * q.w * q.y;
+        Result[2][1] = 2 * q.y * q.z - 2 * q.w * q.x;
+        Result[2][2] = 1 - 2 * q.x * q.x - 2 * q.y * q.y;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> mat4_cast
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        return detail::tmat4x4<T>(mat3_cast(q));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> quat_cast
+	(
+		detail::tmat3x3<T> const & m
+	)
+    {
+        typename detail::tquat<T>::value_type fourXSquaredMinus1 = m[0][0] - m[1][1] - m[2][2];
+        typename detail::tquat<T>::value_type fourYSquaredMinus1 = m[1][1] - m[0][0] - m[2][2];
+        typename detail::tquat<T>::value_type fourZSquaredMinus1 = m[2][2] - m[0][0] - m[1][1];
+        typename detail::tquat<T>::value_type fourWSquaredMinus1 = m[0][0] + m[1][1] + m[2][2];
+        
+        int biggestIndex = 0;
+        typename detail::tquat<T>::value_type fourBiggestSquaredMinus1 = fourWSquaredMinus1;
+        if(fourXSquaredMinus1 > fourBiggestSquaredMinus1)
+        {
+            fourBiggestSquaredMinus1 = fourXSquaredMinus1;
+            biggestIndex = 1;
+        }
+        if(fourYSquaredMinus1 > fourBiggestSquaredMinus1)
+        {
+            fourBiggestSquaredMinus1 = fourYSquaredMinus1;
+            biggestIndex = 2;
+        }
+        if(fourZSquaredMinus1 > fourBiggestSquaredMinus1)
+        {
+            fourBiggestSquaredMinus1 = fourZSquaredMinus1;
+            biggestIndex = 3;
+        }
+
+        typename detail::tquat<T>::value_type biggestVal = sqrt(fourBiggestSquaredMinus1 + typename detail::tquat<T>::value_type(1)) * typename detail::tquat<T>::value_type(0.5);
+        typename detail::tquat<T>::value_type mult = typename detail::tquat<T>::value_type(0.25) / biggestVal;
+
+        detail::tquat<T> Result;
+        switch(biggestIndex)
+        {
+        case 0:
+            Result.w = biggestVal; 
+            Result.x = (m[1][2] - m[2][1]) * mult;
+            Result.y = (m[2][0] - m[0][2]) * mult;
+            Result.z = (m[0][1] - m[1][0]) * mult;
+            break;
+        case 1:
+            Result.w = (m[1][2] - m[2][1]) * mult;
+            Result.x = biggestVal;
+            Result.y = (m[0][1] + m[1][0]) * mult;
+            Result.z = (m[2][0] + m[0][2]) * mult;
+            break;
+        case 2:
+            Result.w = (m[2][0] - m[0][2]) * mult;
+            Result.x = (m[0][1] + m[1][0]) * mult;
+            Result.y = biggestVal;
+            Result.z = (m[1][2] + m[2][1]) * mult;
+            break;
+        case 3:
+            Result.w = (m[0][1] - m[1][0]) * mult;
+            Result.x = (m[2][0] + m[0][2]) * mult;
+            Result.y = (m[1][2] + m[2][1]) * mult;
+            Result.z = biggestVal;
+            break;
+        }
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> quat_cast
+	(
+		detail::tmat4x4<T> const & m4
+	)
+    {
+		return quat_cast(detail::tmat3x3<T>(m4));
+    }
+
+}//namespace quaternion
+}//namespace gtc
+}//namespace glm
diff --git a/ExternalLibs/glm/gtc/swizzle.hpp b/ExternalLibs/glm/gtc/swizzle.hpp
new file mode 100644
index 0000000..bd4cfb8
--- /dev/null
+++ b/ExternalLibs/glm/gtc/swizzle.hpp
@@ -0,0 +1,354 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-02-20
+// Updated : 2010-02-20
+// Licence : This source is under MIT License
+// File    : glm/gtc/swizzle.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_swizzle
+#define glm_gtc_swizzle
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/type_precision.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_swizzle extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace swizzle ///< GLM_GTC_swizzle extension
+{
+	using namespace gtc::half_float;
+
+	template <typename T, template <typename> class vecType>
+	T const & swizzle(	
+		vecType<T> const & v,
+		comp x);
+
+	template <typename T, template <typename> class vecType>
+	detail::tvec2<T> const & swizzle(
+		vecType<T> const & v,
+		comp x, comp y);
+
+	template <typename T, template <typename> class vecType>
+	detail::tvec3<T> const & swizzle(
+		vecType<T> const & v,
+		comp x, comp y, comp z);
+
+	template <typename T, template <typename> class vecType>
+	detail::tvec4<T> const & swizzle(
+		vecType<T> const & v,
+		comp x, comp y, comp z, comp w);
+
+	template <typename T, template <typename> class vecType>
+	T & swizzle(
+		vecType<T> & v,
+		comp x);
+
+	template <typename T, template <typename> class vecType>
+	detail::tref2<T> swizzle(
+		vecType<T> & v,
+		comp x, comp y);
+
+	template <typename T, template <typename> class vecType>
+	detail::tref3<T> swizzle(
+		vecType<T> & v,
+		comp x, comp y, comp z);
+
+	template <typename T, template <typename> class vecType>
+	detail::tref4<T> swizzle(
+		vecType<T> & v,
+		comp x, comp y, comp z, comp w);
+
+#	define static_swizzle1_const(TYPE, SIZE)							\
+		template <comp x>										\
+		GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return v[x];}											
+																
+#	define static_swizzle1_ref(TYPE, SIZE)									\
+		template <comp x>													\
+		GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE> & v)		\
+		{return v[x];}
+
+	static_swizzle1_ref(detail::float16, 2)
+	static_swizzle1_ref(detail::float16, 3)
+	static_swizzle1_ref(detail::float16, 4)
+	static_swizzle1_ref(detail::float32, 2)
+	static_swizzle1_ref(detail::float32, 3)
+	static_swizzle1_ref(detail::float32, 4)
+	static_swizzle1_ref(detail::float64, 2)
+	static_swizzle1_ref(detail::float64, 3)
+	static_swizzle1_ref(detail::float64, 4)
+
+	static_swizzle1_ref(detail::int8,  2)
+	static_swizzle1_ref(detail::int8,  3)
+	static_swizzle1_ref(detail::int8,  4)
+	static_swizzle1_ref(detail::int16, 2)
+	static_swizzle1_ref(detail::int16, 3)
+	static_swizzle1_ref(detail::int16, 4)
+	static_swizzle1_ref(detail::int32, 2)
+	static_swizzle1_ref(detail::int32, 3)
+	static_swizzle1_ref(detail::int32, 4)
+	static_swizzle1_ref(detail::int64, 2)
+	static_swizzle1_ref(detail::int64, 3)
+	static_swizzle1_ref(detail::int64, 4)
+
+	static_swizzle1_ref(detail::uint8,  2)
+	static_swizzle1_ref(detail::uint8,  3)
+	static_swizzle1_ref(detail::uint8,  4)
+	static_swizzle1_ref(detail::uint16, 2)
+	static_swizzle1_ref(detail::uint16, 3)
+	static_swizzle1_ref(detail::uint16, 4)
+	static_swizzle1_ref(detail::uint32, 2)
+	static_swizzle1_ref(detail::uint32, 3)
+	static_swizzle1_ref(detail::uint32, 4)
+	static_swizzle1_ref(detail::uint64, 2)
+	static_swizzle1_ref(detail::uint64, 3)
+	static_swizzle1_ref(detail::uint64, 4)
+/*
+#	define static_swizzle2_const(TYPE) \
+		template <comp x, comp y> \
+		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
+		{return TYPE(v[x], v[y]);}
+
+#	define static_swizzle3_const(TYPE) \
+		template <comp x, comp y, comp z> \
+		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
+		{return TYPE(v[x], v[y], v[z]);}
+
+#	define static_swizzle4_const(TYPE) \
+		template <comp x, comp y, comp z, comp w> \
+		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
+		{return TYPE(v[x], v[y], v[z], v[w]);}
+*/
+
+#	define static_swizzle2_const(TYPE, SIZE)									\
+		template <comp x, comp y>												\
+		GLM_FUNC_QUALIFIER detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return detail::tvec2<TYPE>(v[x], v[y]);}
+
+#	define static_swizzle3_const(TYPE, SIZE)									\
+		template <comp x, comp y, comp z>										\
+		GLM_FUNC_QUALIFIER detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return detail::tvec3<TYPE>(v[x], v[y], v[z]);}
+
+#	define static_swizzle4_const(TYPE, SIZE)									\
+		template <comp x, comp y, comp z, comp w>								\
+		GLM_FUNC_QUALIFIER detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
+
+
+	static_swizzle2_const(glm::f16, 2)
+	static_swizzle2_const(glm::f16, 3)
+	static_swizzle2_const(glm::f16, 4)
+	static_swizzle2_const(glm::f32, 2)
+	static_swizzle2_const(glm::f32, 3)
+	static_swizzle2_const(glm::f32, 4)
+	static_swizzle2_const(glm::f64, 2)
+	static_swizzle2_const(glm::f64, 3)
+	static_swizzle2_const(glm::f64, 4)
+
+	static_swizzle2_const(glm::i8, 2)
+	static_swizzle2_const(glm::i8, 3)
+	static_swizzle2_const(glm::i8, 4)
+	static_swizzle2_const(glm::i16, 2)
+	static_swizzle2_const(glm::i16, 3)
+	static_swizzle2_const(glm::i16, 4)
+	static_swizzle2_const(glm::i32, 2)
+	static_swizzle2_const(glm::i32, 3)
+	static_swizzle2_const(glm::i32, 4)
+	static_swizzle2_const(glm::i64, 2)
+	static_swizzle2_const(glm::i64, 3)
+	static_swizzle2_const(glm::i64, 4)
+
+	static_swizzle2_const(glm::u8, 2)
+	static_swizzle2_const(glm::u8, 3)
+	static_swizzle2_const(glm::u8, 4)
+	static_swizzle2_const(glm::u16, 2)
+	static_swizzle2_const(glm::u16, 3)
+	static_swizzle2_const(glm::u16, 4)
+	static_swizzle2_const(glm::u32, 2)
+	static_swizzle2_const(glm::u32, 3)
+	static_swizzle2_const(glm::u32, 4)
+	static_swizzle2_const(glm::u64, 2)
+	static_swizzle2_const(glm::u64, 3)
+	static_swizzle2_const(glm::u64, 4)
+
+	static_swizzle3_const(glm::f16, 2)
+	static_swizzle3_const(glm::f16, 3)
+	static_swizzle3_const(glm::f16, 4)
+	static_swizzle3_const(glm::f32, 2)
+	static_swizzle3_const(glm::f32, 3)
+	static_swizzle3_const(glm::f32, 4)
+	static_swizzle3_const(glm::f64, 2)
+	static_swizzle3_const(glm::f64, 3)
+	static_swizzle3_const(glm::f64, 4)
+
+	static_swizzle3_const(glm::i8, 2)
+	static_swizzle3_const(glm::i8, 3)
+	static_swizzle3_const(glm::i8, 4)
+	static_swizzle3_const(glm::i16, 2)
+	static_swizzle3_const(glm::i16, 3)
+	static_swizzle3_const(glm::i16, 4)
+	static_swizzle3_const(glm::i32, 2)
+	static_swizzle3_const(glm::i32, 3)
+	static_swizzle3_const(glm::i32, 4)
+	static_swizzle3_const(glm::i64, 2)
+	static_swizzle3_const(glm::i64, 3)
+	static_swizzle3_const(glm::i64, 4)
+
+	static_swizzle3_const(glm::u8, 2)
+	static_swizzle3_const(glm::u8, 3)
+	static_swizzle3_const(glm::u8, 4)
+	static_swizzle3_const(glm::u16, 2)
+	static_swizzle3_const(glm::u16, 3)
+	static_swizzle3_const(glm::u16, 4)
+	static_swizzle3_const(glm::u32, 2)
+	static_swizzle3_const(glm::u32, 3)
+	static_swizzle3_const(glm::u32, 4)
+	static_swizzle3_const(glm::u64, 2)
+	static_swizzle3_const(glm::u64, 3)
+	static_swizzle3_const(glm::u64, 4)
+
+	static_swizzle4_const(glm::f16, 2)
+	static_swizzle4_const(glm::f16, 3)
+	static_swizzle4_const(glm::f16, 4)
+	static_swizzle4_const(glm::f32, 2)
+	static_swizzle4_const(glm::f32, 3)
+	static_swizzle4_const(glm::f32, 4)
+	static_swizzle4_const(glm::f64, 2)
+	static_swizzle4_const(glm::f64, 3)
+	static_swizzle4_const(glm::f64, 4)
+
+	static_swizzle4_const(glm::i8, 2)
+	static_swizzle4_const(glm::i8, 3)
+	static_swizzle4_const(glm::i8, 4)
+	static_swizzle4_const(glm::i16, 2)
+	static_swizzle4_const(glm::i16, 3)
+	static_swizzle4_const(glm::i16, 4)
+	static_swizzle4_const(glm::i32, 2)
+	static_swizzle4_const(glm::i32, 3)
+	static_swizzle4_const(glm::i32, 4)
+	static_swizzle4_const(glm::i64, 2)
+	static_swizzle4_const(glm::i64, 3)
+	static_swizzle4_const(glm::i64, 4)
+
+	static_swizzle4_const(glm::u8, 2)
+	static_swizzle4_const(glm::u8, 3)
+	static_swizzle4_const(glm::u8, 4)
+	static_swizzle4_const(glm::u16, 2)
+	static_swizzle4_const(glm::u16, 3)
+	static_swizzle4_const(glm::u16, 4)
+	static_swizzle4_const(glm::u32, 2)
+	static_swizzle4_const(glm::u32, 3)
+	static_swizzle4_const(glm::u32, 4)
+	static_swizzle4_const(glm::u64, 2)
+	static_swizzle4_const(glm::u64, 3)
+	static_swizzle4_const(glm::u64, 4)
+
+#	define static_swizzle2_ref(TYPE, SIZE) \
+		template <glm::comp x, glm::comp y> \
+		GLM_FUNC_QUALIFIER glm::detail::tref2<TYPE> swizzle(detail::tvec##SIZE<TYPE> & v) \
+		{return glm::detail::tref2<TYPE>(v[x], v[y]);}	
+
+#	define static_swizzle3_ref(TYPE, SIZE) \
+		template <glm::comp x, glm::comp y, glm::comp z> \
+		GLM_FUNC_QUALIFIER glm::detail::tref3<TYPE> swizzle(detail::tvec##SIZE<TYPE> & v) \
+		{return glm::detail::tref3<TYPE>(v[x], v[y], v[z]);}	
+
+#	define static_swizzle4_ref(TYPE, SIZE) \
+		template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
+		GLM_FUNC_QUALIFIER glm::detail::tref4<TYPE> swizzle(detail::tvec##SIZE<TYPE> & v) \
+		{return glm::detail::tref4<TYPE>(v[x], v[y], v[z], v[w]);}	
+
+	static_swizzle2_ref(glm::f16, 2)
+	static_swizzle2_ref(glm::f16, 3)
+	static_swizzle2_ref(glm::f16, 4)
+	static_swizzle2_ref(glm::f32, 2)
+	static_swizzle2_ref(glm::f32, 3)
+	static_swizzle2_ref(glm::f32, 4)
+	static_swizzle2_ref(glm::f64, 2)
+	static_swizzle2_ref(glm::f64, 3)
+	static_swizzle2_ref(glm::f64, 4)
+
+	static_swizzle2_ref(glm::i8, 2)
+	static_swizzle2_ref(glm::i8, 3)
+	static_swizzle2_ref(glm::i8, 4)
+	static_swizzle2_ref(glm::i16, 2)
+	static_swizzle2_ref(glm::i16, 3)
+	static_swizzle2_ref(glm::i16, 4)
+	static_swizzle2_ref(glm::i32, 2)
+	static_swizzle2_ref(glm::i32, 3)
+	static_swizzle2_ref(glm::i32, 4)
+	static_swizzle2_ref(glm::i64, 2)
+	static_swizzle2_ref(glm::i64, 3)
+	static_swizzle2_ref(glm::i64, 4)
+
+	static_swizzle2_ref(glm::u8, 2)
+	static_swizzle2_ref(glm::u8, 3)
+	static_swizzle2_ref(glm::u8, 4)
+	static_swizzle2_ref(glm::u16, 2)
+	static_swizzle2_ref(glm::u16, 3)
+	static_swizzle2_ref(glm::u16, 4)
+	static_swizzle2_ref(glm::u32, 2)
+	static_swizzle2_ref(glm::u32, 3)
+	static_swizzle2_ref(glm::u32, 4)
+	static_swizzle2_ref(glm::u64, 2)
+	static_swizzle2_ref(glm::u64, 3)
+	static_swizzle2_ref(glm::u64, 4)
+
+	static_swizzle3_ref(glm::f16, 3)
+	static_swizzle3_ref(glm::f16, 4)
+	static_swizzle3_ref(glm::f32, 3)
+	static_swizzle3_ref(glm::f32, 4)
+	static_swizzle3_ref(glm::f64, 3)
+	static_swizzle3_ref(glm::f64, 4)
+
+	static_swizzle3_ref(glm::i8, 3)
+	static_swizzle3_ref(glm::i8, 4)
+	static_swizzle3_ref(glm::i16, 3)
+	static_swizzle3_ref(glm::i16, 4)
+	static_swizzle3_ref(glm::i32, 3)
+	static_swizzle3_ref(glm::i32, 4)
+	static_swizzle3_ref(glm::i64, 3)
+	static_swizzle3_ref(glm::i64, 4)
+
+	static_swizzle3_ref(glm::u8, 3)
+	static_swizzle3_ref(glm::u8, 4)
+	static_swizzle3_ref(glm::u16, 3)
+	static_swizzle3_ref(glm::u16, 4)
+	static_swizzle3_ref(glm::u32, 3)
+	static_swizzle3_ref(glm::u32, 4)
+	static_swizzle3_ref(glm::u64, 3)
+	static_swizzle3_ref(glm::u64, 4)
+
+	static_swizzle4_ref(glm::f16, 4)
+	static_swizzle4_ref(glm::f32, 4)
+	static_swizzle4_ref(glm::f64, 4)
+
+	static_swizzle4_ref(glm::i8, 4)
+	static_swizzle4_ref(glm::i16, 4)
+	static_swizzle4_ref(glm::i32, 4)
+	static_swizzle4_ref(glm::i64, 4)
+
+	static_swizzle4_ref(glm::u8, 4)
+	static_swizzle4_ref(glm::u16, 4)
+	static_swizzle4_ref(glm::u32, 4)
+	static_swizzle4_ref(glm::u64, 4)
+
+}//namespace swizzle
+}//namespace gtc
+}//namespace glm
+
+#include "swizzle.inl"
+
+namespace glm{using namespace gtc::swizzle;}
+
+#endif//glm_gtc_swizzle
diff --git a/ExternalLibs/glm/gtc/swizzle.inl b/ExternalLibs/glm/gtc/swizzle.inl
new file mode 100644
index 0000000..9e5f789
--- /dev/null
+++ b/ExternalLibs/glm/gtc/swizzle.inl
@@ -0,0 +1,177 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-01-15
+// Updated : 2011-01-15
+// Licence : This source is under MIT License
+// File    : glm/gtc/swizzle.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtc{
+namespace swizzle{
+
+template <typename T, template <typename> class vecType>
+GLM_FUNC_QUALIFIER T swizzle
+(	
+	vecType<T> const & v,
+	comp x
+)
+{
+	assert(int(x) < int(vecType<T>::value_size));
+	return v[x];
+}
+
+template <typename T, template <typename> class vecType>
+GLM_FUNC_QUALIFIER detail::tvec2<T> swizzle
+(
+	vecType<T> const & v,
+	comp x, comp y
+)
+{
+	return detail::tvec2<T>(
+		v[x],
+		v[y]);
+}
+
+template <typename T, template <typename> class vecType>
+GLM_FUNC_QUALIFIER detail::tvec3<T> swizzle
+(
+	vecType<T> const & v,
+	comp x, comp y, comp z
+)
+{
+	return detail::tvec3<T>(
+		v[x],
+		v[y],
+		v[z]);
+}
+
+template <typename T, template <typename> class vecType>
+GLM_FUNC_QUALIFIER detail::tvec4<T> swizzle
+(
+	vecType<T> const & v,
+	comp x, comp y, comp z, comp w
+)
+{
+	return detail::tvec4<T>(v[x], v[y],	v[z], v[w]);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T& swizzle
+(
+	detail::tvec4<T> & v,
+	comp x
+)
+{
+	return v[x];
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tref2<T> swizzle
+(
+	detail::tvec4<T> & v,
+	comp x, comp y
+)
+{
+	return detail::tref2<T>(v[x], v[y]);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tref3<T> swizzle
+(
+	detail::tvec4<T> & v,
+	comp x, comp y, comp z
+)
+{
+	return detail::tref3<T>(v[x], v[y],	v[z]);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tref4<T> swizzle
+(
+	detail::tvec4<T> & v,
+	comp x, comp y, comp z, comp w
+)
+{
+	return detail::tref4<T>(v[x], v[y],	v[z], v[w]);
+}
+/*
+template <comp x>
+GLM_FUNC_QUALIFIER float& swizzle
+(
+	detail::tvec4<float> & v
+)
+{
+	return v[x];
+}
+
+template <comp x>
+GLM_FUNC_QUALIFIER int& swizzle
+(
+	detail::tvec4<int> & v
+)
+{
+	return v[x];
+}
+
+template <comp x, comp y>
+GLM_FUNC_QUALIFIER detail::tref2<float> swizzle
+(
+	detail::tvec4<float> & v
+)
+{
+	return detail::tref2<float>(v[x], v[y]);
+}
+
+template <comp x, comp y>
+GLM_FUNC_QUALIFIER detail::tref2<int> swizzle
+(
+	detail::tvec4<int> & v
+)
+{
+	return detail::tref2<int>(v[x], v[y]);
+}
+
+template <comp x, comp y, comp z>
+GLM_FUNC_QUALIFIER detail::tref3<float> swizzle
+(
+	detail::tvec4<float> & v
+)
+{
+	return detail::tref3<float>(v[x], v[y],	v[z]);
+}
+	
+template <comp x, comp y, comp z>
+GLM_FUNC_QUALIFIER detail::tref3<int> swizzle
+(
+	detail::tvec4<int> & v
+)
+{
+	return detail::tref3<int>(v[x], v[y], v[z]);
+}
+
+template <comp x, comp y, comp z, comp w>
+GLM_FUNC_QUALIFIER detail::tref4<float> swizzle
+(
+	detail::tvec4<float> & v
+)
+{
+	return detail::tref4<float>(v[x], v[y],	v[z], v[w]);
+}
+
+template <comp x, comp y, comp z, comp w>
+GLM_FUNC_QUALIFIER detail::tref4<int> swizzle
+(
+	detail::tvec4<int> & v
+)
+{
+	return detail::tref4<int>(v[x], v[y],	v[z], v[w]);
+}
+*/
+}//namespace swizzle
+}//namespace gtc
+}//namespace glm
diff --git a/ExternalLibs/glm/gtc/type_precision.hpp b/ExternalLibs/glm/gtc/type_precision.hpp
new file mode 100644
index 0000000..a817ed5
--- /dev/null
+++ b/ExternalLibs/glm/gtc/type_precision.hpp
@@ -0,0 +1,220 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-04
+// Updated : 2009-06-04
+// Licence : This source is under MIT License
+// File    : glm/gtc/type_precision.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half
+// - GLM_GTC_quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_type_precision
+#define glm_gtc_type_precision
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+#include "../gtc/quaternion.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_type_precision extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace type_precision ///< GLM_GTC_type_precision extension: Defined types with specific size.
+{
+	///////////////////////////
+	// Dependences
+
+	using namespace gtc::half_float;
+	using namespace gtc::quaternion;
+
+	///////////////////////////
+	// Signed int vector types 
+
+	/// \addtogroup gtc_type_precision
+	///@{
+
+	typedef detail::int8						int8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int16						int16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int32						int32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int64						int64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
+
+	typedef int8								i8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef int16								i16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef int32								i32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef int64								i64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
+
+	//typedef i8									i8vec1;		//!< \brief 8bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i8>					i8vec2;     //!< \brief 8bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i8>					i8vec3;     //!< \brief 8bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i8>					i8vec4;     //!< \brief 8bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef i16									i16vec1;	//!< \brief 16bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i16>					i16vec2;    //!< \brief 16bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i16>					i16vec3;    //!< \brief 16bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i16>					i16vec4;    //!< \brief 16bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef i32									i32vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i32>					i32vec2;    //!< \brief 32bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i32>					i32vec3;    //!< \brief 32bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i32>					i32vec4;    //!< \brief 32bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef i64									i64vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i64>					i64vec2;    //!< \brief 64bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i64>					i64vec3;    //!< \brief 64bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i64>					i64vec4;    //!< \brief 64bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	/////////////////////////////
+	// Unsigned int vector types 
+
+	typedef detail::uint8						uint8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint16						uint16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint32						uint32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint64						uint64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
+
+	typedef uint8								u8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef uint16								u16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef uint32								u32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef uint64								u64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
+
+	//typedef u8									u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u8>					u8vec2;     //!< \brief 8bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u8>					u8vec3;     //!< \brief 8bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u8>					u8vec4;     //!< \brief 8bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef u16									u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u16>					u16vec2;    //!< \brief 16bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u16>					u16vec3;    //!< \brief 16bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u16>					u16vec4;    //!< \brief 16bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef u32									u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u32>					u32vec2;    //!< \brief 32bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u32>					u32vec3;    //!< \brief 32bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u32>					u32vec4;    //!< \brief 32bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef u64									u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u64>					u64vec2;    //!< \brief 64bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u64>					u64vec3;    //!< \brief 64bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u64>					u64vec4;    //!< \brief 64bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//////////////////////
+	// Float vector types 
+
+	typedef detail::float16						float16;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float32						float32;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float64						float64;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+
+	typedef float16								f16;        //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef float32								f32;        //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef float64								f64;        //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+
+	typedef detail::tvec2<float>				fvec2;		//!<  Vector of 2 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<float>				fvec3;		//!<  Vector of 3 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<float>				fvec4;		//!<  Vector of 4 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
+
+	//typedef f16									f16vec1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<f16>					f16vec2;    //!< \brief Half-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<f16>					f16vec3;    //!< \brief Half-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<f16>					f16vec4;    //!< \brief Half-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									f32vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<f32>					f32vec2;    //!< \brief Single-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<f32>					f32vec3;    //!< \brief Single-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<f32>					f32vec4;    //!< \brief Single-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef f64									f64vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<f64>					f64vec2;    //!< \brief Double-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<f64>					f64vec3;    //!< \brief Double-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<f64>					f64vec4;    //!< \brief Double-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//////////////////////
+	// Float matrix types 
+
+	//typedef f32									fmat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				fmat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				fmat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				fmat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									fmat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				fmat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f32>				fmat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f32>				fmat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f32>				fmat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				fmat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f32>				fmat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f32>				fmat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f32>				fmat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				fmat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f16									f16mat1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f16>				f16mat2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f16>				f16mat3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f16>				f16mat4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f16									f16mat1x1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f16>				f16mat2x2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f16>				f16mat2x3;	//!< \brief Half-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f16>				f16mat2x4;	//!< \brief Half-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f16>				f16mat3x2;	//!< \brief Half-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f16>				f16mat3x3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f16>				f16mat3x4;	//!< \brief Half-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f16>				f16mat4x2;	//!< \brief Half-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f16>				f16mat4x3;	//!< \brief Half-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f16>				f16mat4x4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									f32mat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				f32mat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				f32mat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				f32mat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									f32mat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				f32mat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f32>				f32mat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f32>				f32mat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f32>				f32mat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				f32mat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f32>				f32mat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f32>				f32mat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f32>				f32mat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				f32mat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f64									f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f64>				f64mat2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f64>				f64mat3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f64>				f64mat4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f64									f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f64>				f64mat2x2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f64>				f64mat2x3;	//!< \brief Double-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f64>				f64mat2x4;	//!< \brief Double-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f64>				f64mat3x2;	//!< \brief Double-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f64>				f64mat3x3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f64>				f64mat3x4;	//!< \brief Double-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f64>				f64mat4x2;	//!< \brief Double-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f64>				f64mat4x3;	//!< \brief Double-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f64>				f64mat4x4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//////////////////////////
+	// Float quaternion types 
+
+	typedef detail::tquat<f16>					f16quat;    //!< \brief Half-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	typedef detail::tquat<f32>					f32quat;    //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+
+	///@}
+
+}//namespace type_precision
+}//namespace gtc
+}//namespace glm
+
+#include "type_precision.inl"
+
+namespace glm{using namespace gtc::type_precision;}
+
+#endif//glm_gtc_type_precision
diff --git a/ExternalLibs/glm/gtc/type_precision.inl b/ExternalLibs/glm/gtc/type_precision.inl
new file mode 100644
index 0000000..8eb1ba2
--- /dev/null
+++ b/ExternalLibs/glm/gtc/type_precision.inl
@@ -0,0 +1,13 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-06-14
+// Updated : 2009-06-14
+// Licence : This source is under MIT License
+// File    : glm/gtc/type_precision.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+
+}
diff --git a/ExternalLibs/glm/gtc/type_ptr.hpp b/ExternalLibs/glm/gtc/type_ptr.hpp
new file mode 100644
index 0000000..85f18f3
--- /dev/null
+++ b/ExternalLibs/glm/gtc/type_ptr.hpp
@@ -0,0 +1,449 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-06
+// Updated : 2010-04-30
+// Licence : This source is under MIT License
+// File    : glm/gtc/type_ptr.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtc_type_ptr
+#define glm_gtc_type_ptr
+
+// Dependency:
+#include "../glm.hpp"
+#include <cstring>
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTC_type_ptr extension included")
+#endif
+
+namespace glm{
+namespace gtc{
+namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
+{ 
+
+	/// \addtogroup gtc_type_ptr
+	///@{
+
+	//! Get the const address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tvec2<T> const & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tvec2<T> & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the const address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tvec3<T> const & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tvec3<T> & vec
+	)
+	{
+		return &(vec.x);
+	}
+		
+	//! Get the const address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(	
+		detail::tvec4<T> const & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(	
+		detail::tvec4<T> & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat2x2<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat2x2<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat3x3<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat3x3<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat4x4<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat4x4<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat2x3<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat2x3<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat3x2<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat3x2<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat2x4<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat2x4<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat4x2<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(	
+		detail::tmat4x2<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat3x4<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat3x4<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+		
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat4x3<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Build a vector from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
+	{
+		detail::tvec2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
+		return Result;
+	}
+
+	//! Build a vector from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
+	{
+		detail::tvec3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
+		return Result;
+	}
+
+	//! Build a vector from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
+	{
+		detail::tvec4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
+		return Result;
+	}
+
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
+	{
+		detail::tmat2x2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
+	{
+		detail::tmat2x3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
+	{
+		detail::tmat2x4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
+	{
+		detail::tmat3x2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
+	{
+		detail::tmat3x3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
+		return Result;
+	}
+
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
+	{
+		detail::tmat3x4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
+		return Result;
+	}
+
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
+	{
+		detail::tmat4x2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
+	{
+		detail::tmat4x3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
+	{
+		detail::tmat4x4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
+		return Result;
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
+	{
+		return make_mat2x2(ptr);
+	}
+        
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
+	{
+		return make_mat3x3(ptr);
+	}
+		
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
+	{
+		return make_mat4x4(ptr);
+	}
+        
+	///@}
+
+}//namespace type_ptr
+}//namespace gtc
+}//namespace glm
+
+#include "type_ptr.inl"
+
+namespace glm{using namespace gtc::type_ptr;}
+
+#endif//glm_gtx_type_ptr
+
diff --git a/ExternalLibs/glm/gtc/type_ptr.inl b/ExternalLibs/glm/gtc/type_ptr.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/gtx/associated_min_max.hpp b/ExternalLibs/glm/gtx/associated_min_max.hpp
new file mode 100644
index 0000000..7b8eafc
--- /dev/null
+++ b/ExternalLibs/glm/gtx/associated_min_max.hpp
@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-03-10
+// Updated : 2008-03-15
+// Licence : This source is under MIT License
+// File    : gtx_associated_min_max.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_extented_min_max
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_associated_min_max
+#define glm_gtx_associated_min_max
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_associated_min_max extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
+{
+	/// \addtogroup gtx_associated_min_max
+	///@{
+
+	//! \brief Min comparison between 2 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMin(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b);
+
+	//! \brief Min comparison between 3 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMin(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c);
+
+	//! \brief Min comparison between 4 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMin(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c, 
+		const genTypeT& w, const genTypeU& d);
+
+	//! \brief Max comparison between 2 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMax(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b);
+
+	//! \brief Max comparison between 3 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMax(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c);
+
+	//! \brief Max comparison between 4 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMax(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c, 
+		const genTypeT& w, const genTypeU& d);
+
+	///@}
+} //namespace associated_min_max
+} //namespace gtx
+} //namespace glm
+
+#include "associated_min_max.inl"
+
+namespace glm{using namespace gtx::associated_min_max;}
+
+#endif//glm_gtx_associated_min_max
diff --git a/ExternalLibs/glm/gtx/associated_min_max.inl b/ExternalLibs/glm/gtx/associated_min_max.inl
new file mode 100644
index 0000000..88ea5da
--- /dev/null
+++ b/ExternalLibs/glm/gtx/associated_min_max.inl
@@ -0,0 +1,916 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-03-10
+// Updated : 2008-03-15
+// Licence : This source is under MIT License
+// File    : gtx_associated_min_max.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace associated_min_max{
+
+	// Min comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
+	{
+		return x < y ? a : b;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+		const detail::tvec2<T>& y, const detail::tvec2<U>& b
+	)
+	{
+		detail::tvec2<U> Result;
+		//Result.x = x[0] < y[0] ? a[0] : b[0];
+		//Result.y = x[1] < y[1] ? a[1] : b[1];
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x[i] < y[i] ? a[i] : b[i];
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+		const detail::tvec3<T>& y, const detail::tvec3<U>& b
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x[i] < y[i] ? a[i] : b[i];
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+		const detail::tvec4<T>& y, const detail::tvec4<U>& b
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x[i] < y[i] ? a[i] : b[i];
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		T x, const detail::tvec2<U>& a,
+		T y, const detail::tvec2<U>& b
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x < y ? a[i] : b[i];
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		T x, const detail::tvec3<U>& a,
+		T y, const detail::tvec3<U>& b
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x < y ? a[i] : b[i];
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		T x, const detail::tvec4<U>& a,
+		T y, const detail::tvec4<U>& b
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x < y ? a[i] : b[i];
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		const detail::tvec2<T>& x, U a,
+		const detail::tvec2<T>& y, U b
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = x[i] < y[i] ? a : b;
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		const detail::tvec3<T>& x, U a,
+		const detail::tvec3<T>& y, U b
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = x[i] < y[i] ? a : b;
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		const detail::tvec4<T>& x, U a,
+		const detail::tvec4<T>& y, U b
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = x[i] < y[i] ? a : b;
+		return Result;
+	}
+
+	// Min comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER U associatedMin
+	(
+		T x, U a,
+		T y, U b,
+		T z, U c
+	)
+	{
+		U Result = x < y ? (x < z ? a : c) : (y < z ? b : c);
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+		const detail::tvec2<T>& z, const detail::tvec2<U>& c
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+		const detail::tvec3<T>& z, const detail::tvec3<U>& c
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+		return Result;
+	}
+
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+		const detail::tvec4<T>& z, const detail::tvec4<U>& c
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER U associatedMin
+	(
+		T x, U a,
+		T y, U b,
+		T z, U c,
+		T w, U d
+	)
+	{
+		T Test1 = min(x, y);
+		T Test2 = min(z, w);;
+		U Result1 = x < y ? a : b;
+		U Result2 = z < w ? c : d;
+		U Result = Test1 < Test2 ? Result1 : Result2;
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+		const detail::tvec2<T>& z, const detail::tvec2<U>& c,
+		const detail::tvec2<T>& w, const detail::tvec2<U>& d
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		{
+			T Test1 = min(x[i], y[i]);
+			T Test2 = min(z[i], w[i]);
+			U Result1 = x[i] < y[i] ? a[i] : b[i];
+			U Result2 = z[i] < w[i] ? c[i] : d[i];
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+		const detail::tvec3<T>& z, const detail::tvec3<U>& c,
+		const detail::tvec3<T>& w, const detail::tvec3<U>& d
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		{
+			T Test1 = min(x[i], y[i]);
+			T Test2 = min(z[i], w[i]);
+			U Result1 = x[i] < y[i] ? a[i] : b[i];
+			U Result2 = z[i] < w[i] ? c[i] : d[i];
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+		const detail::tvec4<T>& z, const detail::tvec4<U>& c,
+		const detail::tvec4<T>& w, const detail::tvec4<U>& d
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		{
+			T Test1 = min(x[i], y[i]);
+			T Test2 = min(z[i], w[i]);
+			U Result1 = x[i] < y[i] ? a[i] : b[i];
+			U Result2 = z[i] < w[i] ? c[i] : d[i];
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		T x, const detail::tvec2<U>& a,
+		T y, const detail::tvec2<U>& b,
+		T z, const detail::tvec2<U>& c,
+		T w, const detail::tvec2<U>& d
+	)
+	{
+		T Test1 = min(x, y);
+		T Test2 = min(z, w);
+
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		{
+			U Result1 = x < y ? a[i] : b[i];
+			U Result2 = z < w ? c[i] : d[i];
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		T x, const detail::tvec3<U>& a,
+		T y, const detail::tvec3<U>& b,
+		T z, const detail::tvec3<U>& c,
+		T w, const detail::tvec3<U>& d
+	)
+	{
+		T Test1 = min(x, y);
+		T Test2 = min(z, w);
+
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		{
+			U Result1 = x < y ? a[i] : b[i];
+			U Result2 = z < w ? c[i] : d[i];
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		T x, const detail::tvec4<U>& a,
+		T y, const detail::tvec4<U>& b,
+		T z, const detail::tvec4<U>& c,
+		T w, const detail::tvec4<U>& d
+	)
+	{
+		T Test1 = min(x, y);
+		T Test2 = min(z, w);
+
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		{
+			U Result1 = x < y ? a[i] : b[i];
+			U Result2 = z < w ? c[i] : d[i];
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+	(
+		const detail::tvec2<T>& x, U a,
+		const detail::tvec2<T>& y, U b,
+		const detail::tvec2<T>& z, U c,
+		const detail::tvec2<T>& w, U d
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		{
+			T Test1 = min(x[i], y[i]);
+			T Test2 = min(z[i], w[i]);;
+			U Result1 = x[i] < y[i] ? a : b;
+			U Result2 = z[i] < w[i] ? c : d;
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+	(
+		const detail::tvec3<T>& x, U a,
+		const detail::tvec3<T>& y, U b,
+		const detail::tvec3<T>& z, U c,
+		const detail::tvec3<T>& w, U d
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		{
+			T Test1 = min(x[i], y[i]);
+			T Test2 = min(z[i], w[i]);;
+			U Result1 = x[i] < y[i] ? a : b;
+			U Result2 = z[i] < w[i] ? c : d;
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Min comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+	(
+		const detail::tvec4<T>& x, U a,
+		const detail::tvec4<T>& y, U b,
+		const detail::tvec4<T>& z, U c,
+		const detail::tvec4<T>& w, U d
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		{
+			T Test1 = min(x[i], y[i]);
+			T Test2 = min(z[i], w[i]);;
+			U Result1 = x[i] < y[i] ? a : b;
+			U Result2 = z[i] < w[i] ? c : d;
+			Result[i] = Test1 < Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
+	{
+		return x > y ? a : b;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+		const detail::tvec2<T>& y, const detail::tvec2<U>& b
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x[i] > y[i] ? a[i] : b[i];
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+		const detail::tvec3<T>& y, const detail::tvec3<U>& b
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x[i] > y[i] ? a[i] : b[i];
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+		const detail::tvec4<T>& y, const detail::tvec4<U>& b
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x[i] > y[i] ? a[i] : b[i];
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		T x, const detail::tvec2<U>& a,
+		T y, const detail::tvec2<U>& b
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x > y ? a[i] : b[i];
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		T x, const detail::tvec3<U>& a,
+		T y, const detail::tvec3<U>& b
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x > y ? a[i] : b[i];
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		T x, const detail::tvec4<U>& a,
+		T y, const detail::tvec4<U>& b
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x > y ? a[i] : b[i];
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		const detail::tvec2<T>& x, U a,
+		const detail::tvec2<T>& y, U b
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = x[i] > y[i] ? a : b;
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		const detail::tvec3<T>& x, U a,
+		const detail::tvec3<T>& y, U b
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = x[i] > y[i] ? a : b;
+		return Result;
+	}
+
+	// Max comparison between 2 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		const detail::tvec4<T>& x, U a,
+		const detail::tvec4<T>& y, U b
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = x[i] > y[i] ? a : b;
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER U associatedMax
+	(
+		T x, U a,
+		T y, U b,
+		T z, U c
+	)
+	{
+		U Result = x > y ? (x > z ? a : c) : (y > z ? b : c);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+		const detail::tvec2<T>& z, const detail::tvec2<U>& c
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+		const detail::tvec3<T>& z, const detail::tvec3<U>& c
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+		const detail::tvec4<T>& z, const detail::tvec4<U>& c
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		T x, const detail::tvec2<U>& a,
+		T y, const detail::tvec2<U>& b,
+		T z, const detail::tvec2<U>& c
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+			Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		T x, const detail::tvec3<U>& a,
+		T y, const detail::tvec3<U>& b,
+		T z, const detail::tvec3<U>& c
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+			Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		T x, const detail::tvec4<U>& a,
+		T y, const detail::tvec4<U>& b,
+		T z, const detail::tvec4<U>& c
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+			Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		const detail::tvec2<T>& x, U a,
+		const detail::tvec2<T>& y, U b,
+		const detail::tvec2<T>& z, U c
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		const detail::tvec3<T>& x, U a,
+		const detail::tvec3<T>& y, U b,
+		const detail::tvec3<T>& z, U c
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+		return Result;
+	}
+
+	// Max comparison between 3 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		const detail::tvec4<T>& x, U a,
+		const detail::tvec4<T>& y, U b,
+		const detail::tvec4<T>& z, U c
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER U associatedMax
+	(
+		T x, U a,
+		T y, U b,
+		T z, U c,
+		T w, U d
+	)
+	{
+		T Test1 = max(x, y);
+		T Test2 = max(z, w);;
+		U Result1 = x > y ? a : b;
+		U Result2 = z > w ? c : d;
+		U Result = Test1 > Test2 ? Result1 : Result2;
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+		const detail::tvec2<T>& z, const detail::tvec2<U>& c,
+		const detail::tvec2<T>& w, const detail::tvec2<U>& d
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		{
+			T Test1 = max(x[i], y[i]);
+			T Test2 = max(z[i], w[i]);
+			U Result1 = x[i] > y[i] ? a[i] : b[i];
+			U Result2 = z[i] > w[i] ? c[i] : d[i];
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+		const detail::tvec3<T>& z, const detail::tvec3<U>& c,
+		const detail::tvec3<T>& w, const detail::tvec3<U>& d
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		{
+			T Test1 = max(x[i], y[i]);
+			T Test2 = max(z[i], w[i]);
+			U Result1 = x[i] > y[i] ? a[i] : b[i];
+			U Result2 = z[i] > w[i] ? c[i] : d[i];
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+		const detail::tvec4<T>& z, const detail::tvec4<U>& c,
+		const detail::tvec4<T>& w, const detail::tvec4<U>& d
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		{
+			T Test1 = max(x[i], y[i]);
+			T Test2 = max(z[i], w[i]);
+			U Result1 = x[i] > y[i] ? a[i] : b[i];
+			U Result2 = z[i] > w[i] ? c[i] : d[i];
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		T x, const detail::tvec2<U>& a,
+		T y, const detail::tvec2<U>& b,
+		T z, const detail::tvec2<U>& c,
+		T w, const detail::tvec2<U>& d
+	)
+	{
+		T Test1 = max(x, y);
+		T Test2 = max(z, w);
+
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		{
+			U Result1 = x > y ? a[i] : b[i];
+			U Result2 = z > w ? c[i] : d[i];
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		T x, const detail::tvec3<U>& a,
+		T y, const detail::tvec3<U>& b,
+		T z, const detail::tvec3<U>& c,
+		T w, const detail::tvec3<U>& d
+	)
+	{
+		T Test1 = max(x, y);
+		T Test2 = max(z, w);
+
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		{
+			U Result1 = x > y ? a[i] : b[i];
+			U Result2 = z > w ? c[i] : d[i];
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		T x, const detail::tvec4<U>& a,
+		T y, const detail::tvec4<U>& b,
+		T z, const detail::tvec4<U>& c,
+		T w, const detail::tvec4<U>& d
+	)
+	{
+		T Test1 = max(x, y);
+		T Test2 = max(z, w);
+
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		{
+			U Result1 = x > y ? a[i] : b[i];
+			U Result2 = z > w ? c[i] : d[i];
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+	(
+		const detail::tvec2<T>& x, U a,
+		const detail::tvec2<T>& y, U b,
+		const detail::tvec2<T>& z, U c,
+		const detail::tvec2<T>& w, U d
+	)
+	{
+		detail::tvec2<U> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		{
+			T Test1 = max(x[i], y[i]);
+			T Test2 = max(z[i], w[i]);;
+			U Result1 = x[i] > y[i] ? a : b;
+			U Result2 = z[i] > w[i] ? c : d;
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+	(
+		const detail::tvec3<T>& x, U a,
+		const detail::tvec3<T>& y, U b,
+		const detail::tvec3<T>& z, U c,
+		const detail::tvec3<T>& w, U d
+	)
+	{
+		detail::tvec3<U> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		{
+			T Test1 = max(x[i], y[i]);
+			T Test2 = max(z[i], w[i]);;
+			U Result1 = x[i] > y[i] ? a : b;
+			U Result2 = z[i] > w[i] ? c : d;
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+	// Max comparison between 4 variables
+	template<typename T, typename U>
+	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+	(
+		const detail::tvec4<T>& x, U a,
+		const detail::tvec4<T>& y, U b,
+		const detail::tvec4<T>& z, U c,
+		const detail::tvec4<T>& w, U d
+	)
+	{
+		detail::tvec4<U> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		{
+			T Test1 = max(x[i], y[i]);
+			T Test2 = max(z[i], w[i]);;
+			U Result1 = x[i] > y[i] ? a : b;
+			U Result2 = z[i] > w[i] ? c : d;
+			Result[i] = Test1 > Test2 ? Result1 : Result2;
+		}
+		return Result;
+	}
+
+}//namespace associated_min_max
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/bit.hpp b/ExternalLibs/glm/gtx/bit.hpp
new file mode 100644
index 0000000..c84efa7
--- /dev/null
+++ b/ExternalLibs/glm/gtx/bit.hpp
@@ -0,0 +1,107 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-14
+// Updated : 2008-11-14
+// Licence : This source is under MIT License
+// File    : glm/gtx/bit.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_bit
+#define glm_gtx_bit
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_bit extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
+{
+	using namespace gtc::half_float;
+
+	/// \addtogroup gtx_bit
+	///@{
+
+	//! Build a mask of 'count' bits
+	//! From GLM_GTX_bit extension.
+	template <typename genIType>
+	genIType mask(genIType const & count);
+
+	//! Component wise extraction of bit fields.
+	//! genType and genIType could be a scalar or a vector.
+	//! From GLM_GTX_bit extension.
+	template <typename genIUType, typename sizeType>
+	genIUType extractField(
+		genIUType const & v, 
+		sizeType const & first, 
+		sizeType const & count);
+
+	//! Find the lowest bit set to 1 in a integer variable.
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	int lowestBit(genType const & value);
+
+	//! Find the highest bit set to 1 in a integer variable.
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	int highestBit(genType const & value);
+
+	//! Find the highest bit set to 1 in a integer variable and return its value. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType highestBitValue(genType const & value);
+
+	//! Return true if the value is a power of two number. 
+	//! From GLM_GTX_bit extension. 
+	template <typename genType> 
+	bool isPowerOfTwo(genType const & value);
+
+	//! Return the power of two number which value is just higher the input value.
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType powerOfTwoAbove(genType const & value);
+
+	//! Return the power of two number which value is just lower the input value. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType powerOfTwoBelow(genType const & value);
+
+	//! Return the power of two number which value is the closet to the input value. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType powerOfTwoNearest(genType const & value);
+
+	//! Revert all bits of any integer based type. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType bitRevert(genType const & value);
+
+	//! Rotate all bits to the right.
+	//! From GLM_GTX_bit extension.
+	template <typename genType>
+	genType bitRotateRight(genType const & In, std::size_t Shift);
+
+	//! Rotate all bits to the left.
+	//! From GLM_GTX_bit extension.
+	template <typename genType>
+	genType bitRotateLeft(genType const & In, std::size_t Shift);
+
+	///@}
+}//namespace bit
+}//namespace gtx
+}//namespace glm
+
+#include "bit.inl"
+
+namespace glm{using namespace gtx::bit;}
+
+#endif//glm_gtx_bit
diff --git a/ExternalLibs/glm/gtx/bit.inl b/ExternalLibs/glm/gtx/bit.inl
new file mode 100644
index 0000000..5c3ec8e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/bit.inl
@@ -0,0 +1,743 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-14
+// Updated : 2008-11-14
+// Licence : This source is under MIT License
+// File    : glm/gtx/bit.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "../core/_detail.hpp"
+
+namespace glm{
+namespace gtx{
+namespace bit{
+
+template <typename genIType>
+GLM_FUNC_QUALIFIER genIType mask
+(
+	genIType const & count
+)
+{
+	return ((genIType(1) << (count)) - genIType(1));
+}
+
+template <typename valIType>
+GLM_FUNC_QUALIFIER detail::tvec2<valIType> mask
+(
+	detail::tvec2<valIType> const & count
+)
+{
+	return detail::tvec2<valIType>(
+		mask(count[0]),
+		mask(count[1]));
+}
+
+template <typename valIType>
+GLM_FUNC_QUALIFIER detail::tvec3<valIType> mask
+(
+	detail::tvec3<valIType> const & count
+)
+{
+	return detail::tvec3<valIType>(
+		mask(count[0]),
+		mask(count[1]),
+		mask(count[2]));
+}
+
+template <typename valIType>
+GLM_FUNC_QUALIFIER detail::tvec4<valIType> mask
+(
+	detail::tvec4<valIType> const & count
+)
+{
+	return detail::tvec4<valIType>(
+		mask(count[0]),
+		mask(count[1]),
+		mask(count[2]),
+		mask(count[3]));
+}
+
+// extractField
+template <typename genIType>
+GLM_FUNC_QUALIFIER genIType extractField
+(
+	gtc::half_float::half const & value, 
+	genIType const & first, 
+	genIType const & count
+)
+{
+	assert(first + count < sizeof(gtc::half_float::half));
+	return (value._data() << first) >> ((sizeof(gtc::half_float::half) << 3) - count);
+}
+
+template <typename genIType>
+GLM_FUNC_QUALIFIER genIType extractField
+(
+	float const & value, 
+	genIType const & first, 
+	genIType const & count
+)
+{
+	assert(first + count < sizeof(float));
+	return (detail::uif32(value).i << first) >> ((sizeof(float) << 3) - count);
+}
+
+template <typename genIType>
+GLM_FUNC_QUALIFIER genIType extractField
+(
+	double const & value, 
+	genIType const & first, 
+	genIType const & count
+)
+{
+	assert(first + count < sizeof(double));
+	return (detail::uif64(value).i << first) >> ((sizeof(double) << genIType(3)) - count);
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER genIUType extractField
+(
+	genIUType const & Value, 
+	sizeType const & First, 
+	sizeType const & Count
+)
+{
+	sizeType GenSize = sizeof(genIUType) << 3;
+
+	assert(First + Count <= GenSize);
+
+	genIUType ShiftLeft = Count ? Value << (GenSize - (Count + First)) : 0;
+	genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Count);
+
+	return ShiftBack;
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
+(
+	detail::tvec2<genIUType> const & value, 
+	sizeType const & first, 
+	sizeType const & count
+)
+{
+	return detail::tvec2<genIUType>(
+		extractField(value[0], first, count),
+		extractField(value[1], first, count));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
+(
+	detail::tvec3<genIUType> const & value, 
+	sizeType const & first, 
+	sizeType const & count
+)
+{
+	return detail::tvec3<genIUType>(
+		extractField(value[0], first, count),
+		extractField(value[1], first, count),
+		extractField(value[2], first, count));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
+(
+	detail::tvec4<genIUType> const & value, 
+	sizeType const & first, 
+	sizeType const & count
+)
+{
+	return detail::tvec4<genIUType>(
+		extractField(value[0], first, count),
+		extractField(value[1], first, count),
+		extractField(value[2], first, count),
+		extractField(value[3], first, count));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
+(
+	detail::tvec2<genIUType> const & value, 
+	detail::tvec2<sizeType> const & first, 
+	detail::tvec2<sizeType> const & count
+)
+{
+	return detail::tvec2<genIUType>(
+		extractField(value[0], first[0], count[0]),
+		extractField(value[1], first[1], count[1]));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
+(
+	detail::tvec3<genIUType> const & value, 
+	detail::tvec3<sizeType> const & first, 
+	detail::tvec3<sizeType> const & count
+)
+{
+	return detail::tvec3<genIUType>(
+		extractField(value[0], first[0], count[0]),
+		extractField(value[1], first[1], count[1]),
+		extractField(value[2], first[2], count[2]));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
+(
+	detail::tvec4<genIUType> const & value, 
+	detail::tvec4<sizeType> const & first, 
+	detail::tvec4<sizeType> const & count
+)
+{
+	return detail::tvec4<genIUType>(
+		extractField(value[0], first[0], count[0]),
+		extractField(value[1], first[1], count[1]),
+		extractField(value[2], first[2], count[2]),
+		extractField(value[3], first[3], count[3]));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec2<genIUType> extractField
+(
+	genIUType const & value, 
+	detail::tvec2<sizeType> const & first, 
+	detail::tvec2<sizeType> const & count
+)
+{
+	return detail::tvec2<genIUType>(
+		extractField(value, first[0], count[0]),
+		extractField(value, first[1], count[1]));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec3<genIUType> extractField
+(
+	genIUType const & value, 
+	detail::tvec3<sizeType> const & first, 
+	detail::tvec3<sizeType> const & count
+)
+{
+	return detail::tvec3<genIUType>(
+		extractField(value, first[0], count[0]),
+		extractField(value, first[1], count[1]),
+		extractField(value, first[2], count[2]));
+}
+
+template <typename genIUType, typename sizeType>
+GLM_FUNC_QUALIFIER detail::tvec4<genIUType> extractField
+(
+	genIUType const & value, 
+	detail::tvec4<sizeType> const & first, 
+	detail::tvec4<sizeType> const & count
+)
+{
+	return detail::tvec4<genIUType>(
+		extractField(value, first[0], count[0]),
+		extractField(value, first[1], count[1]),
+		extractField(value, first[2], count[2]),
+		extractField(value, first[3], count[3]));
+}
+
+// lowestBit
+template <typename genType>
+GLM_FUNC_QUALIFIER int lowestBit
+(
+	genType const & Value
+)
+{
+	assert(Value != genType(0)); // not valid call
+
+	genType Bit;
+	for(Bit = genType(0); !(Value & (1 << Bit)); ++Bit){}
+	return Bit;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<int> lowestBit
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<int>(
+		lowestBit(value[0]),
+		lowestBit(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<int> lowestBit
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<int>(
+		lowestBit(value[0]),
+		lowestBit(value[1]),
+		lowestBit(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<int> lowestBit
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<int>(
+		lowestBit(value[0]),
+		lowestBit(value[1]),
+		lowestBit(value[2]),
+		lowestBit(value[3]));
+}
+
+// highestBit
+template <typename genType>
+GLM_FUNC_QUALIFIER int highestBit
+(
+	genType const & value
+)
+{
+	assert(value != genType(0)); // not valid call
+
+	genType bit = genType(-1);
+	for(genType tmp = value; tmp; tmp >>= 1, ++bit){}
+	return bit;
+}
+
+//template <>
+//GLM_FUNC_QUALIFIER int highestBit<int>
+//(
+//	int value
+//)
+//{
+//	int bit = -1;
+//	for(int tmp = value; tmp; tmp >>= 1, ++bit);
+//	return bit;
+//}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<int> highestBit
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<int>(
+		highestBit(value[0]),
+		highestBit(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<int> highestBit
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<int>(
+		highestBit(value[0]),
+		highestBit(value[1]),
+		highestBit(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<int> highestBit
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<int>(
+		highestBit(value[0]),
+		highestBit(value[1]),
+		highestBit(value[2]),
+		highestBit(value[3]));
+}
+
+// highestBitValue
+template <typename genType>
+GLM_FUNC_QUALIFIER genType highestBitValue
+(
+	genType const & value
+)
+{
+	genType tmp = value;
+	genType result = genType(0);
+	while(tmp)
+	{
+		result = (tmp & (~tmp + 1)); // grab lowest bit
+		tmp &= ~result; // clear lowest bit
+	}
+	return result;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<int> highestBitValue
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<int>(
+		highestBitValue(value[0]),
+		highestBitValue(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<int> highestBitValue
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<int>(
+		highestBitValue(value[0]),
+		highestBitValue(value[1]),
+		highestBitValue(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<int> highestBitValue
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<int>(
+		highestBitValue(value[0]),
+		highestBitValue(value[1]),
+		highestBitValue(value[2]),
+		highestBitValue(value[3]));
+}
+
+// isPowerOfTwo
+template <typename genType>
+GLM_FUNC_QUALIFIER bool isPowerOfTwo(genType const & Value)
+{
+	//detail::If<std::numeric_limits<genType>::is_signed>::apply(abs, Value);
+	//return !(Value & (Value - 1));
+
+    // For old complier?
+	genType Result = Value;
+	if(std::numeric_limits<genType>::is_signed)
+		Result = abs(Result);
+	return !(Result & (Result - 1));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<bool> isPowerOfTwo
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<bool>(
+		isPowerOfTwo(value[0]),
+		isPowerOfTwo(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<bool> isPowerOfTwo
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<bool>(
+		isPowerOfTwo(value[0]),
+		isPowerOfTwo(value[1]),
+		isPowerOfTwo(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<bool> isPowerOfTwo
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<bool>(
+		isPowerOfTwo(value[0]),
+		isPowerOfTwo(value[1]),
+		isPowerOfTwo(value[2]),
+		isPowerOfTwo(value[3]));
+}
+
+// powerOfTwoAbove
+template <typename genType>
+GLM_FUNC_QUALIFIER genType powerOfTwoAbove(genType const & value)
+{
+	return isPowerOfTwo(value) ? value : highestBitValue(value) << 1;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoAbove
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<valType>(
+		powerOfTwoAbove(value[0]),
+		powerOfTwoAbove(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoAbove
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<valType>(
+		powerOfTwoAbove(value[0]),
+		powerOfTwoAbove(value[1]),
+		powerOfTwoAbove(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoAbove
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<valType>(
+		powerOfTwoAbove(value[0]),
+		powerOfTwoAbove(value[1]),
+		powerOfTwoAbove(value[2]),
+		powerOfTwoAbove(value[3]));
+}
+
+// powerOfTwoBelow
+template <typename genType>
+GLM_FUNC_QUALIFIER genType powerOfTwoBelow
+(
+	genType const & value
+)
+{
+	return isPowerOfTwo(value) ? value : highestBitValue(value);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoBelow
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<valType>(
+		powerOfTwoBelow(value[0]),
+		powerOfTwoBelow(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoBelow
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<valType>(
+		powerOfTwoBelow(value[0]),
+		powerOfTwoBelow(value[1]),
+		powerOfTwoBelow(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoBelow
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<valType>(
+		powerOfTwoBelow(value[0]),
+		powerOfTwoBelow(value[1]),
+		powerOfTwoBelow(value[2]),
+		powerOfTwoBelow(value[3]));
+}
+
+// powerOfTwoNearest
+template <typename genType>
+GLM_FUNC_QUALIFIER genType powerOfTwoNearest
+(
+	genType const & value
+)
+{
+	if(isPowerOfTwo(value))
+		return value;
+
+	genType prev = highestBitValue(value);
+	genType next = prev << 1;
+	return (next - value) < (value - prev) ? next : prev;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> powerOfTwoNearest
+(
+	detail::tvec2<valType> const & value
+)
+{
+	return detail::tvec2<valType>(
+		powerOfTwoNearest(value[0]),
+		powerOfTwoNearest(value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> powerOfTwoNearest
+(
+	detail::tvec3<valType> const & value
+)
+{
+	return detail::tvec3<valType>(
+		powerOfTwoNearest(value[0]),
+		powerOfTwoNearest(value[1]),
+		powerOfTwoNearest(value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> powerOfTwoNearest
+(
+	detail::tvec4<valType> const & value
+)
+{
+	return detail::tvec4<valType>(
+		powerOfTwoNearest(value[0]),
+		powerOfTwoNearest(value[1]),
+		powerOfTwoNearest(value[2]),
+		powerOfTwoNearest(value[3]));
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType bitRevert(genType const & In)
+{
+	GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRevert' only accept integer values");
+
+	genType Out = 0;
+	std::size_t BitSize = sizeof(genType) * 8;
+	for(std::size_t i = 0; i < BitSize; ++i)
+		if(In & (genType(1) << i))
+			Out |= genType(1) << (BitSize - 1 - i);
+	return Out;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRevert
+(
+	detail::tvec2<valType> const & Value
+)
+{
+	return detail::tvec2<valType>(
+		bitRevert(Value[0]),
+		bitRevert(Value[1]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRevert
+(
+	detail::tvec3<valType> const & Value
+)
+{
+	return detail::tvec3<valType>(
+		bitRevert(Value[0]),
+		bitRevert(Value[1]),
+		bitRevert(Value[2]));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRevert
+(
+	detail::tvec4<valType> const & Value
+)
+{
+	return detail::tvec4<valType>(
+		bitRevert(Value[0]),
+		bitRevert(Value[1]),
+		bitRevert(Value[2]),
+		bitRevert(Value[3]));
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType bitRotateRight(genType const & In, std::size_t Shift)
+{
+	GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateRight' only accept integer values");
+
+	std::size_t BitSize = sizeof(genType) * 8;
+	return (In << Shift) | (In >> (BitSize - Shift));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateRight
+(
+	detail::tvec2<valType> const & Value, 
+	std::size_t Shift
+)
+{
+	return detail::tvec2<valType>(
+		bitRotateRight(Value[0], Shift),
+		bitRotateRight(Value[1], Shift));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateRight
+(
+	detail::tvec3<valType> const & Value, 
+	std::size_t Shift
+)
+{
+	return detail::tvec3<valType>(
+		bitRotateRight(Value[0], Shift),
+		bitRotateRight(Value[1], Shift),
+		bitRotateRight(Value[2], Shift));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateRight
+(
+	detail::tvec4<valType> const & Value, 
+	std::size_t Shift
+)
+{
+	return detail::tvec4<valType>(
+		bitRotateRight(Value[0], Shift),
+		bitRotateRight(Value[1], Shift),
+		bitRotateRight(Value[2], Shift),
+		bitRotateRight(Value[3], Shift));
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType bitRotateLeft(genType const & In, std::size_t Shift)
+{
+	GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_integer, "'bitRotateLeft' only accept integer values");
+
+	std::size_t BitSize = sizeof(genType) * 8;
+	return (In >> Shift) | (In << (BitSize - Shift));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> bitRotateLeft
+(
+	detail::tvec2<valType> const & Value, 
+	std::size_t Shift
+)
+{
+	return detail::tvec2<valType>(
+		bitRotateLeft(Value[0], Shift),
+		bitRotateLeft(Value[1], Shift));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> bitRotateLeft
+(
+	detail::tvec3<valType> const & Value, 
+	std::size_t Shift
+)
+{
+	return detail::tvec3<valType>(
+		bitRotateLeft(Value[0], Shift),
+		bitRotateLeft(Value[1], Shift),
+		bitRotateLeft(Value[2], Shift));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> bitRotateLeft
+(
+	detail::tvec4<valType> const & Value, 
+	std::size_t Shift
+)
+{
+	return detail::tvec4<valType>(
+		bitRotateLeft(Value[0], Shift),
+		bitRotateLeft(Value[1], Shift),
+		bitRotateLeft(Value[2], Shift),
+		bitRotateLeft(Value[3], Shift));
+}
+
+}//namespace bit
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/closest_point.hpp b/ExternalLibs/glm/gtx/closest_point.hpp
new file mode 100644
index 0000000..7c9d513
--- /dev/null
+++ b/ExternalLibs/glm/gtx/closest_point.hpp
@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-30
+// Updated : 2008-10-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/closest_point.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_closest_point
+#define glm_gtx_closest_point
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_closest_point extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
+{
+	/// \addtogroup gtx_closest_point
+	/// @{
+
+	/// Find the point on a straight line which is the closet of a point. 
+	/// From GLM_GTX_closest_point extension.
+	template <typename T> 
+	detail::tvec3<T> closestPointOnLine(
+		detail::tvec3<T> const & point, 
+		detail::tvec3<T> const & a, 
+		detail::tvec3<T> const & b);
+
+	/// @}
+}// namespace closest_point
+}// namespace gtx
+}// namespace glm
+
+#include "closest_point.inl"
+
+namespace glm{using namespace gtx::closest_point;}
+
+#endif//glm_gtx_closest_point
diff --git a/ExternalLibs/glm/gtx/closest_point.inl b/ExternalLibs/glm/gtx/closest_point.inl
new file mode 100644
index 0000000..8fab1e6
--- /dev/null
+++ b/ExternalLibs/glm/gtx/closest_point.inl
@@ -0,0 +1,41 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-30
+// Updated : 2008-10-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/closest_point.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_closest_point
+#define glm_gtx_closest_point
+
+namespace glm{
+namespace gtx{
+namespace closest_point{
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
+(
+	detail::tvec3<valType> const & point, 
+	detail::tvec3<valType> const & a, 
+	detail::tvec3<valType> const & b
+)
+{
+    valType LineLength = distance(a, b);
+    detail::tvec3<valType> Vector = point - a;
+    detail::tvec3<valType> LineDirection = (b - a) / LineLength;
+
+    // Project Vector to LineDirection to get the distance of point from a
+    valType Distance = dot(Vector, LineDirection);
+
+    if(Distance <= valType(0)) return a;
+    if(Distance >= LineLength) return b;
+    return a + LineDirection * Distance;
+}
+
+}//namespace closest_point
+}//namespace gtx
+}//namespace glm
+
+#endif//glm_gtx_closest_point
diff --git a/ExternalLibs/glm/gtx/color_cast.hpp b/ExternalLibs/glm/gtx/color_cast.hpp
new file mode 100644
index 0000000..b50bc96
--- /dev/null
+++ b/ExternalLibs/glm/gtx/color_cast.hpp
@@ -0,0 +1,107 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-06-21
+// Updated : 2009-06-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/color_cast.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_number_precision
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_color_cast
+#define glm_gtx_color_cast
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/number_precision.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_color_cast extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
+{
+	using namespace gtx::number_precision;
+
+	/// \addtogroup gtx_color_cast
+	///@{
+
+	//! Conversion of a floating value into a 8bit unsigned int value. 
+	//! From GLM_GTX_color_cast extension.
+	template <typename valType> gtc::type_precision::uint8 u8channel_cast(valType a);
+
+	//! Conversion of a floating value into a 16bit unsigned int value. 
+	//! From GLM_GTX_color_cast extension.
+	template <typename valType>	gtc::type_precision::uint16 u16channel_cast(valType a);
+
+	template <typename T> gtc::type_precision::uint32 u32_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint32 u32_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint32 u32_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint32 u32_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::uint32 u32_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint32 u32_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint32 u32_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint32 u32_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::uint64 u64_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint64 u64_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint64 u64_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint64 u64_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::uint64 u64_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint64 u64_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint64 u64_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::uint64 u64_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtx::number_precision::f16vec1 f16_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::f16vec3 f16_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f16vec3 f16_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f16vec3 f16_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f16vec3 f16_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::f16vec4 f16_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f16vec4 f16_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f16vec4 f16_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f16vec4 f16_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtx::number_precision::f32vec1 f32_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::f32vec3 f32_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f32vec3 f32_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f32vec3 f32_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f32vec3 f32_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::f32vec4 f32_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f32vec4 f32_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f32vec4 f32_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f32vec4 f32_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtx::number_precision::f64vec1 f64_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::f64vec3 f64_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f64vec3 f64_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f64vec3 f64_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f64vec3 f64_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+
+	template <typename T> gtc::type_precision::f64vec4 f64_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> gtc::type_precision::f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+
+	///@}
+}//namespace color_space
+}//namespace gtx
+}//namespace glm
+
+#include "color_cast.inl"
+
+namespace glm{using namespace gtx::color_cast;}
+
+#endif//glm_gtx_color_cast
diff --git a/ExternalLibs/glm/gtx/color_cast.inl b/ExternalLibs/glm/gtx/color_cast.inl
new file mode 100644
index 0000000..5236869
--- /dev/null
+++ b/ExternalLibs/glm/gtx/color_cast.inl
@@ -0,0 +1,739 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-06-21
+// Updated : 2007-08-03
+// Licence : This source is under MIT License
+// File    : glm/gtx/color_cast.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+//! GLM_GTX_color_cast extension: Conversion between two color types
+namespace color_cast{
+
+template <typename T> 
+GLM_FUNC_QUALIFIER gtc::type_precision::uint8 u8channel_cast(T a)
+{
+	return static_cast<gtc::type_precision::uint8>(a * T(255));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER gtc::type_precision::uint16 u16channel_cast(T a)
+{
+	return static_cast<gtc::type_precision::uint16>(a * T(65535));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_rgbx_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  0;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec3<T>::value_type(255)) << 16;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_xrgb_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+    result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec3<T>::value_type(255)) << 24;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_bgrx_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec3<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_xbgr_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec3<T>::value_type(255)) << 24;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.w * detail::tvec3<T>::value_type(255)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_rgba_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  0;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_argb_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec4<T>::value_type(255)) << 24;
+	result += static_cast<gtc::type_precision::uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_bgra_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  0;
+	result += static_cast<gtc::type_precision::uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint32 u32_abgr_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint32 result = 0;
+	result += static_cast<gtc::type_precision::uint32>(c.x * detail::tvec4<T>::value_type(255)) << 24;
+	result += static_cast<gtc::type_precision::uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<gtc::type_precision::uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<gtc::type_precision::uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u64_rgbx_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec3<T>::value_type(65535)) <<  0;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 32;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u32_xrgb_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 48;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u32_bgrx_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec3<T>::value_type(65535)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u32_xbgr_cast(const detail::tvec3<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 48;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.w * detail::tvec3<T>::value_type(65535)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u64_rgba_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec4<T>::value_type(65535)) <<  0;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u64_argb_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 48;
+	result += static_cast<gtc::type_precision::uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u64_bgra_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec4<T>::value_type(65535)) <<  0;
+	result += static_cast<gtc::type_precision::uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
+	return result;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER gtc::type_precision::uint64 u64_abgr_cast(const detail::tvec4<T>& c)
+{
+	gtc::type_precision::uint64 result = 0;
+	result += static_cast<gtc::type_precision::uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 48;
+	result += static_cast<gtc::type_precision::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<gtc::type_precision::uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<gtc::type_precision::uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec1 f16_channel_cast<gtc::type_precision::uint32>(gtc::type_precision::uint32 color)
+{
+	return gtc::type_precision::f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+}
+
+template <>
+GLM_FUNC_QUALIFIER gtc::type_precision::f16vec3 f16_rgbx_cast<gtc::type_precision::uint32>(gtc::type_precision::uint32 color)
+{
+	gtc::type_precision::f16vec3 result;
+	result.x = gtc::type_precision::f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	result.y = gtc::type_precision::f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.z = gtc::type_precision::f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER gtc::type_precision::f16vec3 f16_xrgb_cast<gtc::type_precision::uint32>(gtc::type_precision::uint32 color)
+{
+	gtc::type_precision::f16vec3 result;
+	result.x = gtc::type_precision::f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.y = gtc::type_precision::f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.z = gtc::type_precision::f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec3 f16_bgrx_cast<uint32>(uint32 color)
+{
+	f16vec3 result;
+	result.x = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec3 f16_xbgr_cast<uint32>(uint32 color)
+{
+	f16vec3 result;
+	result.x = f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec4 f16_rgba_cast<uint32>(uint32 color)
+{
+	f16vec4 result;
+	result.x = f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.w = f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec4 f16_argb_cast<uint32>(uint32 color)
+{
+	f16vec4 result;
+	result.x = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	result.w = f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec4 f16_bgra_cast<uint32>(uint32 color)
+{
+	f16vec4 result;
+	result.x = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	result.w = f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER f16vec4 f16_abgr_cast<uint32>(uint32 color)
+{
+	f16vec4 result;
+	result.x = f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.w = f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER float f32_channel_cast<uint8>(uint8 color)
+{
+	return static_cast<float>(color >>  0) / static_cast<float>(255);
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint32>(uint32 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >>  0) / static_cast<float>(255);
+	result.y = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.z = static_cast<float>(color >> 16) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint32>(uint32 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.z = static_cast<float>(color >> 24) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint32>(uint32 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.y = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.z = static_cast<float>(color >>  0) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint32>(uint32 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >> 24) / static_cast<float>(255);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.z = static_cast<float>(color >>  8) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint32>(uint32 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >>  0) / static_cast<float>(255);
+	result.y = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.z = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.w = static_cast<float>(color >> 24) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint32>(uint32 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.z = static_cast<float>(color >> 24) / static_cast<float>(255);
+	result.w = static_cast<float>(color >>  0) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint32>(uint32 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.y = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.z = static_cast<float>(color >>  0) / static_cast<float>(255);
+	result.w = static_cast<float>(color >> 24) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint32>(uint32 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >> 24) / static_cast<float>(255);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(255);
+	result.z = static_cast<float>(color >>  8) / static_cast<float>(255);
+	result.w = static_cast<float>(color >>  0) / static_cast<float>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER double f64_channel_cast<uint8>(uint8 color)
+{
+	return static_cast<double>(color >>  0) / static_cast<double>(255);
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint32>(uint32 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >>  0) / static_cast<double>(255);
+	result.y = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.z = static_cast<double>(color >> 16) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint32>(uint32 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.z = static_cast<double>(color >> 24) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint32>(uint32 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.y = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.z = static_cast<double>(color >>  0) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint32>(uint32 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >> 24) / static_cast<double>(255);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.z = static_cast<double>(color >>  8) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint32>(uint32 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >>  0) / static_cast<double>(255);
+	result.y = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.z = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.w = static_cast<double>(color >> 24) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint32>(uint32 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.z = static_cast<double>(color >> 24) / static_cast<double>(255);
+	result.w = static_cast<double>(color >>  0) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint32>(uint32 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.y = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.z = static_cast<double>(color >>  0) / static_cast<double>(255);
+	result.w = static_cast<double>(color >> 24) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint32>(uint32 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >> 24) / static_cast<double>(255);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(255);
+	result.z = static_cast<double>(color >>  8) / static_cast<double>(255);
+	result.w = static_cast<double>(color >>  0) / static_cast<double>(255);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::thalf f16_channel_cast<uint16>(uint16 color)
+{
+	return detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<detail::thalf> f16_rgbx_cast<uint64>(uint64 color)
+{
+	detail::tvec3<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<detail::thalf> f16_xrgb_cast<uint64>(uint64 color)
+{
+	detail::tvec3<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >> 48) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<detail::thalf> f16_bgrx_cast<uint64>(uint64 color)
+{
+	detail::tvec3<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<detail::thalf> f16_xbgr_cast<uint64>(uint64 color)
+{
+	detail::tvec3<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >> 48) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<detail::thalf> f16_rgba_cast<uint64>(uint64 color)
+{
+	detail::tvec4<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.w = detail::thalf(static_cast<float>(color >> 48) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<detail::thalf> f16_argb_cast<uint64>(uint64 color)
+{
+	detail::tvec4<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >> 48) / static_cast<float>(65535));
+	result.w = detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<detail::thalf> f16_bgra_cast<uint64>(uint64 color)
+{
+	detail::tvec4<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+	result.w = detail::thalf(static_cast<float>(color >> 48) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<detail::thalf> f16_abgr_cast<uint64>(uint64 color)
+{
+	detail::tvec4<detail::thalf> result;
+	result.x = detail::thalf(static_cast<float>(color >> 48) / static_cast<float>(65535));
+	result.y = detail::thalf(static_cast<float>(color >> 32) / static_cast<float>(65535));
+	result.z = detail::thalf(static_cast<float>(color >> 16) / static_cast<float>(65535));
+	result.w = detail::thalf(static_cast<float>(color >>  0) / static_cast<float>(65535));
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER float f32_channel_cast<uint16>(uint16 color)
+{
+	return static_cast<float>(color >>  0) / static_cast<float>(65535);
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_rgbx_cast<uint64>(uint64 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >>  0) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xrgb_cast<uint64>(uint64 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >> 48) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_bgrx_cast<uint64>(uint64 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >>  0) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<float> f32_xbgr_cast<uint64>(uint64 color)
+{
+	detail::tvec3<float> result;
+	result.x = static_cast<float>(color >> 48) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_rgba_cast<uint64>(uint64 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >>  0) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.w = static_cast<float>(color >> 48) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_argb_cast<uint64>(uint64 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >> 48) / static_cast<float>(65535);
+	result.w = static_cast<float>(color >>  0) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_bgra_cast<uint64>(uint64 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >>  0) / static_cast<float>(65535);
+	result.w = static_cast<float>(color >> 48) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<float> f32_abgr_cast<uint64>(uint64 color)
+{
+	detail::tvec4<float> result;
+	result.x = static_cast<float>(color >> 48) / static_cast<float>(65535);
+	result.y = static_cast<float>(color >> 32) / static_cast<float>(65535);
+	result.z = static_cast<float>(color >> 16) / static_cast<float>(65535);
+	result.w = static_cast<float>(color >>  0) / static_cast<float>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER double f64_channel_cast<uint16>(uint16 color)
+{
+	return static_cast<double>(color >>  0) / static_cast<double>(65535);
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_rgbx_cast<uint64>(uint64 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >>  0) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xrgb_cast<uint64>(uint64 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >> 48) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_bgrx_cast<uint64>(uint64 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >>  0) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec3<double> f64_xbgr_cast<uint64>(uint64 color)
+{
+	detail::tvec3<double> result;
+	result.x = static_cast<double>(color >> 48) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_rgba_cast<uint64>(uint64 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >>  0) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.w = static_cast<double>(color >> 48) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_argb_cast<uint64>(uint64 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >> 48) / static_cast<double>(65535);
+	result.w = static_cast<double>(color >>  0) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_bgra_cast<uint64>(uint64 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >>  0) / static_cast<double>(65535);
+	result.w = static_cast<double>(color >> 48) / static_cast<double>(65535);
+	return result;
+}
+
+template <>
+GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color)
+{
+	detail::tvec4<double> result;
+	result.x = static_cast<double>(color >> 48) / static_cast<double>(65535);
+	result.y = static_cast<double>(color >> 32) / static_cast<double>(65535);
+	result.z = static_cast<double>(color >> 16) / static_cast<double>(65535);
+	result.w = static_cast<double>(color >>  0) / static_cast<double>(65535);
+	return result;
+}
+
+}//namespace color_space
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/color_space.hpp b/ExternalLibs/glm/gtx/color_space.hpp
new file mode 100644
index 0000000..3b76236
--- /dev/null
+++ b/ExternalLibs/glm/gtx/color_space.hpp
@@ -0,0 +1,77 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2007-02-22
+// Licence : This source is under MIT License
+// File    : glm/gtx/color_space.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_color_space
+#define glm_gtx_color_space
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_color_space extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
+{
+	/// \addtogroup gtx_color_space
+	/// @{
+
+	//! Converts a color from HSV color space to its color in RGB color space.
+	//! From GLM_GTX_color_space extension.
+    template <typename valType> 
+	detail::tvec3<valType> rgbColor(
+		detail::tvec3<valType> const & hsvValue);
+
+	//! Converts a color from RGB color space to its color in HSV color space.
+	//! From GLM_GTX_color_space extension.
+    template <typename valType> 
+	detail::tvec3<valType> hsvColor(
+		detail::tvec3<valType> const & rgbValue);
+		
+	//! Build a saturation matrix.
+	//! From GLM_GTX_color_space extension
+    template <typename valType> 
+	detail::tmat4x4<valType> saturation(
+		valType const s);
+
+    //! Modify the saturation of a color.
+	//! From GLM_GTX_color_space extension.
+	template <typename valType> 
+	detail::tvec3<valType> saturation(
+		valType const s, 
+		detail::tvec3<valType> const & color);
+		
+	//! Modify the saturation of a color.
+	//! From GLM_GTX_color_space extension.
+    template <typename valType> 
+	detail::tvec4<valType> saturation(
+		valType const s, 
+		detail::tvec4<valType> const & color);
+		
+	//! Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
+	//! From GLM_GTX_color_space extension.
+	template <typename valType> 
+	valType luminosity(
+		detail::tvec3<valType> const & color);
+
+	/// @}
+}//namespace color_space
+}//namespace gtx
+}//namespace glm
+
+#include "color_space.inl"
+
+namespace glm{using namespace gtx::color_space;}
+
+#endif//glm_gtx_color_space
diff --git a/ExternalLibs/glm/gtx/color_space.inl b/ExternalLibs/glm/gtx/color_space.inl
new file mode 100644
index 0000000..dc8db73
--- /dev/null
+++ b/ExternalLibs/glm/gtx/color_space.inl
@@ -0,0 +1,154 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2007-02-22
+// Licence : This source is under MIT License
+// File    : glm/gtx/color_space.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace color_space
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
+    {
+		detail::tvec3<T> hsv = hsvColor;
+        detail::tvec3<T> rgbColor;
+
+	    if(hsv.y == T(0))
+		    // achromatic (grey)
+            rgbColor = detail::tvec3<T>(hsv.z);
+	    else
+	    {
+            T sector = floor(hsv.x / T(60));
+			T frac = (hsv.x / T(60)) - sector;
+            // factorial part of h
+            T o = hsv.z * (T(1) - hsv.y);
+            T p = hsv.z * (T(1) - hsv.y * frac);
+            T q = hsv.z * (T(1) - hsv.y * (T(1) - frac));
+
+            switch(int(sector))
+            {
+            default:
+            case 0:
+                rgbColor.r = hsv.z;
+                rgbColor.g = q;
+                rgbColor.b = o;
+                break;
+            case 1:
+                rgbColor.r = p;
+                rgbColor.g = hsv.z;
+                rgbColor.b = o;
+                break;
+            case 2:
+                rgbColor.r = o;
+                rgbColor.g = hsv.z;
+                rgbColor.b = q;
+                break;
+            case 3:
+                rgbColor.r = o;
+                rgbColor.g = p;
+                rgbColor.b = hsv.z;
+                break;
+            case 4:
+                rgbColor.r = q; 
+                rgbColor.g = o; 
+                rgbColor.b = hsv.z;
+                break;
+			case 5:
+                rgbColor.r = hsv.z; 
+                rgbColor.g = o; 
+                rgbColor.b = p;
+                break;
+            }
+	    }
+
+		return rgbColor;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
+    {
+        detail::tvec3<T> hsv = rgbColor;
+	    float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
+	    float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
+	    float Delta = Max - Min;
+
+	    hsv.z = Max;                               
+    	
+	    if(Max != T(0))
+	    {
+		    hsv.y = Delta / hsv.z;    
+			T h = T(0);
+
+		    if(rgbColor.r == Max)
+			    // between yellow & magenta
+			    h = T(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta;
+		    else if(rgbColor.g == Max)
+			    // between cyan & yellow
+			    h = T(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta;
+		    else
+			    // between magenta & cyan
+			    h = T(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta;
+            
+		    if(h < T(0)) 
+                hsv.x = h + T(360);
+			else
+				hsv.x = h;
+	    }
+	    else
+	    {
+		    // If r = g = b = 0 then s = 0, h is undefined
+		    hsv.y = T(0);
+		    hsv.x = T(0);
+	    }
+
+		return hsv;
+    }
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
+	{
+		detail::tvec3<T> rgbw = detail::tvec3<T>(T(0.2126), T(0.7152), T(0.0722));
+
+		T col0 = (T(1) - s) * rgbw.r;
+		T col1 = (T(1) - s) * rgbw.g;
+		T col2 = (T(1) - s) * rgbw.b;
+
+		detail::tmat4x4<T> result(T(1));
+		result[0][0] = col0 + s;
+		result[0][1] = col0;
+		result[0][2] = col0;
+		result[1][0] = col1;
+		result[1][1] = col1 + s;
+		result[1][2] = col1;
+		result[2][0] = col2;
+		result[2][1] = col2;
+		result[2][2] = col2 + s;
+		return result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> saturation(const T s, const detail::tvec3<T>& color)
+	{
+		return detail::tvec3<T>(saturation(s) * detail::tvec4<T>(color, T(0)));
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> saturation(const T s, const detail::tvec4<T>& color)
+	{
+		return saturation(s) * color;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T>& color)
+	{
+		const detail::tvec3<T> tmp = detail::tvec3<T>(0.33, 0.59, 0.11);
+		return dot(color, tmp);
+	}
+
+}//namespace color_space
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/color_space_YCoCg.hpp b/ExternalLibs/glm/gtx/color_space_YCoCg.hpp
new file mode 100644
index 0000000..272e3c8
--- /dev/null
+++ b/ExternalLibs/glm/gtx/color_space_YCoCg.hpp
@@ -0,0 +1,65 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-28
+// Updated : 2008-10-28
+// Licence : This source is under MIT License
+// File    : glm/gtx/color_space_YCoCg.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_color_space_YCoCg
+#define glm_gtx_color_space_YCoCg
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
+{
+	/// \addtogroup gtx_color_space_YCoCg
+	///@{
+
+    //! Convert a color from RGB color space to YCoCg color space.
+	//! From GLM_GTX_color_space_YCoCg extension.
+	template <typename valType> 
+	detail::tvec3<valType> rgb2YCoCg(
+		detail::tvec3<valType> const & rgbColor);
+
+    //! Convert a color from YCoCg color space to RGB color space.
+	//! From GLM_GTX_color_space_YCoCg extension.
+    template <typename valType> 
+	detail::tvec3<valType> YCoCg2rgb(
+		detail::tvec3<valType> const & YCoCgColor);
+
+    //! Convert a color from RGB color space to YCoCgR color space.
+	//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	//! From GLM_GTX_color_space_YCoCg extension.
+	template <typename valType> 
+	detail::tvec3<valType> rgb2YCoCgR(
+		detail::tvec3<valType> const & rgbColor);
+
+    //! Convert a color from YCoCgR color space to RGB color space.
+	//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	//! From GLM_GTX_color_space_YCoCg extension.
+    template <typename valType> 
+	detail::tvec3<valType> YCoCgR2rgb(
+		detail::tvec3<valType> const & YCoCgColor);
+
+	/// @}
+}//namespace color_space_YCoCg
+}//namespace gtx
+}//namespace glm
+
+#include "color_space_YCoCg.inl"
+
+namespace glm{using namespace gtx::color_space_YCoCg;}
+
+#endif//glm_gtx_color_space_YCoCg
diff --git a/ExternalLibs/glm/gtx/color_space_YCoCg.inl b/ExternalLibs/glm/gtx/color_space_YCoCg.inl
new file mode 100644
index 0000000..ff2b896
--- /dev/null
+++ b/ExternalLibs/glm/gtx/color_space_YCoCg.inl
@@ -0,0 +1,69 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-28
+// Updated : 2008-10-28
+// Licence : This source is under MIT License
+// File    : glm/gtx/color_space_YCoCg.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace color_space_YCoCg{
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
+(
+	detail::tvec3<valType> const & rgbColor
+)
+{
+	detail::tvec3<valType> result;
+	result.x/*Y */ =   rgbColor.r / valType(4) + rgbColor.g / valType(2) + rgbColor.b / valType(4);
+	result.y/*Co*/ =   rgbColor.r / valType(2) + rgbColor.g * valType(0) - rgbColor.b / valType(2);
+	result.z/*Cg*/ = - rgbColor.r / valType(4) + rgbColor.g / valType(2) - rgbColor.b / valType(4);
+	return result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCgR
+(
+	detail::tvec3<valType> const & rgbColor
+)
+{
+	detail::tvec3<valType> result;
+	result.x/*Y */ = rgbColor.g / valType(2) + (rgbColor.r + rgbColor.b) / valType(4);
+	result.y/*Co*/ = rgbColor.r - rgbColor.b;
+	result.z/*Cg*/ = rgbColor.g - (rgbColor.r + rgbColor.b) / valType(2);
+	return result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCg2rgb
+(
+	detail::tvec3<valType> const & YCoCgColor
+)
+{
+	detail::tvec3<valType> result;
+	result.r = YCoCgColor.x + YCoCgColor.y - YCoCgColor.z;
+	result.g = YCoCgColor.x                + YCoCgColor.z;
+	result.b = YCoCgColor.x - YCoCgColor.y - YCoCgColor.z;
+	return result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
+(
+	detail::tvec3<valType> const & YCoCgRColor
+)
+{
+	detail::tvec3<valType> result;
+	valType tmp = YCoCgRColor.x - (YCoCgRColor.z / valType(2));
+	result.g = YCoCgRColor.z + tmp;
+	result.b = tmp - (YCoCgRColor.y / valType(2));
+	result.r = result.b + YCoCgRColor.y;
+	return result;
+}
+
+}//namespace color_space_YCoCg
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/compatibility.hpp b/ExternalLibs/glm/gtx/compatibility.hpp
new file mode 100644
index 0000000..637addd
--- /dev/null
+++ b/ExternalLibs/glm/gtx/compatibility.hpp
@@ -0,0 +1,170 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-01-24
+// Updated : 2008-10-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/compatibility.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_compatibility
+#define glm_gtx_compatibility
+
+// Dependency:
+#include "../glm.hpp"  
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_compatibility extension included")
+#endif
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#include <cfloat>
+#elif(GLM_COMPILER & GLM_COMPILER_GCC)
+#include <cmath>
+#endif//GLM_COMPILER
+
+namespace glm{
+namespace gtx{
+namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
+{
+	/// \addtogroup gtx_compatibility
+	///@{
+
+	template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+
+	template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> saturate(const detail::tvec3<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> saturate(const detail::tvec4<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+
+	template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> atan2(const detail::tvec2<T>& x, const detail::tvec2<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> atan2(const detail::tvec3<T>& x, const detail::tvec3<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> atan2(const detail::tvec4<T>& x, const detail::tvec4<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+
+	template <typename genType> bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+
+	template <typename genType> bool isinf(genType const & x);														//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+	template <typename genType> detail::tvec2<bool> isinf(const detail::tvec2<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+	template <typename genType> detail::tvec3<bool> isinf(const detail::tvec3<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+	template <typename genType> detail::tvec4<bool> isinf(const detail::tvec4<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+
+	template <typename genType> bool isnan(genType const & x);														//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+	template <typename genType> detail::tvec2<bool> isnan(const detail::tvec2<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+	template <typename genType> detail::tvec3<bool> isnan(const detail::tvec3<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+	template <typename genType> detail::tvec4<bool> isnan(const detail::tvec4<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+
+	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<bool>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<bool>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<bool>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<bool>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<bool>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<bool>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<bool>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<bool>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<bool>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<bool>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<bool>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<bool>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<int>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<int>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<int>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<int>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<int>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<int>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<int>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<int>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<int>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<int>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<int>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<int>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef gtc::half_float::half						half1;			//!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<gtc::half_float::half>		half2;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<gtc::half_float::half>		half3;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<gtc::half_float::half>		half4;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+
+	typedef gtc::half_float::half						half1x1;		//!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<gtc::half_float::half>		half2x2;		//!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<gtc::half_float::half>		half2x3;		//!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<gtc::half_float::half>		half2x4;		//!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<gtc::half_float::half>		half3x2;		//!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<gtc::half_float::half>		half3x3;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<gtc::half_float::half>		half3x4;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<gtc::half_float::half>		half4x2;		//!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<gtc::half_float::half>		half4x3;		//!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<gtc::half_float::half>		half4x4;		//!< \brief half-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef float						float1;			//!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<float>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<float>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<float>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef float						float1x1;		//!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<float>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<float>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<float>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<float>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<float>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<float>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<float>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<float>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<float>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef double						double1;		//!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<double>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<double>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<double>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef double						double1x1;		//!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<double>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<double>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<double>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<double>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<double>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<double>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<double>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	/// @}
+}//namespace compatibility
+}//namespace gtx
+}//namespace glm
+
+#include "compatibility.inl"
+
+namespace glm{using namespace gtx::compatibility;}
+
+#endif//glm_gtx_compatibility
+
+
+
+
+
+
+
+
+
+
diff --git a/ExternalLibs/glm/gtx/compatibility.inl b/ExternalLibs/glm/gtx/compatibility.inl
new file mode 100644
index 0000000..33b9cef
--- /dev/null
+++ b/ExternalLibs/glm/gtx/compatibility.inl
@@ -0,0 +1,141 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-16
+// Updated : 2008-10-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/compatibility.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace compatibility{
+
+// isfinite
+template <typename genType> 
+GLM_FUNC_QUALIFIER bool isfinite(
+	genType const & x)
+{
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+	return _finite(x);
+#else//(GLM_COMPILER & GLM_COMPILER_GCC)
+	return std::isfinite(x) != 0;
+#endif
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec2<bool> isfinite(
+	detail::tvec2<valType> const & x)
+{
+	return detail::tvec2<bool>(
+		isfinite(x.x),
+		isfinite(x.y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<bool> isfinite(
+	detail::tvec3<valType> const & x)
+{
+	return detail::tvec3<bool>(
+		isfinite(x.x),
+		isfinite(x.y),
+		isfinite(x.z));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec4<bool> isfinite(
+	detail::tvec4<valType> const & x)
+{
+	return detail::tvec4<bool>(
+		isfinite(x.x),
+		isfinite(x.y),
+		isfinite(x.z),
+		isfinite(x.w));
+}
+
+// isinf
+template <typename genType> 
+GLM_FUNC_QUALIFIER bool isinf(
+	genType const & x)
+{
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+	return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
+#else
+	return std::isinf(x) != 0;
+#endif
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec2<bool> isinf(
+	detail::tvec2<valType> const & x)
+{
+	return detail::tvec2<bool>(
+		isinf(x.x),
+		isinf(x.y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<bool> isinf(
+	detail::tvec3<valType> const & x)
+{
+	return detail::tvec3<bool>(
+		isinf(x.x),
+		isinf(x.y),
+		isinf(x.z));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec4<bool> isinf(
+	detail::tvec4<valType> const & x)
+{
+	return detail::tvec4<bool>(
+		isinf(x.x),
+		isinf(x.y),
+		isinf(x.z),
+		isinf(x.w));
+}
+
+// isnan
+template <typename genType> 
+GLM_FUNC_QUALIFIER bool isnan(genType const & x)
+{
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+	return _isnan(x);
+#else
+	return std::isnan(x) != 0;
+#endif
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec2<bool> isnan(
+	detail::tvec2<valType> const & x)
+{
+	return detail::tvec2<bool>(
+		isnan(x.x),
+		isnan(x.y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<bool> isnan(
+	detail::tvec3<valType> const & x)
+{
+	return detail::tvec3<bool>(
+		isnan(x.x),
+		isnan(x.y),
+		isnan(x.z));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec4<bool> isnan(
+	detail::tvec4<valType> const & x)
+{
+	return detail::tvec4<bool>(
+		isnan(x.x),
+		isnan(x.y),
+		isnan(x.z),
+		isnan(x.w));
+}
+
+}//namespace compatibility
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/component_wise.hpp b/ExternalLibs/glm/gtx/component_wise.hpp
new file mode 100644
index 0000000..ab65a40
--- /dev/null
+++ b/ExternalLibs/glm/gtx/component_wise.hpp
@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-05-21
+// Updated : 2007-05-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/component_wise.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_component_wise
+#define glm_gtx_component_wise
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_component_wise extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
+{
+	/// \addtogroup gtx_component_wise
+	/// @{
+
+	//! Add all vector components together. 
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compAdd(
+		genType const & v);
+
+	//! Multiply all vector components together. 
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compMul(
+		genType const & v);
+
+	//! Find the minimum value between single vector components.
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compMin(
+		genType const & v);
+
+	//! Find the maximum value between single vector components.
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compMax(
+		genType const & v);
+
+	/// @}
+}//namespace component_wise
+}//namespace gtx
+}//namespace glm
+
+#include "component_wise.inl"
+
+namespace glm{using namespace gtx::component_wise;}
+
+#endif//glm_gtx_component_wise
diff --git a/ExternalLibs/glm/gtx/component_wise.inl b/ExternalLibs/glm/gtx/component_wise.inl
new file mode 100644
index 0000000..d37fe41
--- /dev/null
+++ b/ExternalLibs/glm/gtx/component_wise.inl
@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-05-21
+// Updated : 2010-02-12
+// Licence : This source is under MIT License
+// File    : gtx_component_wise.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace component_wise
+{
+	template <typename genType>
+	GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
+	{
+        typename genType::size_type result = typename genType::value_type(0);
+		for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
+			result += v[i];
+		return result;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER typename genType::value_type compMul(genType const & v)
+	{
+        typename genType::value_type result = typename genType::value_type(1);
+		for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
+			result *= v[i];
+		return result;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER typename genType::value_type compMin(genType const & v)
+	{
+        typename genType::value_type result = typename genType::value_type(v[0]);
+		for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
+			result = min(result, v[i]);
+		return result;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER typename genType::value_type compMax(genType const & v)
+	{
+        typename genType::value_type result = typename genType::value_type(v[0]);
+		for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
+			result = max(result, v[i]);
+		return result;
+	}
+
+}//namespace component_wise
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/epsilon.hpp b/ExternalLibs/glm/gtx/epsilon.hpp
new file mode 100644
index 0000000..7df2cb7
--- /dev/null
+++ b/ExternalLibs/glm/gtx/epsilon.hpp
@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/epsilon.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_half
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_epsilon
+#define glm_gtx_epsilon
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_epsilon extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
+{
+	/// \addtogroup gtx_epsilon
+	///@{
+
+	//! Returns the component-wise compare of |x - y| < epsilon.
+	//! From GLM_GTX_epsilon extension.
+	template <typename genTypeT, typename genTypeU> 
+	bool equalEpsilon(
+		genTypeT const & x, 
+		genTypeT const & y, 
+		genTypeU const & epsilon);
+		
+	//! Returns the component-wise compare of |x - y| >= epsilon.
+	//! From GLM_GTX_epsilon extension.
+	template <typename genTypeT, typename genTypeU>
+	bool notEqualEpsilon(
+		genTypeT const & x, 
+		genTypeT const & y, 
+		genTypeU const & epsilon);
+
+	///@}
+}//namespace epsilon
+}//namespace gtx
+}//namespace glm
+
+#include "epsilon.inl"
+
+namespace glm{using namespace gtx::epsilon;}
+
+#endif//glm_gtx_epsilon
diff --git a/ExternalLibs/glm/gtx/epsilon.inl b/ExternalLibs/glm/gtx/epsilon.inl
new file mode 100644
index 0000000..1e42412
--- /dev/null
+++ b/ExternalLibs/glm/gtx/epsilon.inl
@@ -0,0 +1,204 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-01-16
+// Licence : This source is under MIT License
+// File    : glm/gtx/epsilon.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace epsilon{
+
+template <typename genType>
+GLM_FUNC_QUALIFIER bool equalEpsilon
+(
+	genType const & x, 
+	genType const & y, 
+	genType const & epsilon
+)
+{
+    return abs(x - y) < epsilon;
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER bool notEqualEpsilon
+(
+	genType const & x, 
+	genType const & y, 
+	genType const & epsilon
+)
+{
+    return abs(x - y) >= epsilon;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<bool> equalEpsilon
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y, 
+	valType const & epsilon)
+{
+    return detail::tvec2<bool>(
+        abs(x.x - y.x) < epsilon,
+        abs(x.y - y.y) < epsilon);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<bool> equalEpsilon
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y, 
+	valType const & epsilon)
+{
+    return detail::tvec3<bool>(
+        abs(x.x - y.x) < epsilon,
+        abs(x.y - y.y) < epsilon,
+        abs(x.z - y.z) < epsilon);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y, 
+	valType const & epsilon
+)
+{
+    return detail::tvec4<bool>(
+        abs(x.x - y.x) < epsilon,
+        abs(x.y - y.y) < epsilon,
+        abs(x.z - y.z) < epsilon,
+        abs(x.w - y.w) < epsilon);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<bool> notEqualEpsilon
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y, 
+	valType const & epsilon
+)
+{
+    return detail::tvec2<bool>(
+        abs(x.x - y.x) >= epsilon,
+        abs(x.y - y.y) >= epsilon);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<bool> notEqualEpsilon
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y, 
+	valType const & epsilon
+)
+{
+    return detail::tvec3<bool>(
+        abs(x.x - y.x) >= epsilon,
+        abs(x.y - y.y) >= epsilon,
+        abs(x.z - y.z) >= epsilon);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y, 
+	valType const & epsilon
+)
+{
+    return detail::tvec4<bool>(
+        abs(x.x - y.x) >= epsilon,
+        abs(x.y - y.y) >= epsilon,
+        abs(x.z - y.z) >= epsilon,
+        abs(x.w - y.w) >= epsilon);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<bool> equalEpsilon
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y, 
+	detail::tvec2<valType> const & epsilon
+)
+{
+    return detail::tvec2<bool>(
+        abs(x.x - y.x) < epsilon.x,
+        abs(x.y - y.y) < epsilon.y);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<bool> equalEpsilon
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y, 
+	detail::tvec3<valType> const & epsilon
+)
+{
+    return detail::tvec3<bool>(
+        abs(x.x - y.x) < epsilon.x,
+        abs(x.y - y.y) < epsilon.y,
+        abs(x.z - y.z) < epsilon.z);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<bool> equalEpsilon
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y, 
+	detail::tvec4<valType> const & epsilon
+)
+{
+    return detail::tvec4<bool>(
+        abs(x.x - y.x) < epsilon.x,
+        abs(x.y - y.y) < epsilon.y,
+        abs(x.z - y.z) < epsilon.z,
+        abs(x.w - y.w) < epsilon.w);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<bool> notEqualEpsilon
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y, 
+	detail::tvec2<valType> const & epsilon
+)
+{
+    return detail::tvec2<bool>(
+        abs(x.x - y.x) >= epsilon.x,
+        abs(x.y - y.y) >= epsilon.y);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<bool> notEqualEpsilon
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y, 
+	detail::tvec3<valType> const & epsilon
+)
+{
+    return detail::tvec3<bool>(
+        abs(x.x - y.x) >= epsilon.x,
+        abs(x.y - y.y) >= epsilon.y,
+        abs(x.z - y.z) >= epsilon.z);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y, 
+	detail::tvec4<valType> const & epsilon
+)
+{
+    return detail::tvec4<bool>(
+        abs(x.x - y.x) >= epsilon.x,
+        abs(x.y - y.y) >= epsilon.y,
+        abs(x.z - y.z) >= epsilon.z,
+        abs(x.w - y.w) >= epsilon.w);
+}
+
+}//namespace epsilon
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/euler_angles.hpp b/ExternalLibs/glm/gtx/euler_angles.hpp
new file mode 100644
index 0000000..fd73ee0
--- /dev/null
+++ b/ExternalLibs/glm/gtx/euler_angles.hpp
@@ -0,0 +1,141 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2007-08-14
+// Licence : This source is under MIT License
+// File    : glm/gtx/euler_angles.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// ToDo:
+// - mat2 mat2GTX(const vec2& angles) undefined
+// - mat3 mat3GTX(const vec2& angles) undefined
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_euler_angles
+#define glm_gtx_euler_angles
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_euler_angles extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
+{
+	/// \addtogroup gtx_euler_angles
+	/// @{
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleX(
+		valType const & angleX);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleY(
+		valType const & angleY);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleZ(
+		valType const & angleZ);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleXY(
+		valType const & angleX, 
+		valType const & angleY);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleYX(
+		valType const & angleY, 
+		valType const & angleX);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleXZ(
+		valType const & angleX, 
+		valType const & angleZ);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleZX(
+		valType const & angleZ, 
+		valType const & angleX);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleYZ(
+		valType const & angleY, 
+		valType const & angleZ);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleZY(
+		valType const & angleZ, 
+		valType const & angleY);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleYXZ(
+		valType const & yaw, 
+		valType const & pitch, 
+		valType const & roll);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> yawPitchRoll(
+		valType const & yaw, 
+		valType const & pitch, 
+		valType const & roll);
+
+	//! Creates a 2D 2 * 2 rotation matrix from an euler angle.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat2x2<T> orientate2(T const & angle);
+
+	//! Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat3x3<T> orientate3(T const & angle);
+
+	//! Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). 
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat3x3<T> orientate3(detail::tvec3<T> const & angles);
+		
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
+
+	/// @}
+}//namespace euler_angles
+}//namespace gtx
+}//namespace glm
+
+#include "euler_angles.inl"
+
+namespace glm{using namespace gtx::euler_angles;}
+
+#endif//glm_gtx_euler_angles
diff --git a/ExternalLibs/glm/gtx/euler_angles.inl b/ExternalLibs/glm/gtx/euler_angles.inl
new file mode 100644
index 0000000..afde6ba
--- /dev/null
+++ b/ExternalLibs/glm/gtx/euler_angles.inl
@@ -0,0 +1,249 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2007-08-14
+// Licence : This source is under MIT License
+// File    : glm/gtx/euler_angles.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace euler_angles{
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
+(
+	valType const & angleX
+)
+{
+	valType cosX = glm::cos(angleX);
+	valType sinX = glm::sin(angleX);
+	
+	return detail::tmat4x4<valType>(
+		valType(1), valType(0), valType(0), valType(0),
+		valType(0), cosX,		sinX,		valType(0),
+		valType(0),-sinX,		cosX,		valType(0),
+		valType(0), valType(0), valType(0), valType(1));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleY
+(
+	valType const & angleY
+)
+{
+	valType cosY = glm::cos(angleY);
+	valType sinY = glm::sin(angleY);
+
+	return detail::tmat4x4<valType>(
+		cosY,		valType(0),	sinY,		valType(0),
+		valType(0),	valType(1),	valType(0), valType(0),
+		-sinY,		valType(0),	cosY,		valType(0),
+		valType(0),	valType(0),	valType(0), valType(1));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZ
+(
+	valType const & angleZ
+)
+{
+	valType cosZ = glm::cos(angleZ); 
+	valType sinZ = glm::sin(angleZ);
+
+	return detail::tmat4x4<valType>(
+		cosZ,		sinZ,		valType(0), valType(0),
+		-sinZ,		cosZ,		valType(0), valType(0),
+		valType(0),	valType(0),	valType(1), valType(0),
+		valType(0),	valType(0),	valType(0), valType(1));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXY
+(
+	valType const & angleX, 
+	valType const & angleY
+)
+{
+	valType cosX = glm::cos(angleX);
+	valType sinX = glm::sin(angleX);
+	valType cosY = glm::cos(angleY);
+	valType sinY = glm::sin(angleY);
+
+	return detail::tmat4x4<valType>(
+		cosY,		-sinX * sinY,	cosX * sinY,	valType(0),
+		valType(0), cosX,			sinX,			valType(0),
+		-sinY ,		-sinX * cosY,	cosX * cosY,	valType(0),
+		valType(0), valType(0),     valType(0),		valType(1));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYX
+(
+	valType const & angleY, 
+	valType const & angleX
+)
+{
+	valType cosX = glm::cos(angleX); 
+	valType sinX = glm::sin(angleX); 
+	valType cosY = glm::cos(angleY); 
+	valType sinY = glm::sin(angleY);
+
+	return detail::tmat4x4<valType>(
+		cosY,			valType(0),		sinY,			valType(0),
+		-sinX * sinY,	cosX,			sinX * cosY,	valType(0),
+		-cosX * sinY,	-sinX,			cosX * cosY,	valType(0),
+		valType(0),		valType(0),		valType(0),		valType(1));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleXZ
+(
+	valType const & angleX, 
+	valType const & angleZ
+)
+{
+	return eulerAngleX(angleX) * eulerAngleZ(angleZ);
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleZX
+(
+	valType const & angleZ, 
+	valType const & angleX
+)
+{
+	return eulerAngleZ(angleZ) * eulerAngleX(angleX);
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleYXZ
+(
+	valType const & yaw, 
+	valType const & pitch, 
+	valType const & roll
+)
+{
+    valType tmp_ch = glm::cos(yaw);
+    valType tmp_sh = glm::sin(yaw);
+    valType tmp_cp = glm::cos(pitch);
+    valType tmp_sp = glm::sin(pitch);
+    valType tmp_cb = glm::cos(roll);
+    valType tmp_sb = glm::sin(roll);
+
+    detail::tmat4x4<valType> Result;
+    Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
+    Result[0][1] = tmp_sb * tmp_cp;
+    Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
+    Result[0][3] = valType(0);
+    Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
+    Result[1][1] = tmp_cb * tmp_cp;
+    Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
+    Result[1][3] = valType(0);
+    Result[2][0] = tmp_sh * tmp_cp;
+    Result[2][1] = -tmp_sp;
+    Result[2][2] = tmp_ch * tmp_cp;
+    Result[2][3] = valType(0);
+    Result[3][0] = valType(0);
+    Result[3][1] = valType(0);
+    Result[3][2] = valType(0);
+    Result[3][3] = valType(1);
+    return Result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> yawPitchRoll
+(
+	valType const & yaw, 
+	valType const & pitch, 
+	valType const & roll
+)
+{
+    valType tmp_ch = glm::cos(yaw);
+    valType tmp_sh = glm::sin(yaw);
+    valType tmp_cp = glm::cos(pitch);
+    valType tmp_sp = glm::sin(pitch);
+    valType tmp_cb = glm::cos(roll);
+    valType tmp_sb = glm::sin(roll);
+
+    detail::tmat4x4<valType> Result;
+    Result[0][0] = tmp_ch * tmp_cb + tmp_sh * tmp_sp * tmp_sb;
+    Result[0][1] = tmp_sb * tmp_cp;
+    Result[0][2] = -tmp_sh * tmp_cb + tmp_ch * tmp_sp * tmp_sb;
+    Result[0][3] = valType(0);
+    Result[1][0] = -tmp_ch * tmp_sb + tmp_sh * tmp_sp * tmp_cb;
+    Result[1][1] = tmp_cb * tmp_cp;
+    Result[1][2] = tmp_sb * tmp_sh + tmp_ch * tmp_sp * tmp_cb;
+    Result[1][3] = valType(0);
+    Result[2][0] = tmp_sh * tmp_cp;
+    Result[2][1] = -tmp_sp;
+    Result[2][2] = tmp_ch * tmp_cp;
+    Result[2][3] = valType(0);
+    Result[3][0] = valType(0);
+    Result[3][1] = valType(0);
+    Result[3][2] = valType(0);
+    Result[3][3] = valType(1);
+    return Result;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tmat2x2<valType> orientate2
+(
+	valType const & angle
+)
+{
+    valType c = glm::cos(angle);
+    valType s = glm::sin(angle);
+
+	detail::tmat2x2<valType> Result;
+    Result[0][0] = c;
+    Result[0][1] = s;
+    Result[1][0] = -s;
+    Result[1][1] = c;
+	return Result;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
+(
+	valType const & angle
+)
+{
+    valType c = glm::cos(angle);
+    valType s = glm::sin(angle);
+
+	detail::tmat3x3<valType> Result;
+    Result[0][0] = c;
+    Result[0][1] = s;
+	Result[0][2] = 0.0f;
+    Result[1][0] = -s;
+    Result[1][1] = c;
+	Result[1][2] = 0.0f;
+	Result[2][0] = 0.0f;
+	Result[2][1] = 0.0f;
+	Result[2][2] = 1.0f;
+	return Result;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tmat3x3<valType> orientate3
+(
+	detail::tvec3<valType> const & angles
+)
+{
+	return detail::tmat3x3<valType>(yawPitchRoll(angles.x, angles.y, angles.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
+(
+	detail::tvec3<valType> const & angles
+)
+{
+    return yawPitchRoll(angles.z, angles.x, angles.y);
+}
+
+}//namespace euler_angles
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/extend.hpp b/ExternalLibs/glm/gtx/extend.hpp
new file mode 100644
index 0000000..9b38b61
--- /dev/null
+++ b/ExternalLibs/glm/gtx/extend.hpp
@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-07
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/extend.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_extend
+#define glm_gtx_extend
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_extend extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
+{
+	/// \addtogroup gtx_extend
+	/// @{
+
+	//! Extends of Length the Origin position using the (Source - Origin) direction.
+	//! From GLM_GTX_extend extension.
+	template <typename genType> 
+	genType extend(
+		genType const & Origin, 
+		genType const & Source, 
+		typename genType::value_type const Length);
+
+	/// @}
+}//namespace extend
+}//namespace gtx
+}//namespace glm
+
+#include "extend.inl"
+
+namespace glm{using namespace gtx::extend;}
+
+#endif//glm_gtx_extend
diff --git a/ExternalLibs/glm/gtx/extend.inl b/ExternalLibs/glm/gtx/extend.inl
new file mode 100644
index 0000000..42eb368
--- /dev/null
+++ b/ExternalLibs/glm/gtx/extend.inl
@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-07
+// Updated : 2008-10-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/extend.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace extend{
+
+template <typename genType>
+genType extend
+(
+	genType const & Origin, 
+	genType const & Source, 
+	genType const & Distance
+)
+{
+    return Origin + (Source - Origin) * Distance;
+}
+
+template <typename valType>
+detail::tvec2<valType> extend
+(
+	detail::tvec2<valType> const & Origin, 
+	detail::tvec2<valType> const & Source, 
+	valType const & Distance
+)
+{
+    return Origin + (Source - Origin) * Distance;
+}
+
+template <typename valType>
+detail::tvec3<valType> extend
+(
+	detail::tvec3<valType> const & Origin, 
+	detail::tvec3<valType> const & Source, 
+	valType const & Distance
+)
+{
+    return Origin + (Source - Origin) * Distance;
+}
+
+template <typename valType>
+detail::tvec4<valType> extend
+(
+	detail::tvec4<valType> const & Origin, 
+	detail::tvec4<valType> const & Source, 
+	valType const & Distance
+)
+{
+    return Origin + (Source - Origin) * Distance;
+}
+
+}//namespace extend
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/extented_min_max.hpp b/ExternalLibs/glm/gtx/extented_min_max.hpp
new file mode 100644
index 0000000..2ace702
--- /dev/null
+++ b/ExternalLibs/glm/gtx/extented_min_max.hpp
@@ -0,0 +1,175 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-14
+// Updated : 2010-02-19
+// Licence : This source is under MIT License
+// File    : gtx_extented_min_max.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_extented_min_max
+#define glm_gtx_extented_min_max
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_extented_min_max extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
+{
+	/// \addtogroup gtx_extented_min_max
+	///@{
+
+	//< Return the minimum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T min(
+		T const & x, 
+		T const & y, 
+		T const & z);
+
+	//< Return the minimum component-wise values of 3 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z);
+
+	//< Return the minimum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z);
+
+	//< Return the minimum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T min(
+		T const & x, 
+		T const & y, 
+		T const & z, 
+		T const & w);
+
+	//< Return the minimum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z, 
+		typename C<T>::value_type const & w);
+
+	//< Return the minimum component-wise values of 4 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z,
+		C<T> const & w);
+
+	//< Return the maximum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T max(
+		T const & x, 
+		T const & y, 
+		T const & z);
+
+	//< Return the maximum component-wise values of 3 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z);
+
+	//< Return the maximum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z);
+
+	//< Return the maximum component-wise values of 4 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T max(
+		T const & x, 
+		T const & y, 
+		T const & z, 
+		T const & w);
+
+	//< Return the maximum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z, 
+		typename C<T>::value_type const & w);
+
+	//< Return the maximum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z, 
+		C<T> const & w);
+
+	/// @}
+}//namespace extented_min_max
+}//namespace gtx
+}//namespace glm
+
+#include "extented_min_max.inl"
+
+namespace glm{using namespace gtx::extented_min_max;}
+
+#endif//glm_gtx_extented_min_max
diff --git a/ExternalLibs/glm/gtx/extented_min_max.inl b/ExternalLibs/glm/gtx/extented_min_max.inl
new file mode 100644
index 0000000..2cab82a
--- /dev/null
+++ b/ExternalLibs/glm/gtx/extented_min_max.inl
@@ -0,0 +1,182 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-14
+// Updated : 2010-02-19
+// Licence : This source is under MIT License
+// File    : gtx_extented_min_max.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace extented_min_max
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER T min(
+		T const & x, 
+		T const & y, 
+		T const & z)
+	{
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z
+	)
+	{
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z
+	)
+	{
+		return glm::min(glm::min(x, y), z);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T min
+	(
+		T const & x, 
+		T const & y, 
+		T const & z, 
+		T const & w
+	)
+	{
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z, 
+		typename C<T>::value_type const & w
+	)
+	{
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> min
+	(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z, 
+		C<T> const & w
+	)
+	{
+		return glm::min(glm::min(x, y), glm::min(z, w));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T max(
+		T const & x, 
+		T const & y, 
+		T const & z)
+	{
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z
+	)
+	{
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z
+	)
+	{
+		return glm::max(glm::max(x, y), z);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T max
+	(
+		T const & x, 
+		T const & y, 
+		T const & z, 
+		T const & w
+	)
+	{
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z, 
+		typename C<T>::value_type const & w
+	)
+	{
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	GLM_FUNC_QUALIFIER C<T> max
+	(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z, 
+		C<T> const & w
+	)
+	{
+		return glm::max(glm::max(x, y), glm::max(z, w));
+	}
+
+}//namespace extented_min_max
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/fast_exponential.hpp b/ExternalLibs/glm/gtx/fast_exponential.hpp
new file mode 100644
index 0000000..739fc5b
--- /dev/null
+++ b/ExternalLibs/glm/gtx/fast_exponential.hpp
@@ -0,0 +1,81 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-09
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/fast_exponential.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_fast_exponential
+#define glm_gtx_fast_exponential
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_fast_exponential extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
+{
+	using namespace gtc::half_float;
+	/// \addtogroup gtx_fast_exponential
+	/// @{
+
+	//! Faster than the common pow function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename valType> 
+	valType fastPow(
+		valType const & x, 
+		valType const & y);
+
+	//! Faster than the common pow function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T, typename U> 
+	T fastPow(
+		const T& x, 
+		const U& y);
+		
+	//! Faster than the common exp function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastExp(const T& x);
+		
+	//! Faster than the common log function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastLog(const T& x);
+
+	//! Faster than the common exp2 function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastExp2(const T& x);
+		
+	//! Faster than the common log2 function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastLog2(const T& x);
+
+	//! Faster than the common ln function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastLn(const T& x);
+
+	/// @}
+}//namespace fast_exponential
+}//namespace gtx
+}//namespace glm
+
+#include "fast_exponential.inl"
+
+namespace glm{using namespace gtx::fast_exponential;}
+
+#endif//glm_gtx_fast_exponential
diff --git a/ExternalLibs/glm/gtx/fast_exponential.inl b/ExternalLibs/glm/gtx/fast_exponential.inl
new file mode 100644
index 0000000..64aa2cb
--- /dev/null
+++ b/ExternalLibs/glm/gtx/fast_exponential.inl
@@ -0,0 +1,294 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-09
+// Updated : 2006-01-09
+// Licence : This source is under MIT License
+// File    : glm/gtx/fast_exponential.h
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace fast_exponential
+{
+    // fastPow:
+	template <typename T>
+    GLM_FUNC_QUALIFIER T fastPow(const T x, const T y)
+    {
+        return exp(y * log(x));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
+		const detail::tvec2<T>& x, 
+		const detail::tvec2<T>& y)
+    {
+        return detail::tvec2<T>(
+            fastPow(x.x, y.x),
+            fastPow(x.y, y.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y)
+    {
+        return detail::tvec3<T>(
+            fastPow(x.x, y.x),
+            fastPow(x.y, y.y),
+            fastPow(x.z, y.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
+		const detail::tvec4<T>& x, 
+		const detail::tvec4<T>& y)
+    {
+        return detail::tvec4<T>(
+            fastPow(x.x, y.x),
+            fastPow(x.y, y.y),
+            fastPow(x.z, y.z),
+            fastPow(x.w, y.w));
+    }
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
+    {
+        T f = T(1);
+        for(int i = 0; i < y; ++i)
+            f *= x;
+        return f;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
+		const detail::tvec2<T>& x, 
+		const detail::tvec2<int>& y)
+    {
+        return detail::tvec2<T>(
+            fastPow(x.x, y.x),
+            fastPow(x.y, y.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<int>& y)
+    {
+        return detail::tvec3<T>(
+            fastPow(x.x, y.x),
+            fastPow(x.y, y.y),
+            fastPow(x.z, y.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
+		const detail::tvec4<T>& x, 
+		const detail::tvec4<int>& y)
+    {
+        return detail::tvec4<T>(
+            fastPow(x.x, y.x),
+            fastPow(x.y, y.y),
+            fastPow(x.z, y.z),
+            fastPow(x.w, y.w));
+    }
+
+    // fastExp
+    // Note: This function provides accurate results only for value between -1 and 1, else avoid it.
+	template <typename T>
+    GLM_FUNC_QUALIFIER T fastExp(const T x)
+    {
+        // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
+        // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
+        T x2 = x * x;
+        T x3 = x2 * x;
+        T x4 = x3 * x;
+        T x5 = x4 * x;
+        return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333));
+    }
+/*  // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance
+    GLM_FUNC_QUALIFIER float fastExp(float x)
+    {
+        const float e = 2.718281828f;
+        const float IntegerPart = floor(x);
+        const float FloatPart = x - IntegerPart;
+        float z = 1.f;
+
+        for(int i = 0; i < int(IntegerPart); ++i)
+            z *= e;
+
+        const float x2 = FloatPart * FloatPart;
+        const float x3 = x2 * FloatPart;
+        const float x4 = x3 * FloatPart;
+        const float x5 = x4 * FloatPart;
+        return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f));
+    }
+
+    // Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
+    GLM_FUNC_QUALIFIER float fastExp(float x)
+    {
+        // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
+        // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
+        float x2 = x * x;
+        float x3 = x2 * x;
+        float x4 = x3 * x;
+        float x5 = x4 * x;
+        float x6 = x5 * x;
+        float x7 = x6 * x;
+        float x8 = x7 * x;
+        return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);;
+    }
+*/
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastExp(x.x),
+            fastExp(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastExp(x.x),
+            fastExp(x.y),
+            fastExp(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastExp(x.x),
+            fastExp(x.y),
+            fastExp(x.z),
+            fastExp(x.w));
+    }
+
+    // fastLog
+	template <typename T>
+    GLM_FUNC_QUALIFIER T fastLog(const T x)
+    {
+        return std::log(x);
+    }
+
+    /* Slower than the VC7.1 function...
+    GLM_FUNC_QUALIFIER float fastLog(float x)
+    {
+        float y1 = (x - 1.0f) / (x + 1.0f);
+        float y2 = y1 * y1;
+        return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f)));
+    }
+    */
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastLog(x.x),
+            fastLog(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastLog(x.x),
+            fastLog(x.y),
+            fastLog(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastLog(x.x),
+            fastLog(x.y),
+            fastLog(x.z),
+            fastLog(x.w));
+    }
+
+    //fastExp2, ln2 = 0.69314718055994530941723212145818f
+	template <typename T>
+    GLM_FUNC_QUALIFIER T fastExp2(const T x)
+    {
+        return fastExp(0.69314718055994530941723212145818f * x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp2(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastExp2(x.x),
+            fastExp2(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp2(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastExp2(x.x),
+            fastExp2(x.y),
+            fastExp2(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp2(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastExp2(x.x),
+            fastExp2(x.y),
+            fastExp2(x.z),
+            fastExp2(x.w));
+    }
+
+    // fastLog2, ln2 = 0.69314718055994530941723212145818f
+	template <typename T>
+    GLM_FUNC_QUALIFIER T fastLog2(const T x)
+    {
+        return fastLog(x) / 0.69314718055994530941723212145818f;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog2(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastLog2(x.x),
+            fastLog2(x.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog2(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastLog2(x.x),
+            fastLog2(x.y),
+            fastLog2(x.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog2(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastLog2(x.x),
+            fastLog2(x.y),
+            fastLog2(x.z),
+            fastLog2(x.w));
+    }
+
+}//namespace fast_exponential
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/fast_square_root.hpp b/ExternalLibs/glm/gtx/fast_square_root.hpp
new file mode 100644
index 0000000..333ac30
--- /dev/null
+++ b/ExternalLibs/glm/gtx/fast_square_root.hpp
@@ -0,0 +1,68 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-04
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/fast_square_root.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Note:
+// - Sqrt optimisation based on Newton's method, 
+// www.gamedev.net/community/forums/topic.asp?topic id=139956
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_fast_square_root
+#define glm_gtx_fast_square_root
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_fast_square_root extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace fast_square_root 	///< GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
+{
+	/// \addtogroup gtx_fast_square_root
+	/// @{
+
+	//! Faster than the common sqrt function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	genType fastSqrt(genType const & x);
+
+	//! Faster than the common inversesqrt function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	genType fastInverseSqrt(genType const & x);
+		
+	//! Faster than the common length function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	typename genType::value_type fastLength(genType const & x);
+
+	//! Faster than the common distance function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	typename genType::value_type fastDistance(genType const & x, genType const & y);
+
+	//! Faster than the common normalize function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	genType fastNormalize(genType const & x);
+
+	/// @}
+}// namespace fast_square_root
+}// namespace gtx
+}// namespace glm
+
+#include "fast_square_root.inl"
+
+namespace glm{using namespace gtx::fast_square_root;}
+
+#endif//glm_gtx_fast_square_root
diff --git a/ExternalLibs/glm/gtx/fast_square_root.inl b/ExternalLibs/glm/gtx/fast_square_root.inl
new file mode 100644
index 0000000..0400bde
--- /dev/null
+++ b/ExternalLibs/glm/gtx/fast_square_root.inl
@@ -0,0 +1,237 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-04
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/fast_square_root.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace fast_square_root{
+
+// fastSqrt
+template <typename genType>
+GLM_FUNC_QUALIFIER genType fastSqrt
+(
+	genType const & x
+)
+{
+    return genType(1) / fastInverseSqrt(x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> fastSqrt
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        fastSqrt(x.x), 
+        fastSqrt(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> fastSqrt
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        fastSqrt(x.x), 
+        fastSqrt(x.y), 
+        fastSqrt(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> fastSqrt
+(
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        fastSqrt(x.x), 
+        fastSqrt(x.y), 
+        fastSqrt(x.z), 
+        fastSqrt(x.w));
+}
+
+// fastInversesqrt
+template <typename genType>
+GLM_FUNC_QUALIFIER genType fastInverseSqrt
+(
+	genType const & x
+)
+{
+	genType tmp = x;
+    float xhalf = 0.5f * float(tmp);
+    uint i = *(uint*)&x;
+    i = 0x5f375a86 - (i >> 1);
+    //x = *(float*)&i;
+	//x = *((float*)(char*)&i);
+	tmp = detail::uif(i).f;
+	tmp = tmp * (1.5f - xhalf * tmp * tmp);
+    return genType(tmp);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> fastInverseSqrt
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        fastInverseSqrt(x.x), 
+        fastInverseSqrt(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> fastInverseSqrt
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        fastInverseSqrt(x.x), 
+        fastInverseSqrt(x.y), 
+        fastInverseSqrt(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> fastInverseSqrt
+(
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        fastInverseSqrt(x.x), 
+        fastInverseSqrt(x.y), 
+        fastInverseSqrt(x.z), 
+        fastInverseSqrt(x.w));
+}
+
+// fastLength
+template <typename genType>
+GLM_FUNC_QUALIFIER genType fastLength
+(
+	genType const & x
+)
+{
+    return abs(x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType fastLength
+(
+	detail::tvec2<valType> const & x
+)
+{
+    valType sqr = x.x * x.x + x.y * x.y;
+    return fastSqrt(sqr);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType fastLength
+(
+	detail::tvec3<valType> const & x
+)
+{
+    valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+    return fastSqrt(sqr);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType fastLength
+(
+	detail::tvec4<valType> const & x
+)
+{
+    valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+    return fastSqrt(sqr);
+}
+
+// fastDistance
+template <typename genType>
+GLM_FUNC_QUALIFIER genType fastDistance
+(
+	genType const & x, 
+	genType const & y
+)
+{
+    return fastLength(y - x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType fastDistance
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y
+)
+{
+    return fastLength(y - x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType fastDistance
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y
+)
+{
+    return fastLength(y - x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType fastDistance
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y
+)
+{
+    return fastLength(y - x);
+}
+
+// fastNormalize
+template <typename genType>
+GLM_FUNC_QUALIFIER genType fastNormalize
+(
+	genType const & x
+)
+{
+    return x > genType(0) ? genType(1) : -genType(1);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> fastNormalize
+(
+	detail::tvec2<valType> const & x
+)
+{
+    valType sqr = x.x * x.x + x.y * x.y;
+    return x * fastInverseSqrt(sqr);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> fastNormalize
+(
+	detail::tvec3<valType> const & x
+)
+{
+    valType sqr = x.x * x.x + x.y * x.y + x.z * x.z;
+    return x * fastInverseSqrt(sqr);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> fastNormalize
+(
+	detail::tvec4<valType> const & x
+)
+{
+    valType sqr = x.x * x.x + x.y * x.y + x.z * x.z + x.w * x.w;
+    return x * fastInverseSqrt(sqr);
+}
+
+}//namespace fast_square_root
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/fast_trigonometry.hpp b/ExternalLibs/glm/gtx/fast_trigonometry.hpp
new file mode 100644
index 0000000..daa8487
--- /dev/null
+++ b/ExternalLibs/glm/gtx/fast_trigonometry.hpp
@@ -0,0 +1,81 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-08
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/fast_trigonometry.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_fast_trigonometry
+#define glm_gtx_fast_trigonometry
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace fast_trigonometry	///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
+{
+	/// \addtogroup gtx_fast_trigonometry
+	/// @{
+
+	//! Faster than the common sin function but less accurate. 
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+    template <typename T> 
+	T fastSin(const T& angle);
+
+    //! Faster than the common cos function but less accurate.
+	//! Defined between -2pi and 2pi.
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastCos(const T& angle);
+
+    //! Faster than the common tan function but less accurate. 
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastTan(const T& angle);
+
+    //! Faster than the common asin function but less accurate. 
+	//! Defined between -2pi and 2pi.
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastAsin(const T& angle);
+
+	//! Faster than the common acos function but less accurate. 
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+    template <typename T> 
+	T fastAcos(const T& angle);
+
+	//! Faster than the common atan function but less accurate.
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastAtan(const T& y, const T& x);
+
+	//! Faster than the common atan function but less accurate. 
+	//! Defined between -2pi and 2pi.
+	//! From GLM_GTX_fast_trigonometry extension.
+    template <typename T> 
+	T fastAtan(const T& angle);
+
+	/// @}
+}//namespace fast_trigonometry
+}//namespace gtx
+}//namespace glm
+
+#include "fast_trigonometry.inl"
+
+namespace glm{using namespace gtx::fast_trigonometry;}
+
+#endif//glm_gtx_fast_trigonometry
diff --git a/ExternalLibs/glm/gtx/fast_trigonometry.inl b/ExternalLibs/glm/gtx/fast_trigonometry.inl
new file mode 100644
index 0000000..de3d359
--- /dev/null
+++ b/ExternalLibs/glm/gtx/fast_trigonometry.inl
@@ -0,0 +1,272 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-08
+// Updated : 2006-01-08
+// Licence : This source is under MIT License
+// File    : glm/gtx/fast_trigonometry.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace fast_trigonometry
+{
+    // sin
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastSin(const T x)
+    {
+        return x - ((x * x * x) / T(6)) + ((x * x * x * x * x) / T(120)) - ((x * x * x * x * x * x * x) / T(5040));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastSin(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastSin(x.x),
+            fastSin(x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastSin(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastSin(x.x),
+            fastSin(x.y),
+            fastSin(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastSin(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastSin(x.x),
+            fastSin(x.y),
+            fastSin(x.z),
+            fastSin(x.w));
+    }
+
+    // cos
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastCos(const T x)
+    {
+        return T(1) - (x * x * T(0.5)) + (x * x * x * x * T(0.041666666666)) - (x * x * x * x * x * x * T(0.00138888888888));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastCos(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastCos(x.x),
+            fastCos(x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastCos(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastCos(x.x),
+            fastCos(x.y),
+            fastCos(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastCos(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastCos(x.x),
+            fastCos(x.y),
+            fastCos(x.z),
+            fastCos(x.w));
+    }
+
+    // tan
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastTan(const T x)
+    {
+        return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastTan(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastTan(x.x),
+            fastTan(x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastTan(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastTan(x.x),
+            fastTan(x.y),
+            fastTan(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastTan(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastTan(x.x),
+            fastTan(x.y),
+            fastTan(x.z),
+            fastTan(x.w));
+    }
+
+    // asin
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastAsin(const T x)
+    {
+        return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
+    }
+
+    template <typename T> detail::tvec2<T> fastAsin(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastAsin(x.x),
+            fastAsin(x.y));
+    }
+
+    template <typename T> detail::tvec3<T> fastAsin(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastAsin(x.x),
+            fastAsin(x.y),
+            fastAsin(x.z));
+    }
+
+    template <typename T> detail::tvec4<T> fastAsin(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastAsin(x.x),
+            fastAsin(x.y),
+            fastAsin(x.z),
+            fastAsin(x.w));
+    }
+
+    // acos
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastAcos(const T x)
+    {
+        return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
+    }
+
+    template <typename T> detail::tvec2<T> fastAcos(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastAcos(x.x),
+            fastAcos(x.y));
+    }
+
+    template <typename T> detail::tvec3<T> fastAcos(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastAcos(x.x),
+            fastAcos(x.y),
+            fastAcos(x.z));
+    }
+
+    template <typename T> detail::tvec4<T> fastAcos(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastAcos(x.x),
+            fastAcos(x.y),
+            fastAcos(x.z),
+            fastAcos(x.w));
+    }
+
+    // atan
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastAtan(const T y, const T x)
+    {
+        T sgn = sign(y) * sign(x);
+        return abs(fastAtan(y / x)) * sgn;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastAtan(
+		const detail::tvec2<T>& y, 
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastAtan(y.x, x.x),
+            fastAtan(y.y, x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastAtan(
+		const detail::tvec3<T>& y, 
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastAtan(y.x, x.x),
+            fastAtan(y.y, x.y),
+            fastAtan(y.z, x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastAtan(
+		const detail::tvec4<T>& y, 
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastAtan(y.x, x.x),
+            fastAtan(y.y, x.y),
+            fastAtan(y.z, x.z),
+            fastAtan(y.w, x.w));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T fastAtan(const T x)
+    {
+        return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<T> fastAtan(
+		const detail::tvec2<T>& x)
+    {
+        return detail::tvec2<T>(
+            fastAtan(x.x),
+            fastAtan(x.y));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> fastAtan(
+		const detail::tvec3<T>& x)
+    {
+        return detail::tvec3<T>(
+            fastAtan(x.x),
+            fastAtan(x.y),
+            fastAtan(x.z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> fastAtan(
+		const detail::tvec4<T>& x)
+    {
+        return detail::tvec4<T>(
+            fastAtan(x.x),
+            fastAtan(x.y),
+            fastAtan(x.z),
+            fastAtan(x.w));
+    }
+
+}//namespace fast_trigonometry
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/gradient_paint.hpp b/ExternalLibs/glm/gtx/gradient_paint.hpp
new file mode 100644
index 0000000..ea0bd0a
--- /dev/null
+++ b/ExternalLibs/glm/gtx/gradient_paint.hpp
@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-03-06
+// Updated : 2009-03-09
+// Licence : This source is under MIT License
+// File    : glm/gtx/gradient_paint.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_gradient_paint
+#define glm_gtx_gradient_paint
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/optimum_pow.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_gradient_paint extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
+{
+	using namespace gtx::optimum_pow;
+
+	/// \addtogroup gtx_gradient_paint
+	/// @{
+
+	template <typename valType>
+	valType radialGradient(
+		glm::detail::tvec2<valType> const & Center,
+		valType const & Radius,
+		glm::detail::tvec2<valType> const & Focal,
+		glm::detail::tvec2<valType> const & Position);
+
+	template <typename valType>
+	valType linearGradient(
+		glm::detail::tvec2<valType> const & Point0,
+		glm::detail::tvec2<valType> const & Point1,
+		glm::detail::tvec2<valType> const & Position);
+
+	/// @}
+}// namespace gradient_paint
+}// namespace gtx
+}// namespace glm
+
+#include "gradient_paint.inl"
+
+namespace glm{using namespace gtx::gradient_paint;}
+
+#endif//glm_gtx_gradient_paint
diff --git a/ExternalLibs/glm/gtx/gradient_paint.inl b/ExternalLibs/glm/gtx/gradient_paint.inl
new file mode 100644
index 0000000..d3ad800
--- /dev/null
+++ b/ExternalLibs/glm/gtx/gradient_paint.inl
@@ -0,0 +1,44 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-03-06
+// Updated : 2009-03-09
+// Licence : This source is under MIT License
+// File    : glm/gtx/gradient_paint.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace gradient_paint{
+
+	template <typename valType>
+	valType radialGradient(
+		glm::detail::tvec2<valType> const & Center,
+		valType const & Radius,
+		glm::detail::tvec2<valType> const & Focal,
+		glm::detail::tvec2<valType> const & Position)
+	{
+		glm::detail::tvec2<valType> F = Focal - Center;
+		glm::detail::tvec2<valType> D = Position - Focal;
+		valType Radius2 = gtx::optimum_pow::pow2(Radius);
+		valType Fx2 = gtx::optimum_pow::pow2(F.x);
+		valType Fy2 = gtx::optimum_pow::pow2(F.y);
+
+		valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::optimum_pow::pow2(D.x) + gtx::optimum_pow::pow2(D.y)) - gtx::optimum_pow::pow2(D.x * F.y - D.y * F.x));
+		valType Denominator = Radius2 - (Fx2 + Fy2);
+		return Numerator / Denominator;
+	}
+
+	template <typename valType>
+	valType linearGradient(
+		glm::detail::tvec2<valType> const & Point0,
+		glm::detail::tvec2<valType> const & Point1,
+		glm::detail::tvec2<valType> const & Position)
+	{
+		glm::detail::tvec2<valType> Dist = Point1 - Point0;
+		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
+	}
+
+}//namespace gradient_paint
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/handed_coordinate_space.hpp b/ExternalLibs/glm/gtx/handed_coordinate_space.hpp
new file mode 100644
index 0000000..ca68bc9
--- /dev/null
+++ b/ExternalLibs/glm/gtx/handed_coordinate_space.hpp
@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/handed_coordinate_space.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_handed_coordinate_space
+#define glm_gtx_handed_coordinate_space
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
+{
+	/// \addtogroup gtx_handed_coordinate_space
+	/// @{
+
+	//! Return if a trihedron right handed or not.
+	//! From GLM_GTX_handed_coordinate_space extension.
+	template <typename T> 
+	bool rightHanded(
+		detail::tvec3<T> const & tangent, 
+		detail::tvec3<T> const & binormal, 
+		detail::tvec3<T> const & normal);
+
+	//! Return if a trihedron left handed or not.
+	//! From GLM_GTX_handed_coordinate_space extension.
+	template <typename T> 
+	bool leftHanded(
+		detail::tvec3<T> const & tangent, 
+		detail::tvec3<T> const & binormal, 
+		detail::tvec3<T> const & normal);
+
+	/// @}
+}// namespace handed_coordinate_space
+}// namespace gtx
+}// namespace glm
+
+#include "handed_coordinate_space.inl"
+
+namespace glm{using namespace gtx::handed_coordinate_space;}
+
+#endif//glm_gtx_handed_coordinate_space
diff --git a/ExternalLibs/glm/gtx/handed_coordinate_space.inl b/ExternalLibs/glm/gtx/handed_coordinate_space.inl
new file mode 100644
index 0000000..5660eab
--- /dev/null
+++ b/ExternalLibs/glm/gtx/handed_coordinate_space.inl
@@ -0,0 +1,34 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/handed_coordinate_space.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace handed_coordinate_space
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER bool rightHanded(
+		detail::tvec3<T> const & tangent, 
+		detail::tvec3<T> const & binormal,
+		detail::tvec3<T> const & normal)
+    {
+        return dot(cross(normal, tangent), binormal) > T(0);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER bool leftHanded(
+		detail::tvec3<T> const & tangent, 
+		detail::tvec3<T> const & binormal, 
+		detail::tvec3<T> const & normal)
+    {
+        return dot(cross(normal, tangent), binormal) < T(0);
+    }
+
+}//namespace handed_coordinate_space
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/inertia.hpp b/ExternalLibs/glm/gtx/inertia.hpp
new file mode 100644
index 0000000..18a0653
--- /dev/null
+++ b/ExternalLibs/glm/gtx/inertia.hpp
@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/inertia.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_inertia
+#define glm_gtx_inertia
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_inertia extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
+{
+	/// \addtogroup gtx_inertia
+	/// @{
+
+	//! Build an inertia matrix for a box.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> boxInertia3(
+		const T Mass, 
+		const detail::tvec3<T>& Scale);
+		
+	//! Build an inertia matrix for a box.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> boxInertia4(
+		const T Mass, 
+		const detail::tvec3<T>& Scale);
+		
+	//! Build an inertia matrix for a disk.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> diskInertia3(
+		const T Mass, 
+		const T Radius);
+
+	//! Build an inertia matrix for a disk.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> diskInertia4(
+		const T Mass, 
+		const T Radius);
+
+	//! Build an inertia matrix for a ball.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> ballInertia3(
+		const T Mass, 
+		const T Radius);
+		
+	//! Build an inertia matrix for a ball.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> ballInertia4(
+		const T Mass, 
+		const T Radius);
+
+	//! Build an inertia matrix for a sphere.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> sphereInertia3(
+		const T Mass, 
+		const T Radius);
+
+	//! Build an inertia matrix for a sphere.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> sphereInertia4(
+		const T Mass, 
+		const T Radius);
+
+	/// @}
+}// namespace inertia
+}// namespace gtx
+}// namespace glm
+
+#include "inertia.inl"
+
+namespace glm{using namespace gtx::inertia;}
+
+#endif//glm_gtx_inertia
diff --git a/ExternalLibs/glm/gtx/inertia.inl b/ExternalLibs/glm/gtx/inertia.inl
new file mode 100644
index 0000000..c235298
--- /dev/null
+++ b/ExternalLibs/glm/gtx/inertia.inl
@@ -0,0 +1,103 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-21
+// Updated : 2006-12-06
+// Licence : This source is under MIT License
+// File    : glm/gtx/inertia.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace inertia{
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> boxInertia3(
+		const T Mass, 
+		const detail::tvec3<T>& Scale)
+    {
+	    detail::tmat3x3<T> Result(T(1));
+	    Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
+	    Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
+	    Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> boxInertia4(
+		const T Mass, 
+		const detail::tvec3<T>& Scale)
+    {
+	    detail::tmat4x4<T> Result(T(1));
+	    Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
+	    Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
+	    Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> diskInertia3(
+		const T Mass, 
+		const T Radius)
+    {
+        T a = Mass * Radius * Radius / T(2);
+        detail::tmat3x3<T> Result(a);
+        Result[2][2] *= T(2);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> diskInertia4(
+		const T Mass, 
+		const T Radius)
+    {
+        T a = Mass * Radius * Radius / T(2);
+        detail::tmat4x4<T> Result(a);
+        Result[2][2] *= T(2);
+        Result[3][3] = T(1);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> ballInertia3(
+		const T Mass, 
+		const T Radius)
+    {
+        T a = T(2) * Mass * Radius * Radius / T(5);
+        return detail::tmat3x3<T>(a);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> ballInertia4(
+		const T Mass, 
+		const T Radius)
+    {
+        T a = T(2) * Mass * Radius * Radius / T(5);
+        detail::tmat4x4<T> Result(a);
+        Result[3][3] = T(1);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> sphereInertia3(
+		const T Mass, 
+		const T Radius)
+    {
+        T a = T(2) * Mass * Radius * Radius / T(3);
+        return detail::tmat3x3<T>(a);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> sphereInertia4(
+		const T Mass, 
+		const T Radius)
+    {
+        T a = T(2) * Mass * Radius * Radius / T(3);
+        detail::tmat4x4<T> Result(a);
+        Result[3][3] = T(1);
+        return Result;
+    }
+
+}//namespace inertia
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/int_10_10_10_2.hpp b/ExternalLibs/glm/gtx/int_10_10_10_2.hpp
new file mode 100644
index 0000000..1dddd20
--- /dev/null
+++ b/ExternalLibs/glm/gtx/int_10_10_10_2.hpp
@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-07-07
+// Updated : 2010-07-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/int_10_10_10_2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_int_10_10_10_2
+#define glm_gtx_int_10_10_10_2
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/raw_data.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
+{
+	using namespace gtx::raw_data;
+
+	/// \addtogroup gtx_int_10_10_10_2
+	///@{
+
+	//! From GLM_GTX_int_10_10_10_2 extension.
+	//! Cast a vec4 to an u_10_10_10_2.
+	dword uint10_10_10_2_cast(glm::vec4 const & v);
+
+	///@}
+
+}//namespace integer
+}//namespace gtx
+}//namespace glm
+
+#include "int_10_10_10_2.inl"
+
+namespace glm{using namespace gtx::int_10_10_10_2;}
+
+#endif//glm_gtx_int_10_10_10_2
diff --git a/ExternalLibs/glm/gtx/int_10_10_10_2.inl b/ExternalLibs/glm/gtx/int_10_10_10_2.inl
new file mode 100644
index 0000000..af80f07
--- /dev/null
+++ b/ExternalLibs/glm/gtx/int_10_10_10_2.inl
@@ -0,0 +1,21 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-07-07
+// Updated : 2010-07-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/int_10_10_10_2.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace int_10_10_10_2
+{
+	GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast(glm::vec4 const & v)
+	{
+		return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
+	}
+
+}//namespace int_10_10_10_2
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/integer.hpp b/ExternalLibs/glm/gtx/integer.hpp
new file mode 100644
index 0000000..19651e2
--- /dev/null
+++ b/ExternalLibs/glm/gtx/integer.hpp
@@ -0,0 +1,56 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-24
+// Updated : 2006-11-14
+// Licence : This source is under MIT License
+// File    : glm/gtx/integer.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_integer
+#define glm_gtx_integer
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_integer extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
+{
+	/// \addtogroup gtx_integer
+	/// @{
+
+	//! Returns x raised to the y power. 
+	//! From GLM_GTX_integer extension.
+	int pow(int x, int y);
+
+	//! Returns the positive square root of x.
+	//! From GLM_GTX_integer extension.
+	int sqrt(int x);
+
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
+	//! From GLM_GTX_integer extension.
+	int mod(int x, int y);
+
+	//! Return the factorial value of a number (!12 max, integer only)
+	//! From GLM_GTX_integer extension.
+	template <typename genType> 
+	genType factorial(genType const & x);
+
+	/// @}
+}//namespace integer
+}//namespace gtx
+}//namespace glm
+
+#include "integer.inl"
+
+namespace glm{using namespace gtx::integer;}
+
+#endif//glm_gtx_integer
diff --git a/ExternalLibs/glm/gtx/integer.inl b/ExternalLibs/glm/gtx/integer.inl
new file mode 100644
index 0000000..aef659e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/integer.inl
@@ -0,0 +1,90 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-24
+// Updated : 2006-12-06
+// Licence : This source is under MIT License
+// File    : glm/gtx/integer.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace integer
+{
+    // pow
+    GLM_FUNC_QUALIFIER int pow(int x, int y)
+    {
+		if(y == 0)
+			return 1;
+        int result = x;
+        for(int i = 1; i < y; ++i)
+            result *= x;
+        return result;
+    }
+
+    // sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387
+    GLM_FUNC_QUALIFIER int sqrt(int x)
+    {
+        if(x <= 1) return x;
+
+        int NextTrial = x >> 1;
+        int CurrentAnswer;
+
+        do
+        {
+            CurrentAnswer = NextTrial;
+            NextTrial = (NextTrial + x / NextTrial) >> 1;
+        } while(NextTrial < CurrentAnswer);
+
+        return CurrentAnswer;
+    }
+
+    // mod
+	GLM_FUNC_QUALIFIER int mod(int x, int y)
+	{
+		return x - y * (x / y);
+	}
+
+    // factorial (!12 max, integer only)
+	template <typename genType>
+    GLM_FUNC_QUALIFIER genType factorial(genType const & x)
+    {
+        genType Result;
+        for(Result = 1; x > 1; --x)
+            Result *= x;
+        return Result;
+    }
+
+	template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec2<valType> factorial(
+		detail::tvec2<valType> const & x)
+    {
+        return detail::tvec2<valType>(
+            factorial(x.x),
+            factorial(x.y));
+    }
+
+	template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> factorial(
+		detail::tvec3<valType> const & x)
+    {
+        return detail::tvec3<valType>(
+            factorial(x.x),
+            factorial(x.y),
+            factorial(x.z));
+    }
+
+	template <typename valType>
+    GLM_FUNC_QUALIFIER detail::tvec4<valType> factorial(
+		detail::tvec4<valType> const & x)
+    {
+        return detail::tvec4<valType>(
+            factorial(x.x),
+            factorial(x.y),
+            factorial(x.z),
+            factorial(x.w));
+    }
+
+}//namespace integer
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/intersect.hpp b/ExternalLibs/glm/gtx/intersect.hpp
new file mode 100644
index 0000000..3dec298
--- /dev/null
+++ b/ExternalLibs/glm/gtx/intersect.hpp
@@ -0,0 +1,73 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-04-03
+// Updated : 2009-01-20
+// Licence : This source is under MIT License
+// File    : glm/gtx/intersect.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_closest_point
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_intersect
+#define glm_gtx_intersect
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/closest_point.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_closest_point extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace intersect	///< GLM_GTX_intersect extension: Add intersection functions
+{
+	/// \addtogroup gtx_intersect
+	/// @{
+
+	//! Compute the intersection of a ray and a triangle.
+	//! From GLM_GTX_intersect extension.
+	template <typename genType>
+	bool intersectRayTriangle(
+		genType const & orig, genType const & dir,
+		genType const & vert0, genType const & vert1, genType const & vert2,
+		genType & baryPosition);
+
+    //! Compute the intersection of a line and a triangle.
+	//! From GLM_GTX_intersect extension.
+	template <typename genType>
+	bool intersectLineTriangle(
+		genType const & orig, genType const & dir,
+		genType const & vert0, genType const & vert1, genType const & vert2,
+		genType & position);
+
+    //! Compute the intersection of a ray and a sphere.
+	//! From GLM_GTX_intersect extension.
+	template <typename genType>
+	bool intersectRaySphere(
+		genType const & orig, genType const & dir,
+		genType const & center, typename genType::value_type radius,
+		genType & position, genType & normal);
+
+    //! Compute the intersection of a line and a sphere.
+	//! From GLM_GTX_intersect extension
+	template <typename genType>
+	bool intersectLineSphere(
+		genType const & point0, genType const & point1,
+		genType const & center, typename genType::value_type radius,
+		genType & position, genType & normal);
+
+	/// @}
+}//namespace intersect
+}//namespace gtx
+}//namespace glm
+
+#include "intersect.inl"
+
+namespace glm{using namespace gtx::intersect;}
+
+#endif//glm_gtx_intersect
diff --git a/ExternalLibs/glm/gtx/intersect.inl b/ExternalLibs/glm/gtx/intersect.inl
new file mode 100644
index 0000000..f77b495
--- /dev/null
+++ b/ExternalLibs/glm/gtx/intersect.inl
@@ -0,0 +1,201 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-04-03
+// Updated : 2009-01-20
+// Licence : This source is under MIT licence
+// File    : glm/gtx/intersect.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cfloat>
+#include <limits>
+
+namespace glm{
+namespace gtx{
+namespace intersect{
+
+template <typename genType>
+GLM_FUNC_QUALIFIER bool intersectRayTriangle
+(
+	genType const & orig, genType const & dir,
+	genType const & v0, genType const & v1, genType const & v2,
+	genType & baryPosition
+)
+{
+	genType e1 = v1 - v0;
+	genType e2 = v2 - v0;
+
+	genType p = glm::cross(dir, e2);
+
+	typename genType::value_type a = glm::dot(e1, p);
+
+	typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+	if(a < Epsilon)
+		return false;
+
+	typename genType::value_type f = typename genType::value_type(1.0f) / a;
+
+	genType s = orig - v0;
+	baryPosition.x = f * glm::dot(s, p);
+	if(baryPosition.x < typename genType::value_type(0.0f))
+		return false;
+	if(baryPosition.x > typename genType::value_type(1.0f))
+		return false;
+
+	genType q = glm::cross(s, e1);
+	baryPosition.y = f * glm::dot(dir, q);
+	if(baryPosition.y < typename genType::value_type(0.0f))
+		return false;
+	if(baryPosition.y + baryPosition.x > typename genType::value_type(1.0f))
+		return false;
+
+	baryPosition.z = f * glm::dot(e2, q);
+
+	return baryPosition.z >= typename genType::value_type(0.0f);
+}
+
+//template <typename genType>
+//GLM_FUNC_QUALIFIER bool intersectRayTriangle
+//(
+//	genType const & orig, genType const & dir,
+//	genType const & vert0, genType const & vert1, genType const & vert2,
+//	genType & position
+//)
+//{
+//	typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+//
+//	genType edge1 = vert1 - vert0;
+//	genType edge2 = vert2 - vert0;
+//
+//	genType pvec = cross(dir, edge2);
+//
+//	float det = dot(edge1, pvec);
+//	if(det < Epsilon)
+//		return false;
+//
+//	genType tvec = orig - vert0;
+//
+//	position.y = dot(tvec, pvec);
+//	if (position.y < typename genType::value_type(0) || position.y > det)
+//		return typename genType::value_type(0);
+//
+//	genType qvec = cross(tvec, edge1);
+//
+//	position.z = dot(dir, qvec);
+//	if (position.z < typename genType::value_type(0) || position.y + position.z > det)
+//		return typename genType::value_type(0);
+//
+//	position.x = dot(edge2, qvec);
+//	position *= typename genType::value_type(1) / det;
+//
+//	return typename genType::value_type(1);
+//}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER bool intersectLineTriangle
+(
+	genType const & orig, genType const & dir,
+	genType const & vert0, genType const & vert1, genType const & vert2,
+	genType & position
+)
+{
+    typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+
+	genType edge1 = vert1 - vert0;
+	genType edge2 = vert2 - vert0;
+
+	genType pvec = cross(dir, edge2);
+
+	float det = dot(edge1, pvec);
+
+	if (det > -Epsilon && det < Epsilon)
+		return false;
+	float inv_det = typename genType::value_type(1) / det;
+
+	genType tvec = orig - vert0;
+
+	position.y = dot(tvec, pvec) * inv_det;
+	if (position.y < typename genType::value_type(0) || position.y > typename genType::value_type(1))
+		return false;
+
+	genType qvec = cross(tvec, edge1);
+
+	position.z = dot(dir, qvec) * inv_det;
+	if (position.z < typename genType::value_type(0) || position.y + position.z > typename genType::value_type(1))
+		return false;
+
+	position.x = dot(edge2, qvec) * inv_det;
+
+	return true;
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER bool intersectRaySphere
+(
+	genType const & rayStarting, genType const & rayDirection,
+	genType const & sphereCenter, typename genType::value_type sphereRadius,
+	genType & position, genType & normal
+)
+{
+	typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+
+	typename genType::value_type a = dot(rayDirection, rayDirection);
+	typename genType::value_type b = typename genType::value_type(2) * dot(rayStarting, rayDirection);
+	typename genType::value_type c = dot(rayStarting, rayStarting) - sphereRadius * sphereRadius;
+	typename genType::value_type d = b * b - typename genType::value_type(4) * a * c;
+	typename genType::value_type e = sqrt(d);
+	typename genType::value_type x1 = (-b - e) / (typename genType::value_type(2) * a);
+	typename genType::value_type x2 = (-b + e) / (typename genType::value_type(2) * a);
+
+	if(x1 > Epsilon)
+	{
+		position = rayStarting + rayDirection * sphereRadius;
+		normal = (position - sphereCenter) / sphereRadius;
+		return true;
+	}
+	else if(x2 > Epsilon)
+	{
+		position = rayStarting + rayDirection * sphereRadius;
+		normal = (position - sphereCenter) / sphereRadius;
+		return true;
+	}
+	return false;
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER bool intersectLineSphere
+(
+	genType const & point0, genType const & point1,
+	genType const & center, typename genType::value_type radius,
+	genType & position, genType & normal
+)
+{
+	typename genType::value_type Epsilon = std::numeric_limits<typename genType::value_type>::epsilon();
+
+    genType dir = point1 - point0;
+    typename genType::value_type a = dot(dir, dir);
+	typename genType::value_type b = typename genType::value_type(2) * dot(center, dir);
+	typename genType::value_type c = dot(center, center) - radius * radius;
+	typename genType::value_type d = b * b - typename genType::value_type(4) * a * c;
+	typename genType::value_type e = sqrt(d);
+	typename genType::value_type x1 = (-b - e) / (typename genType::value_type(2) * a);
+	typename genType::value_type x2 = (-b + e) / (typename genType::value_type(2) * a);
+
+	if(x1 > Epsilon)
+	{
+		position = center + dir * radius;
+		normal = (position - center) / radius;
+		return true;
+	}
+	else if(x2 > Epsilon)
+	{
+		position = center + dir * radius;
+		normal = (position - center) / radius;
+		return true;
+	}
+	return false;
+}
+
+}//namespace intersect
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/log_base.hpp b/ExternalLibs/glm/gtx/log_base.hpp
new file mode 100644
index 0000000..edef8f6
--- /dev/null
+++ b/ExternalLibs/glm/gtx/log_base.hpp
@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-24
+// Updated : 2008-10-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/log_base.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_log_base
+#define glm_gtx_log_base
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_log_base extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
+{
+	/// \addtogroup gtx_log_base
+	/// @{
+
+	//! Logarithm for any base.
+	//! From GLM_GTX_log_base.
+	template <typename genType> 
+	genType log(
+		genType const & x, 
+		genType const & base);
+
+	/// @}
+
+}//namespace extend
+}//namespace gtx
+}//namespace glm
+
+#include "log_base.inl"
+
+namespace glm{using namespace gtx::log_base;}
+
+#endif//glm_gtx_log_base
diff --git a/ExternalLibs/glm/gtx/log_base.inl b/ExternalLibs/glm/gtx/log_base.inl
new file mode 100644
index 0000000..cd76b5d
--- /dev/null
+++ b/ExternalLibs/glm/gtx/log_base.inl
@@ -0,0 +1,92 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-24
+// Updated : 2008-10-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/log_base.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace log_base{
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType log(
+	genType const & x, 
+	genType const & base)
+{
+	assert(x != genType(0));
+
+	return glm::log(x) / glm::log(base);
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> log(
+	detail::tvec2<valType> const & v, 
+	valType const & base)
+{
+	return detail::tvec2<valType>(
+		log(v.x, base),
+		log(v.y, base));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> log(
+	detail::tvec3<valType> const & v, 
+	valType const & base)
+{
+	return detail::tvec3<valType>(
+		log(v.x, base),
+		log(v.y, base),
+		log(v.z, base));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> log(
+	detail::tvec4<valType> const & v, 
+	valType const & base)
+{
+	return detail::tvec4<valType>(
+		log(v.x, base),
+		log(v.y, base),
+		log(v.z, base),
+		log(v.w, base));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec2<valType> log(
+	detail::tvec2<valType> const & v, 
+	detail::tvec2<valType> const & base)
+{
+	return detail::tvec2<valType>(
+		log(v.x, base.x),
+		log(v.y, base.y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec3<valType> log(
+	detail::tvec3<valType> const & v, 
+	detail::tvec3<valType> const & base)
+{
+	return detail::tvec3<valType>(
+		log(v.x, base.x),
+		log(v.y, base.y),
+		log(v.z, base.z));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tvec4<valType> log(
+	detail::tvec4<valType> const & v, 
+	detail::tvec4<valType> const & base)
+{
+	return detail::tvec4<valType>(
+		log(v.x, base.x),
+		log(v.y, base.y),
+		log(v.z, base.z),
+		log(v.w, base.w));
+}
+
+}//namespace log_base
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/matrix_cross_product.hpp b/ExternalLibs/glm/gtx/matrix_cross_product.hpp
new file mode 100644
index 0000000..b74b64a
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_cross_product.hpp
@@ -0,0 +1,51 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_cross_product.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_matrix_cross_product
+#define glm_gtx_matrix_cross_product
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
+{
+	/// \addtogroup gtx_matrix_cross_product
+	/// @{
+
+	//! Build a cross product matrix.
+	//! From GLM_GTX_matrix_cross_product extension.
+	template <typename T> 
+	detail::tmat3x3<T> matrixCross3(
+		detail::tvec3<T> const & x);
+		
+	//! Build a cross product matrix.
+	//! From GLM_GTX_matrix_cross_product extension.
+	template <typename T> 
+	detail::tmat4x4<T> matrixCross4(
+		detail::tvec3<T> const & x);
+
+	/// @}
+}//namespace matrix_cross_product
+}//namespace gtx
+}//namespace glm
+
+#include "matrix_cross_product.inl"
+
+namespace glm{using namespace gtx::matrix_cross_product;}
+
+#endif//glm_gtx_matrix_cross_product
diff --git a/ExternalLibs/glm/gtx/matrix_cross_product.inl b/ExternalLibs/glm/gtx/matrix_cross_product.inl
new file mode 100644
index 0000000..3e4173f
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_cross_product.inl
@@ -0,0 +1,44 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2005-12-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_cross_product.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace matrix_cross_product
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3(
+		detail::tvec3<T> const & x)
+    {
+        detail::tmat3x3<T> Result(T(0));
+        Result[0][1] = x.z;
+        Result[1][0] = -x.z;
+        Result[0][2] = -x.y;
+        Result[2][0] = x.y;
+        Result[1][2] = x.x;
+        Result[2][1] = -x.x;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4(
+		detail::tvec3<T> const & x)
+    {
+        detail::tmat4x4<T> Result(T(0));
+        Result[0][1] = x.z;
+        Result[1][0] = -x.z;
+        Result[0][2] = -x.y;
+        Result[2][0] = x.y;
+        Result[1][2] = x.x;
+        Result[2][1] = -x.x;
+        return Result;
+    }
+
+}//namespace matrix_cross_product
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/matrix_interpolation.hpp b/ExternalLibs/glm/gtx/matrix_interpolation.hpp
new file mode 100644
index 0000000..98c4317
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_interpolation.hpp
@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-03-05
+// Updated : 2011-03-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_interpolation.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_matric_interpolation
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// This extension has been written by Ghenadii Ursachi (the.asteroth@gmail.com)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_matrix_interpolation
+#define glm_gtx_matrix_interpolation
+
+// Dependency:
+//#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
+{
+	/// \addtogroup gtx_matrix_interpolation
+	/// @{
+
+	//! Get the axis and angle of the rotation from a matrix.
+    //! From GLM_GTX_matrix_interpolation extension.
+	template <typename T>
+    void axisAngle(
+        detail::tmat4x4<T> const & mat,
+        detail::tvec3<T> & axis,
+        T & angle);
+
+    //! Build a matrix from axis and angle.
+    //! From GLM_GTX_matrix_interpolation extension.
+	template <typename T>
+    detail::tmat4x4<T> axisAngleMatrix(
+        detail::tvec3<T> const & axis,
+        T const angle);
+
+	//! Build a interpolation of 4 * 4 matrixes.
+    //! From GLM_GTX_matrix_interpolation extension.
+    //! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
+	template <typename T>
+    detail::tmat4x4<T> interpolate(
+        detail::tmat4x4<T> const & m1,
+        detail::tmat4x4<T> const & m2,
+        T const delta);
+
+	/// @}
+}//namespace matrix_interpolation
+}//namespace gtx
+}//namespace glm
+
+#include "matrix_interpolation.inl"
+
+namespace glm{using namespace gtx::matrix_interpolation;}
+
+#endif//glm_gtx_transform
diff --git a/ExternalLibs/glm/gtx/matrix_interpolation.inl b/ExternalLibs/glm/gtx/matrix_interpolation.inl
new file mode 100644
index 0000000..ab4d2bb
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_interpolation.inl
@@ -0,0 +1,117 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-03-05
+// Updated : 2011-03-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_interpolation.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace matrix_interpolation
+{
+    template <typename T>
+    GLM_FUNC_QUALIFIER void axisAngle(
+        detail::tmat4x4<T> const & mat,
+        detail::tvec3<T> & axis,
+        T & angle)
+    {
+        T epsilon = (T)0.01;
+        T epsilon2 = (T)0.1;
+
+        if ((fabs(mat[1][0] - mat[0][1]) < epsilon) && (fabs(mat[2][0] - mat[0][2]) < epsilon) && (fabs(mat[2][1] - mat[1][2]) < epsilon)) {
+            if ((fabs(mat[1][0] + mat[0][1]) < epsilon2) && (fabs(mat[2][0] + mat[0][2]) < epsilon2) && (fabs(mat[2][1] + mat[1][2]) < epsilon2) && (fabs(mat[0][0] + mat[1][1] + mat[2][2] - (T)3.0) < epsilon2)) {
+                angle = (T)0.0;
+                axis.x = (T)1.0;
+                axis.y = (T)0.0;
+                axis.z = (T)0.0;
+                return;
+            }
+            angle = M_1_PI;
+            T xx = (mat[0][0] + (T)1.0) / (T)2.0;
+            T yy = (mat[1][1] + (T)1.0) / (T)2.0;
+            T zz = (mat[2][2] + (T)1.0) / (T)2.0;
+            T xy = (mat[1][0] + mat[0][1]) / (T)4.0;
+            T xz = (mat[2][0] + mat[0][2]) / (T)4.0;
+            T yz = (mat[2][1] + mat[1][2]) / (T)4.0;
+            if ((xx > yy) && (xx > zz)) {
+                if (xx < epsilon) {
+                    axis.x = (T)0.0;
+                    axis.y = (T)0.7071;
+                    axis.z = (T)0.7071;
+                } else {
+                    axis.x = sqrt(xx);
+                    axis.y = xy / axis.x;
+                    axis.z = xz / axis.x;
+                }
+            } else if (yy > zz) {
+                if (yy < epsilon) {
+                    axis.x = (T)0.7071;
+                    axis.y = (T)0.0;
+                    axis.z = (T)0.7071;
+                } else {
+                    axis.y = sqrt(yy);
+                    axis.x = xy / axis.y;
+                    axis.z = yz / axis.y;
+                }
+            } else {
+                if (zz < epsilon) {
+                    axis.x = (T)0.7071;
+                    axis.y = (T)0.7071;
+                    axis.z = (T)0.0;
+                } else {
+                    axis.z = sqrt(zz);
+                    axis.x = xz / axis.z;
+                    axis.y = yz / axis.z;
+                }
+            }
+            return;
+        }
+        T s = sqrt((mat[2][1] - mat[1][2]) * (mat[2][1] - mat[1][2]) + (mat[2][0] - mat[0][2]) * (mat[2][0] - mat[0][2]) + (mat[1][0] - mat[0][1]) * (mat[1][0] - mat[0][1]));
+        if (glm::abs(s) < T(0.001))
+            s = (T)1.0;
+        angle = acos((mat[0][0] + mat[1][1] + mat[2][2] - (T)1.0) / (T)2.0);
+        axis.x = (mat[1][2] - mat[2][1]) / s;
+        axis.y = (mat[2][0] - mat[0][2]) / s;
+        axis.z = (mat[0][1] - mat[1][0]) / s;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> axisAngleMatrix(
+		detail::tvec3<T> const & axis,
+		T const angle)
+    {
+        T c = cos(angle);
+        T s = sin(angle);
+        T t = T(1) - c;
+        detail::tvec3<T> n = normalize(axis);
+
+        return detail::tmat4x4<T>(
+            t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    T(0),
+            t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    T(0),
+            t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          T(0),
+            T(0),                        T(0),                        T(0),                     T(1)
+        );
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> interpolate(
+		detail::tmat4x4<T> const & m1,
+		detail::tmat4x4<T> const & m2,
+		T const delta)
+    {
+		detail::tmat4x4<T> dltRotation = m2 * transpose(m1);
+		detail::tvec3<T> dltAxis;
+		T dltAngle;
+		axisAngle(dltRotation, dltAxis, dltAngle);
+		detail::tmat4x4<T> out = axisAngleMatrix(dltAxis, dltAngle * delta) * rotationMatrix(m1);
+		out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
+		out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
+		out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
+		return out;
+    }
+
+}//namespace transform
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/matrix_major_storage.hpp b/ExternalLibs/glm/gtx/matrix_major_storage.hpp
new file mode 100644
index 0000000..751aac8
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_major_storage.hpp
@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-19
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_major_storage.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_matrix_major_storage
+#define glm_gtx_matrix_major_storage
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
+{
+	/// \addtogroup gtx_matrix_major_storage
+	/// @{
+
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> rowMajor2(
+		const detail::tvec2<T>& v1, 
+		const detail::tvec2<T>& v2);
+		
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> rowMajor2(
+		const detail::tmat2x2<T>& m);
+
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> rowMajor3(
+		const detail::tvec3<T>& v1, 
+		const detail::tvec3<T>& v2, 
+		const detail::tvec3<T>& v3);
+
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> rowMajor3(
+		const detail::tmat3x3<T>& m);
+
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> rowMajor4(
+		const detail::tvec4<T>& v1, 
+		const detail::tvec4<T>& v2,
+		const detail::tvec4<T>& v3, 
+		const detail::tvec4<T>& v4);
+
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> rowMajor4(
+		const detail::tmat4x4<T>& m);
+
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> colMajor2(
+		const detail::tvec2<T>& v1, 
+		const detail::tvec2<T>& v2);
+		
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> colMajor2(
+		const detail::tmat2x2<T>& m);
+
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> colMajor3(
+		const detail::tvec3<T>& v1, 
+		const detail::tvec3<T>& v2, 
+		const detail::tvec3<T>& v3);
+		
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> colMajor3(
+		const detail::tmat3x3<T>& m);
+		
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> colMajor4(
+		const detail::tvec4<T>& v1, 
+		const detail::tvec4<T>& v2, 
+		const detail::tvec4<T>& v3, 
+		const detail::tvec4<T>& v4);
+				
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> colMajor4(
+		const detail::tmat4x4<T>& m);
+
+	/// @}
+}//namespace matrix_major_storage
+}//namespace gtx
+}//namespace glm
+
+#include "matrix_major_storage.inl"
+
+namespace glm{using namespace gtx::matrix_major_storage;}
+
+#endif//glm_gtx_matrix_major_storage
diff --git a/ExternalLibs/glm/gtx/matrix_major_storage.inl b/ExternalLibs/glm/gtx/matrix_major_storage.inl
new file mode 100644
index 0000000..281a4fa
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_major_storage.inl
@@ -0,0 +1,176 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-19
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_major_storage.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace matrix_major_storage
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
+		const detail::tvec2<T>& v1, 
+		const detail::tvec2<T>& v2)
+    {
+        detail::tmat2x2<T> Result;
+        Result[0][0] = v1.x;
+        Result[1][0] = v1.y;
+        Result[0][1] = v2.x;
+        Result[1][1] = v2.y;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
+		const detail::tmat2x2<T>& m)
+    {
+        detail::tmat2x2<T> Result;
+        Result[0][0] = m[0][0];
+        Result[0][1] = m[1][0];
+        Result[1][0] = m[0][1];
+        Result[1][1] = m[1][1];
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
+		const detail::tvec3<T>& v1, 
+		const detail::tvec3<T>& v2, 
+		const detail::tvec3<T>& v3)
+    {
+        detail::tmat3x3<T> Result;
+        Result[0][0] = v1.x;
+        Result[1][0] = v1.y;
+        Result[2][0] = v1.z;
+        Result[0][1] = v2.x;
+        Result[1][1] = v2.y;
+        Result[2][1] = v2.z;
+        Result[0][2] = v3.x;
+        Result[1][2] = v3.y;
+        Result[2][2] = v3.z;
+        return Result;
+    }
+
+    template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
+		const detail::tmat3x3<T>& m)
+    {
+        detail::tmat3x3<T> Result;
+        Result[0][0] = m[0][0];
+        Result[0][1] = m[1][0];
+        Result[0][2] = m[2][0];
+        Result[1][0] = m[0][1];
+        Result[1][1] = m[1][1];
+        Result[1][2] = m[2][1];
+        Result[2][0] = m[0][2];
+        Result[2][1] = m[1][2];
+        Result[2][2] = m[2][2];
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
+		const detail::tvec4<T>& v1, 
+		const detail::tvec4<T>& v2, 
+		const detail::tvec4<T>& v3, 
+		const detail::tvec4<T>& v4)
+    {
+        detail::tmat4x4<T> Result;
+        Result[0][0] = v1.x;
+        Result[1][0] = v1.y;
+        Result[2][0] = v1.z;
+        Result[3][0] = v1.w;
+        Result[0][1] = v2.x;
+        Result[1][1] = v2.y;
+        Result[2][1] = v2.z;
+        Result[3][1] = v2.w;
+        Result[0][2] = v3.x;
+        Result[1][2] = v3.y;
+        Result[2][2] = v3.z;
+        Result[3][2] = v3.w;
+        Result[0][3] = v4.x;
+        Result[1][3] = v4.y;
+        Result[2][3] = v4.z;
+        Result[3][3] = v4.w;
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
+		const detail::tmat4x4<T>& m)
+    {
+        detail::tmat4x4<T> Result;
+        Result[0][0] = m[0][0];
+        Result[0][1] = m[1][0];
+        Result[0][2] = m[2][0];
+        Result[0][3] = m[3][0];
+        Result[1][0] = m[0][1];
+        Result[1][1] = m[1][1];
+        Result[1][2] = m[2][1];
+        Result[1][3] = m[3][1];
+        Result[2][0] = m[0][2];
+        Result[2][1] = m[1][2];
+        Result[2][2] = m[2][2];
+        Result[2][3] = m[3][2];
+        Result[3][0] = m[0][3];
+        Result[3][1] = m[1][3];
+        Result[3][2] = m[2][3];
+        Result[3][3] = m[3][3];
+        return Result;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
+		const detail::tvec2<T>& v1, 
+		const detail::tvec2<T>& v2)
+    {
+        return detail::tmat2x2<T>(v1, v2);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
+		const detail::tmat2x2<T>& m)
+    {
+        return detail::tmat2x2<T>(m);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
+		const detail::tvec3<T>& v1, 
+		const detail::tvec3<T>& v2, 
+		const detail::tvec3<T>& v3)
+    {
+        return detail::tmat3x3<T>(v1, v2, v3);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
+		const detail::tmat3x3<T>& m)
+    {
+        return detail::tmat3x3<T>(m);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
+		const detail::tvec4<T>& v1, 
+		const detail::tvec4<T>& v2, 
+		const detail::tvec4<T>& v3, 
+		const detail::tvec4<T>& v4)
+    {
+        return detail::tmat4x4<T>(v1, v2, v3, v4);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
+		const detail::tmat4x4<T>& m)
+    {
+        return detail::tmat4x4<T>(m);
+	}
+
+}//namespace matrix_major_storage
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/matrix_operation.hpp b/ExternalLibs/glm/gtx/matrix_operation.hpp
new file mode 100644
index 0000000..3cf2cff
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_operation.hpp
@@ -0,0 +1,93 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-08-29
+// Updated : 2009-08-29
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_operation.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_matrix_operation
+#define glm_gtx_matrix_operation
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_matrix_operation extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
+{
+	/// \addtogroup gtx_matrix_operation
+	/// @{
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat2x2<valType> diagonal2x2(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat2x3<valType> diagonal2x3(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat2x4<valType> diagonal2x4(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat3x2<valType> diagonal3x2(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat3x3<valType> diagonal3x3(
+		detail::tvec3<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat3x4<valType> diagonal3x4(
+		detail::tvec3<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat4x2<valType> diagonal4x2(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat4x3<valType> diagonal4x3(
+		detail::tvec3<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> diagonal4x4(
+		detail::tvec4<valType> const & v);
+
+	/// @}
+}//namespace matrix_operation
+}//namespace gtx
+}//namespace glm
+
+#include "matrix_operation.inl"
+
+namespace glm{using namespace gtx::matrix_operation;}
+
+#endif//glm_gtx_matrix_operation
diff --git a/ExternalLibs/glm/gtx/matrix_operation.inl b/ExternalLibs/glm/gtx/matrix_operation.inl
new file mode 100644
index 0000000..0d52fbb
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_operation.inl
@@ -0,0 +1,129 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-08-29
+// Updated : 2009-08-29
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_operation.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace matrix_operation
+{
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> diagonal2x2
+	(
+		detail::tvec2<valType> const & v
+	)
+	{
+		detail::tmat2x2<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat2x3<valType> diagonal2x3
+	(
+		detail::tvec2<valType> const & v
+	)
+	{
+		detail::tmat2x3<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat2x4<valType> diagonal2x4
+	(
+		detail::tvec2<valType> const & v
+	)
+	{
+		detail::tmat2x4<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat3x2<valType> diagonal3x2
+	(
+		detail::tvec2<valType> const & v
+	)
+	{
+		detail::tmat3x2<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> diagonal3x3
+	(
+		detail::tvec3<valType> const & v
+	)
+	{
+		detail::tmat3x3<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat3x4<valType> diagonal3x4
+	(
+		detail::tvec3<valType> const & v
+	)
+	{
+		detail::tmat3x4<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		return Result;
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> diagonal4x4
+	(
+		detail::tvec4<valType> const & v
+	)
+	{
+		detail::tmat4x4<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		Result[3][3] = v[3];
+		return Result;		
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x3<valType> diagonal4x3
+	(
+		detail::tvec3<valType> const & v
+	)
+	{
+		detail::tmat4x3<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		Result[2][2] = v[2];
+		return Result;		
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER detail::tmat4x2<valType> diagonal4x2
+	(
+		detail::tvec2<valType> const & v
+	)
+	{
+		detail::tmat4x2<valType> Result(valType(1));
+		Result[0][0] = v[0];
+		Result[1][1] = v[1];
+		return Result;		
+	}
+
+}//namespace matrix_operation
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/matrix_query.hpp b/ExternalLibs/glm/gtx/matrix_query.hpp
new file mode 100644
index 0000000..b71b1af
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_query.hpp
@@ -0,0 +1,95 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-05
+// Updated : 2007-03-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_query.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_matrix_query
+#define glm_gtx_matrix_query
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_matrix_query extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
+{
+	/// \addtogroup gtx_matrix_query
+	/// @{
+
+	//! Return if a matrix a null matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNull(
+		const detail::tmat2x2<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
+		
+	//! Return if a matrix a null matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNull(
+		const detail::tmat3x3<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
+		
+	//! Return if a matrix a null matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNull(
+		const detail::tmat4x4<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
+			
+	//! Return if a matrix an identity matrix. 
+	//! From GLM_GTX_matrix_query extension.
+	template<typename genType> 
+	bool isIdentity(
+		const genType& m, 
+		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+
+	//! Return if a matrix a normalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNormalized(
+		const detail::tmat2x2<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
+		
+	//! Return if a matrix a normalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNormalized(
+		const detail::tmat3x3<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
+		
+	//! Return if a matrix a normalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNormalized(
+		const detail::tmat4x4<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
+
+	//! Return if a matrix an orthonormalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename genType> 
+	bool isOrthogonal(
+		const genType& m, 
+		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+
+	/// @}
+}//namespace matrix_query
+}//namespace gtx
+}//namespace glm
+
+#include "matrix_query.inl"
+
+namespace glm{using namespace gtx::matrix_query;}
+
+#endif//glm_gtx_matrix_query
diff --git a/ExternalLibs/glm/gtx/matrix_query.inl b/ExternalLibs/glm/gtx/matrix_query.inl
new file mode 100644
index 0000000..9ba2b7e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/matrix_query.inl
@@ -0,0 +1,144 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-05
+// Updated : 2007-03-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/matrix_query.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace matrix_query
+{
+	template<typename T> 
+	GLM_FUNC_QUALIFIER bool isNull(
+		const detail::tmat2x2<T>& m, 
+		const T epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < 2 ; ++i)
+			result = isNull(m[i], epsilon);
+		return result;
+	}
+
+	template<typename T> 
+	GLM_FUNC_QUALIFIER bool isNull(
+		const detail::tmat3x3<T>& m, 
+		const T epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < 3 ; ++i)
+			result = isNull(m[i], epsilon);
+		return result;
+	}
+
+	template<typename T> 
+	GLM_FUNC_QUALIFIER bool isNull(
+		const detail::tmat4x4<T>& m, 
+		const T epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < 4 ; ++i)
+			result = isNull(m[i], epsilon);
+		return result;
+	}
+
+	template<typename genType> 
+	GLM_FUNC_QUALIFIER bool isIdentity(
+		const genType& m, 
+		const typename genType::value_type epsilon)
+	{
+		bool result = true;
+		for(typename genType::value_type i = typename genType::value_type(0); result && i < genType::col_size(); ++i)
+		{
+			for(typename genType::value_type j = typename genType::value_type(0); result && j < i ; ++j)
+				result = abs(m[i][j]) <= epsilon;
+			if(result)
+				result = abs(m[i][i] - typename genType::value_type(1)) <= epsilon;
+			for(typename genType::value_type j = i + typename genType::value_type(1); result && j < genType::row_size(); ++j)
+				result = abs(m[i][j]) <= epsilon;
+		}
+		return result;
+	}
+
+	template<typename T> 
+	GLM_FUNC_QUALIFIER bool isNormalized(
+		const detail::tmat2x2<T>& m, 
+		const T epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < 2; ++i)
+			result = isNormalized(m[i], epsilon);
+		for(int i = 0; result && i < 2; ++i)
+		{
+			detail::tvec2<T> v;
+			for(int j = 0; j < 2; ++j)
+				v[j] = m[j][i];
+			result = isNormalized(v, epsilon);
+		}
+		return result;
+	}
+
+	template<typename T> 
+	GLM_FUNC_QUALIFIER bool isNormalized(
+		const detail::tmat3x3<T>& m, 
+		const T epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < 3; ++i)
+			result = isNormalized(m[i], epsilon);
+		for(int i = 0; result && i < 3; ++i)
+		{
+			detail::tvec3<T> v;
+			for(int j = 0; j < 3; ++j)
+				v[j] = m[j][i];
+			result = isNormalized(v, epsilon);
+		}
+		return result;
+	}
+
+	template<typename T> 
+	GLM_FUNC_QUALIFIER bool isNormalized(
+		const detail::tmat4x4<T>& m, 
+		const T epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < 4; ++i)
+			result = isNormalized(m[i], epsilon);
+		for(int i = 0; result && i < 4; ++i)
+		{
+			detail::tvec4<T> v;
+			for(int j = 0; j < 4; ++j)
+				v[j] = m[j][i];
+			result = isNormalized(v, epsilon);
+		}
+		return result;
+	}
+
+	template<typename genType> 
+	GLM_FUNC_QUALIFIER bool isOrthogonal(
+		const genType& m, 
+		const typename genType::value_type epsilon)
+	{
+		bool result = true;
+		for(int i = 0; result && i < genType::col_size() - 1; ++i)
+		for(int j= i + 1; result && j < genType::col_size(); ++j)
+			result = areOrthogonal(m[i], m[j], epsilon);
+
+		if(result)
+		{
+			genType tmp = transpose(m);
+			for(int i = 0; result && i < genType::col_size() - 1 ; ++i)
+			for(int j = i + 1; result && j < genType::col_size(); ++j)
+				result = areOrthogonal(tmp[i], tmp[j], epsilon);
+		}
+		return result;
+	}
+
+}//namespace matrix_query
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/mixed_product.hpp b/ExternalLibs/glm/gtx/mixed_product.hpp
new file mode 100644
index 0000000..5ce5430
--- /dev/null
+++ b/ExternalLibs/glm/gtx/mixed_product.hpp
@@ -0,0 +1,46 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-04-03
+// Updated : 2008-09-17
+// Licence : This source is under MIT License
+// File    : glm/gtx/mixed_product.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_mixed_product
+#define glm_gtx_mixed_product
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_mixed_product extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
+{
+	/// \addtogroup gtx_mixed_product
+	/// @{
+
+	//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
+	template <typename valType> 
+	valType mixedProduct(
+		detail::tvec3<valType> const & v1, 
+		detail::tvec3<valType> const & v2, 
+		detail::tvec3<valType> const & v3);
+
+	/// @}
+}// namespace mixed_product
+}// namespace gtx
+}// namespace glm
+
+#include "mixed_product.inl"
+
+namespace glm{using namespace gtx::mixed_product;}
+
+#endif//glm_gtx_mixed_product
diff --git a/ExternalLibs/glm/gtx/mixed_product.inl b/ExternalLibs/glm/gtx/mixed_product.inl
new file mode 100644
index 0000000..f4985f1
--- /dev/null
+++ b/ExternalLibs/glm/gtx/mixed_product.inl
@@ -0,0 +1,36 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-04-03
+// Updated : 2008-09-17
+// Licence : This source is under MIT License
+// File    : glm/gtx/mixed_product.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+
+namespace mixed_product
+{
+    template <typename valType> 
+	GLM_FUNC_QUALIFIER valType mixedProduct(
+		detail::tvec3<valType> const & v1, 
+		detail::tvec3<valType> const & v2, 
+		detail::tvec3<valType> const & v3)
+	{
+		return dot(cross(v1, v2), v3);
+	}
+}
+//namespace mixed_product
+
+}//namespace gtx
+}//namespace glm
+
+
+
+
+
+
+
+
+
diff --git a/ExternalLibs/glm/gtx/multiple.hpp b/ExternalLibs/glm/gtx/multiple.hpp
new file mode 100644
index 0000000..189320c
--- /dev/null
+++ b/ExternalLibs/glm/gtx/multiple.hpp
@@ -0,0 +1,53 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-10-26
+// Updated : 2009-10-26
+// Licence : This source is under MIT License
+// File    : glm/gtx/multiple.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_multiple
+#define glm_gtx_multiple
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_multiple extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
+{
+	/// \addtogroup gtx_multiple
+	/// @{
+
+	//! Higher Multiple number of Source.
+	//! From GLM_GTX_multiple extension.
+	template <typename genType> 
+	genType higherMultiple(
+		genType const & Source, 
+		genType const & Multiple);
+
+	//! Lower Multiple number of Source.
+	//! From GLM_GTX_multiple extension.
+	template <typename genType> 
+	genType lowerMultiple(
+		genType const & Source, 
+		genType const & Multiple);
+
+	/// @}
+}//namespace multiple
+}//namespace gtx
+}//namespace glm
+
+#include "multiple.inl"
+
+namespace glm{using namespace gtx::multiple;}
+
+#endif//glm_gtx_multiple
diff --git a/ExternalLibs/glm/gtx/multiple.inl b/ExternalLibs/glm/gtx/multiple.inl
new file mode 100644
index 0000000..36bba22
--- /dev/null
+++ b/ExternalLibs/glm/gtx/multiple.inl
@@ -0,0 +1,191 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-10-26
+// Updated : 2009-10-26
+// Licence : This source is under MIT License
+// File    : glm/gtx/multiple.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace multiple
+{
+	//////////////////////
+	// higherMultiple
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER genType higherMultiple
+	(
+		genType const & Source, 
+		genType const & Multiple
+	)
+	{
+		genType Tmp = Source % Multiple;
+		return Tmp ? Source + Multiple - Tmp : Source;
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER detail::thalf higherMultiple
+	(
+		detail::thalf const & Source, 
+		detail::thalf const & Multiple
+	)
+	{
+		int Tmp = int(float(Source)) % int(float(Multiple));
+		return Tmp ? Source + Multiple - detail::thalf(float(Tmp)) : Source;
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER float higherMultiple
+	(	
+		float const & Source, 
+		float const & Multiple
+	)
+	{
+		int Tmp = int(Source) % int(Multiple);
+		return Tmp ? Source + Multiple - float(Tmp) : Source;
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER double higherMultiple
+	(
+		double const & Source, 
+		double const & Multiple
+	)
+	{
+		long Tmp = long(Source) % long(Multiple);
+		return Tmp ? Source + Multiple - double(Tmp) : Source;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec2<T> higherMultiple
+	(
+		detail::tvec2<T> const & Source, 
+		detail::tvec2<T> const & Multiple
+	)
+	{
+		detail::tvec2<T> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = higherMultiple(Source[i], Multiple[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> higherMultiple
+	(
+		detail::tvec3<T> const & Source, 
+		detail::tvec3<T> const & Multiple
+	)
+	{
+		detail::tvec3<T> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = higherMultiple(Source[i], Multiple[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> higherMultiple
+	(
+		detail::tvec4<T> const & Source, 
+		detail::tvec4<T> const & Multiple
+	)
+	{
+		detail::tvec4<T> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = higherMultiple(Source[i], Multiple[i]);
+		return Result;
+	}
+
+	//////////////////////
+	// lowerMultiple
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER genType lowerMultiple
+	(
+		genType const & Source, 
+		genType const & Multiple
+	)
+	{
+		genType Tmp = Source % Multiple;
+		return Tmp ? Source - Tmp : Source;
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER detail::thalf lowerMultiple
+	(
+		detail::thalf const & Source, 
+		detail::thalf const & Multiple
+	)
+	{
+		int Tmp = int(float(Source)) % int(float(Multiple));
+		return Tmp ? Source - detail::thalf(float(Tmp)) : Source;
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER float lowerMultiple
+	(
+		float const & Source, 
+		float const & Multiple
+	)
+	{
+		int Tmp = int(Source) % int(Multiple);
+		return Tmp ? Source - float(Tmp) : Source;
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER double lowerMultiple
+	(
+		double const & Source, 
+		double const & Multiple
+	)
+	{
+		long Tmp = long(Source) % long(Multiple);
+		return Tmp ? Source - double(Tmp) : Source;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec2<T> lowerMultiple
+	(
+		detail::tvec2<T> const & Source, 
+		detail::tvec2<T> const & Multiple
+	)
+	{
+		detail::tvec2<T> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = lowerMultiple(Source[i], Multiple[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> lowerMultiple
+	(
+		detail::tvec3<T> const & Source, 
+		detail::tvec3<T> const & Multiple
+	)
+	{
+		detail::tvec3<T> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = lowerMultiple(Source[i], Multiple[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> lowerMultiple
+	(
+		detail::tvec4<T> const & Source, 
+		detail::tvec4<T> const & Multiple
+	)
+	{
+		detail::tvec4<T> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = lowerMultiple(Source[i], Multiple[i]);
+		return Result;
+	}
+
+}//namespace multiple
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/noise.hpp b/ExternalLibs/glm/gtx/noise.hpp
new file mode 100644
index 0000000..735791d
--- /dev/null
+++ b/ExternalLibs/glm/gtx/noise.hpp
@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
+// https://github.com/ashima/webgl-noise 
+// Following Stefan Gustavson's paper "Simplex noise demystified": 
+// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-04-21
+// Updated : 2011-04-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/noise.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_noise
+#define glm_gtx_noise
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_noise extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace noise	///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
+{
+	/// \addtogroup gtx_noise
+	/// @{
+
+	//! Classic perlin noise.
+	//! From GLM_GTX_noise extension.
+	template <typename T, template<typename> class vecType> 
+    T perlin(
+		vecType<T> const & p);
+		
+	//! Periodic perlin noise.
+	//! From GLM_GTX_noise extension.
+	template <typename T, template<typename> class vecType> 
+    T perlin(
+		vecType<T> const & p, 
+		vecType<T> const & rep);
+
+	//! Simplex noise.
+	//! From GLM_GTX_noise extension.
+	template <typename T, template<typename> class vecType> 
+    T simplex(
+		vecType<T> const & p);
+
+	/// @}
+}//namespace noise
+}//namespace gtx
+}//namespace glm
+
+#include "noise.inl"
+
+namespace glm{using namespace gtx::noise;}
+
+#endif//glm_gtx_noise
diff --git a/ExternalLibs/glm/gtx/noise.inl b/ExternalLibs/glm/gtx/noise.inl
new file mode 100644
index 0000000..839173b
--- /dev/null
+++ b/ExternalLibs/glm/gtx/noise.inl
@@ -0,0 +1,792 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise": 
+// https://github.com/ashima/webgl-noise 
+// Following Stefan Gustavson's paper "Simplex noise demystified": 
+// http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-04-21
+// Updated : 2011-04-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/noise.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER T permute(T const & x)
+	{
+		return mod(((x * T(34)) + T(1)) * x, T(289));
+	}
+
+	template <typename T, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T> permute(vecType<T> const & x)
+	{
+		return mod(((x * T(34)) + T(1)) * x, T(289));
+	}
+  
+	template <typename T>
+	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+
+	template <typename T, template<typename> class vecType>
+	GLM_FUNC_QUALIFIER vecType<T> taylorInvSqrt(vecType<T> const & r)
+	{
+		return T(1.79284291400159) - T(0.85373472095314) * r;
+	}
+
+	template <typename T, template <typename> class vecType> 
+	GLM_FUNC_QUALIFIER vecType<T> fade(vecType<T> const & t) 
+	{
+		return t * t * t * (t * (t * T(6) - T(15)) + T(10));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> grad4(T const & j, detail::tvec4<T> const & ip)
+	{
+		detail::tvec3<T> pXYZ = floor(fract(detail::tvec3<T>(j) * detail::tvec3<T>(ip)) * T(7)) * ip[2] - T(1);
+		T pW = T(1.5) - dot(abs(pXYZ), detail::tvec3<T>(1));
+		detail::tvec4<T> s = detail::tvec4<T>(lessThan(detail::tvec4<T>(pXYZ, pW), detail::tvec4<T>(0.0)));
+		pXYZ = pXYZ + (detail::tvec3<T>(s) * T(2) - T(1)) * s.w; 
+		return detail::tvec4<T>(pXYZ, pW);
+	}
+
+namespace gtx{
+namespace noise
+{
+	// Classic Perlin noise
+	template <typename T>
+	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
+	{
+		detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+		detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+		Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
+		detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+		detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+		detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+		detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+
+		detail::tvec4<T> i = permute(permute(ix) + iy);
+
+		detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
+		detail::tvec4<T> gy = abs(gx) - T(0.5);
+		detail::tvec4<T> tx = floor(gx + T(0.5));
+		gx = gx - tx;
+
+		detail::tvec2<T> g00(gx.x, gy.x);
+		detail::tvec2<T> g10(gx.y, gy.y);
+		detail::tvec2<T> g01(gx.z, gy.z);
+		detail::tvec2<T> g11(gx.w, gy.w);
+
+		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+		g00 *= norm.x;  
+		g01 *= norm.y;  
+		g10 *= norm.z;  
+		g11 *= norm.w;  
+
+		T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
+		T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
+		T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
+		T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
+
+		detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
+		detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
+		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
+		return T(2.3) * n_xy;
+	}
+
+	// Classic Perlin noise
+	template <typename T>
+	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
+	{
+		detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
+		detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
+		Pi0 = mod(Pi0, T(289));
+		Pi1 = mod(Pi1, T(289));
+		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
+		detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		detail::tvec4<T> iz0(Pi0.z);
+		detail::tvec4<T> iz1(Pi1.z);
+
+		detail::tvec4<T> ixy = permute(permute(ix) + iy);
+		detail::tvec4<T> ixy0 = permute(ixy + iz0);
+		detail::tvec4<T> ixy1 = permute(ixy + iz1);
+
+		detail::tvec4<T> gx0 = ixy0 / T(7);
+		detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+		gx0 = fract(gx0);
+		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
+		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
+		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
+		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
+
+		detail::tvec4<T> gx1 = ixy1 / T(7);
+		detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+		gx1 = fract(gx1);
+		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
+		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
+		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
+		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
+
+		detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
+		detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
+		detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
+		detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
+		detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
+		detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
+		detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
+		detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
+
+		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		g000 *= norm0.x;
+		g010 *= norm0.y;
+		g100 *= norm0.z;
+		g110 *= norm0.w;
+		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		g001 *= norm1.x;
+		g011 *= norm1.y;
+		g101 *= norm1.z;
+		g111 *= norm1.w;
+
+		T n000 = dot(g000, Pf0);
+		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
+		T n111 = dot(g111, Pf1);
+
+		detail::tvec3<T> fade_xyz = fade(Pf0);
+		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
+		detail::tvec2<T> n_yz = mix(
+            detail::tvec2<T>(n_z.x, n_z.y), 
+            detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
+		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+		return T(2.2) * n_xyz;
+	}
+
+	// Classic Perlin noise
+	template <typename T>
+	GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P)
+	{
+		detail::tvec4<T> Pi0 = floor(P); // Integer part for indexing
+		detail::tvec4<T> Pi1 = Pi0 + T(1); // Integer part + 1
+		Pi0 = mod(Pi0, T(289));
+		Pi1 = mod(Pi1, T(289));
+		detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
+		detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		detail::tvec4<T> iz0(Pi0.z);
+		detail::tvec4<T> iz1(Pi1.z);
+		detail::tvec4<T> iw0(Pi0.w);
+		detail::tvec4<T> iw1(Pi1.w);
+
+		detail::tvec4<T> ixy = permute(permute(ix) + iy);
+		detail::tvec4<T> ixy0 = permute(ixy + iz0);
+		detail::tvec4<T> ixy1 = permute(ixy + iz1);
+		detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
+		detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
+		detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
+		detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
+
+		detail::tvec4<T> gx00 = ixy00 / T(7);
+		detail::tvec4<T> gy00 = floor(gx00) / T(7);
+		detail::tvec4<T> gz00 = floor(gy00) / T(6);
+		gx00 = fract(gx00) - T(0.5);
+		gy00 = fract(gy00) - T(0.5);
+		gz00 = fract(gz00) - T(0.5);
+		detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+		detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0.0));
+		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
+		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
+
+		detail::tvec4<T> gx01 = ixy01 / T(7);
+		detail::tvec4<T> gy01 = floor(gx01) / T(7);
+		detail::tvec4<T> gz01 = floor(gy01) / T(6);
+		gx01 = fract(gx01) - T(0.5);
+		gy01 = fract(gy01) - T(0.5);
+		gz01 = fract(gz01) - T(0.5);
+		detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+		detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
+		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
+		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
+
+		detail::tvec4<T> gx10 = ixy10 / T(7);
+		detail::tvec4<T> gy10 = floor(gx10) / T(7);
+		detail::tvec4<T> gz10 = floor(gy10) / T(6);
+		gx10 = fract(gx10) - T(0.5);
+		gy10 = fract(gy10) - T(0.5);
+		gz10 = fract(gz10) - T(0.5);
+		detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+		detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0));
+		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
+		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
+
+		detail::tvec4<T> gx11 = ixy11 / T(7);
+		detail::tvec4<T> gy11 = floor(gx11) / T(7);
+		detail::tvec4<T> gz11 = floor(gy11) / T(6);
+		gx11 = fract(gx11) - T(0.5);
+		gy11 = fract(gy11) - T(0.5);
+		gz11 = fract(gz11) - T(0.5);
+		detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+		detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
+		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
+		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
+
+		detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+		detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+		detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+		detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+		detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+		detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+		detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+		detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+		detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+		detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+		detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+		detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+		detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+		detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+		detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+		detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+
+		detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+		g0000 *= norm00.x;
+		g0100 *= norm00.y;
+		g1000 *= norm00.z;
+		g1100 *= norm00.w;
+
+		detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+		g0001 *= norm01.x;
+		g0101 *= norm01.y;
+		g1001 *= norm01.z;
+		g1101 *= norm01.w;
+
+		detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+		g0010 *= norm10.x;
+		g0110 *= norm10.y;
+		g1010 *= norm10.z;
+		g1110 *= norm10.w;
+
+		detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+		g0011 *= norm11.x;
+		g0111 *= norm11.y;
+		g1011 *= norm11.z;
+		g1111 *= norm11.w;
+
+		T n0000 = dot(g0000, Pf0);
+		T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+		T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+		T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+		T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+		T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+		T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+		T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+		T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+		T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+		T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+		T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+		T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+		T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+		T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+		T n1111 = dot(g1111, Pf1);
+
+		detail::tvec4<T> fade_xyzw = fade(Pf0);
+		detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+		detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+		detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+		detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
+		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+		return T(2.2) * n_xyzw;
+	}
+
+	// Classic Perlin noise, periodic variant
+	template <typename T>
+	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P, detail::tvec2<T> const & rep)
+	{
+		detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+		detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+		Pi = mod(Pi, detail::tvec4<T>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
+		Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
+		detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+		detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+		detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+		detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+
+		detail::tvec4<T> i = permute(permute(ix) + iy);
+
+		detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
+		detail::tvec4<T> gy = abs(gx) - T(0.5);
+		detail::tvec4<T> tx = floor(gx + T(0.5));
+		gx = gx - tx;
+
+		detail::tvec2<T> g00(gx.x, gy.x);
+		detail::tvec2<T> g10(gx.y, gy.y);
+		detail::tvec2<T> g01(gx.z, gy.z);
+		detail::tvec2<T> g11(gx.w, gy.w);
+
+		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+		g00 *= norm.x;  
+		g01 *= norm.y;  
+		g10 *= norm.z;  
+		g11 *= norm.w;  
+
+		T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
+		T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
+		T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
+		T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
+
+		detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
+		detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
+		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
+		return T(2.3) * n_xy;
+	}
+
+	// Classic Perlin noise, periodic variant
+	template <typename T>
+	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P, detail::tvec3<T> const & rep)
+	{
+		detail::tvec3<T> Pi0 = mod(floor(P), rep); // Integer part, modulo period
+		detail::tvec3<T> Pi1 = mod(Pi0 + detail::tvec3<T>(1.0), rep); // Integer part + 1, mod period
+		Pi0 = mod(Pi0, T(289));
+		Pi1 = mod(Pi1, T(289));
+		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
+		detail::tvec3<T> Pf1 = Pf0 - detail::tvec3<T>(1.0); // Fractional part - 1.0
+		detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		detail::tvec4<T> iz0(Pi0.z);
+		detail::tvec4<T> iz1(Pi1.z);
+
+		detail::tvec4<T> ixy = permute(permute(ix) + iy);
+		detail::tvec4<T> ixy0 = permute(ixy + iz0);
+		detail::tvec4<T> ixy1 = permute(ixy + iz1);
+
+		detail::tvec4<T> gx0 = ixy0 / T(7);
+		detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+		gx0 = fract(gx0);
+		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
+		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0));
+		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
+		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
+
+		detail::tvec4<T> gx1 = ixy1 / T(7);
+		detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+		gx1 = fract(gx1);
+		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
+		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
+		gx1 -= sz1 * (step(0.0, gx1) - T(0.5));
+		gy1 -= sz1 * (step(0.0, gy1) - T(0.5));
+
+		detail::tvec3<T> g000 = detail::tvec3<T>(gx0.x, gy0.x, gz0.x);
+		detail::tvec3<T> g100 = detail::tvec3<T>(gx0.y, gy0.y, gz0.y);
+		detail::tvec3<T> g010 = detail::tvec3<T>(gx0.z, gy0.z, gz0.z);
+		detail::tvec3<T> g110 = detail::tvec3<T>(gx0.w, gy0.w, gz0.w);
+		detail::tvec3<T> g001 = detail::tvec3<T>(gx1.x, gy1.x, gz1.x);
+		detail::tvec3<T> g101 = detail::tvec3<T>(gx1.y, gy1.y, gz1.y);
+		detail::tvec3<T> g011 = detail::tvec3<T>(gx1.z, gy1.z, gz1.z);
+		detail::tvec3<T> g111 = detail::tvec3<T>(gx1.w, gy1.w, gz1.w);
+
+		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+		g000 *= norm0.x;
+		g010 *= norm0.y;
+		g100 *= norm0.z;
+		g110 *= norm0.w;
+		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+		g001 *= norm1.x;
+		g011 *= norm1.y;
+		g101 *= norm1.z;
+		g111 *= norm1.w;
+
+		T n000 = dot(g000, Pf0);
+		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
+		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
+		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
+		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
+		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
+		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
+		T n111 = dot(g111, Pf1);
+
+		detail::tvec3<T> fade_xyz = fade(Pf0);
+		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
+		detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
+		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+		return T(2.2) * n_xyz;
+	}
+
+	// Classic Perlin noise, periodic version
+	template <typename T>
+	GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P, detail::tvec4<T> const & rep)
+	{
+		detail::tvec4<T> Pi0 = mod(floor(P), rep); // Integer part modulo rep
+		detail::tvec4<T> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
+		detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
+		detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+		detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+		detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+		detail::tvec4<T> iz0(Pi0.z);
+		detail::tvec4<T> iz1(Pi1.z);
+		detail::tvec4<T> iw0(Pi0.w);
+		detail::tvec4<T> iw1(Pi1.w);
+
+		detail::tvec4<T> ixy = permute(permute(ix) + iy);
+		detail::tvec4<T> ixy0 = permute(ixy + iz0);
+		detail::tvec4<T> ixy1 = permute(ixy + iz1);
+		detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
+		detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
+		detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
+		detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
+
+		detail::tvec4<T> gx00 = ixy00 / T(7);
+		detail::tvec4<T> gy00 = floor(gx00) / T(7);
+		detail::tvec4<T> gz00 = floor(gy00) / T(6);
+		gx00 = fract(gx00) - T(0.5);
+		gy00 = fract(gy00) - T(0.5);
+		gz00 = fract(gz00) - T(0.5);
+		detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+		detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0));
+		gx00 -= sw00 * (step(0.0, gx00) - T(0.5));
+		gy00 -= sw00 * (step(0.0, gy00) - T(0.5));
+
+		detail::tvec4<T> gx01 = ixy01 / T(7);
+		detail::tvec4<T> gy01 = floor(gx01) / T(7);
+		detail::tvec4<T> gz01 = floor(gy01) / T(6);
+		gx01 = fract(gx01) - T(0.5);
+		gy01 = fract(gy01) - T(0.5);
+		gz01 = fract(gz01) - T(0.5);
+		detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+		detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
+		gx01 -= sw01 * (step(0.0, gx01) - T(0.5));
+		gy01 -= sw01 * (step(0.0, gy01) - T(0.5));
+
+		detail::tvec4<T> gx10 = ixy10 / T(7);
+		detail::tvec4<T> gy10 = floor(gx10) / T(7);
+		detail::tvec4<T> gz10 = floor(gy10) / T(6);
+		gx10 = fract(gx10) - T(0.5);
+		gy10 = fract(gy10) - T(0.5);
+		gz10 = fract(gz10) - T(0.5);
+		detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+		detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0.0));
+		gx10 -= sw10 * (step(0.0, gx10) - T(0.5));
+		gy10 -= sw10 * (step(0.0, gy10) - T(0.5));
+
+		detail::tvec4<T> gx11 = ixy11 / T(7);
+		detail::tvec4<T> gy11 = floor(gx11) / T(7);
+		detail::tvec4<T> gz11 = floor(gy11) / T(6);
+		gx11 = fract(gx11) - T(0.5);
+		gy11 = fract(gy11) - T(0.5);
+		gz11 = fract(gz11) - T(0.5);
+		detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+		detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
+		gx11 -= sw11 * (step(0.0, gx11) - T(0.5));
+		gy11 -= sw11 * (step(0.0, gy11) - T(0.5));
+
+		detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+		detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+		detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+		detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+		detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+		detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+		detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+		detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+		detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+		detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+		detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+		detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+		detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+		detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+		detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+		detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+
+		detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+		g0000 *= norm00.x;
+		g0100 *= norm00.y;
+		g1000 *= norm00.z;
+		g1100 *= norm00.w;
+
+		detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+		g0001 *= norm01.x;
+		g0101 *= norm01.y;
+		g1001 *= norm01.z;
+		g1101 *= norm01.w;
+
+		detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+		g0010 *= norm10.x;
+		g0110 *= norm10.y;
+		g1010 *= norm10.z;
+		g1110 *= norm10.w;
+
+		detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+		g0011 *= norm11.x;
+		g0111 *= norm11.y;
+		g1011 *= norm11.z;
+		g1111 *= norm11.w;
+
+		T n0000 = dot(g0000, Pf0);
+		T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+		T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+		T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+		T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+		T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+		T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+		T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+		T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+		T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+		T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+		T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+		T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+		T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+		T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+		T n1111 = dot(g1111, Pf1);
+
+		detail::tvec4<T> fade_xyzw = fade(Pf0);
+		detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+		detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+		detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+		detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
+		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+		return T(2.2) * n_xyzw;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T simplex(glm::detail::tvec2<T> const & v)
+	{
+		detail::tvec4<T> const C = detail::tvec4<T>(
+			T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
+			T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
+			T(-0.577350269189626),	// -1.0 + 2.0 * C.x
+			T( 0.024390243902439)); //  1.0 / 41.0
+
+		// First corner
+		detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
+		detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
+
+		// Other corners
+		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+		//i1.y = 1.0 - i1.x;
+		detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
+		// x0 = x0 - 0.0 + 0.0 * C.xx ;
+		// x1 = x0 - i1 + 1.0 * C.xx ;
+		// x2 = x0 - 1.0 + 2.0 * C.xx ;
+		detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
+		x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
+
+		// Permutations
+		i = mod(i, T(289)); // Avoid truncation effects in permutation
+		detail::tvec3<T> p = permute(
+			permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
+			+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
+
+		detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
+			dot(x0, x0), 
+			dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
+			dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
+		m = m * m ;
+		m = m * m ;
+
+		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+		detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
+		detail::tvec3<T> h = abs(x) - T(0.5);
+		detail::tvec3<T> ox = floor(x + T(0.5));
+		detail::tvec3<T> a0 = x - ox;
+
+		// Normalise gradients implicitly by scaling m
+		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
+		m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
+
+		// Compute final noise value at P
+		detail::tvec3<T> g;
+		g.x  = a0.x  * x0.x  + h.x  * x0.y;
+		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+		g.y = a0.y * x12.x + h.y * x12.y;
+		g.z = a0.z * x12.z + h.z * x12.w;
+		return T(130) * dot(m, g);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T simplex(detail::tvec3<T> const & v)
+	{ 
+		detail::tvec2<T> const C = detail::tvec2<T>(1.0 / 6.0, 1.0 / 3.0);
+		detail::tvec4<T> const D = detail::tvec4<T>(0.0, 0.5, 1.0, 2.0);
+
+		// First corner
+		detail::tvec3<T> i  = floor(v + dot(v, detail::tvec3<T>(C.y)));
+		detail::tvec3<T> x0 = v - i + dot(i, detail::tvec3<T>(C.x));
+
+		// Other corners
+		detail::tvec3<T> g = step(detail::tvec3<T>(x0.y, x0.z, x0.x), detail::tvec3<T>(x0.x, x0.y, x0.z));
+		detail::tvec3<T> l = T(1) - g;
+		detail::tvec3<T> i1 = min(detail::tvec3<T>(g.x, g.y, g.z), detail::tvec3<T>(l.z, l.x, l.y));
+		detail::tvec3<T> i2 = max(detail::tvec3<T>(g.x, g.y, g.z), detail::tvec3<T>(l.z, l.x, l.y));
+
+		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
+		//   x1 = x0 - i1  + 1.0 * C.xxx;
+		//   x2 = x0 - i2  + 2.0 * C.xxx;
+		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
+		detail::tvec3<T> x1 = x0 - i1 + C.x;
+		detail::tvec3<T> x2 = x0 - i2 + C.y; // 2.0*C.x = 1/3 = C.y
+		detail::tvec3<T> x3 = x0 - D.y;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+		// Permutations
+		i = mod(i, T(289)); 
+		detail::tvec4<T> p = permute(permute(permute( 
+			i.z + detail::tvec4<T>(0.0, i1.z, i2.z, 1.0)) + 
+			i.y + detail::tvec4<T>(0.0, i1.y, i2.y, 1.0)) + 
+			i.x + detail::tvec4<T>(0.0, i1.x, i2.x, 1.0));
+
+		// Gradients: 7x7 points over a square, mapped onto an octahedron.
+		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+		T n_ = T(0.142857142857); // 1.0/7.0
+		detail::tvec3<T> ns = n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x);
+
+		detail::tvec4<T> j = p - T(49) * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+		detail::tvec4<T> x_ = floor(j * ns.z);
+		detail::tvec4<T> y_ = floor(j - T(7) * x_);    // mod(j,N)
+
+		detail::tvec4<T> x = x_ * ns.x + ns.y;
+		detail::tvec4<T> y = y_ * ns.x + ns.y;
+		detail::tvec4<T> h = T(1) - abs(x) - abs(y);
+
+		detail::tvec4<T> b0 = detail::tvec4<T>(x.x, x.y, y.x, y.y);
+		detail::tvec4<T> b1 = detail::tvec4<T>(x.z, x.w, y.z, y.w);
+
+		//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+		//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+		detail::tvec4<T> s0 = floor(b0) * T(2) + T(1);
+		detail::tvec4<T> s1 = floor(b1) * T(2) + T(1);
+		detail::tvec4<T> sh = -step(h, detail::tvec4<T>(0));
+
+		detail::tvec4<T> a0 = b0 + s0 * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
+		detail::tvec4<T> a1 = b1 + s1 * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
+
+		detail::tvec3<T> p0 = vec3(a0.x, a0.y, h.x);
+		detail::tvec3<T> p1 = vec3(a0.z, a0.w, h.y);
+		detail::tvec3<T> p2 = vec3(a1.x, a1.y, h.z);
+		detail::tvec3<T> p3 = vec3(a1.z, a1.w, h.w);
+
+		//Normalise gradients
+		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(
+			dot(p0, p0), 
+			dot(p1, p1), 
+			dot(p2, p2), 
+			dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+
+		// Mix final noise value
+		vec4 m = max(T(0.6) - detail::tvec4<T>(
+			dot(x0, x0), 
+			dot(x1, x1), 
+			dot(x2, x2), 
+			dot(x3, x3)), T(0));
+		m = m * m;
+		return T(42) * dot(m * m, detail::tvec4<T>(
+			dot(p0, x0), 
+			dot(p1, x1), 
+			dot(p2, x2), 
+			dot(p3, x3)));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T simplex(detail::tvec4<T> const & v)
+	{
+		detail::tvec4<T> const C(
+			0.138196601125011,  // (5 - sqrt(5))/20  G4
+			0.276393202250021,  // 2 * G4
+			0.414589803375032,  // 3 * G4
+			-0.447213595499958); // -1 + 4 * G4
+
+		// (sqrt(5) - 1)/4 = F4, used once below
+		T const F4 = T(0.309016994374947451);
+
+		// First corner
+		detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
+		detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
+
+		// Other corners
+
+		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+		detail::tvec4<T> i0;
+		detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
+		detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
+		//  i0.x = dot(isX, vec3(1.0));
+		//i0.x = isX.x + isX.y + isX.z;
+		//i0.yzw = T(1) - isX;
+        i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
+		//  i0.y += dot(isYZ.xy, vec2(1.0));
+		i0.y += isYZ.x + isYZ.y;
+		//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
+        i0.z += T(1) - isYZ.x;
+        i0.w += T(1) - isYZ.y;
+		i0.z += isYZ.z;
+		i0.w += T(1) - isYZ.z;
+
+		// i0 now contains the unique values 0,1,2,3 in each channel
+		detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
+		detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
+		detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
+
+		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
+		//  x1 = x0 - i1  + 0.0 * C.xxxx
+		//  x2 = x0 - i2  + 0.0 * C.xxxx
+		//  x3 = x0 - i3  + 0.0 * C.xxxx
+		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
+		detail::tvec4<T> x1 = x0 - i1 + C.x;
+		detail::tvec4<T> x2 = x0 - i2 + C.y;
+		detail::tvec4<T> x3 = x0 - i3 + C.z;
+		detail::tvec4<T> x4 = x0 + C.w;
+
+		// Permutations
+		i = mod(i, T(289)); 
+		T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
+		detail::tvec4<T> j1 = permute(permute(permute(permute(
+				 i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
+			   + i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
+			   + i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
+			   + i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
+
+		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+		detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+
+		detail::tvec4<T> p0 = grad4(j0,   ip);
+		detail::tvec4<T> p1 = grad4(j1.x, ip);
+		detail::tvec4<T> p2 = grad4(j1.y, ip);
+		detail::tvec4<T> p3 = grad4(j1.z, ip);
+		detail::tvec4<T> p4 = grad4(j1.w, ip);
+
+		// Normalise gradients
+		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+		p0 *= norm.x;
+		p1 *= norm.y;
+		p2 *= norm.z;
+		p3 *= norm.w;
+		p4 *= taylorInvSqrt(dot(p4, p4));
+
+		// Mix contributions from the five corners
+		detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
+		detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
+		m0 = m0 * m0;
+		m1 = m1 * m1;
+		return T(49) * 
+			(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
+			dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
+	}
+
+}//namespace noise
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/norm.hpp b/ExternalLibs/glm/gtx/norm.hpp
new file mode 100644
index 0000000..34c2e98
--- /dev/null
+++ b/ExternalLibs/glm/gtx/norm.hpp
@@ -0,0 +1,143 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2008-07-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/norm.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// ToDo:
+// - Study the validity of the notion of length2 to quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_norm
+#define glm_gtx_norm
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/quaternion.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_norm extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
+{
+	/// \addtogroup gtx_norm
+	/// @{
+
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T length2(
+		const T x);
+
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T length2(
+		const detail::tvec2<T> & x);
+
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T length2(
+		const detail::tvec3<T>& x);
+		
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T length2(
+		const detail::tvec4<T>& x);
+		
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T length2(
+		const detail::tquat<T>& q);
+
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T distance2(
+		const T p0, 
+		const T p1);
+		
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T distance2(
+		const detail::tvec2<T>& p0, 
+		const detail::tvec2<T>& p1);
+
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T distance2(
+		const detail::tvec3<T>& p0,
+		const detail::tvec3<T>& p1);
+
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T distance2(
+		const detail::tvec4<T>& p0, 
+		const detail::tvec4<T>& p1);
+
+	//! Returns the L1 norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T l1Norm(
+		const detail::tvec3<T>& x,
+		const detail::tvec3<T>& y);
+		
+	//! Returns the L1 norm of v.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T l1Norm(
+		const detail::tvec3<T>& v);
+		
+	//! Returns the L2 norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T l2Norm(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y);
+		
+	//! Returns the L2 norm of v.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T l2Norm(
+		const detail::tvec3<T>& x);
+		
+	//! Returns the L norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T lxNorm(
+		const detail::tvec3<T>& x,
+		const detail::tvec3<T>& y,
+		unsigned int Depth);
+
+	//! Returns the L norm of v.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T lxNorm(
+		const detail::tvec3<T>& x,
+		unsigned int Depth);
+
+	/// @}
+}//namespace norm
+}//namespace gtx
+}//namespace glm
+
+#include "norm.inl"
+
+namespace glm{using namespace gtx::norm;}
+
+#endif//glm_gtx_norm
diff --git a/ExternalLibs/glm/gtx/norm.inl b/ExternalLibs/glm/gtx/norm.inl
new file mode 100644
index 0000000..e062177
--- /dev/null
+++ b/ExternalLibs/glm/gtx/norm.inl
@@ -0,0 +1,130 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2008-07-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/norm.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace norm
+{
+	template <typename T>
+    GLM_FUNC_QUALIFIER T length2(
+		const T x)
+    {
+        return x * x;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T length2(
+		const detail::tvec2<T>& x)
+    {
+        return dot(x, x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T length2(
+		const detail::tvec3<T>& x)
+    {
+        return dot(x, x);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T length2(
+		const detail::tvec4<T>& x)
+    {
+        return dot(x, x);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T length2(
+		const detail::tquat<T>& q)
+    {
+        return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+    }
+
+    template <typename T> 
+	T distance2(
+		const T p0, 
+		const T p1)
+	{
+		return length2(p1 - p0);
+	}
+
+    template <typename T> 
+	T distance2(
+		const detail::tvec2<T>& p0, 
+		const detail::tvec2<T>& p1)
+	{
+		return length2(p1 - p0);
+	}
+
+    template <typename T> 
+	T distance2(
+		const detail::tvec3<T>& p0, 
+		const detail::tvec3<T>& p1)
+	{
+		return length2(p1 - p0);
+	}
+
+    template <typename T>
+	T distance2(
+		const detail::tvec4<T>& p0, 
+		const detail::tvec4<T>& p1)
+	{
+		return length2(p1 - p0);
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T l1Norm(
+		const detail::tvec3<T>& a, 
+		const detail::tvec3<T>& b)
+    {
+        return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T l1Norm(
+		const detail::tvec3<T>& v)
+    {
+        return abs(v.x) + abs(v.y) + abs(v.z);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T l2Norm(
+		const detail::tvec3<T>& a, 
+		const detail::tvec3<T>& b)
+    {
+        return length(b - a);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T l2Norm(
+		const detail::tvec3<T>& v)
+    {
+        return length(v);
+    }
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER T lxNorm(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y, 
+		unsigned int Depth)
+	{
+		return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth));
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER T lxNorm(
+		const detail::tvec3<T>& v, 
+		unsigned int Depth)
+	{
+		return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
+	}
+
+}//namespace norm
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/normal.hpp b/ExternalLibs/glm/gtx/normal.hpp
new file mode 100644
index 0000000..9d598e9
--- /dev/null
+++ b/ExternalLibs/glm/gtx/normal.hpp
@@ -0,0 +1,47 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/normal.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_normal
+#define glm_gtx_normal
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_normal extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
+{
+	/// \addtogroup gtx_normal
+	/// @{
+
+	//! Computes triangle normal from triangle points. 
+	//! From GLM_GTX_normal extension.
+    template <typename T> 
+	detail::tvec3<T> triangleNormal(
+		detail::tvec3<T> const & p1, 
+		detail::tvec3<T> const & p2, 
+		detail::tvec3<T> const & p3);
+
+	/// @}
+}//namespace normal
+}//namespace gtx
+}//namespace glm
+
+#include "normal.inl"
+
+namespace glm{using namespace gtx::normal;}
+
+#endif//glm_gtx_normal
diff --git a/ExternalLibs/glm/gtx/normal.inl b/ExternalLibs/glm/gtx/normal.inl
new file mode 100644
index 0000000..d7e0cfd
--- /dev/null
+++ b/ExternalLibs/glm/gtx/normal.inl
@@ -0,0 +1,27 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2005-12-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/normal.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace normal{
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
+	(
+		detail::tvec3<T> const & p1, 
+		detail::tvec3<T> const & p2, 
+		detail::tvec3<T> const & p3
+	)
+    {
+        return normalize(cross(p1 - p2, p1 - p3));
+    }
+
+}//namespace normal
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/normalize_dot.hpp b/ExternalLibs/glm/gtx/normalize_dot.hpp
new file mode 100644
index 0000000..df83eec
--- /dev/null
+++ b/ExternalLibs/glm/gtx/normalize_dot.hpp
@@ -0,0 +1,59 @@
+//////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+//////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-09-28
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/normalize_dot.hpp
+//////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_fast_square_root
+//////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_normalize_dot
+#define glm_gtx_normalize_dot
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/fast_square_root.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_normalize_dot extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace normalize_dot	///< GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
+{
+	using namespace gtx::fast_square_root;
+
+	/// \addtogroup gtx_normalize_dot
+	/// @{
+
+	//! Normalize parameters and returns the dot product of x and y.
+	//! It's faster that dot(normalize(x), normalize(y)).
+	//! From GLM_GTX_normalize_dot extension.
+	template <typename genType> 
+	typename genType::value_type normalizeDot(
+		genType const & x, 
+		genType const & y);
+
+	//! Normalize parameters and returns the dot product of x and y.
+	//! Faster that dot(fastNormalize(x), fastNormalize(y)).
+	//! From GLM_GTX_normalize_dot extension.
+	template <typename genType> 
+	typename genType::value_type fastNormalizeDot(
+		genType const & x, 
+		genType const & y);
+
+	/// @}
+}//namespace normalize_dot
+}//namespace gtx
+}//namespace glm
+
+#include "normalize_dot.inl"
+
+namespace glm{using namespace gtx::normalize_dot;}
+
+#endif//glm_gtx_normalize_dot
diff --git a/ExternalLibs/glm/gtx/normalize_dot.inl b/ExternalLibs/glm/gtx/normalize_dot.inl
new file mode 100644
index 0000000..4e00d71
--- /dev/null
+++ b/ExternalLibs/glm/gtx/normalize_dot.inl
@@ -0,0 +1,120 @@
+//////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+//////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-09-28
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/normalize_dot.inl
+//////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace normalize_dot{
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType normalizeDot
+(
+	genType const & x, 
+	genType const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::inversesqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType normalizeDot
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::inversesqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType normalizeDot
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::inversesqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType normalizeDot
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::inversesqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType fastNormalizeDot
+(
+	genType const & x, 
+	genType const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType fastNormalizeDot
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType fastNormalizeDot
+(
+	detail::tvec3<valType> const & x, 
+	detail::tvec3<valType> const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType fastNormalizeDot
+(
+	detail::tvec4<valType> const & x, 
+	detail::tvec4<valType> const & y
+)
+{
+	return 
+		glm::dot(x, y) * 
+		glm::gtx::fast_square_root::fastInverseSqrt(glm::dot(x, x) * 
+		glm::dot(y, y));
+}
+
+}//namespace normalize_dot
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/number_precision.hpp b/ExternalLibs/glm/gtx/number_precision.hpp
new file mode 100644
index 0000000..7a086ce
--- /dev/null
+++ b/ExternalLibs/glm/gtx/number_precision.hpp
@@ -0,0 +1,69 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-05-10
+// Updated : 2009-06-04
+// Licence : This source is under MIT License
+// File    : glm/gtx/number_precision.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_type_precision
+// - GLM_GTC_quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_number_precision
+#define glm_gtx_number_precision
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/type_precision.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_number_precision extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
+{
+	using namespace gtc::type_precision;
+
+	/////////////////////////////
+	// Unsigned int vector types 
+
+	/// \addtogroup gtx_number_precision
+	/// @{
+
+	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+	typedef u32			u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+	typedef u64			u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
+
+	//////////////////////
+	// Float vector types 
+
+	typedef f16			f16vec1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f32			f32vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f64			f64vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+
+	//////////////////////
+	// Float matrix types 
+
+	typedef f16			f16mat1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f16			f16mat1x1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f32			f32mat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f32			f32mat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f64			f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
+
+	/// @}
+}//namespace number_precision
+}//namespace gtx
+}//namespace glm
+
+#include "number_precision.inl"
+
+namespace glm{using namespace gtx::number_precision;}
+
+#endif//glm_gtx_number_precision
diff --git a/ExternalLibs/glm/gtx/number_precision.inl b/ExternalLibs/glm/gtx/number_precision.inl
new file mode 100644
index 0000000..e2de65e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/number_precision.inl
@@ -0,0 +1,13 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-05-10
+// Updated : 2007-05-10
+// Licence : This source is under MIT License
+// File    : glm/gtx/number_precision.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+
+}
diff --git a/ExternalLibs/glm/gtx/ocl_type.hpp b/ExternalLibs/glm/gtx/ocl_type.hpp
new file mode 100644
index 0000000..bc1bf90
--- /dev/null
+++ b/ExternalLibs/glm/gtx/ocl_type.hpp
@@ -0,0 +1,110 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-07
+// Updated : 2009-05-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/number_precision.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_ocl_type
+#define glm_gtx_ocl_type
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_ocl_type extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
+{
+	///////////////////////////
+	// Scalar types 
+
+	/// \addtogroup gtx_ocl_type
+	/// @{
+
+	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::int16						cl_short;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::int32						cl_int;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::int64						cl_long;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	typedef detail::uint8						cl_uchar;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::uint16						cl_ushort;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::uint32						cl_uint;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::uint64						cl_ulong;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	typedef detail::float16						cl_half;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+	typedef detail::float32						cl_float;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+
+
+	typedef detail::int8						cl_char1;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::int16						cl_short1;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::int32						cl_int1;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::int64						cl_long1;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	typedef detail::uint8						cl_uchar1;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::uint16						cl_ushort1;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::uint32						cl_uint1;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::uint64						cl_ulong1;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	//typedef detail::float16						cl_half1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+	typedef detail::float32						cl_float1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+
+
+	typedef detail::tvec2<detail::int8>			cl_char2;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::int16>		cl_short2;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::int32>		cl_int2;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::int64>		cl_long2;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	typedef detail::tvec2<detail::uint8>		cl_uchar2;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::uint16>		cl_ushort2;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::uint32>		cl_uint2;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::uint64>		cl_ulong2;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	//typedef detail::tvec2<detail::float16>		cl_half2;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec2<detail::float32>		cl_float2;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+
+
+	typedef detail::tvec3<detail::int8>			cl_char3;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::int16>		cl_short3;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::int32>		cl_int3;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::int64>		cl_long3;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	typedef detail::tvec3<detail::uint8>		cl_uchar3;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::uint16>		cl_ushort3;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::uint32>		cl_uint3;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::uint64>		cl_ulong3;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	//typedef detail::tvec3<detail::float16>		cl_half3;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec3<detail::float32>		cl_float3;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+
+
+	typedef detail::tvec4<detail::int8>			cl_char4;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::int16>		cl_short4;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::int32>		cl_int4;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::int64>		cl_long4;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::uint8>		cl_uchar4;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::uint16>		cl_ushort4;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::uint32>		cl_uint4;		//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::uint64>		cl_ulong4;		//!< \brief 64bit signed integer. (from GLM_GTX_ocl_type extension)
+
+	//typedef detail::tvec4<detail::float16>		cl_half4;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+	typedef detail::tvec4<detail::float32>		cl_float4;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
+
+	/// @}
+}//namespace ocl_type
+}//namespace gtx
+}//namespace glm
+
+#include "ocl_type.inl"
+
+namespace glm{using namespace gtx::ocl_type;}
+
+#endif//glm_gtx_ocl_type
diff --git a/ExternalLibs/glm/gtx/ocl_type.inl b/ExternalLibs/glm/gtx/ocl_type.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/gtx/optimum_pow.hpp b/ExternalLibs/glm/gtx/optimum_pow.hpp
new file mode 100644
index 0000000..05ad426
--- /dev/null
+++ b/ExternalLibs/glm/gtx/optimum_pow.hpp
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/optimum_pow.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_optimum_pow
+#define glm_gtx_optimum_pow
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_optimum_pow extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
+{
+	/// \addtogroup gtx_optimum_pow
+	/// @{
+
+	//! Returns x raised to the power of 2.
+	//! From GLM_GTX_optimum_pow extension.
+    template <typename genType> 
+	genType pow2(const genType& x);
+
+	//! Returns x raised to the power of 3.
+	//! From GLM_GTX_optimum_pow extension.
+    template <typename genType> 
+	genType pow3(const genType& x);
+
+	//! Returns x raised to the power of 4.
+	//! From GLM_GTX_optimum_pow extension.
+	template <typename genType> 
+	genType pow4(const genType& x);
+        
+	//! Checks if the parameter is a power of 2 number. 
+	//! From GLM_GTX_optimum_pow extension.
+    bool powOfTwo(int num);
+
+	//! Checks to determine if the parameter component are power of 2 numbers.
+	//! From GLM_GTX_optimum_pow extension.
+    detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x);
+
+	//! Checks to determine if the parameter component are power of 2 numbers. 
+	//! From GLM_GTX_optimum_pow extension.
+    detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x);
+
+	//! Checks to determine if the parameter component are power of 2 numbers. 
+	//! From GLM_GTX_optimum_pow extension.
+    detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
+
+	/// @}
+}//namespace optimum_pow
+}//namespace gtx
+}//namespace glm
+
+#include "optimum_pow.inl"
+
+namespace glm{using namespace gtx::optimum_pow;}
+
+#endif//glm_gtx_optimum_pow
diff --git a/ExternalLibs/glm/gtx/optimum_pow.inl b/ExternalLibs/glm/gtx/optimum_pow.inl
new file mode 100644
index 0000000..c38b1bc
--- /dev/null
+++ b/ExternalLibs/glm/gtx/optimum_pow.inl
@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2005-12-27
+// Licence : This source is under MIT License
+// File    : glm/gtx/optimum_pow.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace optimum_pow{
+
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType pow2(const genType& x)
+    {
+        return x * x;
+    }
+
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType pow3(const genType& x)
+    {
+        return x * x * x;
+    }
+
+    template <typename genType> 
+    GLM_FUNC_QUALIFIER genType pow4(const genType& x)
+    {
+        return x * x * x * x;
+    }
+
+    GLM_FUNC_QUALIFIER bool powOfTwo(int x)
+    {
+        return !(x & (x - 1));
+    }
+
+    GLM_FUNC_QUALIFIER detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x)
+    {
+        return detail::tvec2<bool>(
+            powOfTwo(x.x),
+            powOfTwo(x.y));
+    }
+
+    GLM_FUNC_QUALIFIER detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x)
+    {
+        return detail::tvec3<bool>(
+            powOfTwo(x.x),
+            powOfTwo(x.y),
+            powOfTwo(x.z));
+    }
+
+    GLM_FUNC_QUALIFIER detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x)
+    {
+        return detail::tvec4<bool>(
+            powOfTwo(x.x),
+            powOfTwo(x.y),
+            powOfTwo(x.z),
+            powOfTwo(x.w));
+    }
+
+}//namespace optimum_pow
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/orthonormalize.hpp b/ExternalLibs/glm/gtx/orthonormalize.hpp
new file mode 100644
index 0000000..38049ba
--- /dev/null
+++ b/ExternalLibs/glm/gtx/orthonormalize.hpp
@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/orthonormalize.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_orthonormalize
+#define glm_gtx_orthonormalize
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_orthonormalize extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
+{
+	/// \addtogroup gtx_orthonormalize
+	/// @{
+
+	//! Returns the orthonormalized matrix of m.
+	//! From GLM_GTX_orthonormalize extension.
+	template <typename T> 
+	detail::tmat3x3<T> orthonormalize(
+		const detail::tmat3x3<T>& m);
+		
+    //! Orthonormalizes x according y.
+	//! From GLM_GTX_orthonormalize extension.
+	template <typename T> 
+	detail::tvec3<T> orthonormalize(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y);
+
+	/// @}
+}//namespace orthonormalize
+}//namespace gtx
+}//namespace glm
+
+#include "orthonormalize.inl"
+
+namespace glm{using namespace gtx::orthonormalize;}
+
+#endif//glm_gtx_orthonormalize
diff --git a/ExternalLibs/glm/gtx/orthonormalize.inl b/ExternalLibs/glm/gtx/orthonormalize.inl
new file mode 100644
index 0000000..8f0f110
--- /dev/null
+++ b/ExternalLibs/glm/gtx/orthonormalize.inl
@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2005-12-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/orthonormalize.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace orthonormalize{
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> orthonormalize
+	(
+		const detail::tmat3x3<T>& m
+	)
+    {
+        detail::tmat3x3<T> r = m;
+
+        r[0] = normalize(r[0]);
+
+	    float d0 = dot(r[0], r[1]);
+	    r[1] -= r[0] * d0;
+	    r[1] = normalize(r[1]);
+
+	    float d1 = dot(r[1], r[2]);
+	    d0 = dot(r[0], r[2]);
+	    r[2] -= r[0] * d0 + r[1] * d1;
+	    r[2] = normalize(r[2]);
+
+        return r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> orthonormalize
+	(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y
+	)
+    {
+        return normalize(x - y * dot(y, x));
+    }
+
+}//namespace orthonormalize
+}//namespace gtx
+}//namespace glm
+
diff --git a/ExternalLibs/glm/gtx/perpendicular.hpp b/ExternalLibs/glm/gtx/perpendicular.hpp
new file mode 100644
index 0000000..a4d16bf
--- /dev/null
+++ b/ExternalLibs/glm/gtx/perpendicular.hpp
@@ -0,0 +1,62 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-03-06
+// Licence : This source is under MIT License
+// File    : glm/gtx/perpendicular.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_projection
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_perpendicular
+#define glm_gtx_perpendicular
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/projection.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_perpendicular extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
+{
+	/// \addtogroup gtx_perpendicular
+	/// @{
+
+	//! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template <typename T> 
+	detail::tvec2<T> perp(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & Normal);
+
+    //! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template <typename T> 
+	detail::tvec3<T> perp(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & Normal);
+
+    //! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template <typename T> 
+	detail::tvec4<T> perp(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & Normal);
+
+	/// @}
+}//namespace perpendicular
+}//namespace gtx
+}//namespace glm
+
+#include "perpendicular.inl"
+
+namespace glm{using namespace gtx::perpendicular;}
+
+#endif//glm_gtx_perpendicular
diff --git a/ExternalLibs/glm/gtx/perpendicular.inl b/ExternalLibs/glm/gtx/perpendicular.inl
new file mode 100644
index 0000000..595053e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/perpendicular.inl
@@ -0,0 +1,40 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-03-06
+// Licence : This source is under MIT License
+// File    : glm/gtx/perpendicular.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace perpendicular{
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> perp(
+	detail::tvec2<T> const & x, 
+	detail::tvec2<T> const & Normal)
+{
+    return x - projection::proj(x, Normal);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> perp(
+	detail::tvec3<T> const & x, 
+	detail::tvec3<T> const & Normal)
+{
+    return x - projection::proj(x, Normal);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> perp(
+	detail::tvec4<T> const & x, 
+	detail::tvec4<T> const & Normal)
+{
+    return x - projection::proj(x, Normal);
+}
+
+}//namespace perpendicular
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/polar_coordinates.hpp b/ExternalLibs/glm/gtx/polar_coordinates.hpp
new file mode 100644
index 0000000..f4d5bf7
--- /dev/null
+++ b/ExternalLibs/glm/gtx/polar_coordinates.hpp
@@ -0,0 +1,49 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-06
+// Updated : 2009-05-01
+// Licence : This source is under MIT License
+// File    : glm/gtx/polar_coordinates.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_polar_coordinates
+#define glm_gtx_polar_coordinates
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_polar_coordinates extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
+{
+	/// \addtogroup gtx_polar_coordinates
+	/// @{
+
+	//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
+	//! From GLM_GTX_polar_coordinates extension.
+	template <typename T> 
+	detail::tvec3<T> polar(const detail::tvec3<T>& euclidean);
+
+	//! Convert Polar to Euclidean coordinates.
+	//! From GLM_GTX_polar_coordinates extension.
+	template <typename T> 
+	detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
+
+	/// @}
+}//namespace polar_coordinates
+}//namespace gtx
+}//namespace glm
+
+#include "polar_coordinates.inl"
+
+namespace glm{using namespace gtx::polar_coordinates;}
+
+#endif//glm_gtx_polar_coordinates
diff --git a/ExternalLibs/glm/gtx/polar_coordinates.inl b/ExternalLibs/glm/gtx/polar_coordinates.inl
new file mode 100644
index 0000000..9d99d56
--- /dev/null
+++ b/ExternalLibs/glm/gtx/polar_coordinates.inl
@@ -0,0 +1,42 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-06
+// Updated : 2009-05-01
+// Licence : This source is under MIT License
+// File    : glm/gtx/polar_coordinates.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace polar_coordinates
+{
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> polar(
+		const detail::tvec3<T>& euclidean)
+	{
+		T length = length(euclidean);
+		detail::tvec3<T> tmp = euclidean / length;
+		T xz_dist = sqrt(tmp.x * tmp.x + tmp.z * tmp.z);
+
+		return detail::tvec3<T>(
+			degrees(atan(xz_dist, tmp.y)),	// latitude
+			degrees(atan(tmp.x, tmp.z)),		// longitude
+			xz_dist);									// xz distance
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> euclidean(
+		const detail::tvec3<T>& polar)
+	{
+		T latitude = radians(polar.x);
+		T longitude = radians(polar.y);
+		return detail::tvec3<T>(
+			cos(latitude) * sin(longitude),
+			sin(latitude),
+			cos(latitude) * cos(longitude));
+	}
+
+}//namespace polar_coordinates
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/projection.hpp b/ExternalLibs/glm/gtx/projection.hpp
new file mode 100644
index 0000000..47e8eb6
--- /dev/null
+++ b/ExternalLibs/glm/gtx/projection.hpp
@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-03-06
+// Licence : This source is under MIT License
+// File    : glm/gtx/projection.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_projection
+#define glm_gtx_projection
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_projection extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
+{
+	/// \addtogroup gtx_projection
+	/// @{
+
+	//! Projects x on Normal.
+	//! From GLM_GTX_projection extension.
+	template <typename T> 
+	detail::tvec2<T> proj(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & Normal);
+		
+	//! Projects x on Normal.
+	//! From GLM_GTX_projection extension.
+	template <typename T> 
+	detail::tvec3<T> proj(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & Normal);
+
+	//! Projects x on Normal.
+	//! From GLM_GTX_projection extension.
+	template <typename T> 
+	detail::tvec4<T> proj(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & Normal);
+
+	/// @}
+}//namespace projection
+}//namespace gtx
+}//namespace glm
+
+#include "projection.inl"
+
+namespace glm{using namespace gtx::projection;}
+
+#endif//glm_gtx_projection
diff --git a/ExternalLibs/glm/gtx/projection.inl b/ExternalLibs/glm/gtx/projection.inl
new file mode 100644
index 0000000..bd36547
--- /dev/null
+++ b/ExternalLibs/glm/gtx/projection.inl
@@ -0,0 +1,40 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-03-06
+// Licence : This source is under MIT License
+// File    : glm/gtx/projection.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace projection{
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> proj(
+	detail::tvec2<T> const & x, 
+	detail::tvec2<T> const & Normal)
+{
+	return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> proj(
+	detail::tvec3<T> const & x, 
+	detail::tvec3<T> const & Normal)
+{
+	return dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> proj(
+	detail::tvec4<T> const & x, 
+	detail::tvec4<T> const & Normal)
+{
+	return glm::dot(x, Normal) / glm::dot(Normal, Normal) * Normal;
+}
+
+}//namespace projection
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/quaternion.hpp b/ExternalLibs/glm/gtx/quaternion.hpp
new file mode 100644
index 0000000..91a0930
--- /dev/null
+++ b/ExternalLibs/glm/gtx/quaternion.hpp
@@ -0,0 +1,217 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-05-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/quaternion.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// ToDo:
+// - Study constructors with angles and axis
+// - Study constructors with vec3 that are the imaginary component of quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_quaternion
+#define glm_gtx_quaternion
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/quaternion.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_quaternion extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
+{
+	using namespace gtc::quaternion;
+
+	/// \addtogroup gtx_quaternion
+	///@{
+
+	//! Compute a cross product between a quaternion and a vector. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> cross(
+		detail::tquat<valType> const & q, 
+		detail::tvec3<valType> const & v);
+
+	//! Compute a cross product between a vector and a quaternion.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> cross(
+		detail::tvec3<valType> const & v, 
+		detail::tquat<valType> const & q);
+
+	//! Compute a point on a path according squad equation. 
+	//! q1 and q2 are control points; s1 and s2 are intermediate control points.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> squad(
+		detail::tquat<valType> const & q1, 
+		detail::tquat<valType> const & q2, 
+		detail::tquat<valType> const & s1, 
+		detail::tquat<valType> const & s2, 
+		valType const & h);
+
+	//! Returns an intermediate control point for squad interpolation.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> intermediate(
+		detail::tquat<valType> const & prev, 
+		detail::tquat<valType> const & curr, 
+		detail::tquat<valType> const & next);
+
+	//! Returns a exp of a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tquat<valType> exp(
+		detail::tquat<valType> const & q, 
+		valType const & exponent);
+
+	//! Returns a log of a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tquat<valType> log(
+		detail::tquat<valType> const & q);
+
+	//! Returns x raised to the y power.
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tquat<valType> pow(
+		detail::tquat<valType> const & x, 
+		valType const & y);
+
+	//! Returns quarternion square root.
+	//! From GLM_GTX_quaternion extension.
+	//template <typename valType> 
+	//detail::tquat<valType> sqrt(
+	//	detail::tquat<valType> const & q);
+
+	//! Rotates a 3 components vector by a quaternion. 
+	//! From GLM_GTX_transform extension.
+	template <typename valType> 
+	detail::tvec3<valType> rotate(
+		detail::tquat<valType> const & q, 
+		detail::tvec3<valType> const & v);
+
+    //! Rotates a 4 components vector by a quaternion.
+	//! From GLM_GTX_transform extension.
+	template <typename valType> 
+	detail::tvec4<valType> rotate(
+		detail::tquat<valType> const & q, 
+		detail::tvec4<valType> const & v);
+		
+    //! Returns the quaternion rotation angle. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType angle(
+		detail::tquat<valType> const & x);
+
+	//! Returns the q rotation axis. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> axis(
+		detail::tquat<valType> const & x);
+
+	//! Build a quaternion from an angle and a normalized axis. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> angleAxis(
+		valType const & angle, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z);
+
+    //! Build a quaternion from an angle and a normalized axis.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> angleAxis(
+		valType const & angle, 
+		detail::tvec3<valType> const & axis);
+
+	//! Extract the real component of a quaternion.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType extractRealComponent(
+		detail::tquat<valType> const & q);
+
+    //! Returns roll value of euler angles. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType roll(
+		detail::tquat<valType> const & x);
+
+	//! Returns pitch value of euler angles. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	valType pitch(
+		detail::tquat<valType> const & x);
+
+    //! Returns yaw value of euler angles. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType yaw(
+		detail::tquat<valType> const & x);
+		
+	//! Returns euler angles, yitch as x, yaw as y, roll as z. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> eularAngles(
+		detail::tquat<valType> const & x);
+
+	//! Converts a quaternion to a 3 * 3 matrix. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tmat3x3<valType> toMat3(
+		detail::tquat<valType> const & x){return gtc::quaternion::mat3_cast(x);}
+
+	//! Converts a quaternion to a 4 * 4 matrix. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> toMat4(
+		detail::tquat<valType> const & x){return gtc::quaternion::mat4_cast(x);}
+
+	//! Converts a 3 * 3 matrix to a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> toQuat(
+		detail::tmat3x3<valType> const & x){return gtc::quaternion::quat_cast(x);}
+
+	//! Converts a 4 * 4 matrix to a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> toQuat(
+		detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
+
+	//! Quaternion interpolation using the rotation short path. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename T>
+	detail::tquat<T> shortMix(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a);
+
+	//! Quaternion normalized linear interpolation. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename T>
+	detail::tquat<T> fastMix(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a);
+
+	/// @}
+}//namespace quaternion
+}//namespace gtx
+} //namespace glm
+
+#include "quaternion.inl"
+
+namespace glm{using namespace gtx::quaternion;}
+
+#endif//glm_gtx_quaternion
diff --git a/ExternalLibs/glm/gtx/quaternion.inl b/ExternalLibs/glm/gtx/quaternion.inl
new file mode 100644
index 0000000..aaf0717
--- /dev/null
+++ b/ExternalLibs/glm/gtx/quaternion.inl
@@ -0,0 +1,303 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2008-11-27
+// Licence : This source is under MIT License
+// File    : glm/gtx/quaternion.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <limits>
+
+namespace glm{
+namespace gtx{
+namespace quaternion
+{
+    template <typename valType> 
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> cross
+	(
+		detail::tvec3<valType> const & v, 
+		detail::tquat<valType> const & q
+	)
+    {
+		return gtc::quaternion::inverse(q) * v;
+    }
+
+	template <typename valType> 
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> cross
+	(
+		detail::tquat<valType> const & q, 
+		detail::tvec3<valType> const & v
+	)
+    {
+		return q * v;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> squad
+	(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2, 
+		detail::tquat<T> const & s1, 
+		detail::tquat<T> const & s2, 
+		T const & h)
+    {
+        return mix(mix(q1, q2, h), mix(s1, s2, h), T(2) * h (T(1) - h));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> intermediate
+	(
+		detail::tquat<T> const & prev, 
+		detail::tquat<T> const & curr, 
+		detail::tquat<T> const & next
+	)
+    {
+        detail::tquat<T> invQuat = gtc::quaternion::inverse(curr);
+        return ext((log(next + invQuat) + log(prev + invQuat)) / T(-4)) * curr;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> exp
+	(
+		detail::tquat<T> const & q, 
+		T const & exponent
+	)
+    {
+        detail::tvec3<T> u(q.x, q.y, q.z);
+		float a = glm::length(u);
+        detail::tvec3<T> v(u / a);
+        return detail::tquat<T>(cos(a), sin(a) * v);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> log
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        if((q.x == T(0)) && (q.y == T(0)) && (q.z == T(0)))
+        {
+            if(q.w > T(0))
+                return detail::tquat<T>(log(q.w), T(0), T(0), T(0));
+            else if(q.w < T(0))
+                return detail::tquat<T>(log(-q.w), T(3.1415926535897932384626433832795), T(0),T(0));
+            else
+                return detail::tquat<T>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
+        } 
+        else 
+        {
+            T Vec3Len = sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
+            T QuatLen = sqrt(Vec3Len * Vec3Len + q.w * q.w);
+            T t = atan(Vec3Len, T(q.w)) / Vec3Len;
+            return detail::tquat<T>(t * q.x, t * q.y, t * q.z, log(QuatLen));
+        }
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tquat<T> pow
+	(
+		detail::tquat<T> const & x, 
+		T const & y
+	)
+    {
+        if(abs(x.w) > T(0.9999))
+            return x;
+        float Angle = acos(y);
+        float NewAngle = Angle * y;
+        float Div = sin(NewAngle) / sin(Angle);
+        return detail::tquat<T>(
+            cos(NewAngle),
+            x.x * Div,
+            x.y * Div,
+            x.z * Div);
+    }
+
+	//template <typename T> 
+	//GLM_FUNC_QUALIFIER detail::tquat<T> sqrt
+	//(
+	//	detail::tquat<T> const & q
+	//)
+	//{
+	//	T q0 = T(1) - dot(q, q);
+	//	return T(2) * (T(1) + q0) * q;
+	//}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> rotate
+	(
+		detail::tquat<T> const & q, 
+		detail::tvec3<T> const & v
+	)
+    {
+		return q * v;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<T> rotate
+	(
+		detail::tquat<T> const & q, 
+		detail::tvec4<T> const & v
+	)
+    {
+        return q * v;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER T angle
+	(
+		detail::tquat<T> const & x
+	)
+    {
+        return acos(x.w) * T(2);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> axis
+	(
+		detail::tquat<T> const & x
+	)
+    {
+        T tmp1 = T(1) - x.w * x.w;
+        if(tmp1 <= T(0))
+            return detail::tvec3<T>(0, 0, 1);
+        T tmp2 = T(1) / sqrt(tmp1);
+        return detail::tvec3<T>(x.x * tmp2, x.y * tmp2, x.z * tmp2);
+    }
+
+    template <typename valType> 
+    GLM_FUNC_QUALIFIER detail::tquat<valType> angleAxis
+	(
+		valType const & angle, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z
+	)
+    {
+        return angleAxis(angle, detail::tvec3<valType>(x, y, z));
+    }
+
+    template <typename valType> 
+    GLM_FUNC_QUALIFIER detail::tquat<valType> angleAxis
+	(
+		valType const & angle, 
+		detail::tvec3<valType> const & v
+	)
+    {
+        detail::tquat<valType> result;
+
+		valType a = glm::radians(angle);
+        valType s = glm::sin(a * valType(0.5));
+
+        result.w = glm::cos(a * valType(0.5));
+        result.x = v.x * s;
+        result.y = v.y * s;
+        result.z = v.z * s;
+        return result;
+    }
+
+    template <typename T> 
+	GLM_FUNC_QUALIFIER T extractRealComponent
+	(
+		detail::tquat<T> const & q
+	)
+    {
+        T w = T(1.0) - q.x * q.x - q.y * q.y - q.z * q.z;
+        if(w < T(0))
+            return T(0);
+        else
+            return -sqrt(w);
+    }
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER valType roll
+	(
+		detail::tquat<valType> const & q
+	)
+	{
+		return atan2(valType(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z);
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER valType pitch
+	(
+		detail::tquat<valType> const & q
+	)
+	{
+		return atan2(valType(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z);
+	}
+
+	template <typename valType> 
+	GLM_FUNC_QUALIFIER valType yaw
+	(
+		detail::tquat<valType> const & q
+	)
+	{
+		return asin(valType(-2) * (q.x * q.z - q.w * q.y));
+	}
+
+    template <typename valType> 
+    GLM_FUNC_QUALIFIER detail::tvec3<valType> eularAngles
+	(
+		detail::tquat<valType> const & x
+	)
+    {
+        return detail::tvec3<valType>(pitch(x), yaw(x), roll(x));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tquat<T> shortMix
+	(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a
+	)
+    {
+        if(a <= typename detail::tquat<T>::value_type(0)) return x;
+        if(a >= typename detail::tquat<T>::value_type(1)) return y;
+
+        float fCos = dot(x, y);
+        detail::tquat<T> y2(y); //BUG!!! tquat<T> y2;
+        if(fCos < typename detail::tquat<T>::value_type(0))
+        {
+            y2 = -y;
+            fCos = -fCos;
+        }
+
+        //if(fCos > 1.0f) // problem
+        float k0, k1;
+        if(fCos > typename detail::tquat<T>::value_type(0.9999))
+        {
+            k0 = typename detail::tquat<T>::value_type(1) - a;
+            k1 = typename detail::tquat<T>::value_type(0) + a; //BUG!!! 1.0f + a;
+        }
+        else
+        {
+            typename detail::tquat<T>::value_type fSin = sqrt(T(1) - fCos * fCos);
+            typename detail::tquat<T>::value_type fAngle = atan(fSin, fCos);
+            typename detail::tquat<T>::value_type fOneOverSin = T(1) / fSin;
+            k0 = sin((typename detail::tquat<T>::value_type(1) - a) * fAngle) * fOneOverSin;
+            k1 = sin((typename detail::tquat<T>::value_type(0) + a) * fAngle) * fOneOverSin;
+        }
+
+        return detail::tquat<T>(
+            k0 * x.w + k1 * y2.w,
+            k0 * x.x + k1 * y2.x,
+            k0 * x.y + k1 * y2.y,
+            k0 * x.z + k1 * y2.z);
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tquat<T> fastMix
+	(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a
+	)
+    {
+		return glm::normalize(x * (1 - a) + (y * a));
+	}
+
+}//namespace quaternion
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/random.hpp b/ExternalLibs/glm/gtx/random.hpp
new file mode 100644
index 0000000..fabc192
--- /dev/null
+++ b/ExternalLibs/glm/gtx/random.hpp
@@ -0,0 +1,89 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-16
+// Updated : 2007-08-30
+// Licence : This source is under MIT License
+// File    : glm/gtx/random.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_vecx
+// - GLM_GTX_half_float
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_random
+#define glm_gtx_random
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_random extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace random ///< GLM_GTX_random extension: Generate random number from various distribution methods
+{
+	/// \addtogroup gtx_random
+	/// @{
+
+	//! Generate a random number in the interval [-1, 1], according a linear distribution.
+	//! From GLM_GTX_random extension.
+    template <typename T> T signedRand1();
+	
+	template <> float signedRand1();                                                                                     //!< \brief Generate a random number in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <> double signedRand1();                                                                                   //!< \brief Generate a random number in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> signedRand2();                                                                           //!< \brief Generate 2 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> signedRand3();                                                                           //!< \brief Generate 3 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> signedRand4();                                                                           //!< \brief Generate 4 random numbers in the interval [-1, 1], according a linear distribution (From GLM_GTX_random extension)
+    
+	template <typename T> detail::tvec2<T> normalizedRand2();                                                                          //!< \brief Generate a normalized 2D vector regulary distribute on a circle (From GLM_GTX_random extension)
+	template <typename T> detail::tvec2<T> normalizedRand2(T Min, T Max);                                                         //!< \brief Generate a scaled and normalized 2D vector regulary distribute on a circle (From GLM_GTX_random extension)
+	template <typename T> detail::tvec3<T> normalizedRand3();                                                                          //!< \brief Generate a normalized 3D vector regulary distribute on a sphere (From GLM_GTX_random extension)
+	template <typename T> detail::tvec3<T> normalizedRand3(T Min, T Max);                                                        //!< \brief Generate a scaled and normalized 3D vector regulary distribute on a sphere (From GLM_GTX_random extension)
+
+    template <typename T> T compRand1();                                                                                       //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
+	template <> float compRand1();                                                                                         //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <> double compRand1();                                                                                      //!< \brief Generate a random number in the interval [0, 1], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> T compRand1(T Min, T Max);                                                                     //!< \brief Generate a random number in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> compRand2(T Min, T Max);                                                              //!< \brief Generate 2 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> compRand3(T Min, T Max);                                                             //!< \brief Generate 3 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> compRand4(T Min, T Max);                                                              //!< \brief Generate 4 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> compRand2(const detail::tvec2<T>& Min, const detail::tvec2<T>& Max);                                //!< \brief Generate 2 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> compRand3(const detail::tvec3<T>& Min, const detail::tvec3<T>& Max);                                //!< \brief Generate 3 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> compRand4(const detail::tvec4<T>& Min, const detail::tvec4<T>& Max);                                //!< \brief Generate 4 random numbers in the interval [Min, Max], according a linear distribution (From GLM_GTX_random extension)
+
+    template <typename T> detail::tvec2<T> vecRand2();                                                                                 //!< \brief Generate a random normalized 2 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> vecRand2(T MinRadius, T MaxRadius);                                        //!< \brief Generate a random normalized 2 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> vecRand3();                                                                                 //!< \brief Generate a random normalized 3 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> vecRand3(T MinRadius, T MaxRadius);                                        //!< \brief Generate a random normalized 3 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> vecRand4();                                                                                 //!< \brief Generate a random normalized 4 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> vecRand4(T MinRadius, T MaxRadius);                                        //!< \brief Generate a random normalized 4 component vector. It's a spherical uniform distribution. (From GLM_GTX_random extension)
+
+    template <typename T> T gaussRand1(T mean, T std_deviation);                                           //!< \brief Gererate a random floating number according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(T mean, T std_deviation);                                   //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(T mean, T std_deviation);                                   //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(T mean, T std_deviation);                                   //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(const detail::tvec2<T>& mean, T std_deviation);                    //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, T std_deviation);                    //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, T std_deviation);                    //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(T  mean, const detail::tvec2<T>& std_deviation);                   //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(T  mean, const detail::tvec3<T>& std_deviation);                   //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(T  mean, const detail::tvec4<T>& std_deviation);                   //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec2<T> gaussRand2(const detail::tvec2<T>& mean, const detail::tvec2<T>& std_deviation);     //!< \brief Gererate 2 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation);     //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+    template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation);     //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
+
+	///@}
+}//namespace random
+}//namespace gtx
+}//namespace glm
+
+#include "random.inl"
+
+namespace glm{using namespace gtx::random;}
+
+#endif//glm_gtx_random
diff --git a/ExternalLibs/glm/gtx/random.inl b/ExternalLibs/glm/gtx/random.inl
new file mode 100644
index 0000000..f325d61
--- /dev/null
+++ b/ExternalLibs/glm/gtx/random.inl
@@ -0,0 +1,536 @@
+//////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+//////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-16
+// Updated : 2006-01-16
+// Licence : This source is under MIT License
+// File    : glm/gtx/random.inl
+//////////////////////////////////////////////////////////////////////////////////
+
+#include <ctime>
+#include <cassert>
+
+namespace glm{
+namespace gtx{
+namespace random
+{
+    template <>
+	GLM_FUNC_QUALIFIER float signedRand1()
+	{
+		#if(GLM_COMPILER & GLM_COMPILER_VC)
+		#define RAND_SHIFT_NUM 5
+		#else
+		#define RAND_SHIFT_NUM 0
+		#endif
+		return float((std::rand() - (RAND_MAX >> 1) - 1) << 1) / float(RAND_MAX - RAND_SHIFT_NUM);
+	}
+
+    template <>
+	GLM_FUNC_QUALIFIER double signedRand1()
+	{
+		return double(signedRand1<float>());
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> signedRand2()
+	{
+		return detail::tvec2<T>(
+			signedRand1<float>(),
+			signedRand1<float>());
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> signedRand3()
+	{
+		return detail::tvec3<T>(
+			signedRand1<float>(),
+			signedRand1<float>(),
+			signedRand1<float>());
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> signedRand4()
+	{
+		return detail::tvec4<T>(
+			signedRand1<float>(),
+			signedRand1<float>(),
+			signedRand1<float>(),
+			signedRand1<float>());
+	}
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> normalizedRand2()
+    {
+        T a = compRand1<T>(T(0), T(6.283185307179586476925286766559f));
+        return detail::tvec2<T>(cos(a), sin(a));
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3()
+    {
+	    T z = compRand1(T(-1), T(1));
+	    T a = compRand1(T(0), T(6.283185307179586476925286766559f));
+
+        T r = sqrt(T(1) - z * z);
+
+	    T x = r * cos(a);
+	    T y = r * sin(a);
+
+        return detail::tvec3<T>(x, y, z);
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> normalizedRand3(
+		T Min, 
+		T Max)
+    {
+        return normalizedRand3<T>() * compRand1(Min, Max);
+    }
+
+	template <>
+	GLM_FUNC_QUALIFIER float compRand1()
+	{
+		return float(std::rand()) / float(RAND_MAX);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER double compRand1()
+	{
+		return double(std::rand()) / double(RAND_MAX);
+	}
+
+	GLM_FUNC_QUALIFIER glm::half compRand1(
+		glm::half Min, 
+		glm::half Max)
+	{
+		return compRand1<glm::half>() * (Max - Min) + Min;
+	}
+
+	GLM_FUNC_QUALIFIER float compRand1(
+		float Min, 
+		float Max)
+	{
+		return compRand1<float>() * (Max - Min) + Min;
+	}
+
+	GLM_FUNC_QUALIFIER double compRand1(
+		double Min, 
+		double Max)
+	{
+		return compRand1<double>() * (Max - Min) + Min;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T compRand1(
+		T Min, 
+		T Max)
+	{
+		return T(compRand1<double>() * double(Max - Min) + double(Min));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+		T Min, 
+		T Max)
+	{
+		return detail::tvec2<T>(
+			compRand1(Min, Max),
+			compRand1(Min, Max));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+		T Min, 
+		T Max)
+	{
+		return detail::tvec3<T>(
+			compRand1(Min, Max),
+			compRand1(Min, Max),
+			compRand1(Min, Max));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+		T Min, 
+		T Max)
+	{
+		return detail::tvec4<T>(
+			compRand1(Min, Max),
+			compRand1(Min, Max),
+			compRand1(Min, Max),
+			compRand1(Min, Max));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+		T Min, 
+		const detail::tvec2<T>& Max)
+	{
+		return detail::tvec2<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+		T Min, 
+		const detail::tvec3<T>& Max)
+	{
+		return detail::tvec3<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y),
+			compRand1(Min.z, Max.z));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+		T Min, 
+		const detail::tvec4<T>& Max)
+	{
+		return detail::tvec4<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y),
+			compRand1(Min.z, Max.z),
+			compRand1(Min.w, Max.w));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+		const detail::tvec2<T>& Min, 
+		T Max)
+	{
+		return detail::tvec2<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+		const detail::tvec3<T>& Min, 
+		T Max)
+	{
+		return detail::tvec3<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y),
+			compRand1(Min.z, Max.z));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+		const detail::tvec4<T>& Min, 
+		T Max)
+	{
+		return detail::tvec4<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y),
+			compRand1(Min.z, Max.z),
+			compRand1(Min.w, Max.w));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> compRand2(
+		const detail::tvec2<T>& Min, 
+		const detail::tvec2<T>& Max)
+	{
+		return detail::tvec2<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> compRand3(
+		const detail::tvec3<T>& Min, 
+		const detail::tvec3<T>& Max)
+	{
+		return detail::tvec3<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y),
+			compRand1(Min.z, Max.z));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> compRand4(
+		const detail::tvec4<T>& Min, 
+		const detail::tvec4<T>& Max)
+	{
+		return detail::tvec4<T>(
+			compRand1(Min.x, Max.x),
+			compRand1(Min.y, Max.y),
+			compRand1(Min.z, Max.z),
+			compRand1(Min.w, Max.w));
+	}
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<float> vecRand2()
+    {
+		detail::tvec2<float> result(float(0));
+		do
+		{
+			result = compRand2(float(-1), float(1));
+		} while (length(result) > float(1));
+
+        return result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<double> vecRand2()
+    {
+		detail::tvec2<double> result(double(0));
+		do
+		{
+			result = compRand2(double(-1), double(1));
+		} while (length(result) > double(1));
+
+        return result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> vecRand2(
+		T MinRadius, 
+		T MaxRadius)
+    {
+		assert(MinRadius <= MaxRadius);
+
+		detail::tvec2<T> Result(T(0));
+		T LenRadius(0);
+
+		do
+		{
+			Result = compRand2(-MaxRadius, MaxRadius);
+			LenRadius = length(Result);
+		}
+		while(LenRadius > MaxRadius || LenRadius < MinRadius);
+
+        return Result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> vecRand3()
+    {
+		detail::tvec3<T> Result(T(0));
+		do
+		{
+			Result = compRand3(T(-1), T(1));
+		}
+		while(length(Result) > T(1));
+
+        return Result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> vecRand3(
+		T MinRadius, 
+		T MaxRadius)
+    {
+		assert(MinRadius <= MaxRadius);
+
+		detail::tvec3<T> Result(0);
+		T LenRadius(0);
+
+		do
+		{
+			Result = compRand3(-MaxRadius, MaxRadius);
+			LenRadius = length(Result);
+		}
+		while(LenRadius > MaxRadius || LenRadius < MinRadius);
+
+        return Result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<float> vecRand4()
+    {
+		detail::tvec4<float> result(float(0));
+		do
+		{
+			result = compRand4(float(-1), float(1));
+		} while (length(result) > float(1));
+
+        return result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<double> vecRand4()
+    {
+		detail::tvec4<double> result(double(0));
+		do
+		{
+			result = compRand4(double(-1), double(1));
+		} while (length(result) > double(1));
+
+        return result;
+    }
+
+	template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> vecRand4(
+		T MinRadius, 
+		T MaxRadius)
+    {
+		assert(MinRadius <= MaxRadius);
+
+		detail::tvec4<T> Result(T(0));
+		T LenRadius(T(0));
+
+		do
+		{
+			Result = compRand4(-MaxRadius, MaxRadius);
+			LenRadius = length(Result);
+		}
+		while(LenRadius > MaxRadius || LenRadius < MinRadius);
+
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T gaussRand1(
+		T mean, 
+		T std_deviation)
+    {
+        T w, x1, x2;
+
+        do
+        {
+            x1 = compRand1(T(-1), T(1));
+            x2 = compRand1(T(-1), T(1));
+
+            w = x1 * x1 + x2 * x2;
+        } while(w > T(1));
+
+        return x2 * std_deviation * std_deviation * sqrt((T(-2) * log(w)) / w) + mean;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+		T mean, 
+		T std_deviation)
+    {
+        return detail::tvec2<T>(
+            gaussRand1(mean, std_deviation),
+            gaussRand1(mean, std_deviation));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+		T mean, 
+		T std_deviation)
+    {
+        return detail::tvec3<T>(
+            gaussRand1(mean, std_deviation),
+            gaussRand1(mean, std_deviation),
+            gaussRand1(mean, std_deviation));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+		T mean, 
+		T std_deviation)
+    {
+        return detail::tvec4<T>(
+            gaussRand1(mean, std_deviation),
+            gaussRand1(mean, std_deviation),
+            gaussRand1(mean, std_deviation),
+            gaussRand1(mean, std_deviation));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+		T mean, 
+		const detail::tvec2<T>& std_deviation)
+    {
+        return detail::tvec2<T>(
+            gaussRand1(mean, std_deviation.x),
+            gaussRand1(mean, std_deviation.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+		T mean, 
+		const detail::tvec3<T>& std_deviation)
+    {
+        return detail::tvec3<T>(
+            gaussRand1(mean, std_deviation.x),
+            gaussRand1(mean, std_deviation.y),
+            gaussRand1(mean, std_deviation.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+		T mean, 
+		const detail::tvec4<T>& std_deviation)
+    {
+        return detail::tvec4<T>(
+            gaussRand1(mean, std_deviation.x),
+            gaussRand1(mean, std_deviation.y),
+            gaussRand1(mean, std_deviation.z),
+            gaussRand1(mean, std_deviation.w));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+		const detail::tvec2<T>& mean, 
+		T std_deviation)
+    {
+        return detail::tvec2<T>(
+            gaussRand1(mean.x, std_deviation),
+            gaussRand1(mean.y, std_deviation));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+		const detail::tvec3<T>& mean, 
+		T std_deviation)
+    {
+        return detail::tvec3<T>(
+            gaussRand1(mean.x, std_deviation),
+            gaussRand1(mean.y, std_deviation),
+            gaussRand1(mean.z, std_deviation));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+		const detail::tvec4<T>& mean, 
+		T std_deviation)
+    {
+        return detail::tvec4<T>(
+            gaussRand1(mean.x, std_deviation),
+            gaussRand1(mean.y, std_deviation),
+            gaussRand1(mean.z, std_deviation),
+            gaussRand1(mean.w, std_deviation));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec2<T> gaussRand2(
+		const detail::tvec2<T>& mean, 
+		const detail::tvec2<T>& std_deviation)
+    {
+        return detail::tvec2<T>(
+            gaussRand1(mean.x, std_deviation.x),
+            gaussRand1(mean.y, std_deviation.y));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec3<T> gaussRand3(
+		const detail::tvec3<T>& mean, 
+		const detail::tvec3<T>& std_deviation)
+    {
+        return detail::tvec3<T>(
+            gaussRand1(mean.x, std_deviation.x),
+            gaussRand1(mean.y, std_deviation.y),
+            gaussRand1(mean.z, std_deviation.z));
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER detail::tvec4<T> gaussRand4(
+		const detail::tvec4<T>& mean, 
+		const detail::tvec4<T>& std_deviation)
+    {
+        return detail::tvec4<T>(
+            gaussRand1(mean.x, std_deviation.x),
+            gaussRand1(mean.y, std_deviation.y),
+            gaussRand1(mean.z, std_deviation.z),
+            gaussRand1(mean.w, std_deviation.w));
+    }
+
+}//namespace random
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/raw_data.hpp b/ExternalLibs/glm/gtx/raw_data.hpp
new file mode 100644
index 0000000..b66dc5a
--- /dev/null
+++ b/ExternalLibs/glm/gtx/raw_data.hpp
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-11-19
+// Updated : 2010-01-28
+// Licence : This source is under MIT License
+// File    : glm/gtx/raw_data.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_raw_data
+#define glm_gtx_raw_data
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/type_precision.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_raw_data extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
+{
+	using namespace gtc::type_precision;
+
+	/// \addtogroup gtx_raw_data
+	///@{
+
+	//! Type for byte numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint8		byte;
+
+	//! Type for word numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint16		word;
+
+	//! Type for dword numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint32		dword;
+
+	//! Type for qword numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint64		qword;
+
+	///@}
+}// namespace raw_data
+}// namespace gtx
+}// namespace glm
+
+#include "raw_data.inl"
+
+namespace glm{using namespace gtx::raw_data;}
+
+#endif//glm_gtx_raw_data
diff --git a/ExternalLibs/glm/gtx/raw_data.inl b/ExternalLibs/glm/gtx/raw_data.inl
new file mode 100644
index 0000000..93b2a55
--- /dev/null
+++ b/ExternalLibs/glm/gtx/raw_data.inl
@@ -0,0 +1,11 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-11-19
+// Updated : 2008-11-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/raw_data.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/ExternalLibs/glm/gtx/reciprocal.hpp b/ExternalLibs/glm/gtx/reciprocal.hpp
new file mode 100644
index 0000000..aac6cf7
--- /dev/null
+++ b/ExternalLibs/glm/gtx/reciprocal.hpp
@@ -0,0 +1,99 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-09
+// Updated : 2008-10-09
+// Licence : This source is under MIT License
+// File    : glm/gtx/reciprocal.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_reciprocal
+#define glm_gtx_reciprocal
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_reciprocal extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
+{
+	/// \addtogroup gtx_reciprocal
+	/// @{
+
+	//! Secant function. 
+	//! hypotenuse / adjacent or 1 / cos(x)
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType sec(genType const & angle);
+
+	//! Cosecant function. 
+	//! hypotenuse / opposite or 1 / sin(x)
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType csc(genType const & angle);
+		
+	//! Cotangent function. 
+	//! adjacent / opposite or 1 / tan(x)
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType cot(genType const & angle);
+
+	//! Inverse secant function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType asec(genType const & x);
+
+	//! Inverse cosecant function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acsc(genType const & x);
+		
+	//! Inverse cotangent function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acot(genType const & x);
+
+	//! Secant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType sech(genType const & angle);
+
+	//! Cosecant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType csch(genType const & angle);
+		
+	//! Cotangent hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType coth(genType const & angle);
+
+	//! Inverse secant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType asech(genType const & x);
+
+	//! Inverse cosecant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acsch(genType const & x);
+		
+	//! Inverse cotangent hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acoth(genType const & x);
+
+	/// @}
+}//namespace reciprocal
+}//namespace gtx
+}//namespace glm
+
+#include "reciprocal.inl"
+
+namespace glm{using namespace gtx::reciprocal;}
+
+#endif//glm_gtx_reciprocal
diff --git a/ExternalLibs/glm/gtx/reciprocal.inl b/ExternalLibs/glm/gtx/reciprocal.inl
new file mode 100644
index 0000000..3a19d3c
--- /dev/null
+++ b/ExternalLibs/glm/gtx/reciprocal.inl
@@ -0,0 +1,593 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-10-09
+// Updated : 2008-10-09
+// Licence : This source is under MIT License
+// File    : glm/gtx/reciprocal.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace reciprocal{
+
+// sec
+template <typename genType>
+GLM_FUNC_QUALIFIER genType sec
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sec' only accept floating-point values");
+
+	return genType(1) / glm::cos(angle);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> sec
+(
+	detail::tvec2<valType> const & angle
+)
+{
+    return detail::tvec2<valType>(
+        sec(angle.x),
+        sec(angle.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> sec
+(
+	detail::tvec3<valType> const & angle
+)
+{
+    return detail::tvec3<valType>(
+        sec(angle.x),
+        sec(angle.y),
+        sec(angle.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> sec
+(
+	detail::tvec4<valType> const & angle
+)
+{
+    return detail::tvec4<valType>(
+        sec(angle.x),
+        sec(angle.y),
+        sec(angle.z),
+        sec(angle.w));
+}
+
+// csc
+template <typename genType>
+GLM_FUNC_QUALIFIER genType csc
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'csc' only accept floating-point values");
+
+    return genType(1) / glm::sin(angle);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> csc
+(
+	detail::tvec2<valType> const & angle
+)
+{
+    return detail::tvec2<valType>(
+        csc(angle.x),
+        csc(angle.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> csc
+(
+	detail::tvec3<valType> const & angle
+)
+{
+    return detail::tvec3<valType>(
+        csc(angle.x),
+        csc(angle.y),
+        csc(angle.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> csc
+(	
+	detail::tvec4<valType> const & angle
+)
+{
+    return detail::tvec4<valType>(
+        csc(angle.x),
+        csc(angle.y),
+        csc(angle.z),
+        csc(angle.w));
+}
+
+// cot
+template <typename genType>
+GLM_FUNC_QUALIFIER genType cot
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cot' only accept floating-point values");
+
+	return genType(1) / glm::tan(angle);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> cot
+(
+	detail::tvec2<valType> const & angle
+)
+{
+    return detail::tvec2<valType>(
+        cot(angle.x),
+        cot(angle.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> cot
+(
+	detail::tvec3<valType> const & angle
+)
+{
+    return detail::tvec3<valType>(
+        cot(angle.x),
+        cot(angle.y),
+        cot(angle.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> cot
+(
+	detail::tvec4<valType> const & angle
+)
+{
+    return detail::tvec4<valType>(
+        cot(angle.x),
+        cot(angle.y),
+        cot(angle.z),
+        cot(angle.w));
+}
+
+// asec
+template <typename genType>
+GLM_FUNC_QUALIFIER genType asec
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asec' only accept floating-point values");
+	
+	return acos(genType(1) / x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> asec
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        asec(x.x),
+        asec(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> asec
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        asec(x.x),
+        asec(x.y),
+        asec(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> asec
+(
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        asec(x.x),
+        asec(x.y),
+        asec(x.z),
+        asec(x.w));
+}
+
+// acsc
+template <typename genType>
+GLM_FUNC_QUALIFIER genType acsc
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acsc' only accept floating-point values");
+
+	return asin(genType(1) / x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> acsc
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        acsc(x.x),
+        acsc(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> acsc
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        acsc(x.x),
+        acsc(x.y),
+        acsc(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> acsc
+(	
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        acsc(x.x),
+        acsc(x.y),
+        acsc(x.z),
+        acsc(x.w));
+}
+
+// acot
+template <typename genType>
+GLM_FUNC_QUALIFIER genType acot
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acot' only accept floating-point values");
+
+	genType const pi_over_2 = genType(3.1415926535897932384626433832795 / 2.0);
+	return pi_over_2 - atan(x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> acot
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        acot(x.x),
+        acot(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> acot
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        acot(x.x),
+        acot(x.y),
+        acot(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> acot
+(
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        acot(x.x),
+        acot(x.y),
+        acot(x.z),
+        acot(x.w));
+}
+
+// sech
+template <typename genType>
+GLM_FUNC_QUALIFIER genType sech
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sech' only accept floating-point values");
+
+	return genType(1) / glm::cosh(angle);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> sech
+(
+	detail::tvec2<valType> const & angle
+)
+{
+    return detail::tvec2<valType>(
+        sech(angle.x),
+        sech(angle.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> sech
+(
+	detail::tvec3<valType> const & angle
+)
+{
+    return detail::tvec3<valType>(
+        sech(angle.x),
+        sech(angle.y),
+        sech(angle.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> sech
+(
+	detail::tvec4<valType> const & angle
+)
+{
+    return detail::tvec4<valType>(
+        sech(angle.x),
+        sech(angle.y),
+        sech(angle.z),
+        sech(angle.w));
+}
+
+// csch
+template <typename genType>
+GLM_FUNC_QUALIFIER genType csch
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'csch' only accept floating-point values");
+
+    return genType(1) / glm::sinh(angle);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> csch
+(
+	detail::tvec2<valType> const & angle
+)
+{
+    return detail::tvec2<valType>(
+        csch(angle.x),
+        csch(angle.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> csch
+(
+	detail::tvec3<valType> const & angle
+)
+{
+    return detail::tvec3<valType>(
+        csch(angle.x),
+        csch(angle.y),
+        csch(angle.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> csch
+(	
+	detail::tvec4<valType> const & angle
+)
+{
+    return detail::tvec4<valType>(
+        csch(angle.x),
+        csch(angle.y),
+        csch(angle.z),
+        csch(angle.w));
+}
+
+// coth
+template <typename genType>
+GLM_FUNC_QUALIFIER genType coth
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'coth' only accept floating-point values");
+
+	return glm::cosh(angle) / glm::sinh(angle);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> coth
+(
+	detail::tvec2<valType> const & angle
+)
+{
+    return detail::tvec2<valType>(
+        coth(angle.x),
+        coth(angle.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> coth
+(
+	detail::tvec3<valType> const & angle
+)
+{
+    return detail::tvec3<valType>(
+        coth(angle.x),
+        coth(angle.y),
+        coth(angle.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> coth
+(
+	detail::tvec4<valType> const & angle
+)
+{
+    return detail::tvec4<valType>(
+        coth(angle.x),
+        coth(angle.y),
+        coth(angle.z),
+        coth(angle.w));
+}
+
+// asech
+template <typename genType>
+GLM_FUNC_QUALIFIER genType asech
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asech' only accept floating-point values");
+
+	return acosh(genType(1) / x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> asech
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        asech(x.x),
+        asech(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> asech
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        asech(x.x),
+        asech(x.y),
+        asech(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> asech
+(
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        asech(x.x),
+        asech(x.y),
+        asech(x.z),
+        asech(x.w));
+}
+
+// acsch
+template <typename genType>
+GLM_FUNC_QUALIFIER genType acsch
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acsch' only accept floating-point values");
+
+    return asinh(genType(1) / x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> acsch
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        acsch(x.x),
+        acsch(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> acsch
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        acsch(x.x),
+        acsch(x.y),
+        acsch(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> acsch
+(	
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        acsch(x.x),
+        acsch(x.y),
+        acsch(x.z),
+        acsch(x.w));
+}
+
+// acoth
+template <typename genType>
+GLM_FUNC_QUALIFIER genType acoth
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acoth' only accept floating-point values");
+
+	return atanh(genType(1) / x);
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> acoth
+(
+	detail::tvec2<valType> const & x
+)
+{
+    return detail::tvec2<valType>(
+        acoth(x.x),
+        acoth(x.y));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> acoth
+(
+	detail::tvec3<valType> const & x
+)
+{
+    return detail::tvec3<valType>(
+        acoth(x.x),
+        acoth(x.y),
+        acoth(x.z));
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> acoth
+(
+	detail::tvec4<valType> const & x
+)
+{
+    return detail::tvec4<valType>(
+        acoth(x.x),
+        acoth(x.y),
+        acoth(x.z),
+        acoth(x.w));
+}
+
+}//namespace reciprocal
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/rotate_vector.hpp b/ExternalLibs/glm/gtx/rotate_vector.hpp
new file mode 100644
index 0000000..1eaec82
--- /dev/null
+++ b/ExternalLibs/glm/gtx/rotate_vector.hpp
@@ -0,0 +1,114 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-11-02
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/rotate_vector.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_rotate_vector
+#define glm_gtx_rotate_vector
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/transform.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_rotate_vector extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
+{
+	using namespace transform;
+
+	/// \addtogroup gtx_rotate_vector
+	/// @{
+
+	//! Rotate a two dimensional vector.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec2<T> rotate(
+        detail::tvec2<T> const & v, 
+		T const & angle);
+		
+	//! Rotate a three dimensional vector around an axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotate(
+        detail::tvec3<T> const & v, 
+		T const & angle, 
+        detail::tvec3<T> const & normal);
+		
+	//! Rotate a four dimensional vector around an axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotate(
+        detail::tvec4<T> const & v, 
+        T const & angle, 
+		detail::tvec3<T> const & normal);
+		
+	//! Rotate a three dimensional vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotateX(
+        detail::tvec3<T> const & v, 
+		T const & angle);
+
+	//! Rotate a three dimensional vector around the Y axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotateY(
+		detail::tvec3<T> const & v, 
+		T const & angle);
+		
+	//! Rotate a three dimensional vector around the Z axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotateZ(
+        detail::tvec3<T> const & v, 
+		T const & angle);
+		
+	//! Rotate a four dimentionnals vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotateX(
+        detail::tvec4<T> const & v, 
+		T const & angle);
+		
+	//! Rotate a four dimensional vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotateY(
+        detail::tvec4<T> const & v, 
+		T const & angle);
+		
+	//! Rotate a four dimensional vector around the X axis. 
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotateZ(
+        detail::tvec4<T> const & v, 
+		T const & angle);
+		
+	//! Build a rotation matrix from a normal and a up vector.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tmat4x4<T> orientation(
+        detail::tvec3<T> const & Normal, 
+        detail::tvec3<T> const & Up);
+
+	/// @}
+}//namespace rotate_vector
+}//namespace gtx
+}//namespace glm
+
+#include "rotate_vector.inl"
+
+namespace glm{using namespace gtx::rotate_vector;}
+
+#endif//glm_gtx_rotate_vector
diff --git a/ExternalLibs/glm/gtx/rotate_vector.inl b/ExternalLibs/glm/gtx/rotate_vector.inl
new file mode 100644
index 0000000..69eaa1f
--- /dev/null
+++ b/ExternalLibs/glm/gtx/rotate_vector.inl
@@ -0,0 +1,149 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-11-02
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/rotate_vector.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace rotate_vector
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> rotate(
+        detail::tvec2<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec2<T> Result;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.x = v.x * Cos - v.y * Sin;
+		Result.y = v.x * Sin + v.y * Cos;
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> rotate(
+		const detail::tvec3<T> & v, 
+        T const & angle, 
+		const detail::tvec3<T> & normal)
+	{
+		return detail::tmat3x3<T>(glm::gtx::transform::rotate(angle, normal)) * v;
+	}
+/*
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<T> rotateGTX(
+        const detail::tvec3<T>& x, 
+        T angle, 
+        const detail::tvec3<T>& normal)
+    {
+        const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+        return x * Cos + ((x * normal) * (T(1) - Cos)) * normal + cross(x, normal) * Sin;
+    }
+*/
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> rotate(
+        detail::tvec4<T> const & v, 
+		T const & angle, 
+        detail::tvec3<T> const & normal)
+	{
+		return glm::gtx::transform::rotate(angle, normal) * v;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateX(
+		detail::tvec3<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec3<T> Result = v;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.y = v.y * Cos - v.z * Sin;
+		Result.z = v.y * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateY(
+		detail::tvec3<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec3<T> Result = v;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.x =  v.x * Cos + v.z * Sin;
+		Result.z = -v.x * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> rotateZ(
+		detail::tvec3<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec3<T> Result = v;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.x = v.x * Cos - v.y * Sin;
+		Result.y = v.x * Sin + v.y * Cos;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> rotateX(
+		detail::tvec4<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec4<T> Result = v;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.y = v.y * Cos - v.z * Sin;
+		Result.z = v.y * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> rotateY(
+		detail::tvec4<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec4<T> Result = v;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.x =  v.x * Cos + v.z * Sin;
+		Result.z = -v.x * Sin + v.z * Cos;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> rotateZ(
+		detail::tvec4<T> const & v, 
+		T const & angle)
+	{
+		detail::tvec4<T> Result = v;
+		const T Cos = cos(radians(angle));
+        const T Sin = sin(radians(angle));
+		Result.x = v.x * Cos - v.y * Sin;
+		Result.y = v.x * Sin + v.y * Cos;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> orientation(
+		detail::tvec3<T> const & Normal, 
+		detail::tvec3<T> const & Up)
+	{
+		if(all(equal(Normal, Up)))
+			return detail::tmat4x4<T>(T(1));
+
+		detail::tvec3<T> RotationAxis = cross(Up, Normal);
+		T Angle = degrees(acos(dot(Normal, Up)));
+		return glm::gtx::transform::rotate(Angle, RotationAxis);
+	}
+
+}//namespace rotate_vector
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/simd_mat4.hpp b/ExternalLibs/glm/gtx/simd_mat4.hpp
new file mode 100644
index 0000000..614cf59
--- /dev/null
+++ b/ExternalLibs/glm/gtx/simd_mat4.hpp
@@ -0,0 +1,183 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-07
+// Updated : 2009-05-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/simd_vec4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - intrinsic
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_simd_mat4
+#define glm_gtx_simd_mat4
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(GLM_ARCH & GLM_ARCH_SSE2)
+#	include "../core/intrinsic_matrix.hpp"
+#	include "../gtx/simd_vec4.hpp"
+#else
+#	error "GLM: GLM_GTX_simd_mat4 requires compiler support of SSE2 through intrinsics"
+#endif
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_simd_mat4 extension included")
+#endif
+
+namespace glm{
+namespace detail
+{
+	/// 4x4 Matrix implemented using SIMD SEE intrinsics.
+	/// \ingroup gtx_simd_mat4
+	GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
+	{
+		enum ctor{null};
+
+		typedef float value_type;
+		typedef fvec4SIMD col_type;
+		typedef fvec4SIMD row_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+		static size_type col_size();
+		static size_type row_size();
+		static bool is_matrix();
+
+		fvec4SIMD Data[4];
+
+		//////////////////////////////////////
+		// Constructors
+
+		fmat4x4SIMD();
+		explicit fmat4x4SIMD(float const & s);
+		explicit fmat4x4SIMD(
+			float const & x0, float const & y0, float const & z0, float const & w0,
+			float const & x1, float const & y1, float const & z1, float const & w1,
+			float const & x2, float const & y2, float const & z2, float const & w2,
+			float const & x3, float const & y3, float const & z3, float const & w3);
+		explicit fmat4x4SIMD(
+			fvec4SIMD const & v0,
+			fvec4SIMD const & v1,
+			fvec4SIMD const & v2,
+			fvec4SIMD const & v3);
+		explicit fmat4x4SIMD(
+			tmat4x4<float> const & m);
+
+		// Conversions
+		//template <typename U> 
+		//explicit tmat4x4(tmat4x4<U> const & m);
+
+		//explicit tmat4x4(tmat2x2<T> const & x);
+		//explicit tmat4x4(tmat3x3<T> const & x);
+		//explicit tmat4x4(tmat2x3<T> const & x);
+		//explicit tmat4x4(tmat3x2<T> const & x);
+		//explicit tmat4x4(tmat2x4<T> const & x);
+		//explicit tmat4x4(tmat4x2<T> const & x);
+		//explicit tmat4x4(tmat3x4<T> const & x);
+		//explicit tmat4x4(tmat4x3<T> const & x);
+
+		// Accesses
+		fvec4SIMD & operator[](size_type i);
+		fvec4SIMD const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator+= (float const & s);
+		fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator-= (float const & s);
+		fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator*= (float const & s);
+		fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator/= (float const & s);
+		fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator++ ();
+		fmat4x4SIMD & operator-- ();
+	};
+
+	// Binary operators
+	fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
+	fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+	    
+	fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
+	fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
+	fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
+
+	fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
+	fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
+
+	fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
+	fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
+
+	fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
+	fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
+
+	fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+
+	// Unary constant operators
+	fmat4x4SIMD const operator-  (fmat4x4SIMD const & m);
+	fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
+	fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
+}//namespace detail
+
+namespace gtx{
+namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
+{
+	typedef detail::fmat4x4SIMD simdMat4;
+
+	/// \addtogroup gtx_simd_mat4
+	///@{
+
+	//! Convert a simdMat4 to a mat4.
+	//! (From GLM_GTX_simd_mat4 extension)
+	detail::tmat4x4<float> mat4_cast(
+		detail::fmat4x4SIMD const & x);
+
+	//! Multiply matrix x by matrix y component-wise, i.e.,
+	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD matrixCompMult(
+		detail::fmat4x4SIMD const & x,
+		detail::fmat4x4SIMD const & y);
+
+	//! Treats the first parameter c as a column vector
+	//! and the second parameter r as a row vector
+	//! and does a linear algebraic matrix multiply c * r.
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD outerProduct(
+		detail::fvec4SIMD const & c,
+		detail::fvec4SIMD const & r);
+
+	//! Returns the transposed matrix of x
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD transpose(
+		detail::fmat4x4SIMD const & x);
+
+	//! Return the determinant of a mat4 matrix.
+	//! (From GLM_GTX_simd_mat4 extension).
+	float determinant(
+		detail::fmat4x4SIMD const & m);
+
+	//! Return the inverse of a mat4 matrix.
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD inverse(
+		detail::fmat4x4SIMD const & m);
+
+	/// @}
+}// namespace simd_mat4
+}// namespace gtx
+}// namespace glm
+
+#include "simd_mat4.inl"
+
+namespace glm{using namespace gtx::simd_mat4;}
+
+#endif//glm_gtx_simd_mat4
diff --git a/ExternalLibs/glm/gtx/simd_mat4.inl b/ExternalLibs/glm/gtx/simd_mat4.inl
new file mode 100644
index 0000000..84771b6
--- /dev/null
+++ b/ExternalLibs/glm/gtx/simd_mat4.inl
@@ -0,0 +1,309 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-19
+// Updated : 2009-05-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/simd_mat4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::value_size()
+	{
+		return sizeof(value_type);
+	}
+
+	GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::col_size()
+	{
+		return 4;
+	}
+
+	GLM_FUNC_QUALIFIER fmat4x4SIMD::size_type fmat4x4SIMD::row_size()
+	{
+		return 4;
+	}
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD()
+    {}
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD(float const & s)
+    {
+		this->Data[0] = fvec4SIMD(s, 0, 0, 0);
+		this->Data[1] = fvec4SIMD(0, s, 0, 0);
+		this->Data[2] = fvec4SIMD(0, 0, s, 0);
+		this->Data[3] = fvec4SIMD(0, 0, 0, s);
+    }
+
+	GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
+	(
+		float const & x0, float const & y0, float const & z0, float const & w0,
+		float const & x1, float const & y1, float const & z1, float const & w1,
+		float const & x2, float const & y2, float const & z2, float const & w2,
+		float const & x3, float const & y3, float const & z3, float const & w3
+	)
+	{
+		this->Data[0] = fvec4SIMD(x0, y0, z0, w0);
+		this->Data[1] = fvec4SIMD(x1, y1, z1, w1);
+		this->Data[2] = fvec4SIMD(x2, y2, z2, w2);
+		this->Data[3] = fvec4SIMD(x3, y3, z3, w3);
+	}
+
+	GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
+	(
+		fvec4SIMD const & v0,
+		fvec4SIMD const & v1,
+		fvec4SIMD const & v2,
+		fvec4SIMD const & v3
+	)
+	{
+		this->Data[0] = v0;
+		this->Data[1] = v1;
+		this->Data[2] = v2;
+		this->Data[3] = v3;
+	}
+
+	GLM_FUNC_QUALIFIER fmat4x4SIMD::fmat4x4SIMD
+	(
+		tmat4x4<float> const & m
+	)
+	{
+		this->Data[0] = fvec4SIMD(m[0]);
+		this->Data[1] = fvec4SIMD(m[1]);
+		this->Data[2] = fvec4SIMD(m[2]);
+		this->Data[3] = fvec4SIMD(m[3]);
+	}
+
+	//////////////////////////////////////
+	// Accesses
+
+	GLM_FUNC_QUALIFIER fvec4SIMD & fmat4x4SIMD::operator[]
+	(
+		fmat4x4SIMD::size_type i
+	)
+	{
+		assert(
+			i >= fmat4x4SIMD::size_type(0) &&
+			i < fmat4x4SIMD::col_size());
+
+		return this->Data[i];
+	}
+
+	GLM_FUNC_QUALIFIER fvec4SIMD const & fmat4x4SIMD::operator[]
+	(
+		fmat4x4SIMD::size_type i
+	) const
+	{
+		assert(
+			i >= fmat4x4SIMD::size_type(0) &&
+			i < fmat4x4SIMD::col_size());
+
+		return this->Data[i];
+	}
+
+    //////////////////////////////////////////////////////////////
+    // mat4 operators
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD& fmat4x4SIMD::operator= 
+	(
+		fmat4x4SIMD const & m
+	)
+    {
+		this->Data[0] = m[0];
+		this->Data[1] = m[1];
+		this->Data[2] = m[2];
+		this->Data[3] = m[3];
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator+= 
+	(
+		fmat4x4SIMD const & m
+	)
+    {
+		this->Data[0].Data = _mm_add_ps(this->Data[0].Data, m[0].Data);
+		this->Data[1].Data = _mm_add_ps(this->Data[1].Data, m[1].Data);
+		this->Data[2].Data = _mm_add_ps(this->Data[2].Data, m[2].Data);
+		this->Data[3].Data = _mm_add_ps(this->Data[3].Data, m[3].Data);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-= 
+	(
+		fmat4x4SIMD const & m
+	)
+    {
+		this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, m[0].Data);
+		this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, m[1].Data);
+		this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, m[2].Data);
+		this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, m[3].Data);
+
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator*= 
+	(
+		fmat4x4SIMD const & m
+	)
+    {
+		sse_mul_ps(&this->Data[0].Data, &m.Data[0].Data, &this->Data[0].Data);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator/= 
+	(
+		fmat4x4SIMD const & m
+	)
+    {
+		__m128 Inv[4];
+		sse_inverse_ps(&this->Data[0].Data, Inv);
+		sse_mul_ps(&this->Data[0].Data, Inv, &this->Data[0].Data);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator+= 
+	(
+		float const & s
+	)
+    {
+		__m128 Operand = _mm_set_ps1(s);
+		this->Data[0].Data = _mm_add_ps(this->Data[0].Data, Operand);
+		this->Data[1].Data = _mm_add_ps(this->Data[1].Data, Operand);
+		this->Data[2].Data = _mm_add_ps(this->Data[2].Data, Operand);
+		this->Data[3].Data = _mm_add_ps(this->Data[3].Data, Operand);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-= 
+	(
+		float const & s
+	)
+    {
+		__m128 Operand = _mm_set_ps1(s);
+		this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, Operand);
+		this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, Operand);
+		this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, Operand);
+		this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, Operand);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator*= 
+	(
+		float const & s
+	)
+    {
+		__m128 Operand = _mm_set_ps1(s);
+		this->Data[0].Data = _mm_mul_ps(this->Data[0].Data, Operand);
+		this->Data[1].Data = _mm_mul_ps(this->Data[1].Data, Operand);
+		this->Data[2].Data = _mm_mul_ps(this->Data[2].Data, Operand);
+		this->Data[3].Data = _mm_mul_ps(this->Data[3].Data, Operand);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator/= 
+	(
+		float const & s
+	)
+    {
+		__m128 Operand = _mm_div_ps(one, _mm_set_ps1(s));
+		this->Data[0].Data = _mm_mul_ps(this->Data[0].Data, Operand);
+		this->Data[1].Data = _mm_mul_ps(this->Data[1].Data, Operand);
+		this->Data[2].Data = _mm_mul_ps(this->Data[2].Data, Operand);
+		this->Data[3].Data = _mm_mul_ps(this->Data[3].Data, Operand);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator++ ()
+    {
+		this->Data[0].Data = _mm_add_ps(this->Data[0].Data, one);
+		this->Data[1].Data = _mm_add_ps(this->Data[1].Data, one);
+		this->Data[2].Data = _mm_add_ps(this->Data[2].Data, one);
+		this->Data[3].Data = _mm_add_ps(this->Data[3].Data, one);
+        return *this;
+    }
+
+    GLM_FUNC_QUALIFIER fmat4x4SIMD & fmat4x4SIMD::operator-- ()
+    {
+		this->Data[0].Data = _mm_sub_ps(this->Data[0].Data, one);
+		this->Data[1].Data = _mm_sub_ps(this->Data[1].Data, one);
+		this->Data[2].Data = _mm_sub_ps(this->Data[2].Data, one);
+		this->Data[3].Data = _mm_sub_ps(this->Data[3].Data, one);
+        return *this;
+    }
+
+}//namespace detail
+
+namespace gtx{
+namespace simd_mat4
+{
+	GLM_FUNC_QUALIFIER detail::tmat4x4<float> mat4_cast
+	(
+		detail::fmat4x4SIMD const & x
+	)
+	{
+		GLM_ALIGN(16) detail::tmat4x4<float> Result;
+		_mm_store_ps(&Result[0][0], x.Data[0].Data);
+		_mm_store_ps(&Result[1][0], x.Data[1].Data);
+		_mm_store_ps(&Result[2][0], x.Data[2].Data);
+		_mm_store_ps(&Result[3][0], x.Data[3].Data);
+		return Result;
+	}
+
+	GLM_FUNC_QUALIFIER detail::fmat4x4SIMD matrixCompMult
+	(
+		detail::fmat4x4SIMD const & x,
+		detail::fmat4x4SIMD const & y
+	)
+	{
+		detail::fmat4x4SIMD result;
+		result[0] = x[0] * y[0];
+		result[1] = x[1] * y[1];
+		result[2] = x[2] * y[2];
+		result[3] = x[3] * y[3];
+		return result;
+	}
+
+	GLM_FUNC_QUALIFIER detail::fmat4x4SIMD outerProduct
+	(
+		detail::fvec4SIMD const & c,
+		detail::fvec4SIMD const & r
+	)
+	{
+		__m128 Shu0 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(0, 0, 0, 0));
+		__m128 Shu1 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(1, 1, 1, 1));
+		__m128 Shu2 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(2, 2, 2, 2));
+		__m128 Shu3 = _mm_shuffle_ps(r.Data, r.Data, _MM_SHUFFLE(3, 3, 3, 3));
+
+		detail::fmat4x4SIMD result(detail::fmat4x4SIMD::null);
+		result[0].Data = _mm_mul_ps(c.Data, Shu0);
+		result[1].Data = _mm_mul_ps(c.Data, Shu1);
+		result[2].Data = _mm_mul_ps(c.Data, Shu2);
+		result[3].Data = _mm_mul_ps(c.Data, Shu3);
+		return result;
+	}
+
+	GLM_FUNC_QUALIFIER detail::fmat4x4SIMD transpose(detail::fmat4x4SIMD const & m)
+	{
+		detail::fmat4x4SIMD result;
+		detail::sse_transpose_ps(&m[0].Data, &result[0].Data);
+		return result;
+	}
+
+	GLM_FUNC_QUALIFIER float determinant(detail::fmat4x4SIMD const & m)
+	{
+		float Result;
+		_mm_store_ss(&Result, detail::sse_det_ps(&m[0].Data));
+		return Result;
+	}
+
+	GLM_FUNC_QUALIFIER detail::fmat4x4SIMD inverse(detail::fmat4x4SIMD const & m)
+	{
+		detail::fmat4x4SIMD result;
+		detail::sse_inverse_ps(&m[0].Data, &result[0].Data);
+		return result;
+	}
+}//namespace simd_mat4
+}//namespace gtx
+
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/simd_vec4.hpp b/ExternalLibs/glm/gtx/simd_vec4.hpp
new file mode 100644
index 0000000..05fb99e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/simd_vec4.hpp
@@ -0,0 +1,474 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-07
+// Updated : 2009-05-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/simd_vec4.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - intrinsic
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_simd_vec4
+#define glm_gtx_simd_vec4
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(GLM_ARCH & GLM_ARCH_SSE2)
+#	include "../core/intrinsic_common.hpp"
+#	include "../core/intrinsic_geometric.hpp"
+#else
+#	error "GLM: GLM_GTX_simd_vec4 requires compiler support of SSE2 through intrinsics"
+#endif
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_simd_vec4 extension included")
+#endif
+
+namespace glm{
+namespace detail
+{
+	/// 4-dimensional vector implemented using SIMD SEE intrinsics.
+	/// \ingroup gtx_simd_vec4
+	GLM_ALIGNED_STRUCT(16) fvec4SIMD
+	{
+		enum ctor{null};
+		typedef __m128 value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef fvec4SIMD type;
+		typedef tvec4<bool> bool_type;
+
+		__m128 Data;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		fvec4SIMD();
+		fvec4SIMD(__m128 const & Data);
+		fvec4SIMD(fvec4SIMD const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit fvec4SIMD(
+			ctor);
+		explicit fvec4SIMD(
+			float const & s);
+		explicit fvec4SIMD(
+			float const & x, 
+			float const & y, 
+			float const & z, 
+			float const & w);
+		explicit fvec4SIMD(
+			tvec4<float> const & v);
+
+		////////////////////////////////////////
+		//// Convertion vector constructors
+
+		fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
+		fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
+		fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
+		fvec4SIMD(vec3 const & v, float const & s);
+		fvec4SIMD(float const & s, vec3 const & v);
+		fvec4SIMD(vec2 const & v1, vec2 const & v2);
+		//fvec4SIMD(ivec4SIMD const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		fvec4SIMD& operator= (fvec4SIMD const & v);
+		fvec4SIMD& operator+=(fvec4SIMD const & v);
+		fvec4SIMD& operator-=(fvec4SIMD const & v);
+		fvec4SIMD& operator*=(fvec4SIMD const & v);
+		fvec4SIMD& operator/=(fvec4SIMD const & v);
+
+		fvec4SIMD& operator+=(float const & s);
+		fvec4SIMD& operator-=(float const & s);
+		fvec4SIMD& operator*=(float const & s);
+		fvec4SIMD& operator/=(float const & s);
+
+		fvec4SIMD& operator++();
+		fvec4SIMD& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <comp X, comp Y, comp Z, comp W>
+		fvec4SIMD& swizzle();
+		template <comp X, comp Y, comp Z, comp W>
+		fvec4SIMD swizzle() const;
+		template <comp X, comp Y, comp Z>
+		fvec4SIMD swizzle() const;
+		template <comp X, comp Y>
+		fvec4SIMD swizzle() const;
+		template <comp X>
+		fvec4SIMD swizzle() const;
+	};
+}//namespace detail
+
+namespace gtx{
+namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
+{
+	typedef glm::detail::fvec4SIMD simdVec4;
+
+	/// \addtogroup gtx_simd_vec4
+	///@{
+
+	//! Convert a simdVec4 to a vec4.
+	//! (From GLM_GTX_simd_vec4 extension)
+	detail::tvec4<float> vec4_cast(
+		detail::fvec4SIMD const & x);
+
+	//! Returns x if x >= 0; otherwise, it returns -x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
+
+	//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer that is less then or equal to x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer to x 
+	//! whose absolute value is not larger than the absolute value of x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer to x. 
+	//! The fraction 0.5 will round in a direction chosen by the 
+	//! implementation, presumably the direction that is fastest. 
+	//! This includes the possibility that round(x) returns the 
+	//! same value as roundEven(x) for all values of x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD round(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer to x.
+	//! A fractional part of 0.5 will round toward the nearest even
+	//! integer. (Both 3.5 and 4.5 for x will return 4.0.) 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer 
+	//! that is greater than or equal to x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
+
+	//! Return x - floor(x).
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD mod(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD mod(
+		detail::fvec4SIMD const & x, 
+		float const & y);
+
+	//! Returns the fractional part of x and sets i to the integer
+	//! part (as a whole number floating point value). Both the
+	//! return value and the output parameter will have the same
+	//! sign as x.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD modf(
+	//	detail::fvec4SIMD const & x, 
+	//	detail::fvec4SIMD & i);
+
+	//! Returns y if y < x; otherwise, it returns x.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD min(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y);
+
+	detail::fvec4SIMD min(
+		detail::fvec4SIMD const & x, 
+		float const & y);
+
+	//! Returns y if x < y; otherwise, it returns x.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD max(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y);
+
+	detail::fvec4SIMD max(
+		detail::fvec4SIMD const & x, 
+		float const & y);
+
+	//! Returns min(max(x, minVal), maxVal) for each component in x 
+	//! using the floating-point values minVal and maxVal.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD clamp(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & minVal, 
+		detail::fvec4SIMD const & maxVal); 
+
+	detail::fvec4SIMD clamp(
+		detail::fvec4SIMD const & x, 
+		float const & minVal, 
+		float const & maxVal); 
+
+	//! \return If genTypeU is a floating scalar or vector: 
+	//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
+	//! x and y using the floating-point value a. 
+	//! The value for a is not restricted to the range [0, 1].
+	//!
+	//! \return If genTypeU is a boolean scalar or vector: 
+	//! Selects which vector each returned component comes
+	//! from. For a component of a that is false, the
+	//! corresponding component of x is returned. For a
+	//! component of a that is true, the corresponding
+	//! component of y is returned. Components of x and y that
+	//! are not selected are allowed to be invalid floating point
+	//! values and will have no effect on the results. Thus, this
+	//! provides different functionality than
+	//! genType mix(genType x, genType y, genType(a))
+	//! where a is a Boolean vector.
+	//! 
+	//! From GLSL 1.30.08 specification, section 8.3
+	//! 
+	//! \param[in]  x Floating point scalar or vector.
+	//! \param[in]  y Floating point scalar or vector.
+	//! \param[in]  a Floating point or boolean scalar or vector.
+	//!
+	// \todo Test when 'a' is a boolean.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD mix(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y, 
+		detail::fvec4SIMD const & a);
+
+	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD step(
+		detail::fvec4SIMD const & edge, 
+		detail::fvec4SIMD const & x);
+
+	detail::fvec4SIMD step(
+		float const & edge, 
+		detail::fvec4SIMD const & x);
+
+	//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	//! performs smooth Hermite interpolation between 0 and 1
+	//! when edge0 < x < edge1. This is useful in cases where
+	//! you would want a threshold function with a smooth
+	//! transition. This is equivalent to:
+	//! genType t;
+	//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
+	//! return t * t * (3 – 2 * t);
+	//! Results are undefined if edge0 >= edge1.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD smoothstep(
+		detail::fvec4SIMD const & edge0, 
+		detail::fvec4SIMD const & edge1, 
+		detail::fvec4SIMD const & x);
+
+	detail::fvec4SIMD smoothstep(
+		float const & edge0, 
+		float const & edge1, 
+		detail::fvec4SIMD const & x);
+
+	//! Returns true if x holds a NaN (not a number)
+	//! representation in the underlying implementation's set of
+	//! floating point representations. Returns false otherwise,
+	//! including for implementations with no NaN
+	//! representations.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//bvec4 isnan(detail::fvec4SIMD const & x);
+
+	//! Returns true if x holds a positive infinity or negative
+	//! infinity representation in the underlying implementation's
+	//! set of floating point representations. Returns false
+	//! otherwise, including for implementations with no infinity
+	//! representations.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//bvec4 isinf(detail::fvec4SIMD const & x);
+
+	//! Returns a signed or unsigned integer value representing
+	//! the encoding of a floating-point value. The floatingpoint
+	//! value's bit-level representation is preserved.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
+
+	//! Returns a floating-point value corresponding to a signed
+	//! or unsigned integer encoding of a floating-point value.
+	//! If an inf or NaN is passed in, it will not signal, and the
+	//! resulting floating point value is unspecified. Otherwise,
+	//! the bit-level representation is preserved.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
+
+	//! Computes and returns a * b + c.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD fma(
+		detail::fvec4SIMD const & a, 
+		detail::fvec4SIMD const & b, 
+		detail::fvec4SIMD const & c);
+
+	//! Splits x into a floating-point significand in the range
+	//! [0.5, 1.0) and an integral exponent of two, such that:
+	//! x = significand * exp(2, exponent)
+	//! The significand is returned by the function and the
+	//! exponent is returned in the parameter exp. For a
+	//! floating-point value of zero, the significant and exponent
+	//! are both zero. For a floating-point value that is an
+	//! infinity or is not a number, the results are undefined.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
+
+	//! Builds a floating-point number from x and the
+	//! corresponding integral exponent of two in exp, returning:
+	//! significand * exp(2, exponent)
+	//! If this product is too large to be represented in the
+	//! floating-point type, the result is undefined.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float length(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Less accurate but much faster than simdLength.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float fastLength(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Slightly more accurate but much slower than simdLength.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float niceLength(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD length4(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Less accurate but much faster than simdLength4.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD fastLength4(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Slightly more accurate but much slower than simdLength4.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD niceLength4(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float distance(
+		detail::fvec4SIMD const & p0,
+		detail::fvec4SIMD const & p1);
+
+	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD distance4(
+		detail::fvec4SIMD const & p0,
+		detail::fvec4SIMD const & p1);
+
+	//! Returns the dot product of x and y, i.e., result = x * y.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float simdDot(
+		detail::fvec4SIMD const & x,
+		detail::fvec4SIMD const & y);
+
+	//! Returns the dot product of x and y, i.e., result = x * y.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD dot4(
+		detail::fvec4SIMD const & x,
+		detail::fvec4SIMD const & y);
+
+	//! Returns the cross product of x and y.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD cross(
+		detail::fvec4SIMD const & x,
+		detail::fvec4SIMD const & y);
+
+	//! Returns a vector in the same direction as x but with length of 1.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD normalize(
+		detail::fvec4SIMD const & x);
+
+	//! Returns a vector in the same direction as x but with length of 1.
+	//! Less accurate but much faster than simdNormalize.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD fastNormalize(
+		detail::fvec4SIMD const & x);
+
+	//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD simdFaceforward(
+		detail::fvec4SIMD const & N,
+		detail::fvec4SIMD const & I,
+		detail::fvec4SIMD const & Nref);
+
+	//! For the incident vector I and surface orientation N,
+	//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD reflect(
+		detail::fvec4SIMD const & I,
+		detail::fvec4SIMD const & N);
+
+	//! For the incident vector I and surface normal N,
+	//! and the ratio of indices of refraction eta,
+	//! return the refraction vector.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD refract(
+		detail::fvec4SIMD const & I,
+		detail::fvec4SIMD const & N,
+		float const & eta);
+
+	//! Returns the positive square root of x.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD sqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the positive square root of x with the nicest quality but very slow.
+	//! Slightly more accurate but much slower than simdSqrt.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD niceSqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the positive square root of x
+	//! Less accurate but much faster than sqrt.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD fastSqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the reciprocal of the positive square root of x.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD inversesqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the reciprocal of the positive square root of x.
+	//! Faster than inversesqrt but less accurate.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD fastInversesqrt(
+		detail::fvec4SIMD const & x);
+
+	/// @}
+}//namespace simd_vec4
+}//namespace gtx
+}//namespace glm
+
+#include "simd_vec4.inl"
+
+namespace glm{using namespace gtx::simd_vec4;}
+
+#endif//glm_gtx_simd_vec4
diff --git a/ExternalLibs/glm/gtx/simd_vec4.inl b/ExternalLibs/glm/gtx/simd_vec4.inl
new file mode 100644
index 0000000..d7b1863
--- /dev/null
+++ b/ExternalLibs/glm/gtx/simd_vec4.inl
@@ -0,0 +1,730 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-05-07
+// Updated : 2009-05-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/simd_vec4.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	namespace detail
+	{
+		template <int Value>
+		struct mask
+		{
+			enum{value = Value};
+		};
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD()
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(__m128 const & Data) :
+			Data(Data)
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(fvec4SIMD const & v) :
+			Data(v.Data)
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(tvec4<float> const & v) :
+			Data(_mm_set_ps(v.w, v.z, v.y, v.x))
+		{}
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s) :
+			Data(_mm_set1_ps(s))
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & x, float const & y, float const & z, float const & w) :
+	//		Data(_mm_setr_ps(x, y, z, w))
+			Data(_mm_set_ps(w, z, y, x))
+		{}
+/*
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const v[4]) :
+			Data(_mm_load_ps(v))
+		{}
+*/
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		//fvec4SIMD(ref4<float> const & r);
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec2 const & v, float const & s1, float const & s2) :
+			Data(_mm_set_ps(s2, s1, v.y, v.x))
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s1, vec2 const & v, float const & s2) :
+			Data(_mm_set_ps(s2, v.y, v.x, s1))
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s1, float const & s2, vec2 const & v) :
+			Data(_mm_set_ps(v.y, v.x, s2, s1))
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec3 const & v, float const & s) :
+			Data(_mm_set_ps(s, v.z, v.y, v.x))
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(float const & s, vec3 const & v) :
+			Data(_mm_set_ps(v.z, v.y, v.x, s))
+		{}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(vec2 const & v1, vec2 const & v2) :
+			Data(_mm_set_ps(v2.y, v2.x, v1.y, v1.x))
+		{}
+
+		//GLM_FUNC_QUALIFIER fvec4SIMD::fvec4SIMD(ivec4SIMD const & v) :
+		//	Data(_mm_cvtepi32_ps(v.Data))
+		//{}
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator=(fvec4SIMD const & v)
+		{
+			this->Data = v.Data;
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator+=(float const & s)
+		{
+			this->Data = _mm_add_ps(Data, _mm_set_ps1(s));
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator+=(fvec4SIMD const & v)
+		{
+			this->Data = _mm_add_ps(this->Data , v.Data);
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator-=(float const & s)
+		{
+			this->Data = _mm_sub_ps(Data, _mm_set_ps1(s));
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator-=(fvec4SIMD const & v)
+		{
+			this->Data = _mm_sub_ps(this->Data , v.Data);
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator*=(float const & s)
+		{
+			this->Data = _mm_mul_ps(this->Data, _mm_set_ps1(s));
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator*=(fvec4SIMD const & v)
+		{
+			this->Data = _mm_mul_ps(this->Data , v.Data);
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator/=(float const & s)
+		{
+			this->Data = _mm_div_ps(Data, _mm_set1_ps(s));
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator/=(fvec4SIMD const & v)
+		{
+			this->Data = _mm_div_ps(this->Data , v.Data);
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator++()
+		{
+			this->Data = _mm_add_ps(this->Data , glm::detail::one);
+			return *this;
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::operator--()
+		{
+			this->Data = _mm_sub_ps(this->Data, glm::detail::one);
+			return *this;
+		}
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <comp X, comp Y, comp Z, comp W>
+		GLM_FUNC_QUALIFIER fvec4SIMD fvec4SIMD::swizzle() const
+		{
+			__m128 Data = _mm_shuffle_ps(
+				this->Data, this->Data, 
+				mask<(W << 6) | (Z << 4) | (Y << 2) | (X << 0)>::value);
+			return fvec4SIMD(Data);
+		}
+
+		template <comp X, comp Y, comp Z, comp W>
+		GLM_FUNC_QUALIFIER fvec4SIMD& fvec4SIMD::swizzle()
+		{
+			this->Data = _mm_shuffle_ps(
+				this->Data, this->Data, 
+				mask<(W << 6) | (Z << 4) | (Y << 2) | (X << 0)>::value);
+			return *this;
+		}
+
+		// operator+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator+ (fvec4SIMD const & v, float s)
+		{
+			return fvec4SIMD(_mm_add_ps(v.Data, _mm_set1_ps(s)));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator+ (float s, fvec4SIMD const & v)
+		{
+			return fvec4SIMD(_mm_add_ps(_mm_set1_ps(s), v.Data));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator+ (fvec4SIMD const & v1, fvec4SIMD const & v2)
+		{
+			return fvec4SIMD(_mm_add_ps(v1.Data, v2.Data));
+		}
+
+		//operator-
+		GLM_FUNC_QUALIFIER fvec4SIMD operator- (fvec4SIMD const & v, float s)
+		{
+			return fvec4SIMD(_mm_sub_ps(v.Data, _mm_set1_ps(s)));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator- (float s, fvec4SIMD const & v)
+		{
+			return fvec4SIMD(_mm_sub_ps(_mm_set1_ps(s), v.Data));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator- (fvec4SIMD const & v1, fvec4SIMD const & v2)
+		{
+			return fvec4SIMD(_mm_sub_ps(v1.Data, v2.Data));
+		}
+
+		//operator*
+		GLM_FUNC_QUALIFIER fvec4SIMD operator* (fvec4SIMD const & v, float s)
+		{
+			__m128 par0 = v.Data;
+			__m128 par1 = _mm_set1_ps(s);
+			return fvec4SIMD(_mm_mul_ps(par0, par1));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator* (float s, fvec4SIMD const & v)
+		{
+			__m128 par0 = _mm_set1_ps(s);
+			__m128 par1 = v.Data;
+			return fvec4SIMD(_mm_mul_ps(par0, par1));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator* (fvec4SIMD const & v1, fvec4SIMD const & v2)
+		{
+			return fvec4SIMD(_mm_mul_ps(v1.Data, v2.Data));
+		}
+
+		//operator/
+		GLM_FUNC_QUALIFIER fvec4SIMD operator/ (fvec4SIMD const & v, float s)
+		{
+			__m128 par0 = v.Data;
+			__m128 par1 = _mm_set1_ps(s);
+			return fvec4SIMD(_mm_div_ps(par0, par1));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator/ (float s, fvec4SIMD const & v)
+		{
+			__m128 par0 = _mm_set1_ps(s);
+			__m128 par1 = v.Data;
+			return fvec4SIMD(_mm_div_ps(par0, par1));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator/ (fvec4SIMD const & v1, fvec4SIMD const & v2)
+		{
+			return fvec4SIMD(_mm_div_ps(v1.Data, v2.Data));
+		}
+
+		// Unary constant operators
+		GLM_FUNC_QUALIFIER fvec4SIMD operator- (fvec4SIMD const & v)
+		{
+			return fvec4SIMD(_mm_sub_ps(_mm_setzero_ps(), v.Data));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator++ (fvec4SIMD const & v, int)
+		{
+			return fvec4SIMD(_mm_add_ps(v.Data, glm::detail::one));
+		}
+
+		GLM_FUNC_QUALIFIER fvec4SIMD operator-- (fvec4SIMD const & v, int)
+		{
+			return fvec4SIMD(_mm_sub_ps(v.Data, glm::detail::one));
+		}
+
+	}//namespace detail
+
+	namespace gtx{
+	namespace simd_vec4
+	{
+		GLM_FUNC_QUALIFIER detail::tvec4<float> vec4_cast
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			GLM_ALIGN(16) detail::tvec4<float> Result;
+			_mm_store_ps(&Result[0], x.Data);
+			return Result;
+		}
+
+		// Other possible implementation
+		//float abs(float a)
+		//{
+		//  return max(-a, a);
+		//}
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD abs
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_abs_ps(x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD sign
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_sgn_ps(x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD floor
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_flr_ps(x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD trunc
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+            //return x < 0 ? -floor(-x) : floor(x);
+
+			__m128 Flr0 = detail::sse_flr_ps(_mm_sub_ps(_mm_setzero_ps(), x.Data));
+			__m128 Sub0 = _mm_sub_ps(Flr0, x.Data);
+			__m128 Flr1 = detail::sse_flr_ps(x.Data);
+
+			__m128 Cmp0 = _mm_cmplt_ps(x.Data, glm::detail::zero);
+			__m128 Cmp1 = _mm_cmpnlt_ps(x.Data, glm::detail::zero);
+
+			__m128 And0 = _mm_and_ps(Sub0, Cmp0);
+			__m128 And1 = _mm_and_ps(Flr1, Cmp1);
+
+			return _mm_or_ps(And0, And1);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD round
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_rnd_ps(x.Data);
+		}
+
+		//GLM_FUNC_QUALIFIER detail::fvec4SIMD roundEven
+		//(
+		//	detail::fvec4SIMD const & x
+		//)
+		//{
+
+		//}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD ceil
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_ceil_ps(x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD fract
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_frc_ps(x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD mod
+		(
+			detail::fvec4SIMD const & x, 
+			detail::fvec4SIMD const & y
+		)
+		{
+			return detail::sse_mod_ps(x.Data, y.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD mod
+		(
+			detail::fvec4SIMD const & x, 
+			float const & y
+		)
+		{
+			return detail::sse_mod_ps(x.Data, _mm_set1_ps(y));
+		}
+
+		//GLM_FUNC_QUALIFIER detail::fvec4SIMD modf
+		//(
+		//	detail::fvec4SIMD const & x, 
+		//	detail::fvec4SIMD & i
+		//)
+		//{
+
+		//}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD min
+		(
+			detail::fvec4SIMD const & x, 
+			detail::fvec4SIMD const & y
+		)
+		{
+			return _mm_min_ps(x.Data, y.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD min
+		(
+			detail::fvec4SIMD const & x, 
+			float const & y
+		)
+		{
+			return _mm_min_ps(x.Data, _mm_set1_ps(y));
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD max
+		(
+			detail::fvec4SIMD const & x, 
+			detail::fvec4SIMD const & y
+		)
+		{
+			return _mm_max_ps(x.Data, y.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD max
+		(
+			detail::fvec4SIMD const & x, 
+			float const & y
+		)
+		{
+			return _mm_max_ps(x.Data, _mm_set1_ps(y));
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD clamp
+		(
+			detail::fvec4SIMD const & x, 
+			detail::fvec4SIMD const & minVal, 
+			detail::fvec4SIMD const & maxVal
+		)
+		{
+			return detail::sse_clp_ps(x.Data, minVal.Data, maxVal.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD clamp
+		(
+			detail::fvec4SIMD const & x, 
+			float const & minVal, 
+			float const & maxVal
+		) 
+		{
+			return detail::sse_clp_ps(x.Data, _mm_set1_ps(minVal), _mm_set1_ps(maxVal));
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD mix
+		(
+			detail::fvec4SIMD const & x, 
+			detail::fvec4SIMD const & y, 
+			detail::fvec4SIMD const & a
+		)
+		{
+			__m128 Sub0 = _mm_sub_ps(y.Data, x.Data);
+			__m128 Mul0 = _mm_mul_ps(a.Data, Sub0);
+			return _mm_mul_ps(x.Data, Mul0);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD step
+		(
+			detail::fvec4SIMD const & edge, 
+			detail::fvec4SIMD const & x
+		)
+		{
+			__m128 cmp0 = _mm_cmpngt_ps(x.Data, edge.Data);
+			return _mm_max_ps(_mm_min_ps(cmp0, _mm_setzero_ps()), detail::one);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD step
+		(
+			float const & edge, 
+			detail::fvec4SIMD const & x
+		)
+		{
+			__m128 cmp0 = _mm_cmpngt_ps(x.Data, _mm_set1_ps(edge));
+			return _mm_max_ps(_mm_min_ps(cmp0, _mm_setzero_ps()), detail::one);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD smoothstep
+		(
+			detail::fvec4SIMD const & edge0, 
+			detail::fvec4SIMD const & edge1, 
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_ssp_ps(edge0.Data, edge1.Data, x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD smoothstep
+		(
+			float const & edge0, 
+			float const & edge1, 
+			detail::fvec4SIMD const & x
+		)
+		{
+			return detail::sse_ssp_ps(_mm_set1_ps(edge0), _mm_set1_ps(edge1), x.Data);
+		}
+
+		//GLM_FUNC_QUALIFIER bvec4 isnan(detail::fvec4SIMD const & x)
+		//{
+
+		//}
+
+		//GLM_FUNC_QUALIFIER bvec4 isinf(detail::fvec4SIMD const & x)
+		//{
+
+		//}
+
+		//GLM_FUNC_QUALIFIER detail::ivec4SIMD floatBitsToInt
+		//(
+		//	detail::fvec4SIMD const & value
+		//)
+		//{
+
+		//}
+
+		//GLM_FUNC_QUALIFIER detail::fvec4SIMD intBitsToFloat
+		//(
+		//	detail::ivec4SIMD const & value
+		//)
+		//{
+
+		//}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD fma
+		(
+			detail::fvec4SIMD const & a, 
+			detail::fvec4SIMD const & b, 
+			detail::fvec4SIMD const & c
+		)
+		{
+			return _mm_add_ps(_mm_mul_ps(a.Data, b.Data), c.Data);
+		}
+
+		GLM_FUNC_QUALIFIER float length
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			detail::fvec4SIMD dot0 = detail::sse_dot_ss(x.Data, x.Data);
+			detail::fvec4SIMD sqt0 = sqrt(dot0);
+			float Result = 0;
+			_mm_store_ss(&Result, sqt0.Data);
+			return Result;
+		}
+
+		GLM_FUNC_QUALIFIER float fastLength
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			detail::fvec4SIMD dot0 = detail::sse_dot_ss(x.Data, x.Data);
+			detail::fvec4SIMD sqt0 = fastSqrt(dot0);
+			float Result = 0;
+			_mm_store_ss(&Result, sqt0.Data);
+			return Result;
+		}
+
+		GLM_FUNC_QUALIFIER float niceLength
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			detail::fvec4SIMD dot0 = detail::sse_dot_ss(x.Data, x.Data);
+			detail::fvec4SIMD sqt0 = niceSqrt(dot0);
+			float Result = 0;
+			_mm_store_ss(&Result, sqt0.Data);
+			return Result;
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD length4
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return sqrt(dot4(x, x));
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD fastLength4
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return fastSqrt(dot4(x, x));
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD niceLength4
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			return niceSqrt(dot4(x, x));
+		}
+
+		GLM_FUNC_QUALIFIER float distance
+		(
+			detail::fvec4SIMD const & p0,
+			detail::fvec4SIMD const & p1
+		)
+		{
+			float Result = 0;
+			_mm_store_ss(&Result, detail::sse_dst_ps(p0.Data, p1.Data));
+			return Result;
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD distance4
+		(
+			detail::fvec4SIMD const & p0,
+			detail::fvec4SIMD const & p1
+		)
+		{
+			return detail::sse_dst_ps(p0.Data, p1.Data);
+		}
+
+		GLM_FUNC_QUALIFIER float dot
+		(
+			detail::fvec4SIMD const & x,
+			detail::fvec4SIMD const & y
+		)
+		{
+			float Result = 0;
+			_mm_store_ss(&Result, detail::sse_dot_ss(x.Data, y.Data));
+			return Result;
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD dot4
+		(
+			detail::fvec4SIMD const & x,
+			detail::fvec4SIMD const & y
+		)
+		{
+			return detail::sse_dot_ps(x.Data, y.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD cross
+		(
+			detail::fvec4SIMD const & x,
+			detail::fvec4SIMD const & y
+		)
+		{
+			return detail::sse_xpd_ps(x.Data, y.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD normalize
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			__m128 dot0 = detail::sse_dot_ps(x.Data, x.Data);
+			__m128 isr0 = inversesqrt(dot0).Data;
+			__m128 mul0 = _mm_mul_ps(x.Data, isr0);
+			return mul0;
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD fastNormalize
+		(
+			detail::fvec4SIMD const & x
+		)
+		{
+			__m128 dot0 = detail::sse_dot_ps(x.Data, x.Data);
+			__m128 isr0 = fastInversesqrt(dot0).Data;
+			__m128 mul0 = _mm_mul_ps(x.Data, isr0);
+			return mul0;
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD faceforward
+		(
+			detail::fvec4SIMD const & N,
+			detail::fvec4SIMD const & I,
+			detail::fvec4SIMD const & Nref
+		)
+		{
+			return detail::sse_ffd_ps(N.Data, I.Data, Nref.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD reflect
+		(
+			detail::fvec4SIMD const & I,
+			detail::fvec4SIMD const & N
+		)
+		{
+			return detail::sse_rfe_ps(I.Data, N.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD refract
+		(
+			detail::fvec4SIMD const & I,
+			detail::fvec4SIMD const & N,
+			float const & eta
+		)
+		{
+			return detail::sse_rfa_ps(I.Data, N.Data, _mm_set1_ps(eta));
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD sqrt(detail::fvec4SIMD const & x)
+		{
+			return _mm_mul_ps(inversesqrt(x.Data).Data, x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD niceSqrt(detail::fvec4SIMD const & x)
+		{
+			return _mm_sqrt_ps(x.Data);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD fastSqrt(detail::fvec4SIMD const & x)
+		{
+			return _mm_mul_ps(fastInversesqrt(x.Data).Data, x.Data);
+		}
+
+		// SSE scalar reciprocal sqrt using rsqrt op, plus one Newton-Rhaphson iteration
+		// By Elan Ruskin, http://assemblyrequired.crashworks.org/
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD inversesqrt(detail::fvec4SIMD const & x)
+		{
+			GLM_ALIGN(4) static const __m128 three = {3, 3, 3, 3}; // aligned consts for fast load
+			GLM_ALIGN(4) static const __m128 half = {0.5,0.5,0.5,0.5};
+
+			__m128 recip = _mm_rsqrt_ps(x.Data);  // "estimate" opcode
+			__m128 halfrecip = _mm_mul_ps(half, recip);
+			__m128 threeminus_xrr = _mm_sub_ps(three, _mm_mul_ps(x.Data, _mm_mul_ps(recip, recip)));
+			return _mm_mul_ps(halfrecip, threeminus_xrr);
+		}
+
+		GLM_FUNC_QUALIFIER detail::fvec4SIMD fastInversesqrt(detail::fvec4SIMD const & x)
+		{
+			return _mm_rsqrt_ps(x.Data);
+		}
+
+	}//namespace simd_vec4
+	}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/simplex.hpp b/ExternalLibs/glm/gtx/simplex.hpp
new file mode 100644
index 0000000..390a641
--- /dev/null
+++ b/ExternalLibs/glm/gtx/simplex.hpp
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-04-09
+// Updated : 2011-04-09
+// Licence : This source is under MIT License
+// File    : glm/gtx/simplex.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_simplex
+#define glm_gtx_simplex
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_simplex extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace spline ///< GLM_GTX_simplex extension: Spline functions
+{
+    /// \addtogroup gtx_spline
+    ///@{
+            
+    //! Return a point from a catmull rom curve.
+    //! From GLM_GTX_spline extension.
+    template <typename genType> 
+    genType catmullRom(
+                        genType const & v1, 
+                        genType const & v2, 
+                        genType const & v3, 
+                        genType const & v4, 
+                        typename genType::value_type const & s);
+            
+    //! Return a point from a hermite curve.
+    //! From GLM_GTX_spline extension.
+    template <typename genType> 
+    genType hermite(
+                    genType const & v1, 
+                    genType const & t1, 
+                    genType const & v2, 
+                    genType const & t2, 
+                    typename genType::value_type const & s);
+            
+    //! Return a point from a cubic curve. 
+    //! From GLM_GTX_spline extension.
+    template <typename genType> 
+    genType cubic(
+                    genType const & v1, 
+                    genType const & v2, 
+                    genType const & v3, 
+                    genType const & v4, 
+                    typename genType::value_type const & s);
+            
+    /// @}
+}// namespace simplex
+}// namespace gtx
+}// namespace glm
+
+#include "simplex.inl"
+
+namespace glm{using namespace gtx::simplex;}
+
+#endif//glm_gtx_spline
+
diff --git a/ExternalLibs/glm/gtx/simplex.inl b/ExternalLibs/glm/gtx/simplex.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/gtx/spline.hpp b/ExternalLibs/glm/gtx/spline.hpp
new file mode 100644
index 0000000..961b76d
--- /dev/null
+++ b/ExternalLibs/glm/gtx/spline.hpp
@@ -0,0 +1,73 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-01-25
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/spline.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_spline
+#define glm_gtx_spline
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/optimum_pow.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_spline extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace spline ///< GLM_GTX_spline extension: Spline functions
+{
+	using namespace gtx::optimum_pow;
+
+	/// \addtogroup gtx_spline
+	/// @{
+
+	//! Return a point from a catmull rom curve.
+	//! From GLM_GTX_spline extension.
+	template <typename genType> 
+	genType catmullRom(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s);
+		
+	//! Return a point from a hermite curve.
+	//! From GLM_GTX_spline extension.
+    template <typename genType> 
+	genType hermite(
+		genType const & v1, 
+		genType const & t1, 
+		genType const & v2, 
+		genType const & t2, 
+		typename genType::value_type const & s);
+		
+    //! Return a point from a cubic curve. 
+	//! From GLM_GTX_spline extension.
+	template <typename genType> 
+	genType cubic(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s);
+
+	/// @}
+}//namespace spline
+}//namespace gtx
+}//namespace glm
+
+#include "spline.inl"
+
+namespace glm{using namespace gtx::spline;}
+
+#endif//glm_gtx_spline
+
diff --git a/ExternalLibs/glm/gtx/spline.inl b/ExternalLibs/glm/gtx/spline.inl
new file mode 100644
index 0000000..3390715
--- /dev/null
+++ b/ExternalLibs/glm/gtx/spline.inl
@@ -0,0 +1,74 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-01-25
+// Updated : 2009-02-19
+// Licence : This source is under MIT License
+// File    : glm/gtx/spline.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace spline
+{
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType catmullRom
+	(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s
+	)
+	{
+		typename genType::value_type s1 = s;
+		typename genType::value_type s2 = optimum_pow::pow2(s);
+		typename genType::value_type s3 = optimum_pow::pow3(s);
+
+		typename genType::value_type f1 = -s3 + typename genType::value_type(2) * s2 - s;
+		typename genType::value_type f2 = typename genType::value_type(3) * s3 - typename genType::value_type(5) * s2 + typename genType::value_type(2);
+		typename genType::value_type f3 = typename genType::value_type(-3) * s3 + typename genType::value_type(4) * s2 + s;
+		typename genType::value_type f4 = s3 - s2;
+
+		return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) / typename genType::value_type(2);
+
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType hermite
+	(
+		genType const & v1, 
+		genType const & t1, 
+		genType const & v2, 
+		genType const & t2, 
+		typename genType::value_type const & s
+	)
+	{
+		typename genType::value_type s1 = s;
+		typename genType::value_type s2 = optimum_pow::pow2(s);
+		typename genType::value_type s3 = optimum_pow::pow3(s);
+
+		typename genType::value_type f1 = typename genType::value_type(2) * s3 - typename genType::value_type(3) * s2 + typename genType::value_type(1);
+		typename genType::value_type f2 = typename genType::value_type(-2) * s3 + typename genType::value_type(3) * s2;
+		typename genType::value_type f3 = s3 - typename genType::value_type(2) * s2 + s;
+		typename genType::value_type f4 = s3 - s2;
+
+		return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER genType cubic
+	(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s
+	)
+	{
+		return ((v1 * s + v2) * s + v3) * s + v4;
+	}
+
+}//namespace spline
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/std_based_type.hpp b/ExternalLibs/glm/gtx/std_based_type.hpp
new file mode 100644
index 0000000..889cd80
--- /dev/null
+++ b/ExternalLibs/glm/gtx/std_based_type.hpp
@@ -0,0 +1,72 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-06-08
+// Updated : 2008-06-08
+// Licence : This source is under MIT License
+// File    : glm/gtx/std_based_type.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_std_based_type
+#define glm_gtx_std_based_type
+
+// Dependency:
+#include "../glm.hpp"
+#include <cstdlib>
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_std_based_type extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
+{
+	typedef detail::tvec2<std::size_t>		size2;
+	typedef detail::tvec3<std::size_t>		size3;
+	typedef detail::tvec4<std::size_t>		size4;
+
+	typedef detail::tvec2<signed char>		scvec2;
+	typedef detail::tvec3<signed char>		scvec3;
+	typedef detail::tvec4<signed char>		scvec4;
+
+	typedef detail::tvec2<unsigned char>	ucvec2;
+	typedef detail::tvec3<unsigned char>	ucvec3;
+	typedef detail::tvec4<unsigned char>	ucvec4;
+
+	typedef detail::tvec2<signed short>		ssvec2;
+	typedef detail::tvec3<signed short>		ssvec3;
+	typedef detail::tvec4<signed short>		ssvec4;
+
+	typedef detail::tvec2<unsigned short>	usvec2;
+	typedef detail::tvec3<unsigned short>	usvec3;
+	typedef detail::tvec4<unsigned short>	usvec4;
+
+	typedef detail::tvec2<signed int>		sivec2;
+	typedef detail::tvec3<signed int>		sivec3;
+	typedef detail::tvec4<signed int>		sivec4;
+
+	typedef detail::tvec2<unsigned int>		uivec2;
+	typedef detail::tvec3<unsigned int>		uivec3;
+	typedef detail::tvec4<unsigned int>		uivec4;
+
+	typedef detail::tvec2<signed long>		slvec2;
+	typedef detail::tvec3<signed long>		slvec3;
+	typedef detail::tvec4<signed long>		slvec4;
+
+	typedef detail::tvec2<unsigned long>	ulvec2;
+	typedef detail::tvec3<unsigned long>	ulvec3;
+	typedef detail::tvec4<unsigned long>	ulvec4;
+
+}//namespace std_based_type
+}//namespace gtx
+}//namespace glm
+
+#include "std_based_type.inl"
+
+namespace glm{using namespace gtx::std_based_type;}
+
+#endif//glm_gtx_std_based_type
diff --git a/ExternalLibs/glm/gtx/std_based_type.inl b/ExternalLibs/glm/gtx/std_based_type.inl
new file mode 100644
index 0000000..5b735af
--- /dev/null
+++ b/ExternalLibs/glm/gtx/std_based_type.inl
@@ -0,0 +1,13 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-06-08
+// Updated : 2008-06-08
+// Licence : This source is under MIT License
+// File    : glm/gtx/std_based_type.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+
+}
diff --git a/ExternalLibs/glm/gtx/string_cast.hpp b/ExternalLibs/glm/gtx/string_cast.hpp
new file mode 100644
index 0000000..1c050b6
--- /dev/null
+++ b/ExternalLibs/glm/gtx/string_cast.hpp
@@ -0,0 +1,57 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-04-26
+// Updated : 2010-01-28
+// Licence : This source is under MIT License
+// File    : glm/gtx/string_cast.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_half_float
+// - GLM_GTX_integer
+// - GLM_GTX_quaternion
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_string_cast
+#define glm_gtx_string_cast
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/half_float.hpp"
+#include "../gtx/integer.hpp"
+#include "../gtx/unsigned_int.hpp"
+#include "../gtx/quaternion.hpp"
+#include <string>
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_string_cast extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
+{
+	using namespace gtc::half_float; 
+	using namespace gtx::integer; 
+	using namespace gtx::unsigned_int; 
+	using namespace gtx::quaternion; 
+
+	/// \addtogroup gtx_string_cast
+	/// @{
+
+	//! Create a string from a GLM type value.
+	//! From GLM_GTX_string_cast extension.
+	template <typename genType> 
+	std::string to_string(genType const & x);
+
+	/// @}
+}//namespace string_cast
+}//namespace gtx
+}//namespace glm
+
+#include "string_cast.inl"
+
+namespace glm{using namespace gtx::string_cast;}
+
+#endif//glm_gtx_string_cast
diff --git a/ExternalLibs/glm/gtx/string_cast.inl b/ExternalLibs/glm/gtx/string_cast.inl
new file mode 100644
index 0000000..031ea55
--- /dev/null
+++ b/ExternalLibs/glm/gtx/string_cast.inl
@@ -0,0 +1,597 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2006 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-04-27
+// Updated : 2008-05-24
+// Licence : This source is under MIT License
+// File    : glm/gtx/string_cast.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cstdarg>
+#include <cstdio>
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER std::string format(const char* msg, ...)
+	{
+		const int STRING_BUFFER = 4096;
+		char text[STRING_BUFFER];
+		va_list list;
+
+		if(msg == 0)
+			return std::string();
+
+		va_start(list, msg);
+			vsprintf(text, msg, list);
+		va_end(list);
+
+		return std::string(text);
+	}
+
+	static const char* True = "true";
+	static const char* False = "false";
+}//namespace detail
+
+namespace gtx{
+namespace string_cast
+{
+	////////////////////////////////
+	// Scalars
+
+	GLM_FUNC_QUALIFIER std::string to_string(detail::thalf const & x)
+	{
+		return detail::format("half(%f)", float(x));
+	}
+
+	GLM_FUNC_QUALIFIER std::string to_string(float x)
+	{
+		return detail::format("float(%f)", x);
+	}
+
+	GLM_FUNC_QUALIFIER std::string to_string(double x)
+	{
+		return detail::format("double(%f)", x);
+	}
+
+	GLM_FUNC_QUALIFIER std::string to_string(int x)
+	{
+		return detail::format("int(%d)", x);
+	}
+
+	GLM_FUNC_QUALIFIER std::string to_string(unsigned int x)
+	{
+		return detail::format("uint(%d)", x);
+	}
+
+	////////////////////////////////
+	// Bool vectors
+
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec2<bool> const & v
+	)
+	{
+		return detail::format("bvec2(%s, %s)", 
+			v.x ? detail::True : detail::False, 
+			v.y ? detail::True : detail::False);
+	}
+
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec3<bool> const & v
+	)
+	{
+		return detail::format("bvec3(%s, %s, %s)", 
+			v.x ? detail::True : detail::False, 
+			v.y ? detail::True : detail::False, 
+			v.z ? detail::True : detail::False);
+	}
+
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec4<bool> const & v
+	)
+	{
+		return detail::format("bvec4(%s, %s, %s, %s)", 
+			v.x ? detail::True : detail::False, 
+			v.y ? detail::True : detail::False, 
+			v.z ? detail::True : detail::False, 
+			v.w ? detail::True : detail::False);
+	}
+
+	////////////////////////////////
+	// Half vectors
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec2<detail::thalf> const & v
+	)
+	{
+		return detail::format("hvec2(%f, %f)", float(v.x), float(v.y));
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec3<detail::thalf> const & v
+	)
+	{
+		return detail::format("hvec3(%f, %f, %f)", float(v.x), float(v.y), float(v.z));
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec4<detail::thalf> const & v
+	)
+	{
+		return detail::format("hvec4(%f, %f, %f, %f)", float(v.x), float(v.y), float(v.z), float(v.w));
+	}
+
+	////////////////////////////////
+	// Float vectors
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec2<float> const & v
+	)
+	{
+		return detail::format("fvec2(%f, %f)", v.x, v.y);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec3<float> const & v
+	)
+	{
+		return detail::format("fvec3(%f, %f, %f)", v.x, v.y, v.z);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec4<float> const & v
+	)
+	{
+		return detail::format("fvec4(%f, %f, %f, %f)", v.x, v.y, v.z, v.w);
+	}
+
+	////////////////////////////////
+	// Double vectors
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec2<double> const & v
+	)
+	{
+		return detail::format("dvec2(%f, %f)", v.x, v.y);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec3<double> const & v
+	)
+	{
+		return detail::format("dvec3(%f, %f, %f)", v.x, v.y, v.z);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec4<double> const & v
+	)
+	{
+		return detail::format("dvec4(%f, %f, %f, %f)", v.x, v.y, v.z, v.w);
+	}
+
+	////////////////////////////////
+	// Int vectors
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec2<int> const & v
+	)
+	{
+		return detail::format("ivec2(%d, %d)", v.x, v.y);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec3<int> const & v
+	)
+	{
+		return detail::format("ivec3(%d, %d, %d)", v.x, v.y, v.z);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec4<int> const & v
+	)
+	{
+		return detail::format("ivec4(%d, %d, %d, %d)", v.x, v.y, v.z, v.w);
+	}
+
+	////////////////////////////////
+	// Unsigned int vectors
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec2<unsigned int> const & v
+	)
+	{
+		return detail::format("uvec2(%d, %d)", v.x, v.y);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec3<unsigned int> const & v
+	)
+	{
+		return detail::format("uvec3(%d, %d, %d)", v.x, v.y, v.z);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tvec4<unsigned int> const & v
+	)
+	{
+		return detail::format("uvec4(%d, %d, %d, %d)", v.x, v.y, v.z, v.w);
+	}
+
+	////////////////////////////////
+	// Half matrices
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x2<detail::thalf> const & m
+	)
+	{
+		detail::tmat2x2<float> x(m);
+		return detail::format("hmat2x2((%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x3<detail::thalf> const & m
+	)
+	{
+		detail::tmat2x3<float> x(m);
+		return detail::format("hmat2x3((%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x4<detail::thalf> const & m
+	)
+	{
+		detail::tmat2x4<float> x(m);
+		return detail::format("hmat2x4((%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3], 
+			x[1][0], x[1][1], x[1][2], x[1][3]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x2<detail::thalf> const & m
+	)
+	{
+		detail::tmat3x2<float> x(m);
+		return detail::format("hmat3x2((%f, %f), (%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1], 
+			x[2][0], x[2][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x3<detail::thalf> const & m
+	)
+	{
+		detail::tmat3x3<float> x(m);
+		return detail::format("hmat3x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2],
+			x[2][0], x[2][1], x[2][2]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x4<detail::thalf> const & m
+	)
+	{
+		detail::tmat3x4<float> x(m);
+		return detail::format("hmat3x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3], 
+			x[1][0], x[1][1], x[1][2], x[1][3], 
+			x[2][0], x[2][1], x[2][2], x[2][3]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x2<detail::thalf> const & m
+	)
+	{
+		detail::tmat4x2<float> x(m);
+		return detail::format("hmat4x2((%f, %f), (%f, %f), (%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1], 
+			x[2][0], x[2][1], 
+			x[3][0], x[3][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x3<detail::thalf> const & m
+	)
+	{
+		detail::tmat4x3<float> x(m);
+		return detail::format("hmat4x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2],
+			x[1][0], x[1][1], x[1][2], 
+			x[2][0], x[2][1], x[2][2],
+			x[3][0], x[3][1], x[3][2]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x4<detail::thalf> const & m
+	)
+	{
+		detail::tmat4x4<float> x(m);
+		return detail::format("hmat4x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3],
+			x[1][0], x[1][1], x[1][2], x[1][3],
+			x[2][0], x[2][1], x[2][2], x[2][3],
+			x[3][0], x[3][1], x[3][2], x[3][3]);
+	}
+
+	////////////////////////////////
+	// Float matrices
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x2<float> const & x
+	)
+	{
+		return detail::format("mat2x2((%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x3<float> const & x
+	)
+	{
+		return detail::format("mat2x3((%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x4<float> const & x
+	)
+	{
+		return detail::format("mat2x4((%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3], 
+			x[1][0], x[1][1], x[1][2], x[1][3]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x2<float> const & x
+	)
+	{
+		return detail::format("mat3x2((%f, %f), (%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1], 
+			x[2][0], x[2][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x3<float> const & x
+	)
+	{
+		return detail::format("mat3x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2],
+			x[2][0], x[2][1], x[2][2]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x4<float> const & x
+	)
+	{
+		return detail::format("mat3x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3], 
+			x[1][0], x[1][1], x[1][2], x[1][3], 
+			x[2][0], x[2][1], x[2][2], x[2][3]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x2<float> const & x
+	)
+	{
+		return detail::format("mat4x2((%f, %f), (%f, %f), (%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1], 
+			x[2][0], x[2][1], 
+			x[3][0], x[3][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x3<float> const & x
+	)
+	{
+		return detail::format("mat4x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2],
+			x[1][0], x[1][1], x[1][2], 
+			x[2][0], x[2][1], x[2][2],
+			x[3][0], x[3][1], x[3][2]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x4<float> const & x
+	)
+	{
+		return detail::format("mat4x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3],
+			x[1][0], x[1][1], x[1][2], x[1][3],
+			x[2][0], x[2][1], x[2][2], x[2][3],
+			x[3][0], x[3][1], x[3][2], x[3][3]);
+	}
+
+	////////////////////////////////
+	// Double matrices
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x2<double> const & x
+	)
+	{
+		return detail::format("dmat2x2((%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x3<double> const & x
+	)
+	{
+		return detail::format("dmat2x3((%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat2x4<double> const & x
+	)
+	{
+		return detail::format("dmat2x4((%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3], 
+			x[1][0], x[1][1], x[1][2], x[1][3]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x2<double> const & x
+	)
+	{
+		return detail::format("dmat3x2((%f, %f), (%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1],
+			x[2][0], x[2][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x3<double> const & x
+	)
+	{
+		return detail::format("dmat3x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2],
+			x[2][0], x[2][1], x[2][2]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat3x4<double> const & x
+	)
+	{
+		return detail::format("dmat3x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3], 
+			x[1][0], x[1][1], x[1][2], x[1][3],
+			x[2][0], x[2][1], x[2][2], x[2][3]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x2<double> const & x
+	)
+	{
+		return detail::format("dmat4x2((%f, %f), (%f, %f), (%f, %f), (%f, %f))", 
+			x[0][0], x[0][1], 
+			x[1][0], x[1][1], 
+			x[2][0], x[2][1], 
+			x[3][0], x[3][1]);
+	}
+
+	template <> 
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x3<double> const & x
+	)
+	{
+		return detail::format("dmat4x3((%f, %f, %f), (%f, %f, %f), (%f, %f, %f), (%f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], 
+			x[1][0], x[1][1], x[1][2], 
+			x[2][0], x[2][1], x[2][2], 
+			x[3][0], x[3][1], x[3][2]);
+	}
+
+	template <>
+	GLM_FUNC_QUALIFIER std::string to_string
+	(
+		detail::tmat4x4<double> const & x
+	)
+	{
+		return detail::format("dmat4x4((%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f), (%f, %f, %f, %f))", 
+			x[0][0], x[0][1], x[0][2], x[0][3],
+			x[1][0], x[1][1], x[1][2], x[1][3],
+			x[2][0], x[2][1], x[2][2], x[2][3],
+			x[3][0], x[3][1], x[3][2], x[3][3]);
+	}
+
+	}//namespace string_cast
+	}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/transform.hpp b/ExternalLibs/glm/gtx/transform.hpp
new file mode 100644
index 0000000..ac050b0
--- /dev/null
+++ b/ExternalLibs/glm/gtx/transform.hpp
@@ -0,0 +1,103 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-04-29
+// Licence : This source is under MIT License
+// File    : glm/gtx/transform.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTC_matric_transform
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_transform
+#define glm_gtx_transform
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtc/matrix_transform.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_transform extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
+{
+	using namespace gtc::matrix_transform; 
+
+	/// \addtogroup gtx_transform
+	/// @{
+
+	//! Builds a translation 4 * 4 matrix created from 3 scalars.
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		T x, T y, T z);
+		
+	//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		detail::tmat4x4<T> const & m, 
+		T x, T y, T z);
+		
+	//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		detail::tvec3<T> const & v);
+
+	//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		T angle, 
+		T x, T y, T z);
+
+	//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		T angle, 
+		detail::tvec3<T> const & v);
+
+	//! Transforms a matrix with a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		detail::tmat4x4<T> const & m, 
+		T angle, 
+		T x, T y, T z);
+		
+	//! Builds a scale 4 * 4 matrix created from 3 scalars. 
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		T x, T y, T z);
+		
+	//! Transforms a matrix with a scale 4 * 4 matrix created from 3 scalars.
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		detail::tmat4x4<T> const & m, 
+		T x, T y, T z);
+
+	//! Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
+	//! From GLM_GTX_transform extension.
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		detail::tvec3<T> const & v);
+
+	/// @}
+}//namespace transform
+}//namespace gtx
+}//namespace glm
+
+#include "transform.inl"
+
+namespace glm{using namespace gtx::transform;}
+
+#endif//glm_gtx_transform
diff --git a/ExternalLibs/glm/gtx/transform.inl b/ExternalLibs/glm/gtx/transform.inl
new file mode 100644
index 0000000..908a327
--- /dev/null
+++ b/ExternalLibs/glm/gtx/transform.inl
@@ -0,0 +1,94 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2009-04-29
+// Licence : This source is under MIT License
+// File    : glm/gtx/transform.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace transform
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
+		T x, T y, T z)
+    {
+		return gtc::matrix_transform::translate(
+			detail::tmat4x4<T>(1.0f), 
+			detail::tvec3<T>(x, y , z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
+		detail::tmat4x4<T> const & m, 
+		T x, T y, T z)
+    {
+        return gtc::matrix_transform::translate(
+			m, detail::tvec3<T>(x, y , z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate(
+		detail::tvec3<T> const & v)
+    {
+		return gtc::matrix_transform::translate(
+			detail::tmat4x4<T>(1.0f), v);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate(
+		T angle, 
+		T x, T y, T z)
+    {
+		return gtc::matrix_transform::rotate(
+			detail::tmat4x4<T>(1), angle, detail::tvec3<T>(x, y, z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate(
+		T angle, 
+		detail::tvec3<T> const & v)
+    {
+		return gtc::matrix_transform::rotate(
+			detail::tmat4x4<T>(1), angle, v);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate(
+		detail::tmat4x4<T> const & m, 
+		T angle, 
+		T x, T y, T z)
+    {
+		return gtc::matrix_transform::rotate(
+			m, angle, detail::tvec3<T>(x, y, z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale(T x, T y, T z)
+    {
+		return gtc::matrix_transform::scale(
+			detail::tmat4x4<T>(1), detail::tvec3<T>(x, y, z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale(
+		detail::tmat4x4<T> const & m, 
+		T x, T y, T z)
+    {
+        return gtc::matrix_transform::scale(
+			m, detail::tvec3<T>(x, y, z));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale(
+		detail::tvec3<T> const & v)
+    {
+        return gtc::matrix_transform::scale(
+			detail::tmat4x4<T>(1.0f), v);
+    }
+
+}//namespace transform
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/transform2.hpp b/ExternalLibs/glm/gtx/transform2.hpp
new file mode 100644
index 0000000..f62b659
--- /dev/null
+++ b/ExternalLibs/glm/gtx/transform2.hpp
@@ -0,0 +1,118 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-21
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/transform2.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_transform
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_transform2
+#define glm_gtx_transform2
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/transform.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_transform2 extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
+{
+	using namespace gtx::transform;
+
+	/// \addtogroup gtx_transform2
+	/// @{
+
+	//! Transforms a matrix with a shearing on X axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat3x3<T> shearX2D(
+		detail::tmat3x3<T> const & m, 
+		T y);
+
+	//! Transforms a matrix with a shearing on Y axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat3x3<T> shearY2D(
+		detail::tmat3x3<T> const & m, 
+		T x);
+
+	//! Transforms a matrix with a shearing on X axis
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> shearX3D(
+		const detail::tmat4x4<T> & m,
+		T y, 
+		T z);
+		
+	//! Transforms a matrix with a shearing on Y axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> shearY3D(
+		const detail::tmat4x4<T> & m, 
+		T x, 
+		T z);
+		
+	//! Transforms a matrix with a shearing on Z axis. 
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> shearZ3D(
+		const detail::tmat4x4<T> & m, 
+		T x, 
+		T y);
+
+	//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T> shear(const detail::tmat4x4<T> & m, shearPlane, planePoint, angle)
+	// Identity + tan(angle) * cross(Normal, OnPlaneVector)     0
+	// - dot(PointOnPlane, normal) * OnPlaneVector              1
+
+	// Reflect functions seem to don't work
+	//template <typename T> detail::tmat3x3<T> reflect2D(const detail::tmat3x3<T> & m, const detail::tvec3<T>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+	//template <typename T> detail::tmat4x4<T> reflect3D(const detail::tmat4x4<T> & m, const detail::tvec3<T>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+		
+	//! Build planar projection matrix along normal axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat3x3<T> proj2D(
+		const detail::tmat3x3<T> & m, 
+		const detail::tvec3<T>& normal);
+				
+	//! Build planar projection matrix along normal axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> proj3D(
+		const detail::tmat4x4<T> & m, 
+		const detail::tvec3<T>& normal);
+
+	//! Build a scale bias matrix. 
+	//! From GLM_GTX_transform2 extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> scaleBias(
+		valType scale, 
+		valType bias);
+
+	//! Build a scale bias matrix.
+	//! From GLM_GTX_transform2 extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> scaleBias(
+		detail::tmat4x4<valType> const & m, 
+		valType scale, 
+		valType bias);
+
+	/// @}
+}// namespace transform2
+}// namespace gtx
+}// namespace glm
+
+#include "transform2.inl"
+
+namespace glm{using namespace gtx::transform2;}
+
+#endif//glm_gtx_transform2
diff --git a/ExternalLibs/glm/gtx/transform2.inl b/ExternalLibs/glm/gtx/transform2.inl
new file mode 100644
index 0000000..37ee94a
--- /dev/null
+++ b/ExternalLibs/glm/gtx/transform2.inl
@@ -0,0 +1,159 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-02-28
+// Updated : 2005-04-23
+// Licence : This source is under MIT License
+// File : glm/gtx/transform2.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace transform2
+{
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> shearX2D(
+		const detail::tmat3x3<T>& m, 
+		T s)
+    {
+        detail::tmat3x3<T> r(1);
+        r[0][1] = s;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> shearY2D(
+		const detail::tmat3x3<T>& m, 
+		T s)
+    {
+        detail::tmat3x3<T> r(1);
+        r[1][0] = s;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> shearX3D(
+		const detail::tmat4x4<T>& m, 
+		T s, 
+		T t)
+    {
+        detail::tmat4x4<T> r(1);
+        r[1][0] = s;
+        r[2][0] = t;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> shearY3D(
+		const detail::tmat4x4<T>& m, 
+		T s, 
+		T t)
+    {
+        detail::tmat4x4<T> r(1);
+        r[0][1] = s;
+        r[2][1] = t;
+        return m * r;
+    }
+
+    template <typename T>     
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> shearZ3D(
+		const detail::tmat4x4<T>& m, 
+		T s, 
+		T t)
+    {
+        detail::tmat4x4<T> r(1);
+        r[0][2] = s;
+        r[1][2] = t;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> reflect2D(
+		const detail::tmat3x3<T>& m, 
+		const detail::tvec3<T>& normal)
+    {
+        detail::tmat3x3<T> r(1);
+        r[0][0] = 1 - 2 * normal.x * normal.x;
+        r[0][1] = -2 * normal.x * normal.y;
+        r[1][0] = -2 * normal.x * normal.y;
+        r[1][1] = 1 - 2 * normal.y * normal.y;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> reflect3D(
+		const detail::tmat4x4<T>& m, 
+		const detail::tvec3<T>& normal)
+    {
+        detail::tmat4x4<T> r(1);
+        r[0][0] = 1 - 2 * normal.x * normal.x;
+        r[0][1] = -2 * normal.x * normal.y;
+        r[0][2] = -2 * normal.x * normal.z;
+
+        r[1][0] = -2 * normal.x * normal.y;
+        r[1][1] = 1 - 2 * normal.y * normal.y;
+        r[1][2] = -2 * normal.y * normal.z;
+
+        r[2][0] = -2 * normal.x * normal.z;
+        r[2][1] = -2 * normal.y * normal.z;
+        r[2][2] = 1 - 2 * normal.z * normal.z;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat3x3<T> proj2D(
+		const detail::tmat3x3<T>& m, 
+		const detail::tvec3<T>& normal)
+    {
+        detail::tmat3x3<T> r(1);
+        r[0][0] = 1 - normal.x * normal.x;
+        r[0][1] = - normal.x * normal.y;
+        r[1][0] = - normal.x * normal.y;
+        r[1][1] = 1 - normal.y * normal.y;
+        return m * r;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tmat4x4<T> proj3D(
+		const detail::tmat4x4<T>& m, 
+		const detail::tvec3<T>& normal)
+    {
+        detail::tmat4x4<T> r(1);
+        r[0][0] = 1 - normal.x * normal.x;
+        r[0][1] = - normal.x * normal.y;
+        r[0][2] = - normal.x * normal.z;
+        r[1][0] = - normal.x * normal.y;
+        r[1][1] = 1 - normal.y * normal.y;
+        r[1][2] = - normal.y * normal.z;
+        r[2][0] = - normal.x * normal.z;
+        r[2][1] = - normal.y * normal.z;
+        r[2][2] = 1 - normal.z * normal.z;
+        return m * r;
+    }
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scaleBias(
+		T scale, 
+		T bias)
+	{
+		detail::tmat4x4<T> result;
+		result[3] = detail::tvec4<T>(detail::tvec3<T>(bias), T(1));
+		result[0][0] = scale;
+		result[1][1] = scale;
+		result[2][2] = scale;
+		return result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> scaleBias(
+		const detail::tmat4x4<T>& m, 
+		T scale, 
+		T bias)
+	{
+		return m * scaleBias(scale, bias);
+	}
+
+}//namespace transform2
+}//namespace gtx
+}//namespace glm
+
diff --git a/ExternalLibs/glm/gtx/ulp.hpp b/ExternalLibs/glm/gtx/ulp.hpp
new file mode 100644
index 0000000..02214ff
--- /dev/null
+++ b/ExternalLibs/glm/gtx/ulp.hpp
@@ -0,0 +1,70 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-02-21
+// Updated : 2009-02-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/ulp.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_ulp
+#define glm_gtx_ulp
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_ulp extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
+{
+	/// \addtogroup gtx_ulp
+	/// @{
+
+	//! Return the next ULP value(s) after the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType next_float(genType const & x);
+        
+	//! Return the previous ULP value(s) before the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType prev_float(genType const & x);
+
+	//! Return the value(s) ULP distance after the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType next_float(genType const & x, uint const & Distance);
+        
+    //! Return the value(s) ULP distance before the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType prev_float(genType const & x, uint const & Distance);
+        
+    //! Return the distance in the number of ULP between 2 scalars.
+	//! From GLM_GTX_ulp extension.
+    template <typename T>
+    uint float_distance(T const & x, T const & y);
+        
+    //! Return the distance in the number of ULP between 2 vectors.
+	//! From GLM_GTX_ulp extension.
+    template<typename T, template<typename> class vecType>
+    vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
+        
+	///@}
+}// namespace ulp
+}// namespace gtx
+}// namespace glm
+
+#include "ulp.inl"
+
+namespace glm{using namespace gtx::ulp;}
+
+#endif//glm_gtx_ulp
+
diff --git a/ExternalLibs/glm/gtx/ulp.inl b/ExternalLibs/glm/gtx/ulp.inl
new file mode 100644
index 0000000..08d886a
--- /dev/null
+++ b/ExternalLibs/glm/gtx/ulp.inl
@@ -0,0 +1,396 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2011-03-07
+// Updated : 2011-04-26
+// Licence : This source is under MIT License
+// File    : glm/gtx/ulp.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cmath>
+#include <cfloat>
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+typedef union
+{
+	float value;
+	/* FIXME: Assumes 32 bit int.  */
+	unsigned int word;
+} ieee_float_shape_type;
+
+typedef union
+{
+	double value;
+	struct
+	{
+		glm::detail::int32 lsw;
+		glm::detail::int32 msw;
+	} parts;
+} ieee_double_shape_type;
+
+#define GLM_EXTRACT_WORDS(ix0,ix1,d)                                \
+do {                                                            \
+  ieee_double_shape_type ew_u;                                  \
+  ew_u.value = (d);                                             \
+  (ix0) = ew_u.parts.msw;                                       \
+  (ix1) = ew_u.parts.lsw;                                       \
+} while (0)
+
+#define GLM_GET_FLOAT_WORD(i,d)                                     \
+do {                                                            \
+  ieee_float_shape_type gf_u;                                   \
+  gf_u.value = (d);                                             \
+  (i) = gf_u.word;                                              \
+} while (0)
+
+#define GLM_SET_FLOAT_WORD(d,i)                                     \
+do {                                                            \
+  ieee_float_shape_type sf_u;                                   \
+  sf_u.word = (i);                                              \
+  (d) = sf_u.value;                                             \
+} while (0)
+
+#define GLM_INSERT_WORDS(d,ix0,ix1)                                 \
+do {                                                            \
+  ieee_double_shape_type iw_u;                                  \
+  iw_u.parts.msw = (ix0);                                       \
+  iw_u.parts.lsw = (ix1);                                       \
+  (d) = iw_u.value;                                             \
+} while (0)
+
+namespace glm{
+namespace detail
+{
+	GLM_FUNC_QUALIFIER float nextafterf(float x, float y)
+	{
+		volatile float t;
+		glm::detail::int32 hx, hy, ix, iy;
+
+		GLM_GET_FLOAT_WORD(hx,x);
+		GLM_GET_FLOAT_WORD(hy,y);
+		ix = hx&0x7fffffff;             // |x|
+		iy = hy&0x7fffffff;             // |y|
+
+		if((ix>0x7f800000) ||   // x is nan 
+			(iy>0x7f800000))     // y is nan 
+			return x+y;
+		if(x==y) return y;              // x=y, return y
+		if(ix==0) {                             // x == 0
+			GLM_SET_FLOAT_WORD(x,(hy&0x80000000)|1);// return +-minsubnormal
+			t = x*x;
+			if(t==x) return t; else return x;   // raise underflow flag
+		}
+		if(hx>=0) {                             // x > 0 
+			if(hx>hy) {                         // x > y, x -= ulp
+				hx -= 1;
+			} else {                            // x < y, x += ulp
+				hx += 1;
+			}
+		} else {                                // x < 0
+			if(hy>=0||hx>hy){                   // x < y, x -= ulp
+				hx -= 1;
+			} else {                            // x > y, x += ulp
+				hx += 1;
+			}
+		}
+		hy = hx&0x7f800000;
+		if(hy>=0x7f800000) return x+x;  // overflow
+		if(hy<0x00800000) {             // underflow
+			t = x*x;
+			if(t!=x) {          // raise underflow flag
+				GLM_SET_FLOAT_WORD(y,hx);
+				return y;
+			}
+		}
+		GLM_SET_FLOAT_WORD(x,hx);
+		return x;
+	}
+
+	GLM_FUNC_QUALIFIER double nextafter(double x, double y)
+	{
+		volatile double t;
+		glm::detail::int32 hx, hy, ix, iy;
+		glm::detail::uint32 lx, ly;
+
+		GLM_EXTRACT_WORDS(hx, lx, x);
+		GLM_EXTRACT_WORDS(hy, ly, y);
+		ix = hx & 0x7fffffff;             // |x| 
+		iy = hy & 0x7fffffff;             // |y| 
+
+		if(((ix>=0x7ff00000)&&((ix-0x7ff00000)|lx)!=0) ||   // x is nan
+			((iy>=0x7ff00000)&&((iy-0x7ff00000)|ly)!=0))     // y is nan
+			return x+y;
+		if(x==y) return y;              // x=y, return y
+		if((ix|lx)==0) {                        // x == 0 
+			GLM_INSERT_WORDS(x, hy & 0x80000000, 1);    // return +-minsubnormal
+			t = x*x;
+			if(t==x) return t; else return x;   // raise underflow flag 
+		}
+		if(hx>=0) {                             // x > 0 
+			if(hx>hy||((hx==hy)&&(lx>ly))) {    // x > y, x -= ulp 
+				if(lx==0) hx -= 1;
+				lx -= 1;
+			} else {                            // x < y, x += ulp
+				lx += 1;
+				if(lx==0) hx += 1;
+			}
+		} else {                                // x < 0 
+			if(hy>=0||hx>hy||((hx==hy)&&(lx>ly))){// x < y, x -= ulp
+				if(lx==0) hx -= 1;
+				lx -= 1;
+			} else {                            // x > y, x += ulp
+				lx += 1;
+				if(lx==0) hx += 1;
+			}
+		}
+		hy = hx&0x7ff00000;
+		if(hy>=0x7ff00000) return x+x;  // overflow
+		if(hy<0x00100000) {             // underflow
+			t = x*x;
+			if(t!=x) {          // raise underflow flag
+				GLM_INSERT_WORDS(y,hx,lx);
+				return y;
+			}
+		}
+		GLM_INSERT_WORDS(x,hx,lx);
+		return x;
+	}
+}//namespace detail
+}//namespace glm
+
+#if(GLM_COMPILER & GLM_COMPILER_VC)
+#	define GLM_NEXT_AFTER_FLT(x, toward) glm::detail::nextafterf((x), (toward))
+#   define GLM_NEXT_AFTER_DBL(x, toward) _nextafter((x), (toward))
+#else
+#   define GLM_NEXT_AFTER_FLT(x, toward) nextafterf((x), (toward))
+#   define GLM_NEXT_AFTER_DBL(x, toward) nextafter((x), (toward))
+#endif
+
+namespace glm{
+namespace gtx{
+namespace ulp
+{
+    GLM_FUNC_QUALIFIER float next_float(float const & x)
+    {
+        return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::max());
+    }
+
+    GLM_FUNC_QUALIFIER double next_float(double const & x)
+    {
+        return GLM_NEXT_AFTER_DBL(x, std::numeric_limits<double>::max());
+    }
+
+    template<typename T, template<typename> class vecType>
+    GLM_FUNC_QUALIFIER vecType<T> next_float(vecType<T> const & x)
+    {
+        vecType<T> Result;
+        for(std::size_t i = 0; i < Result.length(); ++i)
+            Result[i] = next_float(x[i]);
+        return Result;
+    }
+
+    GLM_FUNC_QUALIFIER float prev_float(float const & x)
+    {
+        return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::min());
+    }
+
+    GLM_FUNC_QUALIFIER double prev_float(double const & x)
+    {
+        return GLM_NEXT_AFTER_DBL(x, std::numeric_limits<double>::min());
+    }
+
+    template<typename T, template<typename> class vecType>
+    GLM_FUNC_QUALIFIER vecType<T> prev_float(vecType<T> const & x)
+    {
+        vecType<T> Result;
+        for(std::size_t i = 0; i < Result.length(); ++i)
+            Result[i] = prev_float(x[i]);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T next_float(T const & x, uint const & ulps)
+    {
+        T temp = x;
+        for(std::size_t i = 0; i < ulps; ++i)
+            temp = next_float(temp);
+        return temp;
+    }
+
+    template<typename T, template<typename> class vecType>
+    GLM_FUNC_QUALIFIER vecType<T> next_float(vecType<T> const & x, vecType<uint> const & ulps)
+    {
+        vecType<T> Result;
+        for(std::size_t i = 0; i < Result.length(); ++i)
+            Result[i] = next_float(x[i], ulps[i]);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER T prev_float(T const & x, uint const & ulps)
+    {
+        T temp = x;
+        for(std::size_t i = 0; i < ulps; ++i)
+            temp = prev_float(temp);
+        return temp;
+    }
+
+    template<typename T, template<typename> class vecType>
+    GLM_FUNC_QUALIFIER vecType<T> prev_float(vecType<T> const & x, vecType<uint> const & ulps)
+    {
+        vecType<T> Result;
+        for(std::size_t i = 0; i < Result.length(); ++i)
+            Result[i] = prev_float(x[i], ulps[i]);
+        return Result;
+    }
+
+    template <typename T>
+    GLM_FUNC_QUALIFIER uint float_distance(T const & x, T const & y)
+    {
+        uint ulp = 0;
+
+        if(x < y)
+        {
+            T temp = x;
+            while(temp != y && ulp < std::numeric_limits<std::size_t>::max())
+            {
+                ++ulp;
+                temp = next_float(temp);
+            }
+        }
+        else if(y < x)
+        {
+            T temp = y;
+            while(temp != x && ulp < std::numeric_limits<std::size_t>::max())
+            {
+                ++ulp;
+                temp = next_float(temp);
+            }
+        }
+        else // ==
+        {
+
+        }
+
+        return ulp;
+    }
+
+    template<typename T, template<typename> class vecType>
+    GLM_FUNC_QUALIFIER vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y)
+    {
+        vecType<uint> Result;
+        for(std::size_t i = 0; i < Result.length(); ++i)
+            Result[i] = float_distance(x[i], y[i]);
+        return Result;
+    }
+/*
+	inline std::size_t ulp
+	(
+		detail::thalf const & a,
+		detail::thalf const & b
+	)
+	{
+		std::size_t Count = 0;
+		float TempA(a);
+		float TempB(b);
+		//while((TempA = _nextafterf(TempA, TempB)) != TempB)
+			++Count;
+		return Count;
+	}
+
+	inline std::size_t ulp
+	(
+		float const & a,
+		float const & b
+	)
+	{
+		std::size_t Count = 0;
+		float Temp = a;
+		//while((Temp = _nextafterf(Temp, b)) != b)
+        {
+            std::cout << Temp << " " << b << std::endl;
+			++Count;
+        }
+		return Count;
+	}
+
+	inline std::size_t ulp
+	(
+		double const & a,
+		double const & b
+	)
+	{
+		std::size_t Count = 0;
+		double Temp = a;
+		//while((Temp = _nextafter(Temp, b)) != b)
+        {
+            std::cout << Temp << " " << b << std::endl;
+			++Count;
+        }
+		return Count;
+	}
+
+	template <typename T>
+	inline std::size_t ulp
+	(
+		detail::tvec2<T> const & a,
+		detail::tvec2<T> const & b
+	)
+	{
+        std::size_t ulps[] = 
+        {
+            ulp(a[0], b[0]),
+            ulp(a[1], b[1])
+        };
+
+        return glm::max(ulps[0], ulps[1]);
+	}
+
+	template <typename T>
+	inline std::size_t ulp
+	(
+		detail::tvec3<T> const & a,
+		detail::tvec3<T> const & b
+	)
+	{
+        std::size_t ulps[] = 
+        {
+            ulp(a[0], b[0]),
+            ulp(a[1], b[1]),
+            ulp(a[2], b[2])
+        };
+
+        return glm::max(glm::max(ulps[0], ulps[1]), ulps[2]);
+	}
+
+	template <typename T>
+	inline std::size_t ulp
+	(
+		detail::tvec4<T> const & a,
+		detail::tvec4<T> const & b
+	)
+	{
+        std::size_t ulps[] = 
+        {
+            ulp(a[0], b[0]),
+            ulp(a[1], b[1]),
+            ulp(a[2], b[2]),
+            ulp(a[3], b[3])
+        };
+
+        return glm::max(glm::max(ulps[0], ulps[1]), glm::max(ulps[2], ulps[3]));
+	}
+*/
+}//namespace ulp
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/unsigned_int.hpp b/ExternalLibs/glm/gtx/unsigned_int.hpp
new file mode 100644
index 0000000..2f840ff
--- /dev/null
+++ b/ExternalLibs/glm/gtx/unsigned_int.hpp
@@ -0,0 +1,59 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-24
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/unsigned_int.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_integer
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_unsigned_int
+#define glm_gtx_unsigned_int
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/integer.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_unsigned_int extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
+{
+	using namespace gtx::integer;
+
+	/// \addtogroup gtx_unsigned_int
+	/// @{
+
+	//! 32bit signed integer. 
+	//! From GLM_GTX_unsigned_int extension.
+	typedef signed int					sint;
+
+	//! Returns x raised to the y power.
+	//! From GLM_GTX_unsigned_int extension.
+	uint pow(uint x, uint y);
+
+	//! Returns the positive square root of x. 
+	//! From GLM_GTX_unsigned_int extension.
+	uint sqrt(uint x);
+
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
+	//! From GLM_GTX_unsigned_int extension.
+	uint mod(uint x, uint y);
+
+	/// @}
+}//namespace unsigned_int
+}//namespace gtx
+}//namespace glm
+
+#include "unsigned_int.inl"
+
+namespace glm{using namespace gtx::unsigned_int;}
+
+#endif//glm_gtx_unsigned_int
diff --git a/ExternalLibs/glm/gtx/unsigned_int.inl b/ExternalLibs/glm/gtx/unsigned_int.inl
new file mode 100644
index 0000000..7141918
--- /dev/null
+++ b/ExternalLibs/glm/gtx/unsigned_int.inl
@@ -0,0 +1,45 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-24
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/unsigned_int.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace unsigned_int{
+
+GLM_FUNC_QUALIFIER uint pow(uint x, uint y)
+{
+    uint result = x;
+    for(uint i = 1; i < y; ++i)
+        result *= x;
+    return result;
+}
+
+GLM_FUNC_QUALIFIER uint sqrt(uint x)
+{
+    if(x <= 1) return x;
+
+    uint NextTrial = x >> 1;
+    uint CurrentAnswer;
+
+    do
+    {
+        CurrentAnswer = NextTrial;
+        NextTrial = (NextTrial + x / NextTrial) >> 1;
+    } while(NextTrial < CurrentAnswer);
+
+    return CurrentAnswer;
+}
+
+GLM_FUNC_QUALIFIER uint mod(uint x, uint y)
+{
+	return x - y * (x / y);
+}
+
+}//namespace unsigned_int
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/vec1.hpp b/ExternalLibs/glm/gtx/vec1.hpp
new file mode 100644
index 0000000..1243b33
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vec1.hpp
@@ -0,0 +1,121 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2010-02-08
+// Updated : 2010-02-08
+// Licence : This source is under MIT License
+// File    : glm/gtx/vec1.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_vec1
+#define glm_gtx_vec1
+
+// Dependency:
+#include "../glm.hpp"
+#include "../core/type_vec1.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_vec1 extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
+namespace precision
+{
+	//! 1 component vector of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::highp_vec1_t			highp_vec1;
+	//! 1 component vector of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::mediump_vec1_t			mediump_vec1;
+	//! 1 component vector of low precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::lowp_vec1_t				lowp_vec1;
+
+	//! 1 component vector of high precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::highp_ivec1_t			highp_ivec1;
+	//! 1 component vector of medium precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::mediump_ivec1_t			mediump_ivec1;
+	//! 1 component vector of low precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::lowp_ivec1_t			lowp_ivec1;
+
+	//! 1 component vector of high precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::highp_uvec1_t			highp_uvec1;
+	//! 1 component vector of medium precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::mediump_uvec1_t			mediump_uvec1;
+	//! 1 component vector of low precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::lowp_uvec1_t			lowp_uvec1;
+}//namespace precision
+
+	//////////////////////////
+	// vec1 definition
+
+	//! 1 component vector of boolean.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::tvec1<bool>	bvec1;
+
+#if(defined(GLM_PRECISION_HIGHP_FLOAT))
+	typedef precision::highp_vec1			vec1;
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	typedef precision::mediump_vec1			vec1;
+#elif(defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef precision::lowp_vec1			vec1;
+#else
+	//! 1 component vector of floating-point numbers.
+	//! From GLM_GTX_vec1 extension.
+	typedef precision::mediump_vec1			vec1;
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_HIGHP_INT))
+	typedef precision::highp_ivec1			ivec1;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef precision::mediump_ivec1		ivec1;
+#elif(defined(GLM_PRECISION_LOWP_INT))
+	typedef precision::lowp_ivec1			ivec1;
+#else
+	//! 1 component vector of signed integer numbers. 
+	//! From GLM_GTX_vec1 extension.
+	typedef precision::mediump_ivec1		ivec1;
+#endif//GLM_PRECISION
+
+#if(defined(GLM_PRECISION_HIGHP_UINT))
+	typedef precision::highp_uvec1			uvec1;
+#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
+	typedef precision::mediump_uvec1		uvec1;
+#elif(defined(GLM_PRECISION_LOWP_UINT))
+	typedef precision::lowp_uvec1			uvec1;
+#else
+	//! 1 component vector of unsigned integer numbers. 
+	//! From GLM_GTX_vec1 extension.
+	typedef precision::mediump_uvec1		uvec1;
+#endif//GLM_PRECISION
+
+}// namespace vec1
+}// namespace gtx
+}// namespace glm
+
+#include "vec1.inl"
+
+namespace glm{using namespace gtx::vector1;}
+
+#endif//glm_gtx_vec1
+
diff --git a/ExternalLibs/glm/gtx/vec1.inl b/ExternalLibs/glm/gtx/vec1.inl
new file mode 100644
index 0000000..e69de29
diff --git a/ExternalLibs/glm/gtx/vector_access.hpp b/ExternalLibs/glm/gtx/vector_access.hpp
new file mode 100644
index 0000000..1d40dfe
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vector_access.hpp
@@ -0,0 +1,66 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-16
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/vector_access.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_vector_access
+#define glm_gtx_vector_access
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_vector_access extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
+{
+	/// \addtogroup gtx_vector_access
+	/// @{
+
+	//! Set values to a 2 components vector.
+	//! From GLM_GTX_vector_access extension.
+    template <typename valType> 
+	void set(
+		detail::tvec2<valType> & v, 
+		valType const & x, 
+		valType const & y);
+
+	//! Set values to a 3 components vector.
+	//! From GLM_GTX_vector_access extension.
+    template <typename valType> 
+	void set(
+		detail::tvec3<valType> & v, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z);
+
+	//! Set values to a 4 components vector.
+	//! From GLM_GTX_vector_access extension.
+    template <typename valType> 
+	void set(
+		detail::tvec4<valType> & v, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z, 
+		valType const & w);
+
+	/// @}
+}//namespace vector_access
+}//namespace gtx
+}//namespace glm
+
+#include "vector_access.inl"
+
+namespace glm{using namespace gtx::vector_access;}
+
+#endif//glm_gtx_vector_access
diff --git a/ExternalLibs/glm/gtx/vector_access.inl b/ExternalLibs/glm/gtx/vector_access.inl
new file mode 100644
index 0000000..cf86f58
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vector_access.inl
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-01-16
+// Updated : 2008-10-07
+// Licence : This source is under MIT License
+// File    : glm/gtx/vector_access.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace vector_access{
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER void set
+(
+	detail::tvec2<valType>& v, 
+	valType const & x, 
+	valType const & y
+)
+{
+    v.x = x;
+    v.y = y;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER void set
+(
+	detail::tvec3<valType>& v, 
+	valType const & x, 
+	valType const & y, 
+	valType const & z
+)
+{
+    v.x = x;
+    v.y = y;
+    v.z = z;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER void set
+(
+	detail::tvec4<valType>& v, 
+	valType const & x, 
+	valType const & y, 
+	valType const & z, 
+	valType const & w
+)
+{
+    v.x = x;
+    v.y = y;
+    v.z = z;
+    v.w = w;
+}
+
+}//namespace vector_access
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/vector_angle.hpp b/ExternalLibs/glm/gtx/vector_angle.hpp
new file mode 100644
index 0000000..743b36d
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vector_angle.hpp
@@ -0,0 +1,72 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-30
+// Updated : 2006-11-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/vector_angle.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_quaternion
+// - GLM_GTX_epsilon
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_vector_angle
+#define glm_gtx_vector_angle
+
+// Dependency:
+#include "../glm.hpp"
+#include "../gtx/epsilon.hpp"
+#include "../gtx/quaternion.hpp"
+#include "../gtx/rotate_vector.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_vector_angle extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
+{
+	using namespace quaternion;
+	using namespace epsilon;
+
+	/// \addtogroup gtx_vector_angle
+	///@{
+
+	//! Returns the absolute angle between two vectors
+	//! Parameters need to be normalized.
+	//! From GLM_GTX_vector_angle extension
+	template <typename vecType> 
+	GLM_FUNC_QUALIFIER typename vecType::value_type angle(
+		vecType const & x, 
+		vecType const & y);
+
+	//! Returns the oriented angle between two 2d vectors 
+	//! Parameters need to be normalized.
+	//! From GLM_GTX_vector_angle extension.
+	template <typename T> 
+	GLM_FUNC_QUALIFIER T orientedAngle(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y);
+
+	//! Returns the oriented angle between two 3d vectors based from a reference axis.
+	//! Parameters need to be normalized.
+	//! From GLM_GTX_vector_angle extension.
+	template <typename T>
+	GLM_FUNC_QUALIFIER T orientedAngle(
+		detail::tvec3<T> const & x,
+		detail::tvec3<T> const & y,
+		detail::tvec3<T> const & ref);
+
+	/// @}
+}// namespace vector_angle
+}// namespace gtx
+}// namespace glm
+
+#include "vector_angle.inl"
+
+namespace glm{using namespace gtx::vector_angle;}
+
+#endif//glm_gtx_vector_angle
diff --git a/ExternalLibs/glm/gtx/vector_angle.inl b/ExternalLibs/glm/gtx/vector_angle.inl
new file mode 100644
index 0000000..05df114
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vector_angle.inl
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2005-12-30
+// Updated : 2008-09-29
+// Licence : This source is under MIT License
+// File    : glm/gtx/vector_angle.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace vector_angle{
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER typename genType::value_type angle
+(
+	genType const & x, 
+	genType const & y
+)
+{
+	return degrees(acos(dot(x, y)));
+}
+
+//! \todo epsilon is hard coded to 0.01
+template <typename valType> 
+GLM_FUNC_QUALIFIER valType orientedAngle
+(
+	detail::tvec2<valType> const & x, 
+	detail::tvec2<valType> const & y
+)
+{
+    valType Angle = glm::degrees(acos(dot(x, y)));
+	detail::tvec2<valType> TransformedVector = glm::gtx::rotate_vector::rotate(x, Angle);
+    if(all(equalEpsilon(y, TransformedVector, valType(0.01))))
+		return Angle;
+    else
+        return -Angle;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER valType orientedAngle
+(
+	detail::tvec3<valType> const & x,
+	detail::tvec3<valType> const & y,
+	detail::tvec3<valType> const & ref
+)
+{
+	valType Angle = glm::degrees(glm::acos(glm::dot(x, y)));
+
+	if(glm::dot(ref, glm::cross(x, y)) < valType(0))
+		return -Angle;
+	else
+		return Angle;
+}
+
+}//namespace vector_angle
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/vector_query.hpp b/ExternalLibs/glm/gtx/vector_query.hpp
new file mode 100644
index 0000000..06d9097
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vector_query.hpp
@@ -0,0 +1,95 @@
+ ///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-05
+// Updated : 2007-03-05
+// Licence : This source is under MIT License
+// File    : glm/gtx/vector_query.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_vector_query
+#define glm_gtx_vector_query
+
+// Dependency:
+#include "../glm.hpp"
+#include <cfloat>
+#include <limits>
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_vector_query extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
+{
+	/// \addtogroup gtx_vector_query
+	/// @{
+
+	//! Check if two vectors are collinears.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areCollinear(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		
+    //! Check if two vectors are opposites.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areOpposite(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		
+    //! Check if two vectors are orthogonals.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areOrthogonal(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+
+	//! Check if a vector is normalized.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool isNormalized(
+		genType const & v, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+		
+	//! Check if a vector is null.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool isNull(
+		genType const & v, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+
+	//! Check if two vectors are orthonormal.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType>
+	bool areOrthonormal(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+
+	//! Check if two vectors are similar.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areSimilar(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+
+	/// @}
+}// namespace vector_query
+}// namespace gtx
+}// namespace glm
+
+#include "vector_query.inl"
+
+namespace glm{using namespace gtx::vector_query;}
+
+#endif//glm_gtx_vector_query
diff --git a/ExternalLibs/glm/gtx/vector_query.inl b/ExternalLibs/glm/gtx/vector_query.inl
new file mode 100644
index 0000000..4745c08
--- /dev/null
+++ b/ExternalLibs/glm/gtx/vector_query.inl
@@ -0,0 +1,174 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-03-05
+// Updated : 2010-02-16
+// Licence : This source is under MIT License
+// File    : glm/gtx/vector_query.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <cassert>
+
+namespace glm{
+namespace gtx{
+namespace vector_query
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER bool areCollinear
+	(
+		detail::tvec2<T> const & v0, 
+		detail::tvec2<T> const & v1, 
+		T const & epsilon
+	)
+	{
+		return length(cross(detail::tvec3<T>(v0, T(0)), detail::tvec3<T>(v1, T(0)))) < epsilon;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER bool areCollinear
+	(
+		detail::tvec3<T> const & v0, 
+		detail::tvec3<T> const & v1, 
+		T const & epsilon
+	)
+	{
+		return length(cross(v0, v1)) < epsilon;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER bool areCollinear
+	(
+		detail::tvec4<T> const & v0, 
+		detail::tvec4<T> const & v1, 
+		T const & epsilon
+	)
+	{
+		return length(cross(detail::tvec3<T>(v0), detail::tvec3<T>(v1))) < epsilon;
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER bool areOpposite
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
+	{
+		assert(isNormalized(v0) && isNormalized(v1));
+        return((typename genType::value_type(1) + dot(v0, v1)) <= epsilon);
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER bool areOrthogonal
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
+	{
+		return abs(dot(v0, v1)) <= max(
+			typename genType::value_type(1), 
+			length(v0)) * max(
+				typename genType::value_type(1), 
+				length(v1)) * epsilon;
+	}
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER bool isNormalized
+	(
+		genType const & v, 
+		typename genType::value_type const & epsilon
+	)
+	{
+		return abs(length(v) - typename genType::value_type(1)) <= typename genType::value_type(2) * epsilon;
+	}
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER bool isNull
+	(
+		genType const & v, 
+		typename genType::value_type const & epsilon
+	)
+	{
+		return length(v) <= epsilon;
+	}
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER bool isCompNull
+	(
+		T const & s, 
+		T const & epsilon
+	)
+    {
+        return abs(s) < epsilon;
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec2<bool> isCompNull
+	(
+		detail::tvec2<T> const & v, 
+		T const & epsilon)
+    {
+        return detail::tvec2<bool>(
+            (abs(v.x) < epsilon),
+            (abs(v.y) < epsilon));
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec3<bool> isCompNull
+	(
+		detail::tvec3<T> const & v, 
+		T const & epsilon
+	)
+    {
+        return detail::tvec3<bool>(
+            abs(v.x) < epsilon,
+            abs(v.y) < epsilon,
+            abs(v.z) < epsilon);
+    }
+
+    template <typename T> 
+    GLM_FUNC_QUALIFIER detail::tvec4<bool> isCompNull
+	(
+		detail::tvec4<T> const & v, 
+		T const & epsilon
+	)
+    {
+        return detail::tvec4<bool>(
+            abs(v.x) < epsilon,
+            abs(v.y) < epsilon,
+            abs(v.z) < epsilon,
+            abs(v.w) < epsilon);
+    }
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER bool areOrthonormal
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
+	{
+		return isNormalized(v0, epsilon) && isNormalized(v1, epsilon) && (abs(dot(v0, v1)) <= epsilon);
+	}
+
+	template <typename genType>
+	GLM_FUNC_QUALIFIER bool areSimilar
+	(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon
+	)
+	{
+		bool similar = true;
+        for(typename genType::size_type i = 0; similar && i < genType::value_size(); i++)
+			similar = (abs(v0[i] - v1[i]) <= epsilon);
+		return similar;
+	}
+
+}//namespace vector_query
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/verbose_operator.hpp b/ExternalLibs/glm/gtx/verbose_operator.hpp
new file mode 100644
index 0000000..ecd336e
--- /dev/null
+++ b/ExternalLibs/glm/gtx/verbose_operator.hpp
@@ -0,0 +1,64 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2007-05-21
+// Updated : 2007-05-21
+// Licence : This source is under MIT License
+// File    : glm/gtx/verbose_operator.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_verbose_operator
+#define glm_gtx_verbose_operator
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_verbose_operator extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
+{
+	/// \addtogroup gtx_verbose_operator
+	/// @{
+
+	//! Addition of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT add(genTypeT const & a, genTypeU const & b);
+
+	//! Substration of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT sub(genTypeT const & a, genTypeU const & b);
+
+	//! Multiplication of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT mul(genTypeT const & a, genTypeU const & b);
+
+	//! Division of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT div(genTypeT const & a, genTypeU const & b);
+
+	//! Multiplication and addition of three values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU, typename genTypeV> 
+	genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
+
+	/// @}
+}// namespace verbose_operator
+}// namespace gtx
+}// namespace glm
+
+#include "verbose_operator.inl"
+
+namespace glm{using namespace gtx::verbose_operator;}
+
+#endif//glm_gtx_verbose_operator
diff --git a/ExternalLibs/glm/gtx/verbose_operator.inl b/ExternalLibs/glm/gtx/verbose_operator.inl
new file mode 100644
index 0000000..e806462
--- /dev/null
+++ b/ExternalLibs/glm/gtx/verbose_operator.inl
@@ -0,0 +1,129 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2006-04-20
+// Updated : 2008-09-29
+// Licence : This source is under MIT License
+// File    : glm/gtx/verbose_operator.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace verbose_operator{
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType add(genType const & a, genType const & b)
+{
+    return a + b;
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType sub(genType const & a, genType const & b)
+{
+    return a - b;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat2x2<T> mul
+(
+	detail::tmat2x2<T> const & a, 
+	detail::tmat2x2<T> const & b
+)
+{
+    return a * b;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> mul
+(
+	detail::tmat3x3<T> const & a, 
+	detail::tmat3x3<T> const & b
+)
+{
+    return a * b;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> mul
+(
+	detail::tmat4x4<T> const & a, 
+	detail::tmat4x4<T> const & b
+)
+{
+    return a * b;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> mul
+(
+	detail::tmat2x2<T> const & m, 
+	detail::tvec2<T> const & v
+)
+{
+    return m * v;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> mul
+(
+	detail::tmat3x3<T> const & m, 
+	detail::tvec3<T> const & v)
+{
+    return m * v;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> mul
+(
+	detail::tmat4x4<T> const & m, 
+	detail::tvec4<T> const & v
+)
+{
+    return m * v;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> mul
+(
+	detail::tvec2<T> const & v, 
+	detail::tmat2x2<T> const & m
+)
+{
+    return v * m;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> mul
+(
+	detail::tvec3<T> const & v, 
+	detail::tmat3x3<T> const & m
+)
+{
+    return v * m;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> mul
+(
+	detail::tvec4<T> const & v, 
+	detail::tmat4x4<T> const & m
+)
+{
+    return v * m;
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType div(genType const & a, genType const & b)
+{
+    return a / b;
+}
+
+template <typename genTypeT, typename genTypeU, typename genTypeV> 
+GLM_FUNC_QUALIFIER genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c)
+{
+	return a * b + c;
+}
+
+}//namespace verbose_operator
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/gtx/wrap.hpp b/ExternalLibs/glm/gtx/wrap.hpp
new file mode 100644
index 0000000..e0d0e0f
--- /dev/null
+++ b/ExternalLibs/glm/gtx/wrap.hpp
@@ -0,0 +1,54 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-11-25
+// Updated : 2009-11-25
+// Licence : This source is under MIT License
+// File    : glm/gtx/wrap.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef glm_gtx_wrap
+#define glm_gtx_wrap
+
+// Dependency:
+#include "../glm.hpp"
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_GTX_wrap extension included")
+#endif
+
+namespace glm{
+namespace gtx{
+namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
+{
+	/// \addtogroup gtx_wrap
+	/// @{
+
+	//! Simulate GL_CLAMP OpenGL wrap mode
+	//! From GLM_GTX_wrap extension.
+	template <typename genType> 
+	genType clamp(genType const & Texcoord);
+
+	//! Simulate GL_REPEAT OpenGL wrap mode
+	//! From GLM_GTX_wrap extension.
+	template <typename genType> 
+	genType repeat(genType const & Texcoord);
+
+	//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
+	//! From GLM_GTX_wrap extension.
+	template <typename genType> 
+	genType mirrorRepeat(genType const & Texcoord);
+
+	/// @}
+}// namespace wrap
+}// namespace gtx
+}// namespace glm
+
+#include "wrap.inl"
+
+namespace glm{using namespace gtx::wrap;}
+
+#endif//glm_img_wrap
diff --git a/ExternalLibs/glm/gtx/wrap.inl b/ExternalLibs/glm/gtx/wrap.inl
new file mode 100644
index 0000000..0aaa40c
--- /dev/null
+++ b/ExternalLibs/glm/gtx/wrap.inl
@@ -0,0 +1,173 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2009-11-25
+// Updated : 2010-02-13
+// Licence : This source is under MIT License
+// File    : glm/gtx/wrap.inl
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+namespace glm{
+namespace gtx{
+namespace wrap
+{
+	////////////////////////
+	// clamp
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER genType clamp
+	(
+		genType const & Texcoord
+	)
+	{
+		return glm::clamp(Texcoord, genType(0), genType(1));
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec2<T> clamp
+	(
+		detail::tvec2<T> const & Texcoord
+	)
+	{
+		detail::tvec2<T> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = clamp(Texcoord[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> clamp
+	(
+		detail::tvec3<T> const & Texcoord
+	)
+	{
+		detail::tvec3<T> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = clamp(Texcoord[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> clamp
+	(
+		detail::tvec4<T> const & Texcoord
+	)
+	{
+		detail::tvec4<T> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = clamp(Texcoord[i]);
+		return Result;
+	}
+
+	////////////////////////
+	// repeat
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER genType repeat
+	(
+		genType const & Texcoord
+	)
+	{
+		return glm::fract(Texcoord);
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec2<T> repeat
+	(
+		detail::tvec2<T> const & Texcoord
+	)
+	{
+		detail::tvec2<T> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = repeat(Texcoord[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> repeat
+	(
+		detail::tvec3<T> const & Texcoord
+	)
+	{
+		detail::tvec3<T> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = repeat(Texcoord[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> repeat
+	(
+		detail::tvec4<T> const & Texcoord
+	)
+	{
+		detail::tvec4<T> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = repeat(Texcoord[i]);
+		return Result;
+	}
+
+	////////////////////////
+	// mirrorRepeat
+
+	template <typename genType> 
+	GLM_FUNC_QUALIFIER genType mirrorRepeat
+	(
+		genType const & Texcoord
+	)
+	{
+		genType const Clamp = genType(int(glm::floor(Texcoord)) % 2);
+		genType const Floor = glm::floor(Texcoord);
+		genType const Rest = Texcoord - Floor;
+		genType const Mirror = Clamp + Rest;
+
+		genType Out;
+		if(Mirror >= genType(1))
+			Out = genType(1) - Rest;
+		else
+			Out = Rest;
+		return Out;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec2<T> mirrorRepeat
+	(
+		detail::tvec2<T> const & Texcoord
+	)
+	{
+		detail::tvec2<T> Result;
+		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+			Result[i] = mirrorRepeat(Texcoord[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec3<T> mirrorRepeat
+	(
+		detail::tvec3<T> const & Texcoord
+	)
+	{
+		detail::tvec3<T> Result;
+		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+			Result[i] = mirrorRepeat(Texcoord[i]);
+		return Result;
+	}
+
+	template <typename T> 
+	GLM_FUNC_QUALIFIER detail::tvec4<T> mirrorRepeat
+	(
+		detail::tvec4<T> const & Texcoord
+	)
+	{
+		detail::tvec4<T> Result;
+		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+			Result[i] = mirrorRepeat(Texcoord[i]);
+		return Result;
+	}
+
+}//namespace wrap
+}//namespace gtx
+}//namespace glm
diff --git a/ExternalLibs/glm/virtrev/xstream.hpp b/ExternalLibs/glm/virtrev/xstream.hpp
new file mode 100644
index 0000000..1f19dae
--- /dev/null
+++ b/ExternalLibs/glm/virtrev/xstream.hpp
@@ -0,0 +1,148 @@
+#ifndef GLM_EXT_VIRTREV_XSTREAM_HPP
+#define GLM_EXT_VIRTREV_XSTREAM_HPP
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
+// Virtrev SDK copyright matrem (matrem84.free.fr)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2008-05-24
+// Updated : 2008-05-26
+// Licence : This source is under MIT License
+// File    : glm/ext/virtrev/xstream.hpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Dependency:
+// - GLM core
+// - GLM_GTX_matrix_selection
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "../glm.hpp"
+#include "../gtc/matrix_access.hpp"
+#include <iostream>
+
+#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#	pragma message("GLM: GLM_VIRTREV_xstream extension included")
+#endif
+
+namespace glm
+{
+	namespace virtrev_glmext
+	{
+		//! GLM_VIRTREV_xstream extension: Streaming vector and matrix in a xml way
+		namespace xstream
+		{
+			template<typename T>
+			std::ostream & operator << (std::ostream & stream, glm::detail::tvec2<T> const & vec)
+			{
+				stream << "<glm_vec2 ";
+				stream << "x=\"" << vec.x << "\" ";
+				stream << "y=\"" << vec.y << "\" ";
+				stream << "/>";
+
+				return stream;
+			}
+
+			template<typename T>
+			std::ostream & operator << (std::ostream & stream, glm::detail::tvec3<T> const & vec)
+			{
+				stream << "<glm_vec3 ";
+				stream << "x=\"" << vec.x << "\" ";
+				stream << "y=\"" << vec.y << "\" ";
+				stream << "z=\"" << vec.z << "\" ";
+				stream << "/>";
+
+				return stream;
+			}
+
+			template<typename T>
+			std::ostream & operator << (std::ostream & stream, glm::detail::tvec4<T> const & vec)
+			{
+				stream << "<glm_vec4 ";
+				stream << "x=\"" << vec.x << "\" ";
+				stream << "y=\"" << vec.y << "\" ";
+				stream << "z=\"" << vec.z << "\" ";
+				stream << "w=\"" << vec.w << "\" ";
+				stream << "/>";
+
+				return stream;
+			}
+
+			template<typename T>
+			std::ostream & operator << (std::ostream & stream, glm::detail::tmat2x2<T> const & mat)
+			{
+				stream << "<glm_mat2>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "</glm_mat2>";
+
+				return stream;
+			}
+
+			template<typename T>
+			std::ostream & operator << (std::ostream & stream, glm::detail::tmat3x3<T> const & mat)
+			{
+				stream << "<glm_mat3>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 0)[2] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 1)[2] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 2)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 2)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 2)[2] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "</glm_mat3>";
+
+				return stream;
+			}
+
+			template<typename T>
+			std::ostream & operator << (std::ostream & stream, glm::detail::tmat4x4<T> const & mat)
+			{
+				stream << "<glm_mat4>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 0)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 0)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 0)[2] << "\" ";
+				stream << "w=\"" << glm::row(mat, 0)[3] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 1)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 1)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 1)[2] << "\" ";
+				stream << "w=\"" << glm::row(mat, 1)[3] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 2)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 2)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 2)[2] << "\" ";
+				stream << "w=\"" << glm::row(mat, 2)[3] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "<row ";
+				stream << "x=\"" << glm::row(mat, 3)[0] << "\" ";
+				stream << "y=\"" << glm::row(mat, 3)[1] << "\" ";
+				stream << "z=\"" << glm::row(mat, 3)[2] << "\" ";
+				stream << "w=\"" << glm::row(mat, 3)[3] << "\" ";
+				stream << "/>" << std::endl;
+				stream << "</glm_mat4>";
+			
+				return stream;
+			}
+		}
+	}
+}
+
+namespace glm{using namespace glm::virtrev_glmext::xstream;}
+
+#endif//GLM_EXT_VIRTREV_XSTREAM_HPP
diff --git a/files/scripts/entities/predatorytunicate.lua b/files/scripts/entities/predatorytunicate.lua
index b6f6871..e4f9a20 100644
--- a/files/scripts/entities/predatorytunicate.lua
+++ b/files/scripts/entities/predatorytunicate.lua
@@ -143,27 +143,28 @@ function update(me, dt)
 		entity_setState(me, STATE_IDLE)
 	end
 	]]--
-	
-	if entity_isState(me, STATE_TRAP) and v.trappedEnt ~= 0 then
-		entity_setPosition(v.trappedEnt, v.hx, v.hy, 0.1)
+    
+	if v.trappedEnt ~= 0 then
 		if entity_isDead(v.trappedEnt) then
 			v.trappedEnt = 0
 			entity_setState(me, STATE_IDLE)
-		end		
-	elseif entity_isState(me, STATE_TRAPPED) and v.trappedEnt ~= 0 then
-		entity_setPosition(v.trappedEnt, v.hx, v.hy)
-		v.hurtTimer = v.hurtTimer + dt
-		if v.hurtTimer > 1 then
-			if entity_getEntityType(v.trappedEnt) == ET_ENEMY then
-				entity_damage(v.trappedEnt, me, 2, DT_ENEMY_TRAP)
-			else
-				entity_damage(v.trappedEnt, me, 1, DT_ENEMY_TRAP)
+		elseif entity_isState(me, STATE_TRAP) then
+			entity_setPosition(v.trappedEnt, v.hx, v.hy, 0.1)
+		elseif entity_isState(me, STATE_TRAPPED) then
+			entity_setPosition(v.trappedEnt, v.hx, v.hy)
+			v.hurtTimer = v.hurtTimer + dt
+			if v.hurtTimer > 1 then
+				if entity_getEntityType(v.trappedEnt) == ET_ENEMY then
+					entity_damage(v.trappedEnt, me, 2, DT_ENEMY_TRAP)
+				else
+					entity_damage(v.trappedEnt, me, 1, DT_ENEMY_TRAP)
+				end
+				if entity_isDead(v.trappedEnt) then
+					v.trappedEnt = 0
+					entity_setState(me, STATE_IDLE)
+				end
+				v.hurtTimer = 0
 			end
-			if entity_isDead(v.trappedEnt) then
-				v.trappedEnt = 0
-				entity_setState(me, STATE_IDLE)
-			end
-			v.hurtTimer = 0
 		end
 	end
 end
diff --git a/files/scripts/entities/spinycrab.lua b/files/scripts/entities/spinycrab.lua
index 3c56890..8ebab12 100644
--- a/files/scripts/entities/spinycrab.lua
+++ b/files/scripts/entities/spinycrab.lua
@@ -119,6 +119,9 @@ function enterState(me)
 		quad_alpha(v.glow, 0, 3)
 		bone_alpha(v.eyes, 0, 3)
 		entity_animate(me, "runAway", -1)
+	elseif entity_isState(me, STATE_DEAD) then
+		quad_delete(v.glow)
+		v.glow = 0
 	end
 end
 
diff --git a/win/vc90/Aquaria.vcproj b/win/vc90/Aquaria.vcproj
index 0b704d5..93b13a6 100644
--- a/win/vc90/Aquaria.vcproj
+++ b/win/vc90/Aquaria.vcproj
@@ -42,7 +42,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="0"
 				AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include\freetype\config&quot;;&quot;$(SolutionDir)\..\ExternalLibs\gl&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\zlib&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\png&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libogg-1.3.0\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libvorbis-1.3.3\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\FTGL\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\SDL2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\AL\include&quot;;&quot;$(SolutionDir)\..\BBGE&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lua-5.1.4\src&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs_cfileapi&quot;;&quot;$(SolutionDir)\..\ExternalLibs&quot;"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;BBGE_BUILD_VFS=1;VFS_ENABLE_C_API=1"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;BBGE_BUILD_VFS=1;VFS_ENABLE_C_API=1;BBGE_USE_GLM=1"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="0"
 				RuntimeLibrary="3"
@@ -124,7 +124,7 @@
 				OmitFramePointers="true"
 				EnableFiberSafeOptimizations="true"
 				AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include\freetype\config&quot;;&quot;$(SolutionDir)\..\ExternalLibs\gl&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\zlib&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\png&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libogg-1.3.0\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libvorbis-1.3.3\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\FTGL\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\SDL2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\AL\include&quot;;&quot;$(SolutionDir)\..\BBGE&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lua-5.1.4\src&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs_cfileapi&quot;;&quot;$(SolutionDir)\..\ExternalLibs&quot;"
-				PreprocessorDefinitions="WIN32;NDEBUG;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;_HAS_EXCEPTIONS=0;BBGE_BUILD_VFS=1;VFS_ENABLE_C_API=1"
+				PreprocessorDefinitions="WIN32;NDEBUG;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;_HAS_EXCEPTIONS=0;BBGE_BUILD_VFS=1;VFS_ENABLE_C_API=1;BBGE_USE_GLM=1"
 				StringPooling="true"
 				ExceptionHandling="0"
 				RuntimeLibrary="0"
diff --git a/win/vc90/BBGE.vcproj b/win/vc90/BBGE.vcproj
index 0d3d68d..266c422 100644
--- a/win/vc90/BBGE.vcproj
+++ b/win/vc90/BBGE.vcproj
@@ -43,7 +43,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="0"
 				AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include\freetype\config&quot;;&quot;$(SolutionDir)\..\ExternalLibs\gl&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\zlib&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\png&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libogg-1.3.0\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libvorbis-1.3.3\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\FTGL\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\SDL2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\AL\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs_cfileapi&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs&quot;"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;FTGL_LIBRARY_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;VFS_ENABLE_C_API=1"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;FTGL_LIBRARY_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;VFS_ENABLE_C_API=1;BBGE_USE_GLM=1"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="0"
 				RuntimeLibrary="3"
@@ -116,7 +116,7 @@
 				OmitFramePointers="true"
 				EnableFiberSafeOptimizations="true"
 				AdditionalIncludeDirectories="&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include\freetype\config&quot;;&quot;$(SolutionDir)\..\ExternalLibs\gl&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\zlib&quot;;&quot;$(SolutionDir)\..\ExternalLibs\glpng\png&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libogg-1.3.0\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\libvorbis-1.3.3\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\freetype2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\FTGL\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\SDL2\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\AL\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs&quot;;&quot;$(SolutionDir)\..\ExternalLibs\ttvfs_cfileapi&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa&quot;;&quot;$(SolutionDir)\..\ExternalLibs\lvpa\include&quot;;&quot;$(SolutionDir)\..\ExternalLibs&quot;"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;FTGL_LIBRARY_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;_HAS_EXCEPTIONS=0;VFS_ENABLE_C_API=1"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;GL_GLEXT_LEGACY=1;TIXML_USE_STL=1;HAVE_PUTENV=1;FTGL_LIBRARY_STATIC;_CRT_SECURE_NO_DEPRECATE;_CRT_SECURE_NO_WARNINGS;BBGE_BUILD_WINDOWS=1;_HAS_EXCEPTIONS=0;VFS_ENABLE_C_API=1;BBGE_USE_GLM=1"
 				StringPooling="true"
 				ExceptionHandling="0"
 				RuntimeLibrary="0"
@@ -396,6 +396,10 @@
 				RelativePath="..\..\BBGE\Rect.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\BBGE\Refcounted.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\BBGE\RenderObject.cpp"
 				>
@@ -416,14 +420,6 @@
 				RelativePath="..\..\BBGE\RenderRect.cpp"
 				>
 			</File>
-			<File
-				RelativePath="..\..\BBGE\Resource.cpp"
-				>
-			</File>
-			<File
-				RelativePath="..\..\BBGE\Resource.h"
-				>
-			</File>
 			<File
 				RelativePath="..\..\BBGE\RoundedRect.cpp"
 				>