implemented MATRIX4X4_OPENGLORIENTATION #define option, this is on by default and...

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@6615 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/cl_main.c b/cl_main.c
index 53b7bace7ed8217eeb4f4138cd9e2091c61a79e2..6782cc95fbcd83ec827ea6144a42a85925a3581e 100644 (file)
--- a/cl_main.c
+++ b/cl_main.c
@@ -472,7 +472,11 @@ void CL_BoundingBoxForEntity(entity_render_t *ent)
        if (model)
        {
                // NOTE: this directly extracts vector components from the matrix, which relies on the matrix orientation!
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               if (ent->matrix.m[0][2] != 0 || ent->matrix.m[1][2] != 0)
+#else
                if (ent->matrix.m[2][0] != 0 || ent->matrix.m[2][1] != 0)
+#endif
                {
                        // pitch or roll
                        ent->mins[0] = org[0] + model->rotatedmins[0];
@@ -482,7 +486,11 @@ void CL_BoundingBoxForEntity(entity_render_t *ent)
                        ent->maxs[1] = org[1] + model->rotatedmaxs[1];
                        ent->maxs[2] = org[2] + model->rotatedmaxs[2];
                }
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               else if (ent->matrix.m[1][0] != 0 || ent->matrix.m[0][1] != 0)
+#else
                else if (ent->matrix.m[0][1] != 0 || ent->matrix.m[1][0] != 0)
+#endif
                {
                        // yaw
                        ent->mins[0] = org[0] + model->yawmins[0];

diff --git a/matrixlib.c b/matrixlib.c
index 2800ac0d8f3d4a7fb91c4efa7c6c628b02e9b0a7..2dd212a98eca0b53bb454cf33ef2a5c6726c13d6 100644 (file)
--- a/matrixlib.c
+++ b/matrixlib.c
@@ -39,6 +39,24 @@ void Matrix4x4_CopyRotateOnly (matrix4x4_t *out, const matrix4x4_t *in)
 
 void Matrix4x4_CopyTranslateOnly (matrix4x4_t *out, const matrix4x4_t *in)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = 1.0f;
+       out->m[1][0] = 0.0f;
+       out->m[2][0] = 0.0f;
+       out->m[3][0] = in->m[0][3];
+       out->m[0][1] = 0.0f;
+       out->m[1][1] = 1.0f;
+       out->m[2][1] = 0.0f;
+       out->m[3][1] = in->m[1][3];
+       out->m[0][2] = 0.0f;
+       out->m[1][2] = 0.0f;
+       out->m[2][2] = 1.0f;
+       out->m[3][2] = in->m[2][3];
+       out->m[0][3] = 0.0f;
+       out->m[1][3] = 0.0f;
+       out->m[2][3] = 0.0f;
+       out->m[3][3] = 1.0f;
+#else
        out->m[0][0] = 1.0f;
        out->m[0][1] = 0.0f;
        out->m[0][2] = 0.0f;
@@ -55,10 +73,29 @@ void Matrix4x4_CopyTranslateOnly (matrix4x4_t *out, const matrix4x4_t *in)
        out->m[3][1] = 0.0f;
        out->m[3][2] = 0.0f;
        out->m[3][3] = 1.0f;
+#endif
 }
 
 void Matrix4x4_Concat (matrix4x4_t *out, const matrix4x4_t *in1, const matrix4x4_t *in2)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = in1->m[0][0] * in2->m[0][0] + in1->m[1][0] * in2->m[0][1] + in1->m[2][0] * in2->m[0][2] + in1->m[3][0] * in2->m[0][3];
+       out->m[1][0] = in1->m[0][0] * in2->m[1][0] + in1->m[1][0] * in2->m[1][1] + in1->m[2][0] * in2->m[1][2] + in1->m[3][0] * in2->m[1][3];
+       out->m[2][0] = in1->m[0][0] * in2->m[2][0] + in1->m[1][0] * in2->m[2][1] + in1->m[2][0] * in2->m[2][2] + in1->m[3][0] * in2->m[2][3];
+       out->m[3][0] = in1->m[0][0] * in2->m[3][0] + in1->m[1][0] * in2->m[3][1] + in1->m[2][0] * in2->m[3][2] + in1->m[3][0] * in2->m[3][3];
+       out->m[0][1] = in1->m[0][1] * in2->m[0][0] + in1->m[1][1] * in2->m[0][1] + in1->m[2][1] * in2->m[0][2] + in1->m[3][1] * in2->m[0][3];
+       out->m[1][1] = in1->m[0][1] * in2->m[1][0] + in1->m[1][1] * in2->m[1][1] + in1->m[2][1] * in2->m[1][2] + in1->m[3][1] * in2->m[1][3];
+       out->m[2][1] = in1->m[0][1] * in2->m[2][0] + in1->m[1][1] * in2->m[2][1] + in1->m[2][1] * in2->m[2][2] + in1->m[3][1] * in2->m[2][3];
+       out->m[3][1] = in1->m[0][1] * in2->m[3][0] + in1->m[1][1] * in2->m[3][1] + in1->m[2][1] * in2->m[3][2] + in1->m[3][1] * in2->m[3][3];
+       out->m[0][2] = in1->m[0][2] * in2->m[0][0] + in1->m[1][2] * in2->m[0][1] + in1->m[2][2] * in2->m[0][2] + in1->m[3][2] * in2->m[0][3];
+       out->m[1][2] = in1->m[0][2] * in2->m[1][0] + in1->m[1][2] * in2->m[1][1] + in1->m[2][2] * in2->m[1][2] + in1->m[3][2] * in2->m[1][3];
+       out->m[2][2] = in1->m[0][2] * in2->m[2][0] + in1->m[1][2] * in2->m[2][1] + in1->m[2][2] * in2->m[2][2] + in1->m[3][2] * in2->m[2][3];
+       out->m[3][2] = in1->m[0][2] * in2->m[3][0] + in1->m[1][2] * in2->m[3][1] + in1->m[2][2] * in2->m[3][2] + in1->m[3][2] * in2->m[3][3];
+       out->m[0][3] = in1->m[0][3] * in2->m[0][0] + in1->m[1][3] * in2->m[0][1] + in1->m[2][3] * in2->m[0][2] + in1->m[3][3] * in2->m[0][3];
+       out->m[1][3] = in1->m[0][3] * in2->m[1][0] + in1->m[1][3] * in2->m[1][1] + in1->m[2][3] * in2->m[1][2] + in1->m[3][3] * in2->m[1][3];
+       out->m[2][3] = in1->m[0][3] * in2->m[2][0] + in1->m[1][3] * in2->m[2][1] + in1->m[2][3] * in2->m[2][2] + in1->m[3][3] * in2->m[2][3];
+       out->m[3][3] = in1->m[0][3] * in2->m[3][0] + in1->m[1][3] * in2->m[3][1] + in1->m[2][3] * in2->m[3][2] + in1->m[3][3] * in2->m[3][3];
+#else
        out->m[0][0] = in1->m[0][0] * in2->m[0][0] + in1->m[0][1] * in2->m[1][0] + in1->m[0][2] * in2->m[2][0] + in1->m[0][3] * in2->m[3][0];
        out->m[0][1] = in1->m[0][0] * in2->m[0][1] + in1->m[0][1] * in2->m[1][1] + in1->m[0][2] * in2->m[2][1] + in1->m[0][3] * in2->m[3][1];
        out->m[0][2] = in1->m[0][0] * in2->m[0][2] + in1->m[0][1] * in2->m[1][2] + in1->m[0][2] * in2->m[2][2] + in1->m[0][3] * in2->m[3][2];
@@ -75,6 +112,7 @@ void Matrix4x4_Concat (matrix4x4_t *out, const matrix4x4_t *in1, const matrix4x4
        out->m[3][1] = in1->m[3][0] * in2->m[0][1] + in1->m[3][1] * in2->m[1][1] + in1->m[3][2] * in2->m[2][1] + in1->m[3][3] * in2->m[3][1];
        out->m[3][2] = in1->m[3][0] * in2->m[0][2] + in1->m[3][1] * in2->m[1][2] + in1->m[3][2] * in2->m[2][2] + in1->m[3][3] * in2->m[3][2];
        out->m[3][3] = in1->m[3][0] * in2->m[0][3] + in1->m[3][1] * in2->m[1][3] + in1->m[3][2] * in2->m[2][3] + in1->m[3][3] * in2->m[3][3];
+#endif
 }
 
 void Matrix4x4_Transpose (matrix4x4_t *out, const matrix4x4_t *in1)
@@ -97,27 +135,6 @@ void Matrix4x4_Transpose (matrix4x4_t *out, const matrix4x4_t *in1)
        out->m[3][3] = in1->m[3][3];
 }
 
