1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
#ifndef _MATH3D_H_
#define _MATH3D_H_
#include <math.h>
#include <string.h>
#define M3D_PI (3.14159265358979323846)
#define M3D_PI_DIV_180 (0.017453292519943296)
#define M3D_INV_PI_DIV_180 (57.2957795130823229)
#define m3dDegToRad(x) ((x)*M3D_PI_DIV_180)
#define m3dRadToDeg(x) ((x)*M3D_INV_PI_DIV_180)
typedef float M3DMatrix44f[16]; /* 4x4 matrix */
typedef float M3DMatrix33f[9]; /* 3x3 matrix */
typedef float M3DVector4f[4]; /* vector of 4 floats */
typedef float M3DVector3f[3]; /* vector of 3 floats */
typedef float M3DVector2f[2]; /* vector of 2 floats */
/* math function prototypes */
void m3dFindNormalf(M3DVector3f, const M3DVector3f, const M3DVector3f, const M3DVector3f);
void m3dLoadIdentity33f(M3DMatrix33f);
void m3dLoadIdentity44f(M3DMatrix44f);
void m3dGetPlaneEquationf(M3DVector4f, const M3DVector3f, const M3DVector3f, const M3DVector3f);
void m3dRotationMatrix44f(M3DMatrix44f, float, float, float, float);
void m3dMakePlanarShadowMatrixf(M3DMatrix44f, const M3DVector4f, const M3DVector3f);
void m3dMatrixMultiply44f(M3DMatrix44f, const M3DMatrix44f, const M3DMatrix44f);
void m3dPrintMatrix44f(const M3DMatrix44f);
int m3dInvertMatrix44f(M3DMatrix44f, const M3DMatrix44f);
unsigned int m3dPowerOfTwo(unsigned int);
static inline void m3dCrossProductf(M3DVector3f result, const M3DVector3f u,
const M3DVector3f v)
{
result[0] = u[1] * v[2] - v[1] * u[2];
result[1] = -u[0] * v[2] + v[0] * u[2];
result[2] = u[0] * v[1] - v[0] * u[1];
}
static inline void m3dTransformVector3f(M3DVector3f vout, const M3DVector3f v,
const M3DMatrix44f m)
{
vout[0] = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12];
vout[1] = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13];
vout[2] = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14];
}
static inline void m3dScaleVector3f(M3DVector3f v, const float scale)
{
v[0] *= scale;
v[1] *= scale;
v[2] *= scale;
}
static inline float m3dGetVectorLengthSquaredf(const M3DVector3f u)
{
return (u[0] * u[0]) + (u[1] * u[1]) + (u[2] * u[2]);
}
static inline float m3dGetVectorLengthf(const M3DVector3f u)
{
return (float) (sqrt((double) (m3dGetVectorLengthSquaredf(u))));
}
static inline void m3dNormalizeVectorf(M3DVector3f u)
{
m3dScaleVector3f(u, 1.0f / m3dGetVectorLengthf(u));
}
static inline void m3dTranslateMatrix44f(M3DMatrix44f m, const float x,
const float y, const float z)
{
m[12] += x;
m[13] += y;
m[14] += z;
}
static inline void m3dScaleMatrix44f(M3DMatrix44f m, const float x,
const float y, const float z)
{
m[0] *= x;
m[5] *= y;
m[10] *= z;
}
/* transpose / invert, only 4x4 matricies supported */
#define TRANSPOSE44(dst, src) \
{ \
int i, j; \
for (j = 0; j < 4; j++) \
{ \
for (i = 0; i < 4; i++) \
{ \
dst[(j*4)+i] = src[(i*4)+j]; \
} \
} \
}
static inline void m3dTransposeMatrix44f(M3DMatrix44f dst, const M3DMatrix44f src)
{
TRANSPOSE44(dst, src);
}
static inline void m3dCopyVector3f(M3DVector3f dst, const M3DVector3f src)
{
memcpy(dst, src, sizeof(M3DVector3f));
}
static inline void m3dSetMatrixColumn44f(M3DMatrix44f dst, const M3DVector4f src,
const int col)
{
memcpy(dst + (4 * col), src, sizeof(float) * 4);
}
static inline void m3dLoadVector2f(M3DVector2f v, const float x, const float y)
{
v[0] = x;
v[1] = y;
}
static inline void m3dLoadVector3f(M3DVector3f v, const float x, const float y, const float z)
{
v[0] = x;
v[1] = y;
v[2] = z;
}
static inline void m3dLoadVector4f(M3DVector4f v, const float x, const float y,
const float z, const float w)
{
v[0] = x;
v[1] = y;
v[2] = z;
v[3] = w;
}
#endif
|
