Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/toonshader/src/bullet/BulletCollision/Gimpact/gim_tri_collision.cpp @ 7013

Last change on this file since 7013 was 2662, checked in by rgrieder, 16 years ago
Merged presentation branch back to trunk.
Property svn:eol-style set to `native`
File size: 15.6 KB

Line
1
2	/*! \file gim_tri_collision.h
3	\author Francisco Len Nßjera
4	*/
5	/*
6	-----------------------------------------------------------------------------
7	This source file is part of GIMPACT Library.
8
9	For the latest info, see http://gimpact.sourceforge.net/
10
11	Copyright (c) 2006 Francisco Leon Najera. C.C. 80087371.
12	email: projectileman@yahoo.com
13
14	This library is free software; you can redistribute it and/or
15	modify it under the terms of EITHER:
16	(1) The GNU Lesser General Public License as published by the Free
17	Software Foundation; either version 2.1 of the License, or (at
18	your option) any later version. The text of the GNU Lesser
19	General Public License is included with this library in the
20	file GIMPACT-LICENSE-LGPL.TXT.
21	(2) The BSD-style license that is included with this library in
22	the file GIMPACT-LICENSE-BSD.TXT.
23	(3) The zlib/libpng license that is included with this library in
24	the file GIMPACT-LICENSE-ZLIB.TXT.
25
26	This library is distributed in the hope that it will be useful,
27	but WITHOUT ANY WARRANTY; without even the implied warranty of
28	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
29	GIMPACT-LICENSE-LGPL.TXT, GIMPACT-LICENSE-ZLIB.TXT and GIMPACT-LICENSE-BSD.TXT for more details.
30
31	-----------------------------------------------------------------------------
32	*/
33
34	#include "gim_tri_collision.h"
35
36
37	#define TRI_LOCAL_EPSILON 0.000001f
38	#define MIN_EDGE_EDGE_DIS 0.00001f
39
40
41	class GIM_TRIANGLE_CALCULATION_CACHE
42	{
43	public:
44	GREAL margin;
45	btVector3 tu_vertices[3];
46	btVector3 tv_vertices[3];
47	btVector4 tu_plane;
48	btVector4 tv_plane;
49	btVector3 closest_point_u;
50	btVector3 closest_point_v;
51	btVector3 edge_edge_dir;
52	btVector3 distances;
53	GREAL du[4];
54	GREAL du0du1;
55	GREAL du0du2;
56	GREAL dv[4];
57	GREAL dv0dv1;
58	GREAL dv0dv2;
59	btVector3 temp_points[MAX_TRI_CLIPPING];
60	btVector3 temp_points1[MAX_TRI_CLIPPING];
61	btVector3 contact_points[MAX_TRI_CLIPPING];
62
63
64
65	//! if returns false, the faces are paralele
66	SIMD_FORCE_INLINE bool compute_intervals(
67	const GREAL &D0,
68	const GREAL &D1,
69	const GREAL &D2,
70	const GREAL &D0D1,
71	const GREAL &D0D2,
72	GREAL & scale_edge0,
73	GREAL & scale_edge1,
74	GUINT &edge_index0,
75	GUINT &edge_index1)
76	{
77	if(D0D1>0.0f)
78	{
79	/* here we know that D0D2<=0.0 */
80	/* that is D0, D1 are on the same side, D2 on the other or on the plane */
81	scale_edge0 = -D2/(D0-D2);
82	scale_edge1 = -D1/(D2-D1);
83	edge_index0 = 2;edge_index1 = 1;
84	}
85	else if(D0D2>0.0f)
86	{
87	/* here we know that d0d1<=0.0 */
88	scale_edge0 = -D0/(D1-D0);
89	scale_edge1 = -D1/(D2-D1);
90	edge_index0 = 0;edge_index1 = 1;
91	}
92	else if(D1*D2>0.0f \|\| D0!=0.0f)
93	{
94	/* here we know that d0d1<=0.0 or that D0!=0.0 */
95	scale_edge0 = -D0/(D1-D0);
96	scale_edge1 = -D2/(D0-D2);
97	edge_index0 = 0 ;edge_index1 = 2;
98	}
99	else
100	{
101	return false;
102	}
103	return true;
104	}
105
106
107	//! clip triangle
108	/*!
109	*/
110	SIMD_FORCE_INLINE GUINT clip_triangle(
111	const btVector4 & tri_plane,
112	const btVector3 * tripoints,
113	const btVector3 * srcpoints,
114	btVector3 * clip_points)
115	{
116	// edge 0
117
118	btVector4 edgeplane;
119
120	EDGE_PLANE(tripoints[0],tripoints[1],tri_plane,edgeplane);
121
122	GUINT clipped_count = PLANE_CLIP_TRIANGLE3D(
123	edgeplane,srcpoints[0],srcpoints[1],srcpoints[2],temp_points);
124
125	if(clipped_count == 0) return 0;
126
127	// edge 1
128
129	EDGE_PLANE(tripoints[1],tripoints[2],tri_plane,edgeplane);
130
131	clipped_count = PLANE_CLIP_POLYGON3D(
132	edgeplane,temp_points,clipped_count,temp_points1);
133
134	if(clipped_count == 0) return 0;
135
136	// edge 2
137
138	EDGE_PLANE(tripoints[2],tripoints[0],tri_plane,edgeplane);
139
140	clipped_count = PLANE_CLIP_POLYGON3D(
141	edgeplane,temp_points1,clipped_count,clip_points);
142
143	return clipped_count;
144
145
146	/*GUINT i0 = (tri_plane.closestAxis()+1)%3;
147	GUINT i1 = (i0+1)%3;
148	// edge 0
149	btVector3 temp_points[MAX_TRI_CLIPPING];
150	btVector3 temp_points1[MAX_TRI_CLIPPING];
151
152	GUINT clipped_count= PLANE_CLIP_TRIANGLE_GENERIC(
153	0,srcpoints[0],srcpoints[1],srcpoints[2],temp_points,
154	DISTANCE_EDGE(tripoints[0],tripoints[1],i0,i1));
155
156
157	if(clipped_count == 0) return 0;
158
159	// edge 1
160	clipped_count = PLANE_CLIP_POLYGON_GENERIC(
161	0,temp_points,clipped_count,temp_points1,
162	DISTANCE_EDGE(tripoints[1],tripoints[2],i0,i1));
163
164	if(clipped_count == 0) return 0;
165
166	// edge 2
167	clipped_count = PLANE_CLIP_POLYGON_GENERIC(
168	0,temp_points1,clipped_count,clipped_points,
169	DISTANCE_EDGE(tripoints[2],tripoints[0],i0,i1));
170
171	return clipped_count;*/
172	}
173
174	SIMD_FORCE_INLINE void sort_isect(
175	GREAL & isect0,GREAL & isect1,GUINT &e0,GUINT &e1,btVector3 & vec0,btVector3 & vec1)
176	{
177	if(isect1<isect0)
178	{
179	//swap
180	GIM_SWAP_NUMBERS(isect0,isect1);
181	GIM_SWAP_NUMBERS(e0,e1);
182	btVector3 tmp = vec0;
183	vec0 = vec1;
184	vec1 = tmp;
185	}
186	}
187
188	//! Test verifying interval intersection with the direction between planes
189	/*!
190	\pre tv_plane and tu_plane must be set
191	\post
192	distances[2] is set with the distance
193	closest_point_u, closest_point_v, edge_edge_dir are set too
194	\return
195	- 0: faces are paralele
196	- 1: face U casts face V
197	- 2: face V casts face U
198	- 3: nearest edges
199	*/
200	SIMD_FORCE_INLINE GUINT cross_line_intersection_test()
201	{
202	// Compute direction of intersection line
203	edge_edge_dir = tu_plane.cross(tv_plane);
204	GREAL Dlen;
205	VEC_LENGTH(edge_edge_dir,Dlen);
206
207	if(Dlen<0.0001)
208	{
209	return 0; //faces near paralele
210	}
211
212	edge_edge_dir*= 1/Dlen;//normalize
213
214
215	// Compute interval for triangle 1
216	GUINT tu_e0,tu_e1;//edge indices
217	GREAL tu_scale_e0,tu_scale_e1;//edge scale
218	if(!compute_intervals(du[0],du[1],du[2],
219	du0du1,du0du2,tu_scale_e0,tu_scale_e1,tu_e0,tu_e1)) return 0;
220
221	// Compute interval for triangle 2
222	GUINT tv_e0,tv_e1;//edge indices
223	GREAL tv_scale_e0,tv_scale_e1;//edge scale
224
225	if(!compute_intervals(dv[0],dv[1],dv[2],
226	dv0dv1,dv0dv2,tv_scale_e0,tv_scale_e1,tv_e0,tv_e1)) return 0;
227
228	//proyected vertices
229	btVector3 up_e0 = tu_vertices[tu_e0].lerp(tu_vertices[(tu_e0+1)%3],tu_scale_e0);
230	btVector3 up_e1 = tu_vertices[tu_e1].lerp(tu_vertices[(tu_e1+1)%3],tu_scale_e1);
231
232	btVector3 vp_e0 = tv_vertices[tv_e0].lerp(tv_vertices[(tv_e0+1)%3],tv_scale_e0);
233	btVector3 vp_e1 = tv_vertices[tv_e1].lerp(tv_vertices[(tv_e1+1)%3],tv_scale_e1);
234
235	//proyected intervals
236	GREAL isect_u[] = {up_e0.dot(edge_edge_dir),up_e1.dot(edge_edge_dir)};
237	GREAL isect_v[] = {vp_e0.dot(edge_edge_dir),vp_e1.dot(edge_edge_dir)};
238
239	sort_isect(isect_u[0],isect_u[1],tu_e0,tu_e1,up_e0,up_e1);
240	sort_isect(isect_v[0],isect_v[1],tv_e0,tv_e1,vp_e0,vp_e1);
241
242	const GREAL midpoint_u = 0.5f*(isect_u[0]+isect_u[1]); // midpoint
243	const GREAL midpoint_v = 0.5f*(isect_v[0]+isect_v[1]); // midpoint
244
245	if(midpoint_u<midpoint_v)
246	{
247	if(isect_u[1]>=isect_v[1]) // face U casts face V
248	{
249	return 1;
250	}
251	else if(isect_v[0]<=isect_u[0]) // face V casts face U
252	{
253	return 2;
254	}
255	// closest points
256	closest_point_u = up_e1;
257	closest_point_v = vp_e0;
258	// calc edges and separation
259
260	if(isect_u[1]+ MIN_EDGE_EDGE_DIS<isect_v[0]) //calc distance between two lines instead
261	{
262	SEGMENT_COLLISION(
263	tu_vertices[tu_e1],tu_vertices[(tu_e1+1)%3],
264	tv_vertices[tv_e0],tv_vertices[(tv_e0+1)%3],
265	closest_point_u,
266	closest_point_v);
267
268	edge_edge_dir = closest_point_u-closest_point_v;
269	VEC_LENGTH(edge_edge_dir,distances[2]);
270	edge_edge_dir *= 1.0f/distances[2];// normalize
271	}
272	else
273	{
274	distances[2] = isect_v[0]-isect_u[1];//distance negative
275	//edge_edge_dir *= -1.0f; //normal pointing from V to U
276	}
277
278	}
279	else
280	{
281	if(isect_v[1]>=isect_u[1]) // face V casts face U
282	{
283	return 2;
284	}
285	else if(isect_u[0]<=isect_v[0]) // face U casts face V
286	{
287	return 1;
288	}
289	// closest points
290	closest_point_u = up_e0;
291	closest_point_v = vp_e1;
292	// calc edges and separation
293
294	if(isect_v[1]+MIN_EDGE_EDGE_DIS<isect_u[0]) //calc distance between two lines instead
295	{
296	SEGMENT_COLLISION(
297	tu_vertices[tu_e0],tu_vertices[(tu_e0+1)%3],
298	tv_vertices[tv_e1],tv_vertices[(tv_e1+1)%3],
299	closest_point_u,
300	closest_point_v);
301
302	edge_edge_dir = closest_point_u-closest_point_v;
303	VEC_LENGTH(edge_edge_dir,distances[2]);
304	edge_edge_dir *= 1.0f/distances[2];// normalize
305	}
306	else
307	{
308	distances[2] = isect_u[0]-isect_v[1];//distance negative
309	//edge_edge_dir *= -1.0f; //normal pointing from V to U
310	}
311	}
312	return 3;
313	}
314
315
316	//! collides by two sides
317	SIMD_FORCE_INLINE bool triangle_collision(
318	const btVector3 & u0,
319	const btVector3 & u1,
320	const btVector3 & u2,
321	GREAL margin_u,
322	const btVector3 & v0,
323	const btVector3 & v1,
324	const btVector3 & v2,
325	GREAL margin_v,
326	GIM_TRIANGLE_CONTACT_DATA & contacts)
327	{
328
329	margin = margin_u + margin_v;
330
331	tu_vertices[0] = u0;
332	tu_vertices[1] = u1;
333	tu_vertices[2] = u2;
334
335	tv_vertices[0] = v0;
336	tv_vertices[1] = v1;
337	tv_vertices[2] = v2;
338
339	//create planes
340	// plane v vs U points
341
342	TRIANGLE_PLANE(tv_vertices[0],tv_vertices[1],tv_vertices[2],tv_plane);
343
344	du[0] = DISTANCE_PLANE_POINT(tv_plane,tu_vertices[0]);
345	du[1] = DISTANCE_PLANE_POINT(tv_plane,tu_vertices[1]);
346	du[2] = DISTANCE_PLANE_POINT(tv_plane,tu_vertices[2]);
347
348
349	du0du1 = du[0] * du[1];
350	du0du2 = du[0] * du[2];
351
352
353	if(du0du1>0.0f && du0du2>0.0f) // same sign on all of them + not equal 0 ?
354	{
355	if(du[0]<0) //we need test behind the triangle plane
356	{
357	distances[0] = GIM_MAX3(du[0],du[1],du[2]);
358	distances[0] = -distances[0];
359	if(distances[0]>margin) return false; //never intersect
360
361	//reorder triangle v
362	VEC_SWAP(tv_vertices[0],tv_vertices[1]);
363	VEC_SCALE_4(tv_plane,-1.0f,tv_plane);
364	}
365	else
366	{
367	distances[0] = GIM_MIN3(du[0],du[1],du[2]);
368	if(distances[0]>margin) return false; //never intersect
369	}
370	}
371	else
372	{
373	//Look if we need to invert the triangle
374	distances[0] = (du[0]+du[1]+du[2])/3.0f; //centroid
375
376	if(distances[0]<0.0f)
377	{
378	//reorder triangle v
379	VEC_SWAP(tv_vertices[0],tv_vertices[1]);
380	VEC_SCALE_4(tv_plane,-1.0f,tv_plane);
381
382	distances[0] = GIM_MAX3(du[0],du[1],du[2]);
383	distances[0] = -distances[0];
384	}
385	else
386	{
387	distances[0] = GIM_MIN3(du[0],du[1],du[2]);
388	}
389	}
390
391
392	// plane U vs V points
393
394	TRIANGLE_PLANE(tu_vertices[0],tu_vertices[1],tu_vertices[2],tu_plane);
395
396	dv[0] = DISTANCE_PLANE_POINT(tu_plane,tv_vertices[0]);
397	dv[1] = DISTANCE_PLANE_POINT(tu_plane,tv_vertices[1]);
398	dv[2] = DISTANCE_PLANE_POINT(tu_plane,tv_vertices[2]);
399
400	dv0dv1 = dv[0] * dv[1];
401	dv0dv2 = dv[0] * dv[2];
402
403
404	if(dv0dv1>0.0f && dv0dv2>0.0f) // same sign on all of them + not equal 0 ?
405	{
406	if(dv[0]<0) //we need test behind the triangle plane
407	{
408	distances[1] = GIM_MAX3(dv[0],dv[1],dv[2]);
409	distances[1] = -distances[1];
410	if(distances[1]>margin) return false; //never intersect
411
412	//reorder triangle u
413	VEC_SWAP(tu_vertices[0],tu_vertices[1]);
414	VEC_SCALE_4(tu_plane,-1.0f,tu_plane);
415	}
416	else
417	{
418	distances[1] = GIM_MIN3(dv[0],dv[1],dv[2]);
419	if(distances[1]>margin) return false; //never intersect
420	}
421	}
422	else
423	{
424	//Look if we need to invert the triangle
425	distances[1] = (dv[0]+dv[1]+dv[2])/3.0f; //centroid
426
427	if(distances[1]<0.0f)
428	{
429	//reorder triangle v
430	VEC_SWAP(tu_vertices[0],tu_vertices[1]);
431	VEC_SCALE_4(tu_plane,-1.0f,tu_plane);
432
433	distances[1] = GIM_MAX3(dv[0],dv[1],dv[2]);
434	distances[1] = -distances[1];
435	}
436	else
437	{
438	distances[1] = GIM_MIN3(dv[0],dv[1],dv[2]);
439	}
440	}
441
442	GUINT bl;
443	/* bl = cross_line_intersection_test();
444	if(bl==3)
445	{
446	//take edge direction too
447	bl = distances.maxAxis();
448	}
449	else
450	{*/
451	bl = 0;
452	if(distances[0]<distances[1]) bl = 1;
453	//}
454
455	if(bl==2) //edge edge separation
456	{
457	if(distances[2]>margin) return false;
458
459	contacts.m_penetration_depth = -distances[2] + margin;
460	contacts.m_points[0] = closest_point_v;
461	contacts.m_point_count = 1;
462	VEC_COPY(contacts.m_separating_normal,edge_edge_dir);
463
464	return true;
465	}
466
467	//clip face against other
468
469
470	GUINT point_count;
471	//TODO
472	if(bl == 0) //clip U points against V
473	{
474	point_count = clip_triangle(tv_plane,tv_vertices,tu_vertices,contact_points);
475	if(point_count == 0) return false;
476	contacts.merge_points(tv_plane,margin,contact_points,point_count);
477	}
478	else //clip V points against U
479	{
480	point_count = clip_triangle(tu_plane,tu_vertices,tv_vertices,contact_points);
481	if(point_count == 0) return false;
482	contacts.merge_points(tu_plane,margin,contact_points,point_count);
483	contacts.m_separating_normal *= -1.f;
484	}
485	if(contacts.m_point_count == 0) return false;
486	return true;
487	}
488
489	};
490
491
492	/*class GIM_TRIANGLE_CALCULATION_CACHE
493	{
494	public:
495	GREAL margin;
496	GUINT clipped_count;
497	btVector3 tu_vertices[3];
498	btVector3 tv_vertices[3];
499	btVector3 temp_points[MAX_TRI_CLIPPING];
500	btVector3 temp_points1[MAX_TRI_CLIPPING];
501	btVector3 clipped_points[MAX_TRI_CLIPPING];
502	GIM_TRIANGLE_CONTACT_DATA contacts1;
503	GIM_TRIANGLE_CONTACT_DATA contacts2;
504
505
506	//! clip triangle
507	GUINT clip_triangle(
508	const btVector4 & tri_plane,
509	const btVector3 * tripoints,
510	const btVector3 * srcpoints,
511	btVector3 * clipped_points)
512	{
513	// edge 0
514
515	btVector4 edgeplane;
516
517	EDGE_PLANE(tripoints[0],tripoints[1],tri_plane,edgeplane);
518
519	GUINT clipped_count = PLANE_CLIP_TRIANGLE3D(
520	edgeplane,srcpoints[0],srcpoints[1],srcpoints[2],temp_points);
521
522	if(clipped_count == 0) return 0;
523
524	// edge 1
525
526	EDGE_PLANE(tripoints[1],tripoints[2],tri_plane,edgeplane);
527
528	clipped_count = PLANE_CLIP_POLYGON3D(
529	edgeplane,temp_points,clipped_count,temp_points1);
530
531	if(clipped_count == 0) return 0;
532
533	// edge 2
534
535	EDGE_PLANE(tripoints[2],tripoints[0],tri_plane,edgeplane);
536
537	clipped_count = PLANE_CLIP_POLYGON3D(
538	edgeplane,temp_points1,clipped_count,clipped_points);
539
540	return clipped_count;
541	}
542
543
544
545
546	//! collides only on one side
547	bool triangle_collision(
548	const btVector3 & u0,
549	const btVector3 & u1,
550	const btVector3 & u2,
551	GREAL margin_u,
552	const btVector3 & v0,
553	const btVector3 & v1,
554	const btVector3 & v2,
555	GREAL margin_v,
556	GIM_TRIANGLE_CONTACT_DATA & contacts)
557	{
558
559	margin = margin_u + margin_v;
560
561
562	tu_vertices[0] = u0;
563	tu_vertices[1] = u1;
564	tu_vertices[2] = u2;
565
566	tv_vertices[0] = v0;
567	tv_vertices[1] = v1;
568	tv_vertices[2] = v2;
569
570	//create planes
571	// plane v vs U points
572
573
574	TRIANGLE_PLANE(tv_vertices[0],tv_vertices[1],tv_vertices[2],contacts1.m_separating_normal);
575
576	clipped_count = clip_triangle(
577	contacts1.m_separating_normal,tv_vertices,tu_vertices,clipped_points);
578
579	if(clipped_count == 0 )
580	{
581	return false;//Reject
582	}
583
584	//find most deep interval face1
585	contacts1.merge_points(contacts1.m_separating_normal,margin,clipped_points,clipped_count);
586	if(contacts1.m_point_count == 0) return false; // too far
587
588	//Normal pointing to triangle1
589	//contacts1.m_separating_normal *= -1.f;
590
591	//Clip tri1 by tri2 edges
592
593	TRIANGLE_PLANE(tu_vertices[0],tu_vertices[1],tu_vertices[2],contacts2.m_separating_normal);
594
595	clipped_count = clip_triangle(
596	contacts2.m_separating_normal,tu_vertices,tv_vertices,clipped_points);
597
598	if(clipped_count == 0 )
599	{
600	return false;//Reject
601	}
602
603	//find most deep interval face1
604	contacts2.merge_points(contacts2.m_separating_normal,margin,clipped_points,clipped_count);
605	if(contacts2.m_point_count == 0) return false; // too far
606
607	contacts2.m_separating_normal *= -1.f;
608
609	////check most dir for contacts
610	if(contacts2.m_penetration_depth<contacts1.m_penetration_depth)
611	{
612	contacts.copy_from(contacts2);
613	}
614	else
615	{
616	contacts.copy_from(contacts1);
617	}
618	return true;
619	}
620
621
622	};*/
623
624
625
626	bool GIM_TRIANGLE::collide_triangle_hard_test(
627	const GIM_TRIANGLE & other,
628	GIM_TRIANGLE_CONTACT_DATA & contact_data) const
629	{
630	GIM_TRIANGLE_CALCULATION_CACHE calc_cache;
631	return calc_cache.triangle_collision(
632	m_vertices[0],m_vertices[1],m_vertices[2],m_margin,
633	other.m_vertices[0],other.m_vertices[1],other.m_vertices[2],other.m_margin,
634	contact_data);
635
636	}
637
638
639
640

Note: See TracBrowser for help on using the repository browser.

Download in other formats: