Line data Source code
1 : /*This code is based off the Minkowski Portal Refinement algorithm by Gary Snethen
2 : * in XenoCollide & Game Programming Gems 7.
3 : *
4 : * Minkowski Portal Refinement is a way of finding whether two hulls intersect
5 : * efficiently, useful for finding if two models are intersecting quickly
6 : *
7 : * used in physics.cpp and for model-related collision purposes
8 : */
9 : #include "../libprimis-headers/cube.h"
10 : #include "../../shared/geomexts.h"
11 :
12 : #include "octaworld.h"
13 :
14 : #include "mpr.h"
15 :
16 : namespace mpr
17 : {
18 :
19 : //CubePlanes
20 :
21 0 : vec CubePlanes::center() const
22 : {
23 0 : return p.o;
24 : }
25 :
26 0 : vec CubePlanes::supportpoint(const vec &n) const
27 : {
28 0 : int besti = 7;
29 0 : float bestd = n.dot(p.v[7]);
30 0 : for(int i = 0; i < 7; ++i)
31 : {
32 0 : float d = n.dot(p.v[i]);
33 0 : if(d > bestd)
34 : {
35 0 : besti = i;
36 0 : bestd = d;
37 : }
38 : }
39 0 : return p.v[besti];
40 : }
41 :
42 : //SolidCube
43 :
44 0 : vec SolidCube::center() const
45 : {
46 0 : return vec(o).add(size/2);
47 : }
48 :
49 0 : vec SolidCube::supportpoint (const vec &n) const
50 : {
51 0 : vec p(o);
52 0 : if(n.x > 0)
53 : {
54 0 : p.x += size;
55 : }
56 0 : if(n.y > 0)
57 : {
58 0 : p.y += size;
59 : }
60 0 : if(n.z > 0)
61 : {
62 0 : p.z += size;
63 : }
64 0 : return p;
65 : }
66 :
67 : //Ent
68 :
69 0 : vec Ent::center() const
70 : {
71 0 : return vec(ent->o.x, ent->o.y, ent->o.z + (ent->aboveeye - ent->eyeheight)/2);
72 : }
73 :
74 : //EntOBB
75 :
76 0 : EntOBB::EntOBB(const physent *ent) : Ent(ent)
77 : {
78 0 : orient.setyaw(ent->yaw/RAD);
79 0 : }
80 :
81 0 : vec EntOBB::contactface(const vec &wn, const vec &wdir) const
82 : {
83 0 : vec n = orient.transform(wn).div(vec(ent->xradius, ent->yradius, (ent->aboveeye + ent->eyeheight)/2)),
84 0 : dir = orient.transform(wdir),
85 0 : an(std::fabs(n.x), std::fabs(n.y), dir.z ? std::fabs(n.z) : 0),
86 0 : fn(0, 0, 0);
87 0 : if(an.x > an.y)
88 : {
89 0 : if(an.x > an.z)
90 : {
91 0 : fn.x = n.x*dir.x < 0 ? (n.x > 0 ? 1 : -1) : 0;
92 : }
93 0 : else if(an.z > 0)
94 : {
95 0 : fn.z = n.z*dir.z < 0 ? (n.z > 0 ? 1 : -1) : 0;
96 : }
97 : }
98 0 : else if(an.y > an.z)
99 : {
100 0 : fn.y = n.y*dir.y < 0 ? (n.y > 0 ? 1 : -1) : 0;
101 : }
102 0 : else if(an.z > 0)
103 : {
104 0 : fn.z = n.z*dir.z < 0 ? (n.z > 0 ? 1 : -1) : 0;
105 : }
106 0 : return orient.transposedtransform(fn);
107 : }
108 :
109 0 : vec EntOBB::localsupportpoint(const vec &ln) const
110 : {
111 0 : return vec(ln.x > 0 ? ent->xradius : -ent->xradius,
112 0 : ln.y > 0 ? ent->yradius : -ent->yradius,
113 0 : ln.z > 0 ? ent->aboveeye : -ent->eyeheight);
114 : }
115 0 : vec EntOBB::supportpoint(const vec &n) const
116 : {
117 0 : return orient.transposedtransform(localsupportpoint(orient.transform(n))).add(ent->o);
118 : }
119 :
120 0 : float EntOBB::supportcoordneg(const vec &p) const
121 : {
122 0 : return localsupportpoint(vec(p).neg()).dot(p);
123 : }
124 :
125 0 : float EntOBB::supportcoord(const vec &p) const
126 : {
127 0 : return localsupportpoint(p).dot(p);
128 : }
129 :
130 0 : float EntOBB::left() const { return supportcoordneg(orient.a) + ent->o.x; }
131 0 : float EntOBB::right() const { return supportcoord(orient.a) + ent->o.x; }
132 0 : float EntOBB::back() const { return supportcoordneg(orient.b) + ent->o.y; }
133 0 : float EntOBB::front() const { return supportcoord(orient.b) + ent->o.y; }
134 0 : float EntOBB::bottom() const { return ent->o.z - ent->eyeheight; }
135 0 : float EntOBB::top() const { return ent->o.z + ent->aboveeye; }
136 :
137 : //EntFuzzy
138 :
139 0 : float EntFuzzy::left() const { return ent->o.x - ent->radius; }
140 0 : float EntFuzzy::right() const { return ent->o.x + ent->radius; }
141 0 : float EntFuzzy::back() const { return ent->o.y - ent->radius; }
142 0 : float EntFuzzy::front() const { return ent->o.y + ent->radius; }
143 0 : float EntFuzzy::bottom() const { return ent->o.z - ent->eyeheight; }
144 0 : float EntFuzzy::top() const { return ent->o.z + ent->aboveeye; }
145 :
146 : //EntCylinder
147 :
148 0 : vec EntCylinder::contactface(const vec &n, const vec &dir) const
149 : {
150 0 : float dxy = n.dot2(n)/(ent->radius*ent->radius),
151 0 : dz = n.z*n.z*4/(ent->aboveeye + ent->eyeheight);
152 0 : vec fn(0, 0, 0);
153 0 : if(dz > dxy && dir.z)
154 : {
155 0 : fn.z = n.z*dir.z < 0 ? (n.z > 0 ? 1 : -1) : 0;
156 : }
157 0 : else if(n.dot2(dir) < 0)
158 : {
159 0 : fn.x = n.x;
160 0 : fn.y = n.y;
161 0 : fn.normalize();
162 : }
163 0 : return fn;
164 : }
165 :
166 0 : vec EntCylinder::supportpoint(const vec &n) const
167 : {
168 0 : vec p(ent->o);
169 0 : if(n.z > 0)
170 : {
171 0 : p.z += ent->aboveeye;
172 : }
173 : else
174 : {
175 0 : p.z -= ent->eyeheight;
176 : }
177 0 : if(n.x || n.y)
178 : {
179 0 : float r = ent->radius / n.magnitude2();
180 0 : p.x += n.x*r;
181 0 : p.y += n.y*r;
182 : }
183 0 : return p;
184 : }
185 :
186 : //EntCapsule
187 :
188 0 : vec EntCapsule::supportpoint(const vec &n) const
189 : {
190 0 : vec p(ent->o);
191 0 : if(n.z > 0)
192 : {
193 0 : p.z += ent->aboveeye - ent->radius;
194 : }
195 : else
196 : {
197 0 : p.z -= ent->eyeheight - ent->radius;
198 : }
199 0 : p.add(vec(n).mul(ent->radius / n.magnitude()));
200 0 : return p;
201 : }
202 :
203 : //EntEllipsoid
204 :
205 0 : vec EntEllipsoid::supportpoint(const vec &dir) const
206 : {
207 0 : vec p(ent->o);
208 0 : vec n = vec(dir).normalize();
209 0 : p.x += ent->radius*n.x;
210 0 : p.y += ent->radius*n.y;
211 0 : p.z += (ent->aboveeye + ent->eyeheight)/2*(1 + n.z) - ent->eyeheight;
212 0 : return p;
213 : }
214 :
215 : //Model
216 :
217 0 : Model::Model(const vec &ent, const vec ¢er, const vec &radius, int yaw, int pitch, int roll) : o(ent), radius(radius)
218 : {
219 0 : orient.identity();
220 0 : if(roll)
221 : {
222 0 : orient.rotate_around_y(sincosmod360(roll));
223 : }
224 0 : if(pitch)
225 : {
226 0 : orient.rotate_around_x(sincosmod360(-pitch));
227 : }
228 0 : if(yaw)
229 : {
230 0 : orient.rotate_around_z(sincosmod360(-yaw));
231 : }
232 0 : o.add(orient.transposedtransform(center));
233 0 : }
234 :
235 0 : vec Model::center() const
236 : {
237 0 : return o;
238 : }
239 :
240 : //ModelOBB
241 :
242 0 : vec ModelOBB::contactface(const vec &wn, const vec &wdir) const
243 : {
244 0 : vec n = orient.transform(wn).div(radius),
245 0 : dir = orient.transform(wdir),
246 0 : an(std::fabs(n.x), std::fabs(n.y), dir.z ? std::fabs(n.z) : 0),
247 0 : fn(0, 0, 0);
248 0 : if(an.x > an.y)
249 : {
250 0 : if(an.x > an.z)
251 : {
252 0 : fn.x = n.x*dir.x < 0 ? (n.x > 0 ? 1 : -1) : 0;
253 : }
254 0 : else if(an.z > 0)
255 : {
256 0 : fn.z = n.z*dir.z < 0 ? (n.z > 0 ? 1 : -1) : 0;
257 : }
258 : }
259 0 : else if(an.y > an.z)
260 : {
261 0 : fn.y = n.y*dir.y < 0 ? (n.y > 0 ? 1 : -1) : 0;
262 : }
263 0 : else if(an.z > 0)
264 : {
265 0 : fn.z = n.z*dir.z < 0 ? (n.z > 0 ? 1 : -1) : 0;
266 : }
267 0 : return orient.transposedtransform(fn);
268 : }
269 :
270 0 : vec ModelOBB::supportpoint(const vec &n) const
271 : {
272 0 : vec ln = orient.transform(n),
273 0 : p(0, 0, 0);
274 0 : if(ln.x > 0)
275 : {
276 0 : p.x += radius.x;
277 : }
278 : else
279 : {
280 0 : p.x -= radius.x;
281 : }
282 0 : if(ln.y > 0)
283 : {
284 0 : p.y += radius.y;
285 : }
286 : else
287 : {
288 0 : p.y -= radius.y;
289 : }
290 0 : if(ln.z > 0)
291 : {
292 0 : p.z += radius.z;
293 : }
294 : else
295 : {
296 0 : p.z -= radius.z;
297 : }
298 0 : return orient.transposedtransform(p).add(o);
299 : }
300 :
301 : //ModelEllipse
302 :
303 0 : vec ModelEllipse::contactface(const vec &wn, const vec &wdir) const
304 : {
305 0 : vec n = orient.transform(wn).div(radius),
306 0 : dir = orient.transform(wdir);
307 0 : float dxy = n.dot2(n),
308 0 : dz = n.z*n.z;
309 0 : vec fn(0, 0, 0);
310 0 : if(dz > dxy && dir.z)
311 : {
312 0 : fn.z = n.z*dir.z < 0 ? (n.z > 0 ? 1 : -1) : 0;
313 : }
314 0 : else if(n.dot2(dir) < 0)
315 : {
316 0 : fn.x = n.x*radius.y;
317 0 : fn.y = n.y*radius.x;
318 0 : fn.normalize();
319 : }
320 0 : return orient.transposedtransform(fn);
321 : }
322 :
323 0 : vec ModelEllipse::supportpoint(const vec &n) const
324 : {
325 0 : vec ln = orient.transform(n),
326 0 : p(0, 0, 0);
327 0 : if(ln.z > 0)
328 : {
329 0 : p.z += radius.z;
330 : }
331 : else
332 : {
333 0 : p.z -= radius.z;
334 : }
335 0 : if(ln.x || ln.y)
336 : {
337 0 : float r = ln.magnitude2();
338 0 : p.x += ln.x*radius.x/r;
339 0 : p.y += ln.y*radius.y/r;
340 : }
341 0 : return orient.transposedtransform(p).add(o);
342 : }
343 : }
|
