From e9615a24e73f0c13c19d5948781a042b92ee578b Mon Sep 17 00:00:00 2001
From: leo <leozide@users.noreply.github.com>
Date: Mon, 28 May 2012 23:33:22 +0000
Subject: [PATCH] Store the view matrix for each camera.

---
 common/algebra.h       |   2 +
 common/camera.cpp      | 326 ++++++++++++++++-------------------
 common/camera.h        |  35 +---
 common/lc_math.h       | 272 ++++++++++++++++++++++++++++-
 common/project.cpp     | 379 +++++++++++++++++++----------------------
 common/project.h       |  15 +-
 common/terrain.cpp     |  13 +-
 common/typedefs.h      |  11 +-
 win/Mainfrm.cpp        |   2 +-
 win/propertiespane.cpp |  18 +-
 10 files changed, 630 insertions(+), 443 deletions(-)

diff --git a/common/algebra.h b/common/algebra.h
index a081e382..a5208e1d 100644
--- a/common/algebra.h
+++ b/common/algebra.h
@@ -283,6 +283,8 @@ public:
 		: m_Value(_v) { }
 	inline explicit Vector3(const float _x, const float _y, const float _z)
 		: m_Value(_x, _y, _z) { }
+	inline explicit Vector3(const float* xyz)
+		: m_Value(xyz[0], xyz[1], xyz[2]) { }
 
 	inline operator const float*() const { return (const float*)this; }
 	inline operator float*() { return (float*)this; }
diff --git a/common/camera.cpp b/common/camera.cpp
index b5a80fd2..80cbfc7e 100644
--- a/common/camera.cpp
+++ b/common/camera.cpp
@@ -8,7 +8,6 @@
 #include <math.h>
 #include "opengl.h"
 #include "globals.h"
-#include "matrix.h"
 #include "lc_file.h"
 #include "camera.h"
 #include "tr.h"
@@ -218,7 +217,7 @@ void Camera::Initialize()
   for (unsigned char i = 0 ; i < sizeof(m_strName) ; i++ )
     m_strName[i] = 0;
 
-  float *values[] = { m_fEye, m_fTarget, m_fUp };
+  float *values[] = { mPosition, mTargetPosition, mUpVector };
   RegisterKeys (values, camera_key_info, LC_CK_COUNT);
 
   m_pTarget = new CameraTarget (this);
@@ -412,50 +411,41 @@ void Camera::FileSave(lcFile& file) const
 /////////////////////////////////////////////////////////////////////////////
 // Camera operations
 
-void Camera::Move (unsigned short nTime, bool bAnimation, bool bAddKey, float dx, float dy, float dz)
+void Camera::Move(unsigned short nTime, bool bAnimation, bool bAddKey, float dx, float dy, float dz)
 {
-  if (IsSide())
-  {
-    m_fEye[0] += dx;
-    m_fEye[1] += dy;
-    m_fEye[2] += dz;
-    m_fTarget[0] += dx;
-    m_fTarget[1] += dy;
-    m_fTarget[2] += dz;
+	lcVector3 Move(dx, dy, dz);
 
-    ChangeKey(nTime, bAnimation, bAddKey, m_fEye, LC_CK_EYE);
-    ChangeKey(nTime, bAnimation, bAddKey, m_fTarget, LC_CK_TARGET);
-  }
-  else
-  {
-    if (IsEyeSelected())
-    {
-      m_fEye[0] += dx;
-      m_fEye[1] += dy;
-      m_fEye[2] += dz;
+	if (IsSide())
+	{
+		mPosition += Move;
+		mTargetPosition += Move;
 
-      ChangeKey(nTime, bAnimation, bAddKey, m_fEye, LC_CK_EYE);
-    }
+		ChangeKey(nTime, bAnimation, bAddKey, mPosition, LC_CK_EYE);
+		ChangeKey(nTime, bAnimation, bAddKey, mTargetPosition, LC_CK_TARGET);
+	}
+	else
+	{
+		if (IsEyeSelected())
+		{
+			mPosition += Move;
 
-    if (IsTargetSelected())
-    {
-      m_fTarget[0] += dx;
-      m_fTarget[1] += dy;
-      m_fTarget[2] += dz;
+			ChangeKey(nTime, bAnimation, bAddKey, mPosition, LC_CK_EYE);
+		}
 
-      ChangeKey(nTime, bAnimation, bAddKey, m_fTarget, LC_CK_TARGET);
-    }
+		if (IsTargetSelected())
+		{
+			mTargetPosition += Move;
 
-    // Fix the up vector
-    lcVector3 UpVector(m_fUp[0], m_fUp[1], m_fUp[2]), SideVector;
-    lcVector3 FrontVector(m_fTarget[0] - m_fEye[0], m_fTarget[1] - m_fEye[1], m_fTarget[2] - m_fEye[2]);
-    SideVector = lcCross(FrontVector, UpVector);
-    UpVector = lcCross(SideVector, FrontVector);
-    UpVector.Normalize();
-    memcpy(m_fUp, UpVector, sizeof(m_fUp));
+			ChangeKey(nTime, bAnimation, bAddKey, mTargetPosition, LC_CK_TARGET);
+		}
 
-    ChangeKey(nTime, bAnimation, bAddKey, m_fUp, LC_CK_UP);
-  }
+		// Fix the up vector
+		lcVector3 FrontVector(mTargetPosition - mPosition);
+		lcVector3 SideVector = lcCross(FrontVector, mUpVector);
+		mUpVector = lcNormalize(lcCross(SideVector, FrontVector));
+
+		ChangeKey(nTime, bAnimation, bAddKey, mUpVector, LC_CK_UP);
+	}
 }
 
 void Camera::Select (bool bSelecting, bool bFocus, bool bMultiple)
@@ -512,99 +502,103 @@ void Camera::SelectTarget (bool bSelecting, bool bFocus, bool bMultiple)
 
 void Camera::UpdatePosition(unsigned short nTime, bool bAnimation)
 {
-  CalculateKeys(nTime, bAnimation);
+	CalculateKeys(nTime, bAnimation);
+
+	lcVector3 FrontVector(mPosition - mTargetPosition);
+	lcVector3 SideVector = lcCross(FrontVector, mUpVector);
+	mUpVector = lcNormalize(lcCross(SideVector, FrontVector));
+
+	mWorldView = lcMatrix44LookAt(mPosition, mTargetPosition, mUpVector);
 
 	UpdateBoundingBox();
 }
 
 void Camera::UpdateBoundingBox()
 {
-  // Fix the up vector
-  lcVector3 FrontVector(m_fEye[0] - m_fTarget[0], m_fEye[1] - m_fTarget[1], m_fEye[2] - m_fTarget[2]);
-  lcVector3 UpVector(m_fUp[0], m_fUp[1], m_fUp[2]), SideVector;
+	// Fix the up vector
+	lcVector3 FrontVector(mPosition - mTargetPosition);
+	float len = FrontVector.Length();
 
-  SideVector = lcCross(FrontVector, UpVector);
-  UpVector = lcCross(SideVector, FrontVector);
-  UpVector.Normalize();
-  memcpy(m_fUp, UpVector, sizeof(m_fUp));
+	lcMatrix44 Mat = lcMatrix44AffineInverse(mWorldView);
 
-  float len = FrontVector.Length();
-
-  Matrix mat;
-  mat.CreateLookat (m_fEye, m_fTarget, m_fUp);
-  mat.Invert ();
-
-  mat.SetTranslation (m_fEye[0], m_fEye[1], m_fEye[2]);
-  BoundingBoxCalculate (&mat);
-  mat.SetTranslation (m_fTarget[0], m_fTarget[1], m_fTarget[2]);
-  m_pTarget->BoundingBoxCalculate (&mat);
-  mat.SetTranslation (0, 0, 0);
+	Mat.SetTranslation(mPosition);
+	BoundingBoxCalculate((Matrix*)&Mat);
+	Mat.SetTranslation(mTargetPosition);
+	m_pTarget->BoundingBoxCalculate((Matrix*)&Mat);
+	Mat.SetTranslation(lcVector3(0, 0, 0));
 
 	if (!m_nList)
 		return;
 
-  glNewList(m_nList, GL_COMPILE);
+	glNewList(m_nList, GL_COMPILE);
 
-  glPushMatrix();
-  glTranslatef(m_fEye[0], m_fEye[1], m_fEye[2]);
-  glMultMatrixf(mat.m);
+	glPushMatrix();
+	glTranslatef(mPosition[0], mPosition[1], mPosition[2]);
+	glMultMatrixf(Mat);
 
-  glEnableClientState(GL_VERTEX_ARRAY);
-  float verts[34][3] = {
-    {  0.3f,  0.3f,  0.3f }, { -0.3f,  0.3f,  0.3f },
-    { -0.3f,  0.3f,  0.3f }, { -0.3f, -0.3f,  0.3f },
-    { -0.3f, -0.3f,  0.3f }, {  0.3f, -0.3f,  0.3f },
-    {  0.3f, -0.3f,  0.3f }, {  0.3f,  0.3f,  0.3f },
-    {  0.3f,  0.3f, -0.3f }, { -0.3f,  0.3f, -0.3f },
-    { -0.3f,  0.3f, -0.3f }, { -0.3f, -0.3f, -0.3f },
-    { -0.3f, -0.3f, -0.3f }, {  0.3f, -0.3f, -0.3f },
-    {  0.3f, -0.3f, -0.3f }, {  0.3f,  0.3f, -0.3f },
-    {  0.3f,  0.3f,  0.3f }, {  0.3f,  0.3f, -0.3f },
-    { -0.3f,  0.3f,  0.3f }, { -0.3f,  0.3f, -0.3f },
-    { -0.3f, -0.3f,  0.3f }, { -0.3f, -0.3f, -0.3f },
-    {  0.3f, -0.3f,  0.3f }, {  0.3f, -0.3f, -0.3f },
-    { -0.3f, -0.3f, -0.6f }, { -0.3f,  0.3f, -0.6f },
-    {  0.0f,  0.0f, -0.3f }, { -0.3f, -0.3f, -0.6f },
-    {  0.3f, -0.3f, -0.6f }, {  0.0f,  0.0f, -0.3f },
-    {  0.3f,  0.3f, -0.6f }, {  0.3f, -0.3f, -0.6f },
-    {  0.3f,  0.3f, -0.6f }, { -0.3f,  0.3f, -0.6f } };
-  glVertexPointer (3, GL_FLOAT, 0, verts);
-  glDrawArrays(GL_LINES, 0, 24);
-  glDrawArrays(GL_LINE_STRIP, 24, 10);
+	glEnableClientState(GL_VERTEX_ARRAY);
+	float verts[34][3] =
+	{
+		{  0.3f,  0.3f,  0.3f }, { -0.3f,  0.3f,  0.3f },
+		{ -0.3f,  0.3f,  0.3f }, { -0.3f, -0.3f,  0.3f },
+		{ -0.3f, -0.3f,  0.3f }, {  0.3f, -0.3f,  0.3f },
+		{  0.3f, -0.3f,  0.3f }, {  0.3f,  0.3f,  0.3f },
+		{  0.3f,  0.3f, -0.3f }, { -0.3f,  0.3f, -0.3f },
+		{ -0.3f,  0.3f, -0.3f }, { -0.3f, -0.3f, -0.3f },
+		{ -0.3f, -0.3f, -0.3f }, {  0.3f, -0.3f, -0.3f },
+		{  0.3f, -0.3f, -0.3f }, {  0.3f,  0.3f, -0.3f },
+		{  0.3f,  0.3f,  0.3f }, {  0.3f,  0.3f, -0.3f },
+		{ -0.3f,  0.3f,  0.3f }, { -0.3f,  0.3f, -0.3f },
+		{ -0.3f, -0.3f,  0.3f }, { -0.3f, -0.3f, -0.3f },
+		{  0.3f, -0.3f,  0.3f }, {  0.3f, -0.3f, -0.3f },
+		{ -0.3f, -0.3f, -0.6f }, { -0.3f,  0.3f, -0.6f },
+		{  0.0f,  0.0f, -0.3f }, { -0.3f, -0.3f, -0.6f },
+		{  0.3f, -0.3f, -0.6f }, {  0.0f,  0.0f, -0.3f },
+		{  0.3f,  0.3f, -0.6f }, {  0.3f, -0.3f, -0.6f },
+		{  0.3f,  0.3f, -0.6f }, { -0.3f,  0.3f, -0.6f }
+	};
+
+	glVertexPointer (3, GL_FLOAT, 0, verts);
+	glDrawArrays(GL_LINES, 0, 24);
+	glDrawArrays(GL_LINE_STRIP, 24, 10);
 
 //	glBegin(GL_LINES);
 //	glVertex3f(0,0,0);
 //	glVertex3f(0,0,len);
 //	glEnd();
 
-  glTranslatef(0, 0, -len);
+	glTranslatef(0, 0, -len);
 
-  glEndList();
+	glEndList();
 
-  if (m_nTargetList == 0)
-  {
-    m_nTargetList = glGenLists(1);
-    glNewList (m_nTargetList, GL_COMPILE);
+	if (m_nTargetList == 0)
+	{
+		m_nTargetList = glGenLists(1);
+		glNewList (m_nTargetList, GL_COMPILE);
 
-    glEnableClientState(GL_VERTEX_ARRAY);
-    float box[24][3] = { 
-      {  0.2f,  0.2f,  0.2f }, { -0.2f,  0.2f,  0.2f },
-      { -0.2f,  0.2f,  0.2f }, { -0.2f, -0.2f,  0.2f },
-      { -0.2f, -0.2f,  0.2f }, {  0.2f, -0.2f,  0.2f },
-      {  0.2f, -0.2f,  0.2f }, {  0.2f,  0.2f,  0.2f },
-      {  0.2f,  0.2f, -0.2f }, { -0.2f,  0.2f, -0.2f },
-      { -0.2f,  0.2f, -0.2f }, { -0.2f, -0.2f, -0.2f },
-      { -0.2f, -0.2f, -0.2f }, {  0.2f, -0.2f, -0.2f },
-      {  0.2f, -0.2f, -0.2f }, {  0.2f,  0.2f, -0.2f },
-      {  0.2f,  0.2f,  0.2f }, {  0.2f,  0.2f, -0.2f },
-      { -0.2f,  0.2f,  0.2f }, { -0.2f,  0.2f, -0.2f },
-      { -0.2f, -0.2f,  0.2f }, { -0.2f, -0.2f, -0.2f },
-      {  0.2f, -0.2f,  0.2f }, {  0.2f, -0.2f, -0.2f } };
-    glVertexPointer (3, GL_FLOAT, 0, box);
-    glDrawArrays(GL_LINES, 0, 24);
-    glPopMatrix();
-    glEndList();
-  }
+		glEnableClientState(GL_VERTEX_ARRAY);
+
+		float box[24][3] =
+		{
+			{  0.2f,  0.2f,  0.2f }, { -0.2f,  0.2f,  0.2f },
+			{ -0.2f,  0.2f,  0.2f }, { -0.2f, -0.2f,  0.2f },
+			{ -0.2f, -0.2f,  0.2f }, {  0.2f, -0.2f,  0.2f },
+			{  0.2f, -0.2f,  0.2f }, {  0.2f,  0.2f,  0.2f },
+			{  0.2f,  0.2f, -0.2f }, { -0.2f,  0.2f, -0.2f },
+			{ -0.2f,  0.2f, -0.2f }, { -0.2f, -0.2f, -0.2f },
+			{ -0.2f, -0.2f, -0.2f }, {  0.2f, -0.2f, -0.2f },
+			{  0.2f, -0.2f, -0.2f }, {  0.2f,  0.2f, -0.2f },
+			{  0.2f,  0.2f,  0.2f }, {  0.2f,  0.2f, -0.2f },
+			{ -0.2f,  0.2f,  0.2f }, { -0.2f,  0.2f, -0.2f },
+			{ -0.2f, -0.2f,  0.2f }, { -0.2f, -0.2f, -0.2f },
+			{  0.2f, -0.2f,  0.2f }, {  0.2f, -0.2f, -0.2f }
+		};
+
+		glVertexPointer (3, GL_FLOAT, 0, box);
+		glDrawArrays(GL_LINES, 0, 24);
+		glPopMatrix();
+		glEndList();
+	}
 }
 
 void Camera::Render(float fLineWidth)