-void Matrix4x4_Transpose3x3 (matrix4x4_t *out, const matrix4x4_t *in1)
-{
-       out->m[0][0] = in1->m[0][0];
-       out->m[0][1] = in1->m[1][0];
-       out->m[0][2] = in1->m[2][0];
-       out->m[1][0] = in1->m[0][1];
-       out->m[1][1] = in1->m[1][1];
-       out->m[1][2] = in1->m[2][1];
-       out->m[2][0] = in1->m[0][2];
-       out->m[2][1] = in1->m[1][2];
-       out->m[2][2] = in1->m[2][2];
-
-       out->m[0][3] = in1->m[0][3];
-       out->m[1][3] = in1->m[1][3];
-       out->m[2][3] = in1->m[2][3];
-       out->m[3][0] = in1->m[0][3];
-       out->m[3][1] = in1->m[1][3];
-       out->m[3][2] = in1->m[2][3];
-       out->m[3][3] = in1->m[3][3];
-}
-
 void Matrix4x4_Invert_Simple (matrix4x4_t *out, const matrix4x4_t *in1)
 {
        // we only support uniform scaling, so assume the first row is enough
@@ -136,16 +153,28 @@ void Matrix4x4_Invert_Simple (matrix4x4_t *out, const matrix4x4_t *in1)
 
        // invert the rotation by transposing and multiplying by the squared
        // recipricol of the input matrix scale as described above
-       out->m[0][0] = (float)(in1->m[0][0] * scale);
-       out->m[0][1] = (float)(in1->m[1][0] * scale);
-       out->m[0][2] = (float)(in1->m[2][0] * scale);
-       out->m[1][0] = (float)(in1->m[0][1] * scale);
-       out->m[1][1] = (float)(in1->m[1][1] * scale);
-       out->m[1][2] = (float)(in1->m[2][1] * scale);
-       out->m[2][0] = (float)(in1->m[0][2] * scale);
-       out->m[2][1] = (float)(in1->m[1][2] * scale);
-       out->m[2][2] = (float)(in1->m[2][2] * scale);
+       out->m[0][0] = in1->m[0][0] * scale;
+       out->m[0][1] = in1->m[1][0] * scale;
+       out->m[0][2] = in1->m[2][0] * scale;
+       out->m[1][0] = in1->m[0][1] * scale;
+       out->m[1][1] = in1->m[1][1] * scale;
+       out->m[1][2] = in1->m[2][1] * scale;
+       out->m[2][0] = in1->m[0][2] * scale;
+       out->m[2][1] = in1->m[1][2] * scale;
+       out->m[2][2] = in1->m[2][2] * scale;
+
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       // invert the translate
+       out->m[3][0] = -(in1->m[3][0] * out->m[0][0] + in1->m[3][1] * out->m[1][0] + in1->m[3][2] * out->m[2][0]);
+       out->m[3][1] = -(in1->m[3][0] * out->m[0][1] + in1->m[3][1] * out->m[1][1] + in1->m[3][2] * out->m[2][1]);
+       out->m[3][2] = -(in1->m[3][0] * out->m[0][2] + in1->m[3][1] * out->m[1][2] + in1->m[3][2] * out->m[2][2]);
 
+       // don't know if there's anything worth doing here
+       out->m[0][3] = 0;
+       out->m[1][3] = 0;
+       out->m[2][3] = 0;
+       out->m[3][3] = 1;
+#else
        // invert the translate
        out->m[0][3] = -(in1->m[0][3] * out->m[0][0] + in1->m[1][3] * out->m[0][1] + in1->m[2][3] * out->m[0][2]);
        out->m[1][3] = -(in1->m[0][3] * out->m[1][0] + in1->m[1][3] * out->m[1][1] + in1->m[2][3] * out->m[1][2]);
@@ -156,6 +185,7 @@ void Matrix4x4_Invert_Simple (matrix4x4_t *out, const matrix4x4_t *in1)
        out->m[3][1] = 0;
        out->m[3][2] = 0;
        out->m[3][3] = 1;
+#endif
 }
 
 void Matrix4x4_Normalize (matrix4x4_t *out, matrix4x4_t *in1)
