physics library version update
[spacedolphin:spacedolphin.git] / lib / chipmunk / include / chipmunk / cpVect.h
1 /* Copyright (c) 2007 Scott Lembcke
2  * 
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to deal
5  * in the Software without restriction, including without limitation the rights
6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7  * copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  * 
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  * 
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19  * SOFTWARE.
20  */
21
22 /// @defgroup cpVect cpVect
23 /// Chipmunk's 2D vector type along with a handy 2D vector math lib.
24 /// @{
25
26 /// Constant for the zero vector.
27 static const cpVect cpvzero = {0.0f,0.0f};
28
29 /// Convenience constructor for cpVect structs.
30 static inline cpVect cpv(const cpFloat x, const cpFloat y)
31 {
32         cpVect v = {x, y};
33         return v;
34 }
35
36 /// Spherical linearly interpolate between v1 and v2.
37 cpVect cpvslerp(const cpVect v1, const cpVect v2, const cpFloat t);
38
39 /// Spherical linearly interpolate between v1 towards v2 by no more than angle a radians
40 cpVect cpvslerpconst(const cpVect v1, const cpVect v2, const cpFloat a);
41
42 ///     Returns a string representation of v. Intended mostly for debugging purposes and not production use.
43 ///     @attention The string points to a static local and is reset every time the function is called.
44 ///     If you want to print more than one vector you will have to split up your printing onto separate lines.
45 char* cpvstr(const cpVect v);
46
47 /// Check if two vectors are equal. (Be careful when comparing floating point numbers!)
48 static inline cpBool cpveql(const cpVect v1, const cpVect v2)
49 {
50         return (v1.x == v2.x && v1.y == v2.y);
51 }
52
53 /// Add two vectors
54 static inline cpVect cpvadd(const cpVect v1, const cpVect v2)
55 {
56         return cpv(v1.x + v2.x, v1.y + v2.y);
57 }
58
59 /// Subtract two vectors.
60 static inline cpVect cpvsub(const cpVect v1, const cpVect v2)
61 {
62         return cpv(v1.x - v2.x, v1.y - v2.y);
63 }
64
65 /// Negate a vector.
66 static inline cpVect cpvneg(const cpVect v)
67 {
68         return cpv(-v.x, -v.y);
69 }
70
71 /// Scalar multiplication.
72 static inline cpVect cpvmult(const cpVect v, const cpFloat s)
73 {
74         return cpv(v.x*s, v.y*s);
75 }
76
77 /// Vector dot product.
78 static inline cpFloat cpvdot(const cpVect v1, const cpVect v2)
79 {
80         return v1.x*v2.x + v1.y*v2.y;
81 }
82
83 /// 2D vector cross product analog.
84 /// The cross product of 2D vectors results in a 3D vector with only a z component.
85 /// This function returns the magnitude of the z value.
86 static inline cpFloat cpvcross(const cpVect v1, const cpVect v2)
87 {
88         return v1.x*v2.y - v1.y*v2.x;
89 }
90
91 /// Returns a perpendicular vector. (90 degree rotation)
92 static inline cpVect cpvperp(const cpVect v)
93 {
94         return cpv(-v.y, v.x);
95 }
96
97 /// Returns a perpendicular vector. (-90 degree rotation)
98 static inline cpVect cpvrperp(const cpVect v)
99 {
100         return cpv(v.y, -v.x);
101 }
102
103 /// Returns the vector projection of v1 onto v2.
104 static inline cpVect cpvproject(const cpVect v1, const cpVect v2)
105 {
106         return cpvmult(v2, cpvdot(v1, v2)/cpvdot(v2, v2));
107 }
108
109 /// Returns the unit length vector for the given angle (in radians).
110 static inline cpVect cpvforangle(const cpFloat a)
111 {
112         return cpv(cpfcos(a), cpfsin(a));
113 }
114
115 /// Returns the angular direction v is pointing in (in radians).
116 static inline cpFloat cpvtoangle(const cpVect v)
117 {
118         return cpfatan2(v.y, v.x);
119 }
120
121 /// Uses complex number multiplication to rotate v1 by v2. Scaling will occur if v1 is not a unit vector.
122 static inline cpVect cpvrotate(const cpVect v1, const cpVect v2)
123 {
124         return cpv(v1.x*v2.x - v1.y*v2.y, v1.x*v2.y + v1.y*v2.x);
125 }
126
127 /// Inverse of cpvrotate().
128 static inline cpVect cpvunrotate(const cpVect v1, const cpVect v2)
129 {
130         return cpv(v1.x*v2.x + v1.y*v2.y, v1.y*v2.x - v1.x*v2.y);
131 }
132
133 /// Returns the squared length of v. Faster than cpvlength() when you only need to compare lengths.
134 static inline cpFloat cpvlengthsq(const cpVect v)
135 {
136         return cpvdot(v, v);
137 }
138
139 /// Returns the length of v.
140 static inline cpFloat cpvlength(const cpVect v)
141 {
142         return cpfsqrt(cpvdot(v, v));
143 }
144
145 /// Linearly interpolate between v1 and v2.
146 static inline cpVect cpvlerp(const cpVect v1, const cpVect v2, const cpFloat t)
147 {
148         return cpvadd(cpvmult(v1, 1.0f - t), cpvmult(v2, t));
149 }
150
151 /// Returns a normalized copy of v.
152 static inline cpVect cpvnormalize(const cpVect v)
153 {
154         return cpvmult(v, 1.0f/cpvlength(v));
155 }
156
157 /// Returns a normalized copy of v or cpvzero if v was already cpvzero. Protects against divide by zero errors.
158 static inline cpVect cpvnormalize_safe(const cpVect v)
159 {
160         return (v.x == 0.0f && v.y == 0.0f ? cpvzero : cpvnormalize(v));
161 }
162
163 /// Clamp v to length len.
164 static inline cpVect cpvclamp(const cpVect v, const cpFloat len)
165 {
166         return (cpvdot(v,v) > len*len) ? cpvmult(cpvnormalize(v), len) : v;
167 }
168
169 /// Linearly interpolate between v1 towards v2 by distance d.
170 static inline cpVect cpvlerpconst(cpVect v1, cpVect v2, cpFloat d)
171 {
172         return cpvadd(v1, cpvclamp(cpvsub(v2, v1), d));
173 }
174
175 /// Returns the distance between v1 and v2.
176 static inline cpFloat cpvdist(const cpVect v1, const cpVect v2)
177 {
178         return cpvlength(cpvsub(v1, v2));
179 }
180
181 /// Returns the squared distance between v1 and v2. Faster than cpvdist() when you only need to compare distances.
182 static inline cpFloat cpvdistsq(const cpVect v1, const cpVect v2)
183 {
184         return cpvlengthsq(cpvsub(v1, v2));
185 }
186
187 /// Returns true if the distance between v1 and v2 is less than dist.
188 static inline cpBool cpvnear(const cpVect v1, const cpVect v2, const cpFloat dist)
189 {
190         return cpvdistsq(v1, v2) < dist*dist;
191 }
192
193 /// @}
194
195 /// @defgroup cpMat2x2 cpMat2x2
196 /// 2x2 matrix type used for tensors and such.
197 /// @{
198
199 static inline cpMat2x2
200 cpMat2x2New(cpFloat a, cpFloat b, cpFloat c, cpFloat d)
201 {
202         cpMat2x2 m = {a, b, c, d};
203         return m;
204 }
205
206 static inline cpVect
207 cpMat2x2Transform(cpMat2x2 m, cpVect v)
208 {
209         return cpv(v.x*m.a + v.y*m.b, v.x*m.c + v.y*m.d);
210 }
211
212 ///@}