@@ -650,25 +644,22 @@ void Camera::Render(float fLineWidth)
 
   lcSetColorCamera();
   glBegin(GL_LINES);
-  glVertex3fv(m_fEye);
-  glVertex3fv(m_fTarget);
+  glVertex3fv(mPosition);
+  glVertex3fv(mTargetPosition);
   glEnd();
 
   if (IsSelected())
   {
-    Matrix projection, modelview;
-    lcVector3 FrontVector(m_fTarget[0] - m_fEye[0], m_fTarget[1] - m_fEye[1], m_fTarget[2] - m_fEye[2]);
+    lcVector3 FrontVector(mTargetPosition - mPosition);
     float len = FrontVector.Length();
 
     glPushMatrix ();
 
-    modelview.CreateLookat (m_fEye, m_fTarget, m_fUp);
-    modelview.Invert ();
-    glMultMatrixf (modelview.m);
+	lcMatrix44 ViewWorld = lcMatrix44AffineInverse(mWorldView);
+    glMultMatrixf(ViewWorld);
 
-    projection.CreatePerspective (m_fovy, 1.33f, 0.01f, len);
-    projection.Invert ();
-    glMultMatrixf (projection.m);
+	lcMatrix44 InvProjection = lcMatrix44Inverse(lcMatrix44Perspective(m_fovy, 1.33f, 0.01f, len));
+    glMultMatrixf(InvProjection);
 
     // draw the viewing frustum
     glBegin(GL_LINE_LOOP);
@@ -731,90 +722,67 @@ void Camera::LoadProjection(float fAspect)
   }
 
   glMatrixMode(GL_MODELVIEW);
-  glLoadIdentity();
-  gluLookAt(m_fEye[0], m_fEye[1], m_fEye[2], m_fTarget[0], m_fTarget[1], m_fTarget[2], m_fUp[0], m_fUp[1], m_fUp[2]);
+  glLoadMatrixf(mWorldView);
 }
 
 void Camera::DoZoom(int dy, int mouse, unsigned short nTime, bool bAnimation, bool bAddKey)
 {
-  lcVector3 FrontVector(m_fEye[0] - m_fTarget[0], m_fEye[1] - m_fTarget[1], m_fEye[2] - m_fTarget[2]);
-  FrontVector.Normalize();
-  FrontVector *= 2.0f * dy / (21 - mouse);
+	lcVector3 FrontVector(mPosition - mTargetPosition);
+	FrontVector.Normalize();
+	FrontVector *= 2.0f * dy / (21 - mouse);
 
-  // TODO: option to move eye, target or both
-  m_fEye[0] += FrontVector[0];
-  m_fEye[1] += FrontVector[1];
-  m_fEye[2] += FrontVector[2];
-  m_fTarget[0] += FrontVector[0];
-  m_fTarget[1] += FrontVector[1];
-  m_fTarget[2] += FrontVector[2];
+	// TODO: option to move eye, target or both
+	mPosition += FrontVector;
+	mTargetPosition += FrontVector;
 
-  ChangeKey(nTime, bAnimation, bAddKey, m_fEye, LC_CK_EYE);
-  ChangeKey(nTime, bAnimation, bAddKey, m_fTarget, LC_CK_TARGET);
-  UpdatePosition(nTime, bAnimation);
+	ChangeKey(nTime, bAnimation, bAddKey, mPosition, LC_CK_EYE);
+	ChangeKey(nTime, bAnimation, bAddKey, mTargetPosition, LC_CK_TARGET);
+	UpdatePosition(nTime, bAnimation);
 }
 
 void Camera::DoPan(int dx, int dy, int mouse, unsigned short nTime, bool bAnimation, bool bAddKey)
 {
-  lcVector3 UpVector(m_fUp[0], m_fUp[1], m_fUp[2]), FrontVector(m_fEye[0] - m_fTarget[0], m_fEye[1] - m_fTarget[1], m_fEye[2] - m_fTarget[2]), SideVector;
-  SideVector = lcCross(FrontVector, UpVector);
-  SideVector.Normalize();
-  SideVector *= 2.0f*dx/(21-mouse);
-  UpVector.Normalize();
-  UpVector *= -2.0f*dy/(21-mouse);
+	lcVector3 FrontVector(mPosition - mTargetPosition);
+	lcVector3 SideVector = lcNormalize(lcCross(FrontVector, mUpVector));
 
-  m_fEye[0] += UpVector[0] + SideVector[0];
-  m_fEye[1] += UpVector[1] + SideVector[1];
-  m_fEye[2] += UpVector[2] + SideVector[2];
-  m_fTarget[0] += UpVector[0] + SideVector[0];
-  m_fTarget[1] += UpVector[1] + SideVector[1];
-  m_fTarget[2] += UpVector[2] + SideVector[2];
+	lcVector3 Move = (SideVector * (2.0f * dx / (21 - mouse))) + (mUpVector * (-2.0f * dy / (21 - mouse)));
+	mPosition += Move;
+	mTargetPosition += Move;
 
-  ChangeKey(nTime, bAnimation, bAddKey, m_fEye, LC_CK_EYE);
-  ChangeKey(nTime, bAnimation, bAddKey, m_fTarget, LC_CK_TARGET);
-  UpdatePosition(nTime, bAnimation);
+	ChangeKey(nTime, bAnimation, bAddKey, mPosition, LC_CK_EYE);
+	ChangeKey(nTime, bAnimation, bAddKey, mTargetPosition, LC_CK_TARGET);
+	UpdatePosition(nTime, bAnimation);
 }
 
 void Camera::DoRotate(int dx, int dy, int mouse, unsigned short nTime, bool bAnimation, bool bAddKey, float* /*center*/)
 {
-  lcVector3 UpVector(m_fUp[0], m_fUp[1], m_fUp[2]), FrontVector(m_fEye[0] - m_fTarget[0], m_fEye[1] - m_fTarget[1], m_fEye[2] - m_fTarget[2]), SideVector;
-  SideVector = lcCross(FrontVector, UpVector);
-  SideVector.Normalize();
-  SideVector *= 2.0f*dx/(21-mouse);
-  UpVector.Normalize();
-  UpVector *= -2.0f*dy/(21-mouse);
+	lcVector3 FrontVector(mPosition - mTargetPosition);
+	lcVector3 SideVector = lcNormalize(lcCross(FrontVector, mUpVector));
 
-  // TODO: option to move eye or target
-  float len = FrontVector.Length();
-  FrontVector += lcVector3(UpVector[0] + SideVector[0], UpVector[1] + SideVector[1], UpVector[2] + SideVector[2]);
-  FrontVector.Normalize();
-  FrontVector *= len;
-  FrontVector += lcVector3(m_fTarget[0], m_fTarget[1], m_fTarget[2]);
-  memcpy(m_fEye, FrontVector, sizeof(m_fEye));
+	// TODO: option to move eye or target
+	float len = FrontVector.Length();
+	FrontVector += (SideVector * (2.0f * dx / (21 - mouse))) + (mUpVector * (-2.0f * dy / (21 - mouse)));
+	FrontVector.Normalize();
+	mPosition = (FrontVector * len) + mTargetPosition;
 
-  // Calculate new up
-  UpVector = lcVector3(m_fUp[0], m_fUp[1], m_fUp[2]);
-  FrontVector = lcVector3(m_fEye[0] - m_fTarget[0], m_fEye[1] - m_fTarget[1], m_fEye[2] - m_fTarget[2]);
-  SideVector = lcCross(FrontVector, UpVector);
-  UpVector = lcCross(SideVector, FrontVector);
-  UpVector.Normalize();
-  memcpy(m_fUp, UpVector, sizeof(m_fUp));
+	// Calculate new up
+	FrontVector = mPosition - mTargetPosition;
+	SideVector = lcCross(FrontVector, mUpVector);
+	mUpVector = lcNormalize(lcCross(SideVector, FrontVector));
 
-  ChangeKey(nTime, bAnimation, bAddKey, m_fEye, LC_CK_EYE);
-  ChangeKey(nTime, bAnimation, bAddKey, m_fUp, LC_CK_UP);
-  UpdatePosition(nTime, bAnimation);
+	ChangeKey(nTime, bAnimation, bAddKey, mPosition, LC_CK_EYE);
+	ChangeKey(nTime, bAnimation, bAddKey, mUpVector, LC_CK_UP);
+	UpdatePosition(nTime, bAnimation);
 }
 
 void Camera::DoRoll(int dx, int mouse, unsigned short nTime, bool bAnimation, bool bAddKey)
 {
-  Matrix mat;
-  float front[3] = { m_fEye[0]-m_fTarget[0], m_fEye[1]-m_fTarget[1], m_fEye[2]-m_fTarget[2] };
+	lcVector3 FrontVector(mPosition - mTargetPosition);
+	lcMatrix44 Rotation = lcMatrix44FromAxisAngle(FrontVector, 2.0f * dx / (21 - mouse) * LC_DTOR);
 
-  mat.FromAxisAngle(front, 2.0f*dx/(21-mouse));
-  mat.TransformPoints(m_fUp, 1);
-
-  ChangeKey(nTime, bAnimation, bAddKey, m_fUp, LC_CK_UP);
-  UpdatePosition(nTime, bAnimation);
+	mUpVector = lcMul30(mUpVector, Rotation);
+	ChangeKey(nTime, bAnimation, bAddKey, mUpVector, LC_CK_UP);
+	UpdatePosition(nTime, bAnimation);
 }
 
 void Camera::StartTiledRendering(int tw, int th, int iw, int ih, float fAspect)