@@ -163,22 +193,8 @@ void Matrix4x4_Normalize (matrix4x4_t *out, matrix4x4_t *in1)
        // scale rotation matrix vectors to a length of 1
        // note: this is only designed to undo uniform scaling
        double scale = 1.0 / sqrt(in1->m[0][0] * in1->m[0][0] + in1->m[0][1] * in1->m[0][1] + in1->m[0][2] * in1->m[0][2]);
-       out->m[0][0] = (float)(in1->m[0][0] * scale);
-       out->m[0][1] = (float)(in1->m[0][1] * scale);
-       out->m[0][2] = (float)(in1->m[0][2] * scale);
-       out->m[0][3] = (float)(in1->m[0][3]);
-       out->m[1][0] = (float)(in1->m[1][0] * scale);
-       out->m[1][1] = (float)(in1->m[1][1] * scale);
-       out->m[1][2] = (float)(in1->m[1][2] * scale);
-       out->m[1][3] = (float)(in1->m[1][3]);
-       out->m[2][0] = (float)(in1->m[2][0] * scale);
-       out->m[2][1] = (float)(in1->m[2][1] * scale);
-       out->m[2][2] = (float)(in1->m[2][2] * scale);
-       out->m[2][3] = (float)(in1->m[2][3]);
-       out->m[3][0] = 0;
-       out->m[3][1] = 0;
-       out->m[3][2] = 0;
-       out->m[3][3] = 1;
+       *out = *in1;
+       Matrix4x4_Scale(out, scale, 1);
 }
 
 void Matrix4x4_CreateIdentity (matrix4x4_t *out)
@@ -203,6 +219,24 @@ void Matrix4x4_CreateIdentity (matrix4x4_t *out)
 
 void Matrix4x4_CreateTranslate (matrix4x4_t *out, double x, double y, double z)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0]=1.0f;
+       out->m[1][0]=0.0f;
+       out->m[2][0]=0.0f;
+       out->m[3][0]=x;
+       out->m[0][1]=0.0f;
+       out->m[1][1]=1.0f;
+       out->m[2][1]=0.0f;
+       out->m[3][1]=y;
+       out->m[0][2]=0.0f;
+       out->m[1][2]=0.0f;
+       out->m[2][2]=1.0f;
+       out->m[3][2]=z;
+       out->m[0][3]=0.0f;
+       out->m[1][3]=0.0f;
+       out->m[2][3]=0.0f;
+       out->m[3][3]=1.0f;
+#else
        out->m[0][0]=1.0f;
        out->m[0][1]=0.0f;
        out->m[0][2]=0.0f;
@@ -219,6 +253,7 @@ void Matrix4x4_CreateTranslate (matrix4x4_t *out, double x, double y, double z)
        out->m[3][1]=0.0f;
        out->m[3][2]=0.0f;
        out->m[3][3]=1.0f;
+#endif
 }
 
 void Matrix4x4_CreateRotate (matrix4x4_t *out, double angle, double x, double y, double z)
@@ -227,15 +262,33 @@ void Matrix4x4_CreateRotate (matrix4x4_t *out, double angle, double x, double y,
 
        len = x*x+y*y+z*z;
        if (len != 0.0f)
-               len = 1.0f / (float)sqrt(len);
+               len = 1.0f / sqrt(len);
        x *= len;
        y *= len;
        z *= len;
 
-       angle *= (float)(-M_PI / 180.0);
-       c = (float)cos(angle);
-       s = (float)sin(angle);
+       angle *= (-M_PI / 180.0);
+       c = cos(angle);
+       s = sin(angle);
 
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0]=x * x + c * (1 - x * x);
+       out->m[1][0]=x * y * (1 - c) + z * s;
+       out->m[2][0]=z * x * (1 - c) - y * s;
+       out->m[3][0]=0.0f;
+       out->m[0][1]=x * y * (1 - c) - z * s;
+       out->m[1][1]=y * y + c * (1 - y * y);
+       out->m[2][1]=y * z * (1 - c) + x * s;
+       out->m[3][1]=0.0f;
+       out->m[0][2]=z * x * (1 - c) + y * s;
+       out->m[1][2]=y * z * (1 - c) - x * s;
+       out->m[2][2]=z * z + c * (1 - z * z);
+       out->m[3][2]=0.0f;
+       out->m[0][3]=0.0f;
+       out->m[1][3]=0.0f;
+       out->m[2][3]=0.0f;
+       out->m[3][3]=1.0f;
+#else
        out->m[0][0]=x * x + c * (1 - x * x);
        out->m[0][1]=x * y * (1 - c) + z * s;
        out->m[0][2]=z * x * (1 - c) - y * s;
@@ -252,6 +305,7 @@ void Matrix4x4_CreateRotate (matrix4x4_t *out, double angle, double x, double y,
        out->m[3][1]=0.0f;
        out->m[3][2]=0.0f;
        out->m[3][3]=1.0f;
+#endif
 }
 
 void Matrix4x4_CreateScale (matrix4x4_t *out, double x)
