1. also play sounds outside cdtracks/ as CD tracks

[xonotic/darkplaces.git] / matrixlib.c

diff --git a/matrixlib.c b/matrixlib.c
index 7e4783e2c7ec01c44c07f382b10319be352fdfcd..7b7bfad6fa7a43aa8e214e1a73fc0b167d8fe40e 100644 (file)
--- a/matrixlib.c
+++ b/matrixlib.c
@@ -1,7 +1,13 @@
+#include "quakedef.h"
 
 #include <math.h>
 #include "matrixlib.h"
 
+#ifdef _MSC_VER
+#pragma warning(disable : 4244)     // LordHavoc: MSVC++ 4 x86, double/float
+#pragma warning(disable : 4305)         // LordHavoc: MSVC++ 6 x86, double/float
+#endif
+
 const matrix4x4_t identitymatrix =
 {
        {
@@ -356,6 +362,30 @@ void Matrix4x4_Invert_Simple (matrix4x4_t *out, const matrix4x4_t *in1)
 #endif
 }
 
+void Matrix4x4_Interpolate (matrix4x4_t *out, matrix4x4_t *in1, matrix4x4_t *in2, double frac)
+{
+       int i, j;
+       for (i = 0;i < 4;i++)
+               for (j = 0;j < 4;j++)
+                       out->m[i][j] = in1->m[i][j] + frac * (in2->m[i][j] - in1->m[i][j]);
+}
+
+void Matrix4x4_Clear (matrix4x4_t *out)
+{
+       int i, j;
+       for (i = 0;i < 4;i++)
+               for (j = 0;j < 4;j++)
+                       out->m[i][j] = 0;
+}
+
+void Matrix4x4_Accumulate (matrix4x4_t *out, matrix4x4_t *in, double weight)
+{
+       int i, j;
+       for (i = 0;i < 4;i++)
+               for (j = 0;j < 4;j++)
+                       out->m[i][j] += in->m[i][j] * weight;
+}
+
 void Matrix4x4_Normalize (matrix4x4_t *out, matrix4x4_t *in1)
 {
        // scale rotation matrix vectors to a length of 1
@@ -365,6 +395,62 @@ void Matrix4x4_Normalize (matrix4x4_t *out, matrix4x4_t *in1)
        Matrix4x4_Scale(out, scale, 1);
 }
 
+void Matrix4x4_Normalize3 (matrix4x4_t *out, matrix4x4_t *in1)
+{
+       int i;
+       double scale;
+       // scale each rotation matrix vector to a length of 1
+       // intended for use after Matrix4x4_Interpolate or Matrix4x4_Accumulate
+       *out = *in1;
+       for (i = 0;i < 3;i++)
+       {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               scale = sqrt(in1->m[i][0] * in1->m[i][0] + in1->m[i][1] * in1->m[i][1] + in1->m[i][2] * in1->m[i][2]);
+               if (scale)
+                       scale = 1.0 / scale;
+               out->m[i][0] *= scale;
+               out->m[i][1] *= scale;
+               out->m[i][2] *= scale;
+#else
+               scale = sqrt(in1->m[0][i] * in1->m[0][i] + in1->m[1][i] * in1->m[1][i] + in1->m[2][i] * in1->m[2][i]);
+               if (scale)
+                       scale = 1.0 / scale;
+               out->m[0][i] *= scale;
+               out->m[1][i] *= scale;
+               out->m[2][i] *= scale;
+#endif
+       }
+}
+
+void Matrix4x4_Reflect (matrix4x4_t *out, double normalx, double normaly, double normalz, double dist, double axisscale)
+{
+       int i;
+       double d;
+       double p[4], p2[4];
+       p[0] = normalx;
+       p[1] = normaly;
+       p[2] = normalz;
+       p[3] = -dist;
+       p2[0] = p[0] * axisscale;
+       p2[1] = p[1] * axisscale;
+       p2[2] = p[2] * axisscale;
+       p2[3] = 0;
+       for (i = 0;i < 4;i++)
+       {
+#ifdef MATRIX4x4_OPENGLORIENTATION
+               d = out->m[i][0] * p[0] + out->m[i][1] * p[1] + out->m[i][2] * p[2] + out->m[i][3] * p[3];
+               out->m[i][0] += p2[0] * d;
+               out->m[i][1] += p2[1] * d;
+               out->m[i][2] += p2[2] * d;
+#else
+               d = out->m[0][i] * p[0] + out->m[1][i] * p[1] + out->m[2][i] * p[2] + out->m[3][i] * p[3];
+               out->m[0][i] += p2[0] * d;
+               out->m[1][i] += p2[1] * d;
+               out->m[2][i] += p2[2] * d;
+#endif
+       }
+}
+
 void Matrix4x4_CreateIdentity (matrix4x4_t *out)
 {
        out->m[0][0]=1.0f;