diff --git a/common/camera.h b/common/camera.h
index f0b00603..975f6044 100644
--- a/common/camera.h
+++ b/common/camera.h
@@ -3,7 +3,7 @@
 
 #include "opengl.h"
 #include "object.h"
-#include "algebra.h"
+#include "lc_math.h"
 
 #define LC_CAMERA_HIDDEN            0x01
 #define LC_CAMERA_SELECTED          0x02
@@ -69,13 +69,6 @@ public:
 	virtual ~Camera ();
 
 	// Query functions.
-	inline Vector3 GetEyePosition() const
-	{ return Vector3(m_fEye[0], m_fEye[1], m_fEye[2]); };
-	inline Vector3 GetTargetPosition() const
-	{ return Vector3(m_fTarget[0], m_fTarget[1], m_fTarget[2]); };
-	inline Vector3 GetUpVector() const
-	{ return Vector3(m_fUp[0], m_fUp[1], m_fUp[2]); };
-
 	const char* GetName() const
 	{ return m_strName; };
 
@@ -83,22 +76,6 @@ public:
 		{ return m_pTarget; }
 
 
-	// Deprecated functions:
-	const float* GetEyePos () const
-		{ return m_fEye; };
-	void GetEyePos (float* eye) const
-		{ memcpy(eye, m_fEye, sizeof(m_fEye)); };
-	const float* GetTargetPos () const
-		{ return m_fTarget; };
-	void GetTargetPos (float* target) const
-		{ memcpy(target, m_fTarget, sizeof(m_fTarget)); };
-	const float* GetUpVec () const
-		{ return m_fUp; };
-	void GetUpVec (float* up) const
-		{ memcpy(up, m_fUp, sizeof(m_fUp)); };
-
-
-
 
 
 
@@ -169,6 +146,11 @@ public:
 	float m_zNear;
 	float m_zFar;
 
+	lcMatrix44 mWorldView;
+	lcVector3 mPosition;
+	lcVector3 mTargetPosition;
+	lcVector3 mUpVector;
+
 protected:
 	void Initialize();
 	void UpdateBoundingBox();
@@ -183,11 +165,6 @@ protected:
 	GLuint m_nList;
 	static GLuint m_nTargetList;
 
-	// Current position and orientation.
-	float m_fEye[3];
-	float m_fTarget[3];
-	float m_fUp[3];
-
 	TiledRender* m_pTR;
 };
 
diff --git a/common/lc_math.h b/common/lc_math.h
index 7d7ff0ac..0a450b20 100644
--- a/common/lc_math.h
+++ b/common/lc_math.h
@@ -46,8 +46,8 @@ public:
 	}
 
 	void Normalize();
-	void Dot();
 	float Length() const;
+	float LengthSquared() const;
 
 	float x, y, z;
 };
@@ -64,6 +64,11 @@ public:
 	{
 	}
 
+	lcVector4(const lcVector3& _xyz, const float _w)
+		: x(_xyz.x), y(_xyz.y), z(_xyz.z), w(_w)
+	{
+	}
+
 	operator const float*() const
 	{
 		return (const float*)this;
@@ -233,6 +238,11 @@ inline float lcVector3::Length() const
 	return sqrtf(x * x + y * y + z * z);
 }
 
+inline float lcVector3::LengthSquared() const
+{
+	return x * x + y * y + z * z;
+}
+
 inline lcVector3 lcNormalize(const lcVector3& a)
 {
 	lcVector3 Ret(a);
@@ -285,6 +295,26 @@ inline lcVector4 operator/(const lcVector4& a, const lcVector4& b)
 	return lcVector4(a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w);
 }
 
+inline lcVector4& operator*=(lcVector4& a, float b)
+{
+	a.x *= b;
+	a.y *= b;
+	a.z *= b;
+	a.w *= b;
+
+	return a;
+}
+
+inline lcVector4& operator/=(lcVector4& a, float b)
+{
+	a.x /= b;
+	a.y /= b;
+	a.z /= b;
+	a.w /= b;
+
+	return a;
+}
+
 inline lcVector3 lcMul31(const lcVector3& a, const lcMatrix44& b)
 {
 	lcVector4 v = b.r[0] * a[0] + b.r[1] * a[1] + b.r[2] * a[2] + b.r[3];
@@ -394,6 +424,57 @@ inline lcMatrix44 lcMatrix44RotationZ(const float Radians)
 	return m;
 }
 
+inline lcMatrix44 lcMatrix44LookAt(const lcVector3& Eye, const lcVector3& Target, const lcVector3& Up)
+{
+	lcVector3 x, y, z;
+
+	z = lcNormalize(Eye - Target);
+	x = lcNormalize(lcCross(Up, z));
+	y = lcNormalize(lcCross(z, x));
+
+	lcMatrix44 m;
+
+	m.r[0] = lcVector4(x[0], y[0], z[0], 0.0f);
+	m.r[1] = lcVector4(x[1], y[1], z[1], 0.0f);
+	m.r[2] = lcVector4(x[2], y[2], z[2], 0.0f);
+	m.r[3] = m.r[0] * -Eye[0] + m.r[1] * -Eye[1] + m.r[2] * -Eye[2];
+	m.r[3][3] = 1.0f;
+
+	return m;
+}
+
+inline lcMatrix44 lcMatrix44Perspective(float FoVy, float Aspect, float Near, float Far)
+{
+	float Left, Right, Bottom, Top;
+
+	Top = Near * (float)tan(FoVy * LC_PI / 360.0f);
+	Bottom = -Top;
+
+	Left = Bottom * Aspect;
+	Right = Top * Aspect;
+
+	if ((Near <= 0.0f) || (Far <= 0.0f) || (Near == Far) || (Left == Right) || (Top == Bottom))
+		return lcMatrix44Identity();
+
+	float x, y, a, b, c, d;
+
+	x = (2.0f * Near) / (Right - Left);
+	y = (2.0f * Near) / (Top - Bottom);
+	a = (Right + Left) / (Right - Left);
+	b = (Top + Bottom) / (Top - Bottom);
+	c = -(Far + Near) / (Far - Near);
+	d = -(2.0f * Far * Near) / (Far - Near);
+
+	lcMatrix44 m;
+
+	m.r[0] = lcVector4(x, 0, 0,  0);
+	m.r[1] = lcVector4(0, y, 0,  0);
+	m.r[2] = lcVector4(a, b, c, -1);
+	m.r[3] = lcVector4(0, 0, d,  0);
+
+	return m;
+}
+
 inline lcMatrix44 lcMatrix44FromAxisAngle(const lcVector3& Axis, const float Radians)
 {
 	float s, c, mag, xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
@@ -524,4 +605,193 @@ inline lcVector4 lcMatrix44ToAxisAngle(const lcMatrix44& m)
 	return rot;
 }
 
+inline lcMatrix44 lcMatrix44AffineInverse(const lcMatrix44& m)
+{
+	lcMatrix44 Inv;
+
+	Inv.r[0] = lcVector4(m.r[0][0], m.r[1][0], m.r[2][0], m.r[0][3]);
+	Inv.r[1] = lcVector4(m.r[0][1], m.r[1][1], m.r[2][1], m.r[1][3]);
+	Inv.r[2] = lcVector4(m.r[0][2], m.r[1][2], m.r[2][2], m.r[2][3]);
+
+	lcVector3 Trans = -lcMul30(lcVector3(Inv[3][0], Inv[3][1], Inv[3][2]), Inv);
+	Inv.r[3] = lcVector4(Trans[0], Trans[1], Trans[2], 1.0f);
+
+	return Inv;
+}
+
+// Inverse code from the GLU library.
+inline lcMatrix44 lcMatrix44Inverse(const lcMatrix44& m)
+{
+#define SWAP_ROWS(a, b) { float *_tmp = a; (a)=(b); (b)=_tmp; }
+#define MAT(m,col,row) m.r[row][col]
+
+	float wtmp[4][8];
+	float m0, m1, m2, m3, s;
+	float *r0, *r1, *r2, *r3;
+
+	r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
+
+	r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
+	r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
+	r0[4] = 1.0, r0[5] = r0[6] = r0[7] = 0.0,
+
+	r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
+	r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
+	r1[5] = 1.0, r1[4] = r1[6] = r1[7] = 0.0,
+
+	r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
+	r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
+	r2[6] = 1.0, r2[4] = r2[5] = r2[7] = 0.0,
+
+	r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
+	r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
+	r3[7] = 1.0, r3[4] = r3[5] = r3[6] = 0.0;
+
+	// choose pivot - or die
+	if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
+	if (fabs(r2[0])>fabs(r1[0])) SWAP_ROWS(r2, r1);
+	if (fabs(r1[0])>fabs(r0[0])) SWAP_ROWS(r1, r0);
+//	if (0.0 == r0[0])  return GL_FALSE;
+
+	// eliminate first variable
+	m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
+	s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
+	s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
+	s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
+	s = r0[4];
+	if (s != 0.0) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
+	s = r0[5];
+	if (s != 0.0) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
+	s = r0[6];
+	if (s != 0.0) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
+	s = r0[7];
+	if (s != 0.0) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
+
+	// choose pivot - or die
+	if (fabs(r3[1])>fabs(r2[1])) SWAP_ROWS(r3, r2);
+	if (fabs(r2[1])>fabs(r1[1])) SWAP_ROWS(r2, r1);
+//	if (0.0 == r1[1])  return GL_FALSE;
+
+	// eliminate second variable
+	m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
+	r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
+	r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
+	s = r1[4]; if (0.0 != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
+	s = r1[5]; if (0.0 != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
+	s = r1[6]; if (0.0 != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
+	s = r1[7]; if (0.0 != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
+
+	// choose pivot - or die
+	if (fabs(r3[2])>fabs(r2[2])) SWAP_ROWS(r3, r2);
+//	if (0.0 == r2[2])  return GL_FALSE;
+
+	// eliminate third variable
+	m3 = r3[2]/r2[2];
+	r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4],
+	r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
+	r3[7] -= m3 * r2[7];
+
+	// last check
+//	if (0.0 == r3[3]) return GL_FALSE;
+
+	s = 1.0f/r3[3];              // now back substitute row 3
+	r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
+
+	m2 = r2[3];                 // now back substitute row 2
+	s  = 1.0f/r2[2];
+	r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
+	r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
+	m1 = r1[3];
+	r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
+	r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
+	m0 = r0[3];
+	r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0,
+	r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
+
+	m1 = r1[2];                 // now back substitute row 1
+	s  = 1.0f/r1[1];
+	r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
+	r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
+	m0 = r0[2];
+	r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0,
+	r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
+
+	m0 = r0[1];                 // now back substitute row 0
+	s  = 1.0f/r0[0];
+	r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
+	r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
+
+	lcVector4 Row0(r0[4], r1[4], r2[4], r3[4]);
+	lcVector4 Row1(r0[5], r1[5], r2[5], r3[5]);
+	lcVector4 Row2(r0[6], r1[6], r2[6], r3[6]);
+	lcVector4 Row3(r0[7], r1[7], r2[7], r3[7]);
+	
+	lcMatrix44 out(Row0, Row1, Row2, Row3);
+	
+	return out;
+
+#undef MAT
+#undef SWAP_ROWS
+}
+
+// Convert world coordinates to screen coordinates.
+inline lcVector3 lcProjectPoint(const lcVector3& Point, const lcMatrix44& ModelView, const lcMatrix44& Projection, const int Viewport[4])
+{
+	lcVector4 Tmp;
+
+	Tmp = lcMul4(lcVector4(Point[0], Point[1], Point[2], 1.0f), ModelView);
+	Tmp = lcMul4(Tmp, Projection);
+
+	// Normalize.
+	Tmp /= Tmp[3];
+
+	// Screen coordinates.
+	return lcVector3(Viewport[0] + (1 + Tmp[0]) * Viewport[2] / 2, Viewport[1] + (1 + Tmp[1]) * Viewport[3] / 2, (1 + Tmp[2]) / 2);
+}
+
+inline lcVector3 lcUnprojectPoint(const lcVector3& Point, const lcMatrix44& ModelView, const lcMatrix44& Projection, const int Viewport[4])
+{
+	// Calculate the screen to model transform.
+	lcMatrix44 Transform = lcMatrix44Inverse(lcMul(ModelView, Projection));
+
+	lcVector4 Tmp;
+
+	// Convert the point to homogeneous coordinates.
+	Tmp[0] = (Point[0] - Viewport[0]) * 2.0f / Viewport[2] - 1.0f;
+	Tmp[1] = (Point[1] - Viewport[1]) * 2.0f / Viewport[3] - 1.0f;
+	Tmp[2] = Point[2] * 2.0f - 1.0f;
+	Tmp[3] = 1.0f;
+
+	Tmp = lcMul4(Tmp, Transform);
+
+	if (Tmp[3] != 0.0f)
+		Tmp /= Tmp[3];
+
+	return lcVector3(Tmp[0], Tmp[1], Tmp[2]);
+}
+
+inline void lcUnprojectPoints(lcVector3* Points, int NumPoints, const lcMatrix44& ModelView, const lcMatrix44& Projection, const int Viewport[4])
+{
+	// Calculate the screen to model transform.
+	lcMatrix44 Transform = lcMatrix44Inverse(lcMul(ModelView, Projection));
+
+	for (int i = 0; i < NumPoints; i++)
+	{
+		lcVector4 Tmp;
+
+		// Convert the point to homogeneous coordinates.
+		Tmp[0] = (Points[i][0] - Viewport[0]) * 2.0f / Viewport[2] - 1.0f;
+		Tmp[1] = (Points[i][1] - Viewport[1]) * 2.0f / Viewport[3] - 1.0f;
+		Tmp[2] = Points[i][2] * 2.0f - 1.0f;
+		Tmp[3] = 1.0f;
+
+		Tmp = lcMul4(Tmp, Transform);
+
+		if (Tmp[3] != 0.0f)
+			Tmp /= Tmp[3];
+
+		Points[i] = lcVector3(Tmp[0], Tmp[1], Tmp[2]);
+	}
+}
+
 #endif // _LC_MATH_H_
diff --git a/common/project.cpp b/common/project.cpp
index 5b4eb26f..f2fad141 100644
--- a/common/project.cpp
+++ b/common/project.cpp
@@ -1764,9 +1764,7 @@ void Project::RenderScenePieces(View* view)
 	PtrArray<Piece> OpaquePieces(512);
 	ObjArray<lcTranslucentRenderSection> TranslucentSections(512);
 
-	Matrix44 ModelView;
-	Camera* Cam = view->m_Camera;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
+	const lcMatrix44& WorldView = view->m_Camera->mWorldView;
 
 	for (Piece* pPiece = m_pPieces; pPiece; pPiece = pPiece->m_pNext)
 	{
@@ -1781,7 +1779,7 @@ void Project::RenderScenePieces(View* view)
 
 		if ((Info->m_nFlags & LC_PIECE_HAS_TRANSLUCENT) || ((Info->m_nFlags & LC_PIECE_HAS_DEFAULT) && Translucent))
 		{
-			Vector3 Pos = Mul31(pPiece->GetPosition(), ModelView);
+			lcVector3 Pos = lcMul31(pPiece->mPosition, WorldView);
 
 			lcTranslucentRenderSection RenderSection;
 
@@ -2006,7 +2004,7 @@ void Project::RenderSceneObjects(View* view)
 //		glClear(GL_DEPTH_BUFFER_BIT);
 
 		Matrix Mats[3];
-		Mats[0].CreateLookat(view->m_Camera->GetEyePos(), view->m_Camera->GetTargetPos(), view->m_Camera->GetUpVec());
+		Mats[0].CreateLookat(view->m_Camera->mPosition, view->m_Camera->mTargetPosition, view->m_Camera->mUpVector);
 		Mats[0].SetTranslation(0, 0, 0);
 
 		float m1[] = { 0, 1, 0, 0,  1, 0, 0, 0,  0, 0, 1, 0,  0, 0, 0, 1 };
@@ -2229,7 +2227,6 @@ void Project::RenderOverlays(View* view)
 		glDisable(GL_DEPTH_TEST);
 
 		Camera* Cam = view->m_Camera;
-		Matrix44 Mat;
 		int j;
 
 		// Find the rotation from the focused piece if relative snap is enabled.
@@ -2332,8 +2329,7 @@ void Project::RenderOverlays(View* view)
 			}
 		}
 
-		Mat.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-		Mat.Transpose3();
+		lcMatrix44 Mat = lcMatrix44AffineInverse(Cam->mWorldView);
 		Mat.SetTranslation(m_OverlayCenter);
 
 		// Draw the circles.
@@ -2342,29 +2338,28 @@ void Project::RenderOverlays(View* view)
 
 		for (j = 0; j < 32; j++)
 		{
-			Vector3 Pt;
+			lcVector3 Pt;
 
 			Pt[0] = cosf(LC_2PI * j / 32) * OverlayRotateRadius * OverlayScale;
 			Pt[1] = sinf(LC_2PI * j / 32) * OverlayRotateRadius * OverlayScale;
 			Pt[2] = 0.0f;
 
-			Pt = Mul31(Pt, Mat);
+			Pt = lcMul31(Pt, Mat);
 
 			glVertex3f(Pt[0], Pt[1], Pt[2]);
 		}
 
 		glEnd();
 
-		Vector3 ViewDir = Cam->GetTargetPosition() - Cam->GetEyePosition();
+		lcVector3 ViewDir = Cam->mTargetPosition - Cam->mPosition;
 		ViewDir.Normalize();
 
 		// Transform ViewDir to local space.
 		if (Focus)
 		{
-			Matrix33 RotMat;
-			RotMat.CreateFromAxisAngle(Vector3(Rot[0], Rot[1], Rot[2]), -Rot[3] * LC_DTOR);
+			lcMatrix44 RotMat = lcMatrix44FromAxisAngle(lcVector3(Rot[0], Rot[1], Rot[2]), -Rot[3] * LC_DTOR);
 
-			ViewDir = Mul(ViewDir, RotMat);
+			ViewDir = lcMul30(ViewDir, RotMat);
 		}
 
 		glTranslatef(m_OverlayCenter[0], m_OverlayCenter[1], m_OverlayCenter[2]);
@@ -2399,30 +2394,30 @@ void Project::RenderOverlays(View* view)
 
 			for (int j = 0; j < 32; j++)
 			{
-				Vector3 v1, v2;
+				lcVector3 v1, v2;
 
 				switch (i)
 				{
 				case 0:
-					v1 = Vector3(0.0f, cosf(LC_2PI * j / 32), sinf(LC_2PI * j / 32));
-					v2 = Vector3(0.0f, cosf(LC_2PI * (j + 1) / 32), sinf(LC_2PI * (j + 1) / 32));
+					v1 = lcVector3(0.0f, cosf(LC_2PI * j / 32), sinf(LC_2PI * j / 32));
+					v2 = lcVector3(0.0f, cosf(LC_2PI * (j + 1) / 32), sinf(LC_2PI * (j + 1) / 32));
 					break;
 
 				case 1:
-					v1 = Vector3(cosf(LC_2PI * j / 32), 0.0f, sinf(LC_2PI * j / 32));
-					v2 = Vector3(cosf(LC_2PI * (j + 1) / 32), 0.0f, sinf(LC_2PI * (j + 1) / 32));
+					v1 = lcVector3(cosf(LC_2PI * j / 32), 0.0f, sinf(LC_2PI * j / 32));
+					v2 = lcVector3(cosf(LC_2PI * (j + 1) / 32), 0.0f, sinf(LC_2PI * (j + 1) / 32));
 					break;
 
 				case 2:
-					v1 = Vector3(cosf(LC_2PI * j / 32), sinf(LC_2PI * j / 32), 0.0f);
-					v2 = Vector3(cosf(LC_2PI * (j + 1) / 32), sinf(LC_2PI * (j + 1) / 32), 0.0f);
+					v1 = lcVector3(cosf(LC_2PI * j / 32), sinf(LC_2PI * j / 32), 0.0f);
+					v2 = lcVector3(cosf(LC_2PI * (j + 1) / 32), sinf(LC_2PI * (j + 1) / 32), 0.0f);
 					break;
 				}
 
-				if (Dot3(ViewDir, v1+v2) <= 0.0f)
+				if (lcDot(ViewDir, v1 + v2) <= 0.0f)
 				{
-					Vector3 Pt1 = v1 * OverlayRotateRadius * OverlayScale;
-					Vector3 Pt2 = v2 * OverlayRotateRadius * OverlayScale;
+					lcVector3 Pt1 = v1 * (OverlayRotateRadius * OverlayScale);
+					lcVector3 Pt2 = v2 * (OverlayRotateRadius * OverlayScale);
 
 					glVertex3f(Pt1[0], Pt1[1], Pt1[2]);
 					glVertex3f(Pt2[0], Pt2[1], Pt2[2]);
@@ -2437,23 +2432,23 @@ void Project::RenderOverlays(View* view)
 		{
 			if ((m_OverlayMode == LC_OVERLAY_X) || (m_OverlayMode == LC_OVERLAY_Y) || (m_OverlayMode == LC_OVERLAY_Z))
 			{
-				Vector3 Tangent, Normal = m_OverlayTrackStart - m_OverlayCenter;
-				Normal.Normalize();
+				lcVector3 Normal = lcNormalize(m_OverlayTrackStart - m_OverlayCenter);
+				lcVector3 Tangent;
 				float Angle;
 
 				switch (m_OverlayMode)
 				{
 				case LC_OVERLAY_X:
 					Angle = m_MouseTotalDelta[0];
-					Tangent = Vector3(0.0f, -Normal[2], Normal[1]);
+					Tangent = lcVector3(0.0f, -Normal[2], Normal[1]);
 					break;
 				case LC_OVERLAY_Y:
 					Angle = m_MouseTotalDelta[1];
-					Tangent = Vector3(Normal[2], 0.0f, -Normal[0]);
+					Tangent = lcVector3(Normal[2], 0.0f, -Normal[0]);
 					break;
 				case LC_OVERLAY_Z:
 					Angle = m_MouseTotalDelta[2];
-					Tangent = Vector3(-Normal[1], Normal[0], 0.0f);
+					Tangent = lcVector3(-Normal[1], Normal[0], 0.0f);
 					break;
 				}
 
@@ -2469,10 +2464,10 @@ void Project::RenderOverlays(View* view)
 					const float OverlayRotateArrowSize = 1.5f;
 					const float OverlayRotateArrowCapSize = 0.25f;
 
-					Vector3 Pt = Normal * OverlayScale * OverlayRotateRadius;
-					Vector3 Tip = Pt + Tangent * OverlayScale * OverlayRotateArrowSize;
-					Vector3 Arrow;
-					Matrix33 Rot;
+					lcVector3 Pt = Normal * (OverlayScale * OverlayRotateRadius);
+					lcVector3 Tip = Pt + Tangent * (OverlayScale * OverlayRotateArrowSize);
+					lcVector3 Arrow;
+					lcMatrix44 Rot;
 
 					glBegin(GL_LINES);
 					glColor3f(0.8f, 0.8f, 0.0f);
@@ -2480,14 +2475,14 @@ void Project::RenderOverlays(View* view)
 					glVertex3f(Pt[0], Pt[1], Pt[2]);
 					glVertex3f(Tip[0], Tip[1], Tip[2]);
 
-					Rot.CreateFromAxisAngle(Normal, LC_PI * 0.15f);
-					Arrow = Mul(Tangent, Rot) * OverlayRotateArrowCapSize;
+					Rot = lcMatrix44FromAxisAngle(Normal, LC_PI * 0.15f);
+					Arrow = lcMul30(Tangent, Rot) * OverlayRotateArrowCapSize;
 
 					glVertex3f(Tip[0], Tip[1], Tip[2]);
 					glVertex3f(Tip[0] - Arrow[0], Tip[1] - Arrow[1], Tip[2] - Arrow[2]);
 
-					Rot.CreateFromAxisAngle(Normal, -LC_PI * 0.15f);
-					Arrow = Mul(Tangent, Rot) * OverlayRotateArrowCapSize;
+					Rot = lcMatrix44FromAxisAngle(Normal, -LC_PI * 0.15f);
+					Arrow = lcMul30(Tangent, Rot) * OverlayRotateArrowCapSize;
 
 					glVertex3f(Tip[0], Tip[1], Tip[2]);
 					glVertex3f(Tip[0] - Arrow[0], Tip[1] - Arrow[1], Tip[2] - Arrow[2]);
@@ -2502,11 +2497,10 @@ void Project::RenderOverlays(View* view)
 					float Aspect = (float)Viewport[2]/(float)Viewport[3];
 					Camera* Cam = view->m_Camera;
 
-					Matrix44 ModelView, Projection;
-					ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-					Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+					const lcMatrix44& ModelView = Cam->mWorldView;
+					lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-					Vector3 Screen = ProjectPoint(Vector3(0, 0, 0), ModelView, Projection, Viewport);
+					lcVector3 Screen = lcProjectPoint(lcVector3(0, 0, 0), ModelView, Projection, Viewport);
 
 					glMatrixMode(GL_PROJECTION);
 					glPushMatrix();
@@ -3321,13 +3315,13 @@ void Project::HandleNotify(LC_NOTIFY id, unsigned long param)
 			else
 				pCamera->UnHide();
 
-			if (pCamera->GetEyePosition() != mod->Eye)
+			if (pCamera->mPosition != mod->Eye)
 				pCamera->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, mod->Eye, LC_CK_EYE);
 
-			if (pCamera->GetTargetPosition() != mod->Target)
+			if (pCamera->mTargetPosition != mod->Target)
 				pCamera->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, mod->Target, LC_CK_TARGET);
 
-			if (pCamera->GetUpVector() != mod->Up)
+			if (pCamera->mUpVector != mod->Up)
 				pCamera->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, mod->Up, LC_CK_UP);
 
 			pCamera->m_fovy = mod->fovy;
@@ -3990,13 +3984,12 @@ void Project::HandleCommand(LC_COMMANDS id, unsigned long nParam)
 				POVFile.WriteLine(Line);
 			}
 
-			float eye[3], target[3], up[3];
-			m_ActiveView->m_Camera->GetEyePos(eye);
-			m_ActiveView->m_Camera->GetTargetPos(target);
-			m_ActiveView->m_Camera->GetUpVec(up);
+			const lcVector3& Position = m_ActiveView->m_Camera->mPosition;
+			const lcVector3& Target = m_ActiveView->m_Camera->mTargetPosition;
+			const lcVector3& Up = m_ActiveView->m_Camera->mUpVector;
 
 			sprintf(Line, "camera {\n  sky<%1g,%1g,%1g>\n  location <%1g, %1g, %1g>\n  look_at <%1g, %1g, %1g>\n  angle %.0f\n}\n\n",
-				up[0], up[1], up[2], eye[1], eye[0], eye[2], target[1], target[0], target[2], m_ActiveView->m_Camera->m_fovy);
+				Up[0], Up[1], Up[2], Position[1], Position[0], Position[2], Target[1], Target[0], Target[2], m_ActiveView->m_Camera->m_fovy);
 			POVFile.WriteLine(Line);
 			sprintf(Line, "background { color rgb <%1g, %1g, %1g> }\n\nlight_source { <0, 0, 20> White shadowless }\n\n",
 				m_fBackground[0], m_fBackground[1], m_fBackground[2]);
@@ -5384,10 +5377,10 @@ void Project::HandleCommand(LC_COMMANDS id, unsigned long nParam)
 				float Aspect = (float)Viewport[2]/(float)Viewport[3];
 				Camera* Cam = view->m_Camera;
 
-				Vector3 Position(Cam->GetEyePosition() + Center - Cam->GetTargetPosition());
+				Vector3 Position(Vector3(Cam->mPosition) + Center - Vector3(Cam->mTargetPosition));
 
 				Matrix44 ModelView, Projection;
-				ModelView.CreateLookAt(Position, Center, Cam->GetUpVector());
+				ModelView.CreateLookAt(Position, Center, Vector3(Cam->mUpVector));
 				Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
 				Position = ZoomExtents(Position, ModelView, Projection, &Points[0], Points.GetSize());
@@ -6053,7 +6046,7 @@ void Project::SelectAndFocusNone(bool bFocusOnly)
 //	AfxGetMainWnd()->PostMessage(WM_LC_UPDATE_INFO, NULL, OT_PIECE);
 }
 
-bool Project::GetSelectionCenter(Vector3& Center) const
+bool Project::GetSelectionCenter(lcVector3& Center) const
 {
 	float bs[6] = { 10000, 10000, 10000, -10000, -10000, -10000 };
 	bool Selected = false;
@@ -6067,7 +6060,7 @@ bool Project::GetSelectionCenter(Vector3& Center) const
 		}
 	}
 