@@ -309,22 +363,41 @@ void Matrix4x4_CreateFromQuakeEntity(matrix4x4_t *out, double x, double y, doubl
                angle = roll * (M_PI*2 / 360);
                sr = sin(angle);
                cr = cos(angle);
-               out->m[0][0] = (float)((cp*cy) * scale);
-               out->m[0][1] = (float)((sr*sp*cy+cr*-sy) * scale);
-               out->m[0][2] = (float)((cr*sp*cy+-sr*-sy) * scale);
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               out->m[0][0] = (cp*cy) * scale;
+               out->m[1][0] = (sr*sp*cy+cr*-sy) * scale;
+               out->m[2][0] = (cr*sp*cy+-sr*-sy) * scale;
+               out->m[3][0] = x;
+               out->m[0][1] = (cp*sy) * scale;
+               out->m[1][1] = (sr*sp*sy+cr*cy) * scale;
+               out->m[2][1] = (cr*sp*sy+-sr*cy) * scale;
+               out->m[3][1] = y;
+               out->m[0][2] = (-sp) * scale;
+               out->m[1][2] = (sr*cp) * scale;
+               out->m[2][2] = (cr*cp) * scale;
+               out->m[3][2] = z;
+               out->m[0][3] = 0;
+               out->m[1][3] = 0;
+               out->m[2][3] = 0;
+               out->m[3][3] = 1;
+#else
+               out->m[0][0] = (cp*cy) * scale;
+               out->m[0][1] = (sr*sp*cy+cr*-sy) * scale;
+               out->m[0][2] = (cr*sp*cy+-sr*-sy) * scale;
                out->m[0][3] = x;
-               out->m[1][0] = (float)((cp*sy) * scale);
-               out->m[1][1] = (float)((sr*sp*sy+cr*cy) * scale);
-               out->m[1][2] = (float)((cr*sp*sy+-sr*cy) * scale);
+               out->m[1][0] = (cp*sy) * scale;
+               out->m[1][1] = (sr*sp*sy+cr*cy) * scale;
+               out->m[1][2] = (cr*sp*sy+-sr*cy) * scale;
                out->m[1][3] = y;
-               out->m[2][0] = (float)((-sp) * scale);
-               out->m[2][1] = (float)((sr*cp) * scale);
-               out->m[2][2] = (float)((cr*cp) * scale);
+               out->m[2][0] = (-sp) * scale;
+               out->m[2][1] = (sr*cp) * scale;
+               out->m[2][2] = (cr*cp) * scale;
                out->m[2][3] = z;
                out->m[3][0] = 0;
                out->m[3][1] = 0;
                out->m[3][2] = 0;
                out->m[3][3] = 1;
+#endif
        }
        else if (pitch)
        {
@@ -334,34 +407,71 @@ void Matrix4x4_CreateFromQuakeEntity(matrix4x4_t *out, double x, double y, doubl
                angle = pitch * (M_PI*2 / 360);
                sp = sin(angle);
                cp = cos(angle);
-               out->m[0][0] = (float)((cp*cy) * scale);
-               out->m[0][1] = (float)((-sy) * scale);
-               out->m[0][2] = (float)((sp*cy) * scale);
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               out->m[0][0] = (cp*cy) * scale;
+               out->m[1][0] = (-sy) * scale;
+               out->m[2][0] = (sp*cy) * scale;
+               out->m[3][0] = x;
+               out->m[0][1] = (cp*sy) * scale;
+               out->m[1][1] = (cy) * scale;
+               out->m[2][1] = (sp*sy) * scale;
+               out->m[3][1] = y;
+               out->m[0][2] = (-sp) * scale;
+               out->m[1][2] = 0;
+               out->m[2][2] = (cp) * scale;
+               out->m[3][2] = z;
+               out->m[0][3] = 0;
+               out->m[1][3] = 0;
+               out->m[2][3] = 0;
+               out->m[3][3] = 1;
+#else
+               out->m[0][0] = (cp*cy) * scale;
+               out->m[0][1] = (-sy) * scale;
+               out->m[0][2] = (sp*cy) * scale;
                out->m[0][3] = x;
-               out->m[1][0] = (float)((cp*sy) * scale);
-               out->m[1][1] = (float)((cy) * scale);
-               out->m[1][2] = (float)((sp*sy) * scale);
+               out->m[1][0] = (cp*sy) * scale;
+               out->m[1][1] = (cy) * scale;
+               out->m[1][2] = (sp*sy) * scale;
                out->m[1][3] = y;
-               out->m[2][0] = (float)((-sp) * scale);
+               out->m[2][0] = (-sp) * scale;
                out->m[2][1] = 0;
-               out->m[2][2] = (float)((cp) * scale);
+               out->m[2][2] = (cp) * scale;
                out->m[2][3] = z;
                out->m[3][0] = 0;
                out->m[3][1] = 0;
                out->m[3][2] = 0;
                out->m[3][3] = 1;
+#endif
        }
        else if (yaw)
        {
                angle = yaw * (M_PI*2 / 360);
                sy = sin(angle);
                cy = cos(angle);
-               out->m[0][0] = (float)((cy) * scale);
-               out->m[0][1] = (float)((-sy) * scale);
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               out->m[0][0] = (cy) * scale;
+               out->m[1][0] = (-sy) * scale;
+               out->m[2][0] = 0;
+               out->m[3][0] = x;
+               out->m[0][1] = (sy) * scale;
+               out->m[1][1] = (cy) * scale;
+               out->m[2][1] = 0;
+               out->m[3][1] = y;
+               out->m[0][2] = 0;
+               out->m[1][2] = 0;
+               out->m[2][2] = scale;
+               out->m[3][2] = z;
+               out->m[0][3] = 0;
+               out->m[1][3] = 0;
+               out->m[2][3] = 0;
+               out->m[3][3] = 1;
+#else
+               out->m[0][0] = (cy) * scale;
+               out->m[0][1] = (-sy) * scale;
                out->m[0][2] = 0;
                out->m[0][3] = x;
-               out->m[1][0] = (float)((sy) * scale);
-               out->m[1][1] = (float)((cy) * scale);
+               out->m[1][0] = (sy) * scale;
+               out->m[1][1] = (cy) * scale;
                out->m[1][2] = 0;
                out->m[1][3] = y;
                out->m[2][0] = 0;
@@ -372,9 +482,28 @@ void Matrix4x4_CreateFromQuakeEntity(matrix4x4_t *out, double x, double y, doubl
                out->m[3][1] = 0;
                out->m[3][2] = 0;
                out->m[3][3] = 1;
+#endif
        }
        else
        {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               out->m[0][0] = scale;
+               out->m[1][0] = 0;
+               out->m[2][0] = 0;
+               out->m[3][0] = x;
+               out->m[0][1] = 0;
+               out->m[1][1] = scale;
+               out->m[2][1] = 0;
+               out->m[3][1] = y;
+               out->m[0][2] = 0;
+               out->m[1][2] = 0;
+               out->m[2][2] = scale;
+               out->m[3][2] = z;
+               out->m[0][3] = 0;
+               out->m[1][3] = 0;
+               out->m[2][3] = 0;
+               out->m[3][3] = 1;
+#else
                out->m[0][0] = scale;
                out->m[0][1] = 0;
                out->m[0][2] = 0;
@@ -391,11 +520,26 @@ void Matrix4x4_CreateFromQuakeEntity(matrix4x4_t *out, double x, double y, doubl
                out->m[3][1] = 0;
                out->m[3][2] = 0;
                out->m[3][3] = 1;
+#endif
        }
 }
 
 void Matrix4x4_ToVectors(const matrix4x4_t *in, float vx[3], float vy[3], float vz[3], float t[3])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       vx[0] = in->m[0][0];
+       vx[1] = in->m[0][1];
+       vx[2] = in->m[0][2];
+       vy[0] = in->m[1][0];
+       vy[1] = in->m[1][1];
+       vy[2] = in->m[1][2];
+       vz[0] = in->m[2][0];
+       vz[1] = in->m[2][1];
+       vz[2] = in->m[2][2];
+       t [0] = in->m[3][0];
+       t [1] = in->m[3][1];
+       t [2] = in->m[3][2];
+#else
        vx[0] = in->m[0][0];
        vx[1] = in->m[1][0];
        vx[2] = in->m[2][0];
@@ -405,13 +549,32 @@ void Matrix4x4_ToVectors(const matrix4x4_t *in, float vx[3], float vy[3], float
        vz[0] = in->m[0][2];
        vz[1] = in->m[1][2];
        vz[2] = in->m[2][2];
-       t[0] = in->m[0][3];
-       t[1] = in->m[1][3];
-       t[2] = in->m[2][3];
+       t [0] = in->m[0][3];
+       t [1] = in->m[1][3];
+       t [2] = in->m[2][3];
+#endif
 }
 
 void Matrix4x4_FromVectors(matrix4x4_t *out, const float vx[3], const float vy[3], const float vz[3], const float t[3])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = vx[0];
+       out->m[1][0] = vy[0];
+       out->m[2][0] = vz[0];
+       out->m[3][0] = t[0];
+       out->m[0][1] = vx[1];
+       out->m[1][1] = vy[1];
+       out->m[2][1] = vz[1];
+       out->m[3][1] = t[1];
+       out->m[0][2] = vx[2];
+       out->m[1][2] = vy[2];
+       out->m[2][2] = vz[2];
+       out->m[3][2] = t[2];
+       out->m[0][3] = 0.0f;
+       out->m[1][3] = 0.0f;
+       out->m[2][3] = 0.0f;
+       out->m[3][3] = 1.0f;
+#else
        out->m[0][0] = vx[0];
        out->m[0][1] = vy[0];
        out->m[0][2] = vz[0];
@@ -428,10 +591,29 @@ void Matrix4x4_FromVectors(matrix4x4_t *out, const float vx[3], const float vy[3
        out->m[3][1] = 0.0f;
        out->m[3][2] = 0.0f;
        out->m[3][3] = 1.0f;
+#endif
 }
 
 void Matrix4x4_ToArrayDoubleGL(const matrix4x4_t *in, double out[16])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[ 0] = in->m[0][0];
+       out[ 1] = in->m[0][1];
+       out[ 2] = in->m[0][2];
+       out[ 3] = in->m[0][3];
+       out[ 4] = in->m[1][0];
+       out[ 5] = in->m[1][1];
+       out[ 6] = in->m[1][2];
+       out[ 7] = in->m[1][3];
+       out[ 8] = in->m[2][0];
+       out[ 9] = in->m[2][1];
+       out[10] = in->m[2][2];
+       out[11] = in->m[2][3];
+       out[12] = in->m[3][0];
+       out[13] = in->m[3][1];
+       out[14] = in->m[3][2];
+       out[15] = in->m[3][3];
+#else
        out[ 0] = in->m[0][0];
        out[ 1] = in->m[1][0];
        out[ 2] = in->m[2][0];
@@ -448,10 +630,29 @@ void Matrix4x4_ToArrayDoubleGL(const matrix4x4_t *in, double out[16])
        out[13] = in->m[1][3];
        out[14] = in->m[2][3];
        out[15] = in->m[3][3];
+#endif
 }
 
 void Matrix4x4_FromArrayDoubleGL (matrix4x4_t *out, const double in[16])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = in[0];
+       out->m[0][1] = in[1];
+       out->m[0][2] = in[2];
+       out->m[0][3] = in[3];
+       out->m[1][0] = in[4];
+       out->m[1][1] = in[5];
+       out->m[1][2] = in[6];
+       out->m[1][3] = in[7];
+       out->m[2][0] = in[8];
+       out->m[2][1] = in[9];
+       out->m[2][2] = in[10];
+       out->m[2][3] = in[11];
+       out->m[3][0] = in[12];
+       out->m[3][1] = in[13];
+       out->m[3][2] = in[14];
+       out->m[3][3] = in[15];
+#else
        out->m[0][0] = in[0];
        out->m[1][0] = in[1];
        out->m[2][0] = in[2];
@@ -468,10 +669,29 @@ void Matrix4x4_FromArrayDoubleGL (matrix4x4_t *out, const double in[16])
        out->m[1][3] = in[13];
        out->m[2][3] = in[14];
        out->m[3][3] = in[15];
+#endif
 }
 
 void Matrix4x4_ToArrayDoubleD3D(const matrix4x4_t *in, double out[16])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[ 0] = in->m[0][0];
+       out[ 1] = in->m[1][0];
+       out[ 2] = in->m[2][0];
+       out[ 3] = in->m[3][0];
+       out[ 4] = in->m[0][1];
+       out[ 5] = in->m[1][1];
+       out[ 6] = in->m[2][1];
+       out[ 7] = in->m[3][1];
+       out[ 8] = in->m[0][2];
+       out[ 9] = in->m[1][2];
+       out[10] = in->m[2][2];
+       out[11] = in->m[3][2];
+       out[12] = in->m[0][3];
+       out[13] = in->m[1][3];
+       out[14] = in->m[2][3];
+       out[15] = in->m[3][3];
+#else
        out[ 0] = in->m[0][0];
        out[ 1] = in->m[0][1];
        out[ 2] = in->m[0][2];
@@ -488,10 +708,29 @@ void Matrix4x4_ToArrayDoubleD3D(const matrix4x4_t *in, double out[16])
        out[13] = in->m[3][1];
        out[14] = in->m[3][2];
        out[15] = in->m[3][3];
+#endif
 }
 
 void Matrix4x4_FromArrayDoubleD3D (matrix4x4_t *out, const double in[16])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = in[0];
