]>
Dogcows Code - chaz/yoink/blob - src/moof/math.hh
2 /*] Copyright (c) 2009-2011, Charles McGarvey [*****************************
3 **] All rights reserved.
5 * Distributable under the terms and conditions of the 2-clause BSD license;
6 * see the file COPYING for a complete text of the license.
8 *****************************************************************************/
10 #ifndef _MOOF_MATH_HH_
11 #define _MOOF_MATH_HH_
15 * General math-related types and functions.
25 #include <SDL/SDL_opengl.h>
27 #if ENABLE_DOUBLE_PRECISION
28 typedef GLdouble GLscalar
;
29 #define GL_SCALAR GL_DOUBLE
32 typedef GLfloat GLscalar
;
33 #define GL_SCALAR GL_FLOAT
34 #define SCALAR(F) (F##f)
43 typedef GLscalar scalar
;
45 typedef vector
< scalar
, fixed
<2> > vector2
;
46 typedef vector
< scalar
, fixed
<3> > vector3
;
47 typedef vector
< scalar
, fixed
<4> > vector4
;
49 typedef matrix
< scalar
, fixed
<2,2>, col_basis
, col_major
> matrix2
;
50 typedef matrix
< scalar
, fixed
<3,3>, col_basis
, col_major
> matrix3
;
51 typedef matrix
< scalar
, fixed
<4,4>, col_basis
, col_major
> matrix4
;
53 typedef quaternion
< scalar
, fixed
<>, vector_first
, positive_cross
> quaternion
;
55 typedef constants
<scalar
> constants
;
57 inline vector3
demote(const vector4
& vec
)
59 return vector3(vec
[0], vec
[1], vec
[2]);
62 inline vector2
demote(const vector3
& vec
)
64 return vector2(vec
[0], vec
[1]);
67 inline vector4
promote(const vector3
& vec
, scalar extra
= SCALAR(0.0))
69 return vector4(vec
[0], vec
[1], vec
[2], extra
);
72 inline vector3
promote(const vector2
& vec
, scalar extra
= SCALAR(0.0))
74 return vector3(vec
[0], vec
[1], extra
);
78 const scalar EPSILON
= SCALAR(0.000001);
81 * Check the equality of scalars with a certain degree of error allowed.
84 inline bool is_equal(scalar a
, scalar b
, scalar epsilon
= EPSILON
)
86 return std::abs(a
- b
) < epsilon
;
90 // Here are some generic implementations of a few simple integrators. To use,
91 // you need one type representing the state and another containing the
92 // derivatives of the primary state variables. The state class must implement
95 // void calculate_derivative(Derivative_Type& derivative, scalar absoluteTime);
96 // void step(const Derivative_Type& derivative, scalar deltaTime);
98 // Additionally, the derivative class must overload a few operators:
100 // Derivative_Type operator + (const Derivative_Type& other) const
101 // Derivative_Type operator * (const Derivative_Type& other) const
103 template <class S
, class D
>
104 inline D
evaluate(const S
& state
, scalar t
)
107 state
.calculate_derivative(derivative
, t
);
111 template <class S
, class D
>
112 inline D
evaluate(S state
, scalar t
, scalar dt
, const D
& derivative
)
114 state
.step(derivative
, dt
);
115 return evaluate
<S
,D
>(state
, t
+ dt
);
118 template <class S
, class D
>
119 inline void euler(S
& state
, scalar t
, scalar dt
)
121 D a
= evaluate
<S
,D
>(state
, t
);
125 template <class S
, class D
>
126 inline void rk2(S
& state
, scalar t
, scalar dt
)
128 D a
= evaluate
<S
,D
>(state
, t
);
129 D b
= evaluate
<S
,D
>(state
, t
, dt
* SCALAR(0.5), a
);
133 template <class S
, class D
>
134 inline void rk4(S
& state
, scalar t
, scalar dt
)
136 D a
= evaluate
<S
,D
>(state
, t
);
137 D b
= evaluate
<S
,D
>(state
, t
, dt
* SCALAR(0.5), a
);
138 D c
= evaluate
<S
,D
>(state
, t
, dt
* SCALAR(0.5), b
);
139 D d
= evaluate
<S
,D
>(state
, t
, dt
, c
);
140 state
.step((a
+ (b
+ c
) * SCALAR(2.0) + d
) * SCALAR(1.0/6.0), dt
);
146 #endif // _MOOF_MATH_HH_
This page took 0.041832 seconds and 4 git commands to generate.