-	Center = Vector3((bs[0] + bs[3]) * 0.5f, (bs[1] + bs[4]) * 0.5f, (bs[2] + bs[5]) * 0.5f);
+	Center = lcVector3((bs[0] + bs[3]) * 0.5f, (bs[1] + bs[4]) * 0.5f, (bs[2] + bs[5]) * 0.5f);
 
 	return Selected;
 }
@@ -6081,28 +6074,27 @@ Camera* Project::GetCamera(int i)
 	return pCamera;
 }
 
-void Project::ConvertToUserUnits(Vector3& Value) const
+void Project::ConvertToUserUnits(lcVector3& Value) const
 {
 	if ((m_nSnap & LC_DRAW_CM_UNITS) == 0)
 		Value /= 0.04f;
 }
 
-void Project::ConvertFromUserUnits(Vector3& Value) const
+void Project::ConvertFromUserUnits(lcVector3& Value) const
 {
 	if ((m_nSnap & LC_DRAW_CM_UNITS) == 0)
 		Value *= 0.04f;
 }
 
-bool Project::GetFocusPosition(Vector3& Position) const
+bool Project::GetFocusPosition(lcVector3& Position) const
 {
 	Piece* pPiece;
 	Camera* pCamera;
-	float* pos = &Position[0];
 
 	for (pPiece = m_pPieces; pPiece; pPiece = pPiece->m_pNext)
 		if (pPiece->IsFocused())
 		{
-			pPiece->GetPosition(pos);
+			Position = pPiece->mPosition;
 			return true;
 		}
 
@@ -6110,20 +6102,20 @@ bool Project::GetFocusPosition(Vector3& Position) const
 	{
 		if (pCamera->IsEyeFocused())
 		{
-			pCamera->GetEyePos(pos);
+			Position = pCamera->mPosition;
 			return true;
 		}
 
 		if (pCamera->IsTargetFocused())
 		{
-			pCamera->GetTargetPos(pos);
+			Position = pCamera->mTargetPosition;
 			return true;
 		}
 	}
 
 	// TODO: light
 
-	pos[0] = pos[1] = pos[2] = 0.0f;
+	Position = lcVector3(0.0f, 0.0f, 0.0f);
 
 	return false;
 }
@@ -6184,16 +6176,14 @@ void Project::GetPieceInsertPosition(View* view, int MouseX, int MouseY, Vector3
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	// Build the matrices.
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 ClickPoints[2] = { Vector3((float)m_nDownX, (float)m_nDownY, 0.0f), Vector3((float)m_nDownX, (float)m_nDownY, 1.0f) };
-	UnprojectPoints(ClickPoints, 2, ModelView, Projection, Viewport);
+	lcVector3 ClickPoints[2] = { lcVector3((float)m_nDownX, (float)m_nDownY, 0.0f), lcVector3((float)m_nDownX, (float)m_nDownY, 1.0f) };
+	lcUnprojectPoints(ClickPoints, 2, ModelView, Projection, Viewport);
 
 	Vector3 Intersection;
-	if (LinePlaneIntersection(Intersection, ClickPoints[0], ClickPoints[1], Vector4(0, 0, 1, 0)))
+	if (LinePlaneIntersection(Intersection, Vector3(ClickPoints[0]), Vector3(ClickPoints[1]), Vector4(0, 0, 1, 0)))
 	{
 		SnapVector(Intersection);
 		Position = Intersection;
@@ -6202,7 +6192,7 @@ void Project::GetPieceInsertPosition(View* view, int MouseX, int MouseY, Vector3
 	}
 
 	// Couldn't find a good position, so just place the piece somewhere near the camera.
-	Position = UnprojectPoint(Vector3((float)m_nDownX, (float)m_nDownY, 0.9f), ModelView, Projection, Viewport);
+	Position = Vector3(lcUnprojectPoint(lcVector3((float)m_nDownX, (float)m_nDownY, 0.9f), ModelView, Projection, Viewport));
 	Rotation = Vector4(0, 0, 1, 0);
 }
 
@@ -6212,12 +6202,11 @@ Object* Project::FindObjectFromPoint(View* view, int x, int y, bool PiecesOnly)
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 Start = UnprojectPoint(Vector3((float)x, (float)y, 0.0f), ModelView, Projection, Viewport);
-	Vector3 End = UnprojectPoint(Vector3((float)x, (float)y, 1.0f), ModelView, Projection, Viewport);
+	lcVector3 Start = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.0f), ModelView, Projection, Viewport);
+	lcVector3 End = lcUnprojectPoint(lcVector3((float)x, (float)y, 1.0f), ModelView, Projection, Viewport);
 
 	LC_CLICKLINE ClickLine;
 