+       out->m[1][0] = in[1];
+       out->m[2][0] = in[2];
+       out->m[3][0] = in[3];
+       out->m[0][1] = in[4];
+       out->m[1][1] = in[5];
+       out->m[2][1] = in[6];
+       out->m[3][1] = in[7];
+       out->m[0][2] = in[8];
+       out->m[1][2] = in[9];
+       out->m[2][2] = in[10];
+       out->m[3][2] = in[11];
+       out->m[0][3] = in[12];
+       out->m[1][3] = in[13];
+       out->m[2][3] = in[14];
+       out->m[3][3] = in[15];
+#else
        out->m[0][0] = in[0];
        out->m[0][1] = in[1];
        out->m[0][2] = in[2];
@@ -508,10 +747,25 @@ void Matrix4x4_FromArrayDoubleD3D (matrix4x4_t *out, const double in[16])
        out->m[3][1] = in[13];
        out->m[3][2] = in[14];
        out->m[3][3] = in[15];
+#endif
 }
 
 void Matrix4x4_ToArray12FloatGL(const matrix4x4_t *in, float out[12])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[ 0] = in->m[0][0];
+       out[ 1] = in->m[0][1];
+       out[ 2] = in->m[0][2];
+       out[ 3] = in->m[1][0];
+       out[ 4] = in->m[1][1];
+       out[ 5] = in->m[1][2];
+       out[ 6] = in->m[2][0];
+       out[ 7] = in->m[2][1];
+       out[ 8] = in->m[2][2];
+       out[ 9] = in->m[3][0];
+       out[10] = in->m[3][1];
+       out[11] = in->m[3][2];
+#else
        out[ 0] = in->m[0][0];
        out[ 1] = in->m[1][0];
        out[ 2] = in->m[2][0];
