#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
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;
#endif
}
+void Matrix4x4_TransformPositivePlane(const matrix4x4_t *in, float x, float y, float z, float d, float *o)
+{
+#ifdef MATRIX4x4_OPENGLORIENTATION
+ o[0] = x * in->m[0][0] + y * in->m[1][0] + z * in->m[2][0];
+ o[1] = x * in->m[0][1] + y * in->m[1][1] + z * in->m[2][1];
+ o[2] = x * in->m[0][2] + y * in->m[1][2] + z * in->m[2][2];
+ o[3] = d + (x * in->m[3][0] + y * in->m[3][1] + z * in->m[3][2]);
+#else
+ o[0] = x * in->m[0][0] + y * in->m[0][1] + z * in->m[0][2];
+ o[1] = x * in->m[1][0] + y * in->m[1][1] + z * in->m[1][2];
+ o[2] = x * in->m[2][0] + y * in->m[2][1] + z * in->m[2][2];
+ o[3] = d + (x * in->m[0][3] + y * in->m[1][3] + z * in->m[2][3]);
+#endif
+}
+
+void Matrix4x4_TransformStandardPlane(const matrix4x4_t *in, float x, float y, float z, float d, float *o)
+{
+#ifdef MATRIX4x4_OPENGLORIENTATION
+ o[0] = x * in->m[0][0] + y * in->m[1][0] + z * in->m[2][0];
+ o[1] = x * in->m[0][1] + y * in->m[1][1] + z * in->m[2][1];
+ o[2] = x * in->m[0][2] + y * in->m[1][2] + z * in->m[2][2];
+ o[3] = d - (x * in->m[3][0] + y * in->m[3][1] + z * in->m[3][2]);
+#else
+ o[0] = x * in->m[0][0] + y * in->m[0][1] + z * in->m[0][2];
+ o[1] = x * in->m[1][0] + y * in->m[1][1] + z * in->m[1][2];
+ o[2] = x * in->m[2][0] + y * in->m[2][1] + z * in->m[2][2];
+ o[3] = d - (x * in->m[0][3] + y * in->m[1][3] + z * in->m[2][3]);
+#endif
+}
+
/*
void Matrix4x4_SimpleUntransform (const matrix4x4_t *in, const float v[3], float out[3])
{