@@ -6253,10 +6242,8 @@ void Project::FindObjectsInBox(float x1, float y1, float x2, float y2, PtrArray<
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = m_ActiveView->m_Camera;
 
-	// Build the matrices.
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
 	// Find out the top-left and bottom-right corners in screen coordinates.
 	float Left, Top, Bottom, Right;
@@ -6284,37 +6271,38 @@ void Project::FindObjectsInBox(float x1, float y1, float x2, float y2, PtrArray<
 	}
 
 	// Unproject 6 points to world space.
-	Vector3 Corners[6] =
+	lcVector3 Corners[6] =
 	{
-		Vector3(Left, Top, 0), Vector3(Left, Bottom, 0), Vector3(Right, Bottom, 0),
-		Vector3(Right, Top, 0), Vector3(Left, Top, 1), Vector3(Right, Bottom, 1)
+		lcVector3(Left, Top, 0), lcVector3(Left, Bottom, 0), lcVector3(Right, Bottom, 0),
+		lcVector3(Right, Top, 0), lcVector3(Left, Top, 1), lcVector3(Right, Bottom, 1)
 	};
 
-	UnprojectPoints(Corners, 6, ModelView, Projection, Viewport);
+	lcUnprojectPoints(Corners, 6, ModelView, Projection, Viewport);
 
 	// Build the box planes.
-	Vector4 Planes[6];
+	lcVector3 PlaneNormals[6];
 
-	Planes[0] = Cross3(Corners[4] - Corners[0], Corners[1] - Corners[0]).Normalize(); // Left
-	Planes[1] = Cross3(Corners[5] - Corners[2], Corners[3] - Corners[2]).Normalize(); // Right
-	Planes[2] = Cross3(Corners[3] - Corners[0], Corners[4] - Corners[0]).Normalize(); // Top
-	Planes[3] = Cross3(Corners[1] - Corners[2], Corners[5] - Corners[2]).Normalize(); // Bottom
-	Planes[4] = Cross3(Corners[1] - Corners[0], Corners[3] - Corners[0]).Normalize(); // Front
-	Planes[5] = Cross3(Corners[1] - Corners[2], Corners[3] - Corners[2]).Normalize(); // Back
+	PlaneNormals[0] = lcNormalize(lcCross(Corners[4] - Corners[0], Corners[1] - Corners[0])); // Left
+	PlaneNormals[1] = lcNormalize(lcCross(Corners[5] - Corners[2], Corners[3] - Corners[2])); // Right
+	PlaneNormals[2] = lcNormalize(lcCross(Corners[3] - Corners[0], Corners[4] - Corners[0])); // Top
+	PlaneNormals[3] = lcNormalize(lcCross(Corners[1] - Corners[2], Corners[5] - Corners[2])); // Bottom
+	PlaneNormals[4] = lcNormalize(lcCross(Corners[1] - Corners[0], Corners[3] - Corners[0])); // Front
+	PlaneNormals[5] = lcNormalize(lcCross(Corners[1] - Corners[2], Corners[3] - Corners[2])); // Back
 
-	Planes[0][3] = -Dot3(Planes[0], Corners[0]);
-	Planes[1][3] = -Dot3(Planes[1], Corners[5]);
-	Planes[2][3] = -Dot3(Planes[2], Corners[0]);
-	Planes[3][3] = -Dot3(Planes[3], Corners[5]);
-	Planes[4][3] = -Dot3(Planes[4], Corners[0]);
-	Planes[5][3] = -Dot3(Planes[5], Corners[5]);
+	lcVector4 Planes[6];
+	Planes[0] = lcVector4(PlaneNormals[0], -lcDot(PlaneNormals[0], Corners[0]));
+	Planes[1] = lcVector4(PlaneNormals[1], -lcDot(PlaneNormals[1], Corners[5]));
+	Planes[2] = lcVector4(PlaneNormals[2], -lcDot(PlaneNormals[2], Corners[0]));
+	Planes[3] = lcVector4(PlaneNormals[3], -lcDot(PlaneNormals[3], Corners[5]));
+	Planes[4] = lcVector4(PlaneNormals[4], -lcDot(PlaneNormals[4], Corners[0]));
+	Planes[5] = lcVector4(PlaneNormals[5], -lcDot(PlaneNormals[5], Corners[5]));
 
 	// Check if any objects are inside the volume.
 	for (Piece* piece = m_pPieces; piece != NULL; piece = piece->m_pNext)
 	{
 		if (piece->IsVisible(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation))
 		{
-			if (piece->IntersectsVolume(Planes, 6))
+			if (piece->IntersectsVolume((Vector4*)Planes, 6))
 				Objects.Add(piece);
 		}
 	}
@@ -6448,10 +6436,8 @@ bool Project::StopTracking(bool bAccept)
 				float Aspect = (float)Viewport[2]/(float)Viewport[3];
 				Camera* Cam = m_ActiveView->m_Camera;
 
-				// Build the matrices.
-				Matrix44 ModelView, Projection;
-				ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-				Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+				const lcMatrix44& ModelView = Cam->mWorldView;
+				lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
 				// Find out the top-left and bottom-right corners in screen coordinates.
 				float Left, Top, Bottom, Right;
@@ -6479,20 +6465,20 @@ bool Project::StopTracking(bool bAccept)
 				}
 
 				// Unproject screen points to world space.
-				Vector3 Points[3] =
+				lcVector3 Points[3] =
 				{
-					Vector3((Left + Right) / 2, (Top + Bottom) / 2, 0.9f),
-					Vector3((float)Viewport[2] / 2.0f, (float)Viewport[3] / 2.0f, 0.9f),
-					Vector3((float)Viewport[2] / 2.0f, (float)Viewport[3] / 2.0f, 0.1f),
+					lcVector3((Left + Right) / 2, (Top + Bottom) / 2, 0.9f),
+					lcVector3((float)Viewport[2] / 2.0f, (float)Viewport[3] / 2.0f, 0.9f),
+					lcVector3((float)Viewport[2] / 2.0f, (float)Viewport[3] / 2.0f, 0.1f),
 				};
 
-				UnprojectPoints(Points, 3, ModelView, Projection, Viewport);
+				lcUnprojectPoints(Points, 3, ModelView, Projection, Viewport);
 
 				// Center camera.
-				Vector3 Eye = Cam->GetEyePosition();
+				lcVector3 Eye = Cam->mPosition;
 				Eye = Eye + (Points[0] - Points[1]);
 
-				Vector3 Target = Cam->GetTargetPosition();
+				lcVector3 Target = Cam->mTargetPosition;
 				Target = Target + (Points[0] - Points[1]);
 
 				// Zoom in/out.
@@ -6500,14 +6486,14 @@ bool Project::StopTracking(bool bAccept)
 				float RatioY = (Top - Bottom) / Viewport[3];
 				float ZoomFactor = -max(RatioX, RatioY) + 0.75f;
 
-				Vector3 Dir = Points[1] - Points[2];
+				lcVector3 Dir = Points[1] - Points[2];
 				Eye = Eye + Dir * ZoomFactor;
 				Target = Target + Dir * ZoomFactor;
 
 				// Change the camera and redraw.
-			  Cam->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, Eye, LC_CK_EYE);
-			  Cam->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, Target, LC_CK_TARGET);
-			  Cam->UpdatePosition(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation);
+				Cam->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, Eye, LC_CK_EYE);
+				Cam->ChangeKey(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation, m_bAddKeys, Target, LC_CK_TARGET);
+				Cam->UpdatePosition(m_bAnimation ? m_nCurFrame : m_nCurStep, m_bAnimation);
 
 				SystemUpdateFocus(NULL);
 				UpdateAllViews();