@@ -524,10 +778,29 @@ void Matrix4x4_ToArray12FloatGL(const matrix4x4_t *in, float out[12])
        out[ 9] = in->m[0][3];
        out[10] = in->m[1][3];
        out[11] = in->m[2][3];
+#endif
 }
 
 void Matrix4x4_FromArray12FloatGL(matrix4x4_t *out, const float in[12])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = in[0];
+       out->m[0][1] = in[1];
+       out->m[0][2] = in[2];
+       out->m[0][3] = 0;
+       out->m[1][0] = in[3];
+       out->m[1][1] = in[4];
+       out->m[1][2] = in[5];
+       out->m[1][3] = 0;
+       out->m[2][0] = in[6];
+       out->m[2][1] = in[7];
+       out->m[2][2] = in[8];
+       out->m[2][3] = 0;
+       out->m[3][0] = in[9];
+       out->m[3][1] = in[10];
+       out->m[3][2] = in[11];
+       out->m[3][3] = 1;
+#else
        out->m[0][0] = in[0];
        out->m[1][0] = in[1];
        out->m[2][0] = in[2];
@@ -544,10 +817,25 @@ void Matrix4x4_FromArray12FloatGL(matrix4x4_t *out, const float in[12])
        out->m[1][3] = in[10];
        out->m[2][3] = in[11];
        out->m[3][3] = 1;
+#endif
 }
 
 void Matrix4x4_ToArray12FloatD3D(const matrix4x4_t *in, float out[12])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[ 0] = in->m[0][0];
+       out[ 1] = in->m[1][0];
+       out[ 2] = in->m[2][0];
+       out[ 3] = in->m[3][0];
+       out[ 4] = in->m[0][1];
+       out[ 5] = in->m[1][1];
+       out[ 6] = in->m[2][1];
+       out[ 7] = in->m[3][1];
+       out[ 8] = in->m[0][2];
+       out[ 9] = in->m[1][2];
+       out[10] = in->m[2][2];
+       out[11] = in->m[3][2];
+#else
        out[ 0] = in->m[0][0];
        out[ 1] = in->m[0][1];
        out[ 2] = in->m[0][2];
@@ -560,10 +848,29 @@ void Matrix4x4_ToArray12FloatD3D(const matrix4x4_t *in, float out[12])
        out[ 9] = in->m[2][1];
        out[10] = in->m[2][2];
        out[11] = in->m[2][3];
+#endif
 }
 
 void Matrix4x4_FromArray12FloatD3D(matrix4x4_t *out, const float in[12])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[0][0] = in[0];
+       out->m[1][0] = in[1];
+       out->m[2][0] = in[2];
+       out->m[3][0] = in[3];
+       out->m[0][1] = in[4];
+       out->m[1][1] = in[5];
+       out->m[2][1] = in[6];
+       out->m[3][1] = in[7];
+       out->m[0][2] = in[8];
+       out->m[1][2] = in[9];
+       out->m[2][2] = in[10];
+       out->m[3][2] = in[11];
+       out->m[0][3] = 0;
+       out->m[1][3] = 0;
+       out->m[2][3] = 0;
+       out->m[3][3] = 1;
+#else
        out->m[0][0] = in[0];
        out->m[0][1] = in[1];
        out->m[0][2] = in[2];
@@ -580,14 +887,22 @@ void Matrix4x4_FromArray12FloatD3D(matrix4x4_t *out, const float in[12])
        out->m[3][1] = 0;
        out->m[3][2] = 0;
        out->m[3][3] = 1;
+#endif
 }
 
 void Matrix4x4_FromOriginQuat(matrix4x4_t *m, double ox, double oy, double oz, double x, double y, double z, double w)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       m->m[0][0]=1-2*(y*y+z*z);m->m[1][0]=  2*(x*y-z*w);m->m[2][0]=  2*(x*z+y*w);m->m[3][0]=ox;
+       m->m[0][1]=  2*(x*y+z*w);m->m[1][1]=1-2*(x*x+z*z);m->m[2][1]=  2*(y*z-x*w);m->m[3][1]=oy;
+       m->m[0][2]=  2*(x*z-y*w);m->m[1][2]=  2*(y*z+x*w);m->m[2][2]=1-2*(x*x+y*y);m->m[3][2]=oz;
+       m->m[0][3]=  0          ;m->m[1][3]=  0          ;m->m[2][3]=  0          ;m->m[3][3]=1;
+#else
        m->m[0][0]=1-2*(y*y+z*z);m->m[0][1]=  2*(x*y-z*w);m->m[0][2]=  2*(x*z+y*w);m->m[0][3]=ox;
        m->m[1][0]=  2*(x*y+z*w);m->m[1][1]=1-2*(x*x+z*z);m->m[1][2]=  2*(y*z-x*w);m->m[1][3]=oy;
        m->m[2][0]=  2*(x*z-y*w);m->m[2][1]=  2*(y*z+x*w);m->m[2][2]=1-2*(x*x+y*y);m->m[2][3]=oz;
        m->m[3][0]=  0          ;m->m[3][1]=  0          ;m->m[3][2]=  0          ;m->m[3][3]=1;
+#endif
 }
 
 // LordHavoc: I got this code from:
@@ -596,10 +911,17 @@ void Matrix4x4_FromDoom3Joint(matrix4x4_t *m, double ox, double oy, double oz, d
 {
        double w = 1.0 - (x*x+y*y+z*z);
        w = w > 0.0 ? -sqrt(w) : 0.0;
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       m->m[0][0]=1-2*(y*y+z*z);m->m[1][0]=  2*(x*y-z*w);m->m[2][0]=  2*(x*z+y*w);m->m[3][0]=ox;
+       m->m[0][1]=  2*(x*y+z*w);m->m[1][1]=1-2*(x*x+z*z);m->m[2][1]=  2*(y*z-x*w);m->m[3][1]=oy;
+       m->m[0][2]=  2*(x*z-y*w);m->m[1][2]=  2*(y*z+x*w);m->m[2][2]=1-2*(x*x+y*y);m->m[3][2]=oz;
+       m->m[0][3]=  0          ;m->m[1][3]=  0          ;m->m[2][3]=  0          ;m->m[3][3]=1;
+#else
        m->m[0][0]=1-2*(y*y+z*z);m->m[0][1]=  2*(x*y-z*w);m->m[0][2]=  2*(x*z+y*w);m->m[0][3]=ox;
        m->m[1][0]=  2*(x*y+z*w);m->m[1][1]=1-2*(x*x+z*z);m->m[1][2]=  2*(y*z-x*w);m->m[1][3]=oy;
        m->m[2][0]=  2*(x*z-y*w);m->m[2][1]=  2*(y*z+x*w);m->m[2][2]=1-2*(x*x+y*y);m->m[2][3]=oz;
        m->m[3][0]=  0          ;m->m[3][1]=  0          ;m->m[3][2]=  0          ;m->m[3][3]=1;
+#endif
 }
 
 void Matrix4x4_Blend (matrix4x4_t *out, const matrix4x4_t *in1, const matrix4x4_t *in2, double blend)
@@ -626,36 +948,64 @@ void Matrix4x4_Blend (matrix4x4_t *out, const matrix4x4_t *in1, const matrix4x4_
 
 void Matrix4x4_Transform (const matrix4x4_t *in, const float v[3], float out[3])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[0] = v[0] * in->m[0][0] + v[1] * in->m[1][0] + v[2] * in->m[2][0] + in->m[3][0];
+       out[1] = v[0] * in->m[0][1] + v[1] * in->m[1][1] + v[2] * in->m[2][1] + in->m[3][1];
+       out[2] = v[0] * in->m[0][2] + v[1] * in->m[1][2] + v[2] * in->m[2][2] + in->m[3][2];
+#else
        out[0] = v[0] * in->m[0][0] + v[1] * in->m[0][1] + v[2] * in->m[0][2] + in->m[0][3];
        out[1] = v[0] * in->m[1][0] + v[1] * in->m[1][1] + v[2] * in->m[1][2] + in->m[1][3];
        out[2] = v[0] * in->m[2][0] + v[1] * in->m[2][1] + v[2] * in->m[2][2] + in->m[2][3];
+#endif
 }
 
 void Matrix4x4_Transform4 (const matrix4x4_t *in, const float v[4], float out[4])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[0] = v[0] * in->m[0][0] + v[1] * in->m[1][0] + v[2] * in->m[2][0] + v[3] * in->m[3][0];
+       out[1] = v[0] * in->m[0][1] + v[1] * in->m[1][1] + v[2] * in->m[2][1] + v[3] * in->m[3][1];
+       out[2] = v[0] * in->m[0][2] + v[1] * in->m[1][2] + v[2] * in->m[2][2] + v[3] * in->m[3][2];
+       out[3] = v[0] * in->m[0][3] + v[1] * in->m[1][3] + v[2] * in->m[2][3] + v[3] * in->m[3][3];
+#else
        out[0] = v[0] * in->m[0][0] + v[1] * in->m[0][1] + v[2] * in->m[0][2] + v[3] * in->m[0][3];
        out[1] = v[0] * in->m[1][0] + v[1] * in->m[1][1] + v[2] * in->m[1][2] + v[3] * in->m[1][3];
        out[2] = v[0] * in->m[2][0] + v[1] * in->m[2][1] + v[2] * in->m[2][2] + v[3] * in->m[2][3];
        out[3] = v[0] * in->m[3][0] + v[1] * in->m[3][1] + v[2] * in->m[3][2] + v[3] * in->m[3][3];
+#endif
 }
 
 void Matrix4x4_Transform3x3 (const matrix4x4_t *in, const float v[3], float out[3])
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[0] = v[0] * in->m[0][0] + v[1] * in->m[1][0] + v[2] * in->m[2][0];
+       out[1] = v[0] * in->m[0][1] + v[1] * in->m[1][1] + v[2] * in->m[2][1];
+       out[2] = v[0] * in->m[0][2] + v[1] * in->m[1][2] + v[2] * in->m[2][2];
+#else
        out[0] = v[0] * in->m[0][0] + v[1] * in->m[0][1] + v[2] * in->m[0][2];
        out[1] = v[0] * in->m[1][0] + v[1] * in->m[1][1] + v[2] * in->m[1][2];
        out[2] = v[0] * in->m[2][0] + v[1] * in->m[2][1] + v[2] * in->m[2][2];