@@ -7180,7 +7166,7 @@ bool Project::OnKeyDown(char nKey, bool bControl, bool bShift)
 				{
 					Matrix mat;
 
-					mat.CreateLookat(camera->GetEyePos (), camera->GetTargetPos (), camera->GetUpVec ());
+					mat.CreateLookat(camera->mPosition, camera->mTargetPosition, camera->mUpVector);
 					mat.SetTranslation(0, 0, 0);
 					mat.Invert();
 
@@ -7244,12 +7230,11 @@ bool Project::OnKeyDown(char nKey, bool bControl, bool bShift)
 					float Aspect = (float)Viewport[2]/(float)Viewport[3];
 					Camera* Cam = m_ActiveView->m_Camera;
 
-					Matrix44 ModelView, Projection;
-					ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-					Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+					const lcMatrix44& ModelView = Cam->mWorldView;
+					lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-					Vector3 Pts[3] = { Vector3(5.0f, 5.0f, 0.1f), Vector3(10.0f, 5.0f, 0.1f), Vector3(5.0f, 10.0f, 0.1f) };
-					UnprojectPoints(Pts, 3, ModelView, Projection, Viewport);
+					lcVector3 Pts[3] = { lcVector3(5.0f, 5.0f, 0.1f), lcVector3(10.0f, 5.0f, 0.1f), lcVector3(5.0f, 10.0f, 0.1f) };
+					lcUnprojectPoints(Pts, 3, ModelView, Projection, Viewport);
 
 					float ax, ay;
 					Vector3 vx((Pts[1][0] - Pts[0][0]), (Pts[1][1] - Pts[0][1]), 0);//Pts[1][2] - Pts[0][2] };
@@ -7348,11 +7333,10 @@ void Project::OnLeftButtonDown(View* view, int x, int y, bool bControl, bool bSh
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 point = UnprojectPoint(Vector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
+	lcVector3 point = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
 	m_fTrack[0] = point[0]; m_fTrack[1] = point[1]; m_fTrack[2] = point[2];
 
 	if (Sys_KeyDown(KEY_ALT))
@@ -7563,7 +7547,7 @@ void Project::OnLeftButtonDown(View* view, int x, int y, bool bControl, bool bSh
       if (count == max)
         break;
 
-	  Vector3 tmp = UnprojectPoint(Vector3(x+1.0f, y-1.0f, 0.9f), ModelView, Projection, Viewport);
+	  lcVector3 tmp = lcUnprojectPoint(lcVector3(x+1.0f, y-1.0f, 0.9f), ModelView, Projection, Viewport);
       SelectAndFocusNone(false);
       StartTracking(LC_TRACK_START_LEFT);
       pLight = new Light (m_fTrack[0], m_fTrack[1], m_fTrack[2], tmp[0], tmp[1], tmp[2]);
@@ -7577,7 +7561,7 @@ void Project::OnLeftButtonDown(View* view, int x, int y, bool bControl, bool bSh
 
     case LC_ACTION_CAMERA:
     {
-	  Vector3 tmp = UnprojectPoint(Vector3(x+1.0f, y-1.0f, 0.9f), ModelView, Projection, Viewport);
+	  lcVector3 tmp = lcUnprojectPoint(lcVector3(x+1.0f, y-1.0f, 0.9f), ModelView, Projection, Viewport);
       SelectAndFocusNone(false);
       StartTracking(LC_TRACK_START_LEFT);
       Camera* pCamera = new Camera(m_fTrack[0], m_fTrack[1], m_fTrack[2], tmp[0], tmp[1], tmp[2], m_pCameras);
@@ -7627,7 +7611,7 @@ void Project::OnLeftButtonDown(View* view, int x, int y, bool bControl, bool bSh
 			if (sel)
 			{
 				StartTracking(LC_TRACK_START_LEFT);
-				m_OverlayDelta = Vector3(0.0f, 0.0f, 0.0f);
+				m_OverlayDelta = lcVector3(0.0f, 0.0f, 0.0f);
 				m_MouseSnapLeftover = Vector3(0.0f, 0.0f, 0.0f);
 			}
 		} break;
@@ -7641,7 +7625,7 @@ void Project::OnLeftButtonDown(View* view, int x, int y, bool bControl, bool bSh
 				if (pPiece->IsSelected())
 				{
 					StartTracking(LC_TRACK_START_LEFT);
-					m_OverlayDelta = Vector3(0.0f, 0.0f, 0.0f);
+					m_OverlayDelta = lcVector3(0.0f, 0.0f, 0.0f);
 					break;
 				}
 			}
@@ -7674,11 +7658,10 @@ void Project::OnLeftButtonDoubleClick(View* view, int x, int y, bool bControl, b
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 point = UnprojectPoint(Vector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
+	lcVector3 point = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
 	m_fTrack[0] = point[0]; m_fTrack[1] = point[1]; m_fTrack[2] = point[2];
 
 	Object* Closest = FindObjectFromPoint(view, x, y);
@@ -7779,11 +7762,10 @@ void Project::OnMiddleButtonDown(View* view, int x, int y, bool bControl, bool b
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 point = UnprojectPoint(Vector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
+	lcVector3 point = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
 	m_fTrack[0] = point[0]; m_fTrack[1] = point[1]; m_fTrack[2] = point[2];
 
 	if (Sys_KeyDown(KEY_ALT))
@@ -7822,11 +7804,10 @@ void Project::OnRightButtonDown(View* view, int x, int y, bool bControl, bool bS
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 point = UnprojectPoint(Vector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
+	lcVector3 point = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
 	m_fTrack[0] = point[0]; m_fTrack[1] = point[1]; m_fTrack[2] = point[2];
 
 	if (Sys_KeyDown(KEY_ALT))
@@ -7920,11 +7901,10 @@ void Project::OnMouseMove(View* view, int x, int y, bool bControl, bool bShift)
 	float Aspect = (float)Viewport[2]/(float)Viewport[3];
 	Camera* Cam = view->m_Camera;
 
-	Matrix44 ModelView, Projection;
-	ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-	Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+	const lcMatrix44& ModelView = Cam->mWorldView;
+	lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-	Vector3 tmp = UnprojectPoint(Vector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
+	lcVector3 tmp = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.9f), ModelView, Projection, Viewport);
 	ptx = tmp[0]; pty = tmp[1]; ptz = tmp[2];
 
 	switch (m_nCurAction)
@@ -8011,8 +7991,8 @@ void Project::OnMouseMove(View* view, int x, int y, bool bControl, bool bShift)
 
 			if ((m_OverlayActive && (m_OverlayMode != LC_OVERLAY_XYZ)) || (!Camera->IsSide()))
 			{
-				Vector3 ScreenX = Cross3(Camera->GetTargetPosition() - Camera->GetEyePosition(), Camera->GetUpVector());
-				Vector3 ScreenY = Camera->GetUpVector();
+				Vector3 ScreenX = Cross3(Vector3(Camera->mTargetPosition) - Vector3(Camera->mPosition), Vector3(Camera->mUpVector));
+				Vector3 ScreenY = Vector3(Camera->mUpVector);
 				ScreenX.Normalize();
 				Vector3 Dir1, Dir2;
 				bool SingleDir = true;
@@ -8148,9 +8128,9 @@ void Project::OnMouseMove(View* view, int x, int y, bool bControl, bool bShift)
 			else
 			{
 				// 3D movement.
-				Vector3 ScreenZ = (Camera->GetTargetPosition() - Camera->GetEyePosition()).Normalize();
-				Vector3 ScreenX = Cross3(ScreenZ, Camera->GetUpVector());
-				Vector3 ScreenY = Camera->GetUpVector();
+				Vector3 ScreenZ = (Vector3(Camera->mTargetPosition) - Vector3(Camera->mPosition)).Normalize();
+				Vector3 ScreenX = Cross3(ScreenZ, Vector3(Camera->mUpVector));
+				Vector3 ScreenY = Vector3(Camera->mUpVector);
 
 				Vector3 TotalMove;
 
@@ -8190,8 +8170,8 @@ void Project::OnMouseMove(View* view, int x, int y, bool bControl, bool bShift)
 
 			if ((m_OverlayActive && (m_OverlayMode != LC_OVERLAY_XYZ)) || (!Camera->IsSide()))
 			{
-				Vector3 ScreenX = Cross3(Camera->GetTargetPosition() - Camera->GetEyePosition(), Camera->GetUpVector());
-				Vector3 ScreenY = Camera->GetUpVector();
+				Vector3 ScreenX = Cross3(Vector3(Camera->mTargetPosition) - Vector3(Camera->mPosition), Vector3(Camera->mUpVector));
+				Vector3 ScreenY = Vector3(Camera->mUpVector);
 				ScreenX.Normalize();
 				Vector3 Dir1, Dir2;
 				bool SingleDir = true;
@@ -8306,9 +8286,9 @@ void Project::OnMouseMove(View* view, int x, int y, bool bControl, bool bShift)
 			else
 			{
 				// 3D movement.
-				Vector3 ScreenZ = (Camera->GetTargetPosition() - Camera->GetEyePosition()).Normalize();
-				Vector3 ScreenX = Cross3(ScreenZ, Camera->GetUpVector());
-				Vector3 ScreenY = Camera->GetUpVector();
+				Vector3 ScreenZ = (Vector3(Camera->mTargetPosition) - Vector3(Camera->mPosition)).Normalize();
+				Vector3 ScreenX = Cross3(ScreenZ, Vector3(Camera->mUpVector));
+				Vector3 ScreenY = Vector3(Camera->mUpVector);
 
 				Vector3 Delta;
 
@@ -8383,11 +8363,10 @@ void Project::OnMouseMove(View* view, int x, int y, bool bControl, bool bShift)
 			// We can't rotate the side cameras.
 			if (m_ActiveView->m_Camera->IsSide())
 			{
-				float eye[3], target[3], up[3];
-				m_ActiveView->m_Camera->GetEyePos(eye);
-				m_ActiveView->m_Camera->GetTargetPos(target);
-				m_ActiveView->m_Camera->GetUpVec(up);
-				Camera* pCamera = new Camera(eye, target, up, m_pCameras);
+				const lcVector3& Position = m_ActiveView->m_Camera->mPosition;
+				const lcVector3& Target = m_ActiveView->m_Camera->mTargetPosition;
+				const lcVector3& Up = m_ActiveView->m_Camera->mUpVector;
+				Camera* pCamera = new Camera(Position, Target, Up, m_pCameras);
 
 				m_ActiveView->m_Camera = pCamera;
 				SystemUpdateCameraMenu(m_pCameras);
@@ -8482,17 +8461,16 @@ void Project::MouseUpdateOverlays(View* view, int x, int y)
 		float Aspect = (float)Viewport[2]/(float)Viewport[3];
 		Camera* Cam = view->m_Camera;
 
-		Matrix44 ModelView, Projection;
-		ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-		Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+		const lcMatrix44& ModelView = Cam->mWorldView;
+		lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
 		// Array of points for the arrow edges.
-		Vector3 Points[4] =
+		lcVector3 Points[4] =
 		{
-			Vector3(m_OverlayCenter[0], m_OverlayCenter[1], m_OverlayCenter[2]),
-			Vector3(OverlayMoveArrowSize * OverlayScale, 0, 0),
-			Vector3(0, OverlayMoveArrowSize * OverlayScale, 0),
-			Vector3(0, 0, OverlayMoveArrowSize * OverlayScale),
+			lcVector3(m_OverlayCenter[0], m_OverlayCenter[1], m_OverlayCenter[2]),
+			lcVector3(OverlayMoveArrowSize * OverlayScale, 0, 0),
+			lcVector3(0, OverlayMoveArrowSize * OverlayScale, 0),
+			lcVector3(0, 0, OverlayMoveArrowSize * OverlayScale),
 		};
 
 		// Find the rotation from the focused piece if relative snap is enabled.
@@ -8502,39 +8480,36 @@ void Project::MouseUpdateOverlays(View* view, int x, int y)
 
 			if ((Focus != NULL) && Focus->IsPiece())
 			{
-				float Rot[4];
-				((Piece*)Focus)->GetRotation(Rot);
-
-				Matrix33 RotMat;
-				RotMat.CreateFromAxisAngle(Vector3(Rot[0], Rot[1], Rot[2]), Rot[3] * LC_DTOR);
+				const lcMatrix44& RotMat = ((Piece*)Focus)->mModelWorld;
 
 				for (int i = 1; i < 4; i++)
-					Points[i] = Mul(Points[i], RotMat);
+					Points[i] = lcMul30(Points[i], RotMat);
 			}
 		}
 
 		int i, Mode = -1;
-		Vector3 Pt((float)x, (float)y, 0);
+		lcVector3 Pt((float)x, (float)y, 0);
 
 		for (i = 1; i < 4; i++)
+		{
 			Points[i] += Points[0];
-
-		ProjectPoints(Points, 4, ModelView, Projection, Viewport);
+			Points[i] = lcProjectPoint(Points[i], ModelView, Projection, Viewport);
+		}
 
 		// Check if the mouse is over an arrow.
 		for (i = 1; i < 4; i++)
 		{
-			Vector3 Line = Points[i] - Points[0];
-			Vector3 Vec = Pt - Points[0];
+			lcVector3 Line = Points[i] - Points[0];
+			lcVector3 Vec = Pt - Points[0];
 
-			float u = Dot3(Vec, Line) / Line.LengthSquared();
+			float u = lcDot(Vec, Line) / Line.LengthSquared();
 
 			// Point is outside the line segment.
 			if (u < 0.0f || u > 1.0f)
 				continue;
 
 			// Closest point in the line segment to the mouse.
-			Vector3 Closest = Points[0] + u * Line;
+			lcVector3 Closest = Points[0] + Line * u;
 
 			if ((Closest - Pt).LengthSquared() < 100.0f)
 			{
@@ -8586,23 +8561,22 @@ void Project::MouseUpdateOverlays(View* view, int x, int y)
 		float Aspect = (float)Viewport[2]/(float)Viewport[3];
 		Camera* Cam = view->m_Camera;
 
-		Matrix44 ModelView, Projection;
-		ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-		Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+		const lcMatrix44& ModelView = Cam->mWorldView;
+		lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
 		// Unproject the mouse point against both the front and the back clipping planes.
-		Vector3 SegStart = UnprojectPoint(Vector3((float)x, (float)y, 0.0f), ModelView, Projection, Viewport);
-		Vector3 SegEnd = UnprojectPoint(Vector3((float)x, (float)y, 1.0f), ModelView, Projection, Viewport);
+		lcVector3 SegStart = lcUnprojectPoint(lcVector3((float)x, (float)y, 0.0f), ModelView, Projection, Viewport);
+		lcVector3 SegEnd = lcUnprojectPoint(lcVector3((float)x, (float)y, 1.0f), ModelView, Projection, Viewport);
 
-		Vector3 Center(m_OverlayCenter[0], m_OverlayCenter[1], m_OverlayCenter[2]);
+		lcVector3 Center(m_OverlayCenter);
 
-		Vector3 Line = SegEnd - SegStart;
-		Vector3 Vec = Center - SegStart;
+		lcVector3 Line = SegEnd - SegStart;
+		lcVector3 Vec = Center - SegStart;
 
-		float u = Dot3(Vec, Line) / Line.LengthSquared();
+		float u = lcDot(Vec, Line) / Line.LengthSquared();
 
 		// Closest point in the line to the mouse.
-		Vector3 Closest = SegStart + u * Line;
+		lcVector3 Closest = SegStart + Line * u;
 
 		int Mode = -1;
 		float Distance = (Closest - Center).Length();
@@ -8643,22 +8617,22 @@ void Project::MouseUpdateOverlays(View* view, int x, int y)
 			if (f >= 0.0f)
 			{
 				Camera* Cam = view->m_Camera;
-				Vector3 ViewDir = Cam->GetTargetPosition() - Cam->GetEyePosition();
+				lcVector3 ViewDir(Cam->mTargetPosition - Cam->mPosition);
 
 				float u1 = (-b + sqrtf(f)) / (2*a);
 				float u2 = (-b - sqrtf(f)) / (2*a);
 
-				Vector3 Intersections[2] =
+				lcVector3 Intersections[2] =
 				{
-					Vector3(x1 + u1*(x2-x1), y1 + u1*(y2-y1), z1 + u1*(z2-z1)),
-					Vector3(x1 + u2*(x2-x1), y1 + u2*(y2-y1), z1 + u2*(z2-z1))
+					lcVector3(x1 + u1*(x2-x1), y1 + u1*(y2-y1), z1 + u1*(z2-z1)),
+					lcVector3(x1 + u2*(x2-x1), y1 + u2*(y2-y1), z1 + u2*(z2-z1))
 				};
 
 				for (int i = 0; i < 2; i++)
 				{
-					Vector3 Dist = Intersections[i] - Center;
+					lcVector3 Dist = Intersections[i] - Center;
 
-					if (Dot3(ViewDir, Dist) > 0.0f)
+					if (lcDot(ViewDir, Dist) > 0.0f)
 						continue;
 
 					// Find the rotation from the focused piece if relative snap is enabled.
@@ -8668,13 +8642,11 @@ void Project::MouseUpdateOverlays(View* view, int x, int y)
 
 						if ((Focus != NULL) && Focus->IsPiece())
 						{
-							float Rot[4];
-							((Piece*)Focus)->GetRotation(Rot);
+							const lcVector4& Rot = ((Piece*)Focus)->mRotation;
 
-							Matrix33 RotMat;
-							RotMat.CreateFromAxisAngle(Vector3(Rot[0], Rot[1], Rot[2]), -Rot[3] * LC_DTOR);
+							lcMatrix44 RotMat = lcMatrix44FromAxisAngle(lcVector3(Rot[0], Rot[1], Rot[2]), -Rot[3] * LC_DTOR);
 
-							Dist = Mul(Dist, RotMat);
+							Dist = lcMul30(Dist, RotMat);
 						}
 					}
 
@@ -8814,15 +8786,14 @@ void Project::UpdateOverlayScale()
 		float Aspect = (float)Viewport[2]/(float)Viewport[3];
 		Camera* Cam = m_ActiveView->m_Camera;
 
-		Matrix44 ModelView, Projection;
-		ModelView.CreateLookAt(Cam->GetEyePosition(), Cam->GetTargetPosition(), Cam->GetUpVector());
-		Projection.CreatePerspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
+		const lcMatrix44& ModelView = Cam->mWorldView;
+		lcMatrix44 Projection = lcMatrix44Perspective(Cam->m_fovy, Aspect, Cam->m_zNear, Cam->m_zFar);
 
-		Vector3 Screen = ProjectPoint(m_OverlayCenter, ModelView, Projection, Viewport);
+		lcVector3 Screen = lcProjectPoint(m_OverlayCenter, ModelView, Projection, Viewport);
 		Screen[0] += 10.0f;
-		Vector3 Point = UnprojectPoint(Screen, ModelView, Projection, Viewport);
+		lcVector3 Point = lcUnprojectPoint(Screen, ModelView, Projection, Viewport);
 
-		Vector3 Dist(Point - m_OverlayCenter);
+		lcVector3 Dist(Point - m_OverlayCenter);
 		m_ActiveView->m_OverlayScale = Dist.Length() * 5.0f;
 	}
 }
diff --git a/common/project.h b/common/project.h
index 41c9c3f3..c4d0a9b7 100644
--- a/common/project.h
+++ b/common/project.h
@@ -6,6 +6,7 @@
 #include "opengl.h"
 #include "array.h"
 #include "algebra.h"
+#include "lc_math.h"
 
 typedef enum 
 {
@@ -105,8 +106,8 @@ public:
 	unsigned short GetTotalFrames () const
 		{ return m_nTotalFrames; }
 
-	void ConvertToUserUnits(Vector3& Value) const;
-	void ConvertFromUserUnits(Vector3& Value) const;
+	void ConvertToUserUnits(lcVector3& Value) const;
+	void ConvertFromUserUnits(lcVector3& Value) const;
 	void GetArrays(Piece** ppPiece, Camera** ppCamera, Light** ppLight)
 	{
 		*ppPiece = m_pPieces;
@@ -128,8 +129,8 @@ public:
 	void CreateImages(Image* images, int width, int height, unsigned short from, unsigned short to, bool hilite);
 	void Render(View* view, bool bToMemory);
 	void CheckAutoSave();
-	bool GetSelectionCenter(Vector3& Center) const;
-	bool GetFocusPosition(Vector3& Position) const;
+	bool GetSelectionCenter(lcVector3& Center) const;
+	bool GetFocusPosition(lcVector3& Position) const;
 	Object* GetFocusObject() const;
 	Group* AddGroup (const char* name, Group* pParent, float x, float y, float z);
 
@@ -219,9 +220,9 @@ protected:
 
 	int m_OverlayMode;
 	bool m_OverlayActive;
-	Vector3 m_OverlayCenter;
-	Vector3 m_OverlayTrackStart;
-	Vector3 m_OverlayDelta;
+	lcVector3 m_OverlayCenter;
+	lcVector3 m_OverlayTrackStart;
+	lcVector3 m_OverlayDelta;
 	void MouseUpdateOverlays(View* view, int x, int y);
 	void ActivateOverlay();
 	void UpdateOverlayScale();
diff --git a/common/terrain.cpp b/common/terrain.cpp
index a07330f7..4d5525c0 100644
--- a/common/terrain.cpp
+++ b/common/terrain.cpp
@@ -575,8 +575,7 @@ void Terrain::Render(Camera* pCam, float aspect)
 {
 	if (m_nOptions & LC_TERRAIN_FLAT)
 	{
-		float eye[3];
-		pCam->GetEyePos(eye);
+		const lcVector3& eye = pCam->mPosition;
 		glPushMatrix();
 		glTranslatef(eye[0], eye[1], 0);
 		glScalef(pCam->m_zFar, pCam->m_zFar, 1);
@@ -669,9 +668,8 @@ ty = (th*eye[1])/(2*pCam->m_zFar);
 void Terrain::FindVisiblePatches(Camera* pCam, float aspect)
 {
 	// Get camera position information.
-	float eye[3];
-	pCam->GetEyePos(eye);
-	
+	const lcVector3& eye = pCam->mPosition;
+
 	// Get perspective information.
 	float alpha = pCam->m_fovy / 2.0f;
 	float halfFovY = pCam->m_fovy / 2.0f;
@@ -681,9 +679,8 @@ void Terrain::FindVisiblePatches(Camera* pCam, float aspect)
 	float beta = 2.0f * halfFovX;
 
 	// Get vector stuff from the position.
-	float nonOrthoTop[3], target[3];
-	pCam->GetUpVec(nonOrthoTop);
-	pCam->GetTargetPos(target);
+	const lcVector3& nonOrthoTop = pCam->mUpVector;
+	const lcVector3& target = pCam->mTargetPosition;
 	float front[3] = { target[0] - eye[0], target[1] - eye[1], target[2] - eye[2]};
 	float side[3];
 	side[0] = nonOrthoTop[1]*front[2] - nonOrthoTop[2]*front[1];
diff --git a/common/typedefs.h b/common/typedefs.h
index cd3d21f8..a57bddf1 100644
--- a/common/typedefs.h
+++ b/common/typedefs.h
@@ -11,6 +11,7 @@ class Camera;
 
 #include "str.h"
 #include "algebra.h"
+#include "lc_math.h"
 
 typedef enum
 {
@@ -200,8 +201,8 @@ struct LC_SEL_DATA
 struct LC_PIECE_MODIFY
 {
 	Piece* piece;
-	Vector3 Position;
-	Vector3 Rotation;
+	lcVector3 Position;
+	lcVector3 Rotation;
 	char name[81];
 	int from;
 	int to;
@@ -212,9 +213,9 @@ struct LC_PIECE_MODIFY
 struct LC_CAMERA_MODIFY
 {
 	Camera* camera;
-	Vector3 Eye;
-	Vector3 Target;
-	Vector3 Up;
+	lcVector3 Eye;
+	lcVector3 Target;
+	lcVector3 Up;
 	char name[81];
 	float fovy;
 	float znear;
diff --git a/win/Mainfrm.cpp b/win/Mainfrm.cpp
index 18ed19f7..78a74c76 100644
--- a/win/Mainfrm.cpp
+++ b/win/Mainfrm.cpp
@@ -432,7 +432,7 @@ LONG CMainFrame::OnUpdateInfo(UINT lParam, LONG wParam)
 	m_wndProperties.Update(Focus);
 
 	char str[128];
-	Vector3 pos;
+	lcVector3 pos;
 
 	lcGetActiveProject()->GetFocusPosition(pos);
 	lcGetActiveProject()->ConvertToUserUnits(pos);
diff --git a/win/propertiespane.cpp b/win/propertiespane.cpp
index 1fe87953..4dc3ccb8 100644
--- a/win/propertiespane.cpp
+++ b/win/propertiespane.cpp
@@ -205,7 +205,7 @@ void CPropertiesPane::SetPiece(Object* Focus)
 
 	float Rot[4];
 	Piece* pPiece = (Piece*)Focus;
-	Vector3 Pos = pPiece->GetPosition();
+	lcVector3 Pos = pPiece->mPosition;
 	pPiece->GetRotation(Rot);
 	Matrix mat(Rot, Pos);
 	mat.ToEulerAngles(Rot);
@@ -249,11 +249,11 @@ void CPropertiesPane::ModifyPiece()
 	Modify.piece = (Piece*)mObject;
 
 	CMFCPropertyGridProperty* Position = m_wndPropList.GetProperty(0);
-	Modify.Position = Vector3(Position->GetSubItem(0)->GetValue().fltVal, Position->GetSubItem(1)->GetValue().fltVal, Position->GetSubItem(2)->GetValue().fltVal);
+	Modify.Position = lcVector3(Position->GetSubItem(0)->GetValue().fltVal, Position->GetSubItem(1)->GetValue().fltVal, Position->GetSubItem(2)->GetValue().fltVal);
 	lcGetActiveProject()->ConvertFromUserUnits(Modify.Position);
 
 	CMFCPropertyGridProperty* Rotation = m_wndPropList.GetProperty(1);
-	Modify.Rotation = Vector3(Rotation->GetSubItem(0)->GetValue().fltVal, Rotation->GetSubItem(1)->GetValue().fltVal, Rotation->GetSubItem(2)->GetValue().fltVal);
+	Modify.Rotation = lcVector3(Rotation->GetSubItem(0)->GetValue().fltVal, Rotation->GetSubItem(1)->GetValue().fltVal, Rotation->GetSubItem(2)->GetValue().fltVal);
 
 	CMFCPropertyGridProperty* Appearence = m_wndPropList.GetProperty(2);
 	Modify.from = Appearence->GetSubItem(0)->GetValue().ulVal;
@@ -330,7 +330,7 @@ void CPropertiesPane::SetCamera(Object* Focus)
 
 	Camera* pCamera = (Camera*)Focus;
 
-	Vector3 Pos = pCamera->GetEyePosition();
+	lcVector3 Pos = pCamera->mPosition;
 	lcGetActiveProject()->ConvertToUserUnits(Pos);
 
 	CMFCPropertyGridProperty* Position = m_wndPropList.GetProperty(0);
@@ -338,7 +338,7 @@ void CPropertiesPane::SetCamera(Object* Focus)
 	UpdateProperty(Position->GetSubItem(1), Pos[1]);
 	UpdateProperty(Position->GetSubItem(2), Pos[2]);
 
-	Vector3 Target = pCamera->GetTargetPosition();
+	lcVector3 Target = pCamera->mTargetPosition;
 	lcGetActiveProject()->ConvertToUserUnits(Target);
 
 	CMFCPropertyGridProperty* TargetProp = m_wndPropList.GetProperty(1);
@@ -346,7 +346,7 @@ void CPropertiesPane::SetCamera(Object* Focus)
 	UpdateProperty(TargetProp->GetSubItem(1), Target[1]);
 	UpdateProperty(TargetProp->GetSubItem(2), Target[2]);
 
-	Vector3 Up = pCamera->GetUpVector();
+	lcVector3 Up = pCamera->mUpVector;
 
 	CMFCPropertyGridProperty* UpProp = m_wndPropList.GetProperty(2);
 	UpdateProperty(UpProp->GetSubItem(0), Up[0]);
@@ -369,15 +369,15 @@ void CPropertiesPane::ModifyCamera()
 	Modify.camera = (Camera*)mObject;
 
 	CMFCPropertyGridProperty* PositionProp = m_wndPropList.GetProperty(0);
-	Modify.Eye = Vector3(PositionProp->GetSubItem(0)->GetValue().fltVal, PositionProp->GetSubItem(1)->GetValue().fltVal, PositionProp->GetSubItem(2)->GetValue().fltVal);
+	Modify.Eye = lcVector3(PositionProp->GetSubItem(0)->GetValue().fltVal, PositionProp->GetSubItem(1)->GetValue().fltVal, PositionProp->GetSubItem(2)->GetValue().fltVal);
 	lcGetActiveProject()->ConvertFromUserUnits(Modify.Eye);
 
 	CMFCPropertyGridProperty* TargetProp = m_wndPropList.GetProperty(1);
-	Modify.Target = Vector3(TargetProp->GetSubItem(0)->GetValue().fltVal, TargetProp->GetSubItem(1)->GetValue().fltVal, TargetProp->GetSubItem(2)->GetValue().fltVal);
+	Modify.Target = lcVector3(TargetProp->GetSubItem(0)->GetValue().fltVal, TargetProp->GetSubItem(1)->GetValue().fltVal, TargetProp->GetSubItem(2)->GetValue().fltVal);
 	lcGetActiveProject()->ConvertFromUserUnits(Modify.Target);
 
 	CMFCPropertyGridProperty* UpProp = m_wndPropList.GetProperty(2);
-	Modify.Up = Vector3(UpProp->GetSubItem(0)->GetValue().fltVal, UpProp->GetSubItem(1)->GetValue().fltVal, UpProp->GetSubItem(2)->GetValue().fltVal);
+	Modify.Up = lcVector3(UpProp->GetSubItem(0)->GetValue().fltVal, UpProp->GetSubItem(1)->GetValue().fltVal, UpProp->GetSubItem(2)->GetValue().fltVal);
 
 	CMFCPropertyGridProperty* SettingsProp = m_wndPropList.GetProperty(3);
 	Modify.fovy = SettingsProp->GetSubItem(0)->GetValue().fltVal;