+#endif
 }
 
 /*
 void Matrix4x4_SimpleUntransform (const matrix4x4_t *in, const float v[3], float out[3])
 {
        double t[3];
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       t[0] = v[0] - in->m[3][0];
+       t[1] = v[1] - in->m[3][1];
+       t[2] = v[2] - in->m[3][2];
+       out[0] = t[0] * in->m[0][0] + t[1] * in->m[0][1] + t[2] * in->m[0][2];
+       out[1] = t[0] * in->m[1][0] + t[1] * in->m[1][1] + t[2] * in->m[1][2];
+       out[2] = t[0] * in->m[2][0] + t[1] * in->m[2][1] + t[2] * in->m[2][2];
+#else
        t[0] = v[0] - in->m[0][3];
        t[1] = v[1] - in->m[1][3];
        t[2] = v[2] - in->m[2][3];
        out[0] = t[0] * in->m[0][0] + t[1] * in->m[1][0] + t[2] * in->m[2][0];
        out[1] = t[0] * in->m[0][1] + t[1] * in->m[1][1] + t[2] * in->m[2][1];
        out[2] = t[0] * in->m[0][2] + t[1] * in->m[1][2] + t[2] * in->m[2][2];
+#endif
 }
 */
 
@@ -697,29 +1047,47 @@ void Matrix4x4_ConcatScale3 (matrix4x4_t *out, double x, double y, double z)
 
 void Matrix4x4_OriginFromMatrix (const matrix4x4_t *in, float *out)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out[0] = in->m[3][0];
+       out[1] = in->m[3][1];
+       out[2] = in->m[3][2];
+#else
        out[0] = in->m[0][3];
        out[1] = in->m[1][3];
        out[2] = in->m[2][3];
+#endif
 }
 
 double Matrix4x4_ScaleFromMatrix (const matrix4x4_t *in)
 {
        // we only support uniform scaling, so assume the first row is enough
-       return (float)sqrt(in->m[0][0] * in->m[0][0] + in->m[0][1] * in->m[0][1] + in->m[0][2] * in->m[0][2]);
+       return sqrt(in->m[0][0] * in->m[0][0] + in->m[0][1] * in->m[0][1] + in->m[0][2] * in->m[0][2]);
 }
 
 void Matrix4x4_SetOrigin (matrix4x4_t *out, double x, double y, double z)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[3][0] = x;
+       out->m[3][1] = y;
+       out->m[3][2] = z;
+#else
        out->m[0][3] = x;
        out->m[1][3] = y;
        out->m[2][3] = z;
+#endif
 }
 
 void Matrix4x4_AdjustOrigin (matrix4x4_t *out, double x, double y, double z)
 {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[3][0] += x;
+       out->m[3][1] += y;
+       out->m[3][2] += z;
+#else
        out->m[0][3] += x;
        out->m[1][3] += y;
        out->m[2][3] += z;
+#endif
 }
 
 void Matrix4x4_Scale (matrix4x4_t *out, double rotatescale, double originscale)
@@ -727,13 +1095,19 @@ void Matrix4x4_Scale (matrix4x4_t *out, double rotatescale, double originscale)
        out->m[0][0] *= rotatescale;
        out->m[0][1] *= rotatescale;
        out->m[0][2] *= rotatescale;
-       out->m[0][3] *= originscale;
        out->m[1][0] *= rotatescale;
        out->m[1][1] *= rotatescale;
        out->m[1][2] *= rotatescale;
-       out->m[1][3] *= originscale;
        out->m[2][0] *= rotatescale;
        out->m[2][1] *= rotatescale;
        out->m[2][2] *= rotatescale;
+#ifdef MATRIX4x4_OPENGLORIENTATION
+       out->m[3][0] *= originscale;
+       out->m[3][1] *= originscale;
+       out->m[3][2] *= originscale;
+#else
+       out->m[0][3] *= originscale;
+       out->m[1][3] *= originscale;
        out->m[2][3] *= originscale;
+#endif
 }

diff --git a/matrixlib.h b/matrixlib.h
index 90e816270a4b7cc5346058673f9feadba872c1a8..7d834eac38d28df04a676aac8960a6febd14e6f1 100644 (file)
--- a/matrixlib.h
+++ b/matrixlib.h
@@ -6,6 +6,8 @@
 #define M_PI           3.14159265358979323846  // matches value in gcc v2 math.h
 #endif
 
+#define MATRIX4x4_OPENGLORIENTATION
+
 typedef struct matrix4x4_s
 {
        float m[4][4];
@@ -28,9 +30,6 @@ void Matrix4x4_Concat (matrix4x4_t *out, const matrix4x4_t *in1, const matrix4x4
 // swaps the rows and columns of the matrix
 // (is this useful for anything?)
 void Matrix4x4_Transpose (matrix4x4_t *out, const matrix4x4_t *in1);
-// swaps the rows and columns of the rotation matrix
-// (inverting the rotation, but leaving everything else the same)
-void Matrix4x4_Transpose3x3 (matrix4x4_t *out, const matrix4x4_t *in1);
 // creates a matrix that does the opposite of the matrix provided
 // only supports translate, rotate, scale (not scale3) matrices
 void Matrix4x4_Invert_Simple (matrix4x4_t *out, const matrix4x4_t *in1);