Context Navigation

HavranDynRayCaster.cpp @ 2710

Revision 2710, 26.4 KB checked in by mattausch, 17 years ago (diff)

Line
1
2	// Written by Vlastimil Havran, December 2007
3
4	// This macro allows to use the ray shooting written by
5	// Vlastimil Havran, 2007-2008
6
7
8	#include "VssRay.h"
9	#include "KdTree.h"
10	#include "Preprocessor.h"
11	#include "IntersectableWrapper.h"
12
13	#ifdef USE_HAVRAN_RAYCASTER
14	#include "ktbconf.h"
15	#include "timer.h"
16	#include "ktball.h"
17	#include "ktb.h"
18	#ifdef _USE_HAVRAN_SSE
19
20	#include "raypack.h"
21	#endif // _USE_HAVRAN_SSE
22	#endif // _USE_HAVRAN_RAYCASTER
23
24	#include "HavranRayCaster.h"
25
26	#define DEBUG_RAYCAST 0
27
28	namespace GtpVisibilityPreprocessor {
29
30	#ifdef _USE_HAVRAN_SSE
31	// static rays
32	GALIGN16 RayPacket2x2
33	HavranDynRayCaster::raypack_t;
34	#endif // _USE_HAVRAN_SSE
35
36	HavranDynRayCaster::HavranDynRayCaster(const Preprocessor &preprocessor):
37	HavranRayCaster(preprocessor), mDynKtbtree(0),
38	dynobjects(0), dynamicFlag(false)
39	{
40	#ifdef USE_HAVRAN_RAYCASTER
41	#ifdef _USE_HAVRAN_SSE
42	if ( ((int)(&raypack_t)) & 0xf != 0) {
43	cerr << "The ray pack data type not aligned on 16 Bytes boundary" << endl;
44	cerr << "Address is " << (void*)(&raypack_t) << endl;
45	cerr << "Reorganize your data structure to make it aligned" << endl;
46	abort();
47	}
48	#endif
49	#endif
50	}
51
52
53	HavranDynRayCaster::~HavranDynRayCaster()
54	{
55	#ifdef USE_HAVRAN_RAYCASTER
56	DeleteDynamicObjects();
57	#endif // USE_HAVRAN_RAYCASTER
58	}
59
60	void
61	HavranDynRayCaster::DeleteDynamicObjects()
62	{
63	#ifdef USE_HAVRAN_RAYCASTER
64	delete mDynKtbtree; mDynKtbtree = 0;
65	delete dynobjects; dynobjects = 0;
66	dynamicFlag = false;
67	#endif // USE_HAVRAN_RAYCASTER
68	}
69
70	void
71	HavranDynRayCaster::AddDynamicObjecs(const ObjectContainer &objects, const Matrix4x4 &m)
72	{
73	#ifdef USE_HAVRAN_RAYCASTER
74	if (dynobjects)
75	DeleteDynamicObjects();
76
77	dynamicFlag = false;
78
79	if (objects.size()) {
80	dynamicFlag = true;
81	dynobjects = new ObjectContainer(objects);
82	assert(dynobjects);
83	// kd-tree built over the objects
84	mDynKtbtree = new CKTB;
85	mDynKtbtree->BuildUp(*dynobjects);
86
87	// The matrix to transform the objects
88	UpdateDynamicObjects(m);
89	}
90	#endif // USE_HAVRAN_RAYCASTER
91	}
92
93	void
94	HavranDynRayCaster::UpdateDynamicObjects(const Matrix4x4 &m)
95	{
96	#ifdef USE_HAVRAN_RAYCASTER
97	matTr = m;
98	matTr_inv = Invert(matTr);
99	#endif // USE_HAVRAN_RAYCASTER
100	}
101
102	// Using packet of 4 rays supposing that these are coherent
103	// We give a box to which each ray is clipped to before the
104	// ray shooting is computed !
105	void HavranDynRayCaster::CastRaysPacket4(const Vector3 &minBox,
106	const Vector3 &maxBox,
107	const Vector3 origin4[],
108	const Vector3 direction4[],
109	int result4[],
110	float dist4[])
111	{
112	#ifdef USE_HAVRAN_RAYCASTER
113	#ifdef _USE_HAVRAN_SSE
114	for (int i = 0; i < 4; i++) {
115	result4[i] = -1;
116	result4_t[4] = -1;
117	raypack.SetLoc(i, origin4[i]);
118	raypack.SetDir(i, direction4[i]);
119	}
120
121	// The same operations for packets of rays, if implemented by
122	// a particular ASDS, otherwise it is emulated by decomposition
123	// of a packet to individual rays and traced individually.
124	mKtbtree->FindNearestI(raypack, minBox, maxBox);
125
126	for (int i = 0; i < 4; i++) {
127	// if ray intersects an object, we set the pointer to
128	// this object
129	Intersectable* intersectable = raypack.GetObject(i);
130	if (intersectable) {
131	result4[i] = intersectable->mId;
132	dist4[i] = raypack.GetT(i);
133	}
134	}
135
136	if (dynamicFlag) {
137	// The ray pack to be transformed
138	raypack_t = raypack;
139	raypack_t.ApplyTransform(matTr_inv);
140
141	mDynKtbtree->FindNearestI(raypack_t, minBox, maxBox);
142
143	for (int i = 0; i < 4; i++) {
144	// if ray intersects an object, we set the pointer to
145	// this object
146	Intersectable* intersectable = raypack_t.GetObject(i);
147	if (intersectable) {
148	float t = raypack_t.GetT(i);
149	if ( ( (result4[i] != -1) && (t < dist4[i]) ) \|\|
150	(result4[i] == -1) ) {
151	// update, dynamic object is closer
152	dist4[i] = t;
153	result4[i] = intersectable->mId;
154	}
155	}
156	} // for i
157	} // dynamic flag
158
159	return;
160	#else // _USE_HAVRAN_SSE
161	// Compute the result ray by ray
162	SimpleRay sray;
163	for (int i = 0; i < 4; i++) {
164	result4[i] = -1; // no intersection
165	sray.mOrigin = origin4[i];
166	sray.mDirection = direction4[i];
167	mKtbtree->FindNearestI(sray, minBox, maxBox);
168	if (SimpleRay::IntersectionRes[0].intersectable) {
169	// This is object ID - is this the triangle index ???
170	result4[i] = SimpleRay::IntersectionRes[0].intersectable->mId;
171	dist4[i] = SimpleRay::IntersectionRes[0].tdist;
172	}
173
174	if (dynamicFlag) {
175	// Now apply transform
176	ApplyTransform(sray);
177	mDynKtbtree->FindNearestI(sray, minBox, maxBox);
178	Intersectable *objdyn = SimpleRay::IntersectionRes[0].intersectable;
179	if (objdyn) {
180	float t = SimpleRay::IntersectionRes[0].tdist;
181	if ( ((result4[i] != -1) && (t < dist4[i])) \|\|
182	(result4[i] == -1) ) {
183	// = update, dynamic object is closer
184	dist4[i] = t;
185	result4[i] = objdyn->mId;
186	}
187	}
188	} // dynamic flag
189	} // for i;
190
191	#endif // _USE_HAVRAN_SSE
192	#endif // USE_HAVRAN_RAYCASTER
193	}
194
195
196	int HavranDynRayCaster::CastRay(const SimpleRay &simpleRay,
197	VssRayContainer &vssRays,
198	const AxisAlignedBox3 &box,
199	const bool castDoubleRay,
200	const bool pruneInvalidRays)
201	{
202	#ifdef USE_HAVRAN_RAYCASTER
203
204	// rays forwards - TESTED 21/1/2008 VH (only for forward rays)
205
206	int hits = 0;
207	Intersection hitA(simpleRay.mOrigin), hitB(simpleRay.mOrigin);
208
209	// ray.mFlags &= ~Ray::CULL_BACKFACES;
210	bool result;
211	hitA.mObject = 0;
212	if ((result = mKtbtree->FindNearestI(simpleRay))) {
213	hitA.mObject = SimpleRay::IntersectionRes[0].intersectable;
214	tdist[0] = SimpleRay::IntersectionRes[0].tdist;
215	hitA.mPoint = simpleRay.Extrap(tdist[0]);
216	hitA.mNormal = SimpleRay::IntersectionRes[0].intersectable->GetNormal(0);
217	//hitA.mNormal = (dynamic_cast< TriangleIntersectable *>
218	// (hitA.mObject))->GetNormal(0);
219	}
220
221	if (dynamicFlag) {
222	bool result2 = false;
223	// For a dynamic object
224	sray_t = simpleRay;
225	// Now apply transform
226	ApplyTransform(sray_t);
227	if (mDynKtbtree->FindNearestI(sray_t)) {
228	float t = SimpleRay::IntersectionRes[0].tdist;
229	if ( ((hitA.mObject) && (t < tdist[0])) \|\|
230	(!hitA.mObject) ) {
231	result = result2 = true; // dynamic object hit
232	// There is an intersection closer than the previous one
233	hitA.mObject = SimpleRay::IntersectionRes[0].intersectable;
234	tdist[0] = SimpleRay::IntersectionRes[0].tdist;
235	hitA.mPoint = simpleRay.Extrap(tdist[0]);
236	hitA.mNormal = hitA.mObject->GetNormal(0);
237	// We have to transform the normal
238	hitA.mNormal = TransformNormal(matTr_inv, hitA.mNormal);
239	}
240	}
241	if (result && (!result2)) {
242	// We put back the result from hitA.mObject for ray tracing
243	SimpleRay::IntersectionRes[0].intersectable = hitA.mObject;
244	SimpleRay::IntersectionRes[0].tdist = tdist[0];
245	}
246	}
247
248	bool resultB = false;
249	if (castDoubleRay) {
250	bool result2 = false;
251	// casting rays backward
252	Vector3 v = (Vector3)(&simpleRay.mDirection);
253	v = -(v);
254	// ray.mFlags &= ~Ray::CULL_BACKFACES;
255	if (mKtbtree->FindNearestI(simpleRay)) {
256	resultB = true;
257	hitB.mObject = SimpleRay::IntersectionRes[0].intersectable;
258	assert(hitB.mObject);
259	float tdist = SimpleRay::IntersectionRes[0].tdist;
260	hitB.mPoint = simpleRay.Extrap(tdist);
261	hitB.mNormal = hitB.mObject->GetNormal(0);
262	}
263
264	if (dynamicFlag) {
265	// For a dynamic object
266	sray_t = simpleRay;
267	// Now apply transform
268	ApplyTransform(sray_t);
269	bool result2;
270	if ( mDynKtbtree->FindNearestI(sray_t)) {
271	assert(SimpleRay::IntersectionRes[0].intersectable);
272	float t = SimpleRay::IntersectionRes[0].tdist;
273	if ( ((hitB.mObject) && (t < tdist[0])) \|\|
274	(!hitB.mObject) ) {
275	// There is an intersection closer than the previous one
276	resultB = result2 = true; // dynamic object hit
277	hitB.mObject = SimpleRay::IntersectionRes[0].intersectable;
278	tdist[0] = SimpleRay::IntersectionRes[0].tdist;
279	hitB.mPoint = simpleRay.Extrap(tdist[0]);
280	hitB.mNormal = hitB.mObject->GetNormal(0);
281	// We have to transform the normal
282	hitB.mNormal = TransformNormal(matTr_inv, hitB.mNormal);
283	}
284	}
285	if ((resultB) && (!result2)) {
286	// For visualization
287	SimpleRay::IntersectionRes[0].intersectable = hitB.mObject;
288	SimpleRay::IntersectionRes[0].tdist = tdist[0];
289	}
290	} // dynamicFlag
291
292	// restore the direction to the original
293	*v = -simpleRay.mDirection;
294	} // castDoubleRay
295
296	#ifdef _PROCESS_RAY
297	// This code is also in IntelRayCaster.cpp
298	return ProcessRay(
299	simpleRay,
300	hitA,
301	hitB,
302	vssRays,
303	box,
304	castDoubleRay,
305	pruneInvalidRays
306	);
307	#else // _PROCESS_RAY
308	if (castDoubleRay)
309	return resultB;
310	return result;
311	#endif // _PROCESS_RAY
312
313	#else
314	return 0;
315	#endif // USE_HAVRAN_RAYCASTER
316	}
317
318	void HavranDynRayCaster::CastRays16(SimpleRayContainer &rays,
319	VssRayContainer &vssRays,
320	const AxisAlignedBox3 &sbox,
321	const bool castDoubleRay,
322	const bool pruneInvalidRays)
323	{
324	CastRays16(rays, 0, vssRays, sbox, castDoubleRay, pruneInvalidRays);
325	}
326
327
328	void HavranDynRayCaster::CastRays16(SimpleRayContainer &rays,
329	int offset,
330	VssRayContainer &vssRays,
331	const AxisAlignedBox3 &sbox,
332	const bool castDoubleRays,
333	const bool pruneInvalidRays)
334	{
335	#ifdef USE_HAVRAN_RAYCASTER
336
337	#if DEBUG_RAYCAST
338	Debug << "C16 " << flush;
339	#endif
340
341	// Use special algorithm for 16 rays at once
342	if (castDoubleRays) {
343	// Here we decompose shooting into two phases
344
345	// First we delete the results from casting dynamic objects
346	if (dynamicFlag) {
347	for (int i = 0; i < 32; i++)
348	objI[i] = 0;
349	}
350	// Here we shoot first backward rays and forward ones
351	SimpleRayContainer::iterator sit = rays.begin() + offset;
352	SimpleRayContainer::const_iterator sit_end = rays.begin() + offset + 16;
353	for ( ; sit != sit_end; ++ sit)
354	{
355	(sit).mDirection = - (sit).mDirection;
356	}
357	// backward rays to be shot - saving with offset 16
358
359	#ifdef _USE_HAVRAN_SSE
360	mKtbtree->SetOffset(0);
361	mKtbtree->FindNearestI_16oneDir(rays, offset, 16);
362	#else
363	mKtbtree->SetOffset(16);
364	mKtbtree->FindNearestI_16oneDirNoSSE(rays, offset);
365	#endif // _USE_HAVRAN_SSE
366
367	if (dynamicFlag) {
368	for (int i = 0; i < 16; i++) {
369	// store the origin and direction of the ray
370	orig[i] = rays[offset+i].mOrigin;
371	dirs[i] = rays[offset+i].mDirection;
372
373	objI[i+16] = SimpleRay::IntersectionRes[i+16].intersectable;
374	if (objI[i+16])
375	normal[i+16] = objI[i+16]->GetNormal(0);
376	tdist[i+16] = SimpleRay::IntersectionRes[i+16].tdist;
377	ApplyTransform(rays[offset+i]);
378	} // for
379	// Now shoot the ray with dynamic object
380	#ifdef _USE_HAVRAN_SSE
381	mDynKtbtree->SetOffset(0);
382	mDynKtbtree->FindNearestI_16oneDir(rays, offset, 16);
383	#else
384	mDynKtbtree->SetOffset(16);
385	mDynKtbtree->FindNearestI_16oneDirNoSSE(rays, offset);
386	#endif // _USE_HAVRAN_SSE
387	for (int i = 0; i < 16; i++) {
388	Intersectable *intersectable =
389	SimpleRay::IntersectionRes[i+16].intersectable;
390	if (intersectable) {
391	float t = SimpleRay::IntersectionRes[i+16].tdist;
392	if ( ((objI[i+16]) && (t < tdist[i+16])) \|\|
393	(!objI[i+16]) ) {
394	// There is an intersection closer than the previous one
395	objI[i+16] = intersectable;
396	tdist[i+16] = SimpleRay::IntersectionRes[i+16].tdist;
397	normal[i+16] = intersectable->GetNormal(0);
398	// We have to transform the normal
399	normal[i+16] = TransformNormal(matTr_inv, normal[i+16]);
400	} // if update
401	} // if intersected dynamic object
402	else {
403	// we copy back the static object - only for visualization
404	SimpleRay::IntersectionRes[i+16].intersectable = objI[i+16];
405	SimpleRay::IntersectionRes[i+16].tdist = tdist[i+16];
406	}
407	} // for
408	} // dynamic flag
409
410	// set the ray direction to original direction
411	if (dynamicFlag) {
412	sit = rays.begin() + offset;
413	int i = 0;
414	for ( ; sit != sit_end; ++sit, ++i)
415	{
416	rays[offset+i].mOrigin = orig[i];
417	rays[offset+i].mDirection = -dirs[i];
418	}
419	}
420	else {
421	// no dynamic objects
422	sit = rays.begin() + offset;
423	for ( ; sit != sit_end; ++ sit)
424	{
425	(sit).mDirection = - (sit).mDirection;
426	}
427	}
428	// forward rays to be shot
429	#ifdef _USE_HAVRAN_SSE
430	mKtbtree->SetOffset(0);
431	mKtbtree->FindNearestI_16oneDir(rays, offset, 0);
432	#else
433	mKtbtree->SetOffset(0);
434	mKtbtree->FindNearestI_16oneDirNoSSE(rays, offset);
435	#endif // _USE_HAVRAN_SSE
436
437	if (dynamicFlag) {
438	for (int i = 0; i < 16; i++) {
439	objI[i] = SimpleRay::IntersectionRes[i].intersectable;
440	if (objI[i])
441	normal[i] = objI[i]->GetNormal(0);
442	tdist[i] = SimpleRay::IntersectionRes[i].tdist;
443	ApplyTransform(rays[offset+i]);
444	} // for
445	// Now shoot the ray with dynamic object
446	#ifdef _USE_HAVRAN_SSE
447	mDynKtbtree->SetOffset(0);
448	mDynKtbtree->FindNearestI_16oneDir(rays, offset, 0);
449	#else
450	mDynKtbtree->SetOffset(0);
451	mDynKtbtree->FindNearestI_16oneDirNoSSE(rays, offset);
452	#endif // _USE_HAVRAN_SSE
453	for (int i = 0; i < 16; i++) {
454	Intersectable *intersectable
455	= SimpleRay::IntersectionRes[i].intersectable;
456	if (intersectable) {
457	float t = SimpleRay::IntersectionRes[i].tdist;
458	if ( ((objI[i]) && (t < tdist[i])) \|\|
459	(!objI[i]) ) {
460	// There is an intersection closer than the previous one
461	objI[i] = intersectable;
462	tdist[i] = SimpleRay::IntersectionRes[i].tdist;
463	normal[i] = objI[i]->GetNormal(0);
464	// We have to transform the normal
465	normal[i] = TransformNormal(matTr_inv, normal[i]);
466	} // update
467	} // intersection
468	// we have to recover the ray
469	rays[offset+i].mOrigin = orig[i];
470	rays[offset+i].mDirection = -dirs[i];
471	} // for i
472	} // dynamic flag
473	} // cast double rays
474	else {
475	// ONLY forward rays - TESTED 21/1/2007 VH
476
477	// First we delete the results from casting dynamic objects
478	if (dynamicFlag) {
479	for (int i = 0; i < 16; i++) {
480	objI[i] = 0;
481	orig[i] = rays[offset+i].mOrigin;
482	dirs[i] = rays[offset+i].mDirection;
483	}
484	}
485
486	// Shoot all 16 rays at the same time using a special algorithm
487	mKtbtree->SetOffset(0);
488	#ifdef _USE_HAVRAN_SSE
489	mKtbtree->FindNearestI_16oneDir(rays, offset, 0);
490	#else
491	mKtbtree->FindNearestI_16oneDirNoSSE(rays, offset);
492	#endif // _USE_HAVRAN_SSE
493
494	// Here we must add dynamic objects
495	if (dynamicFlag) {
496	for (int i = 0; i < 16; i++) {
497	objI[i] = SimpleRay::IntersectionRes[i].intersectable;
498	if (objI[i])
499	normal[i] = objI[i]->GetNormal(0);
500	tdist[i] = SimpleRay::IntersectionRes[i].tdist;
501	ApplyTransform(rays[offset+i]);
502	} // for
503	// Now shoot the ray with dynamic object
504	#ifdef _USE_HAVRAN_SSE
505	mDynKtbtree->SetOffset(0);
506	mDynKtbtree->FindNearestI_16oneDir(rays, offset, 0);
507	#else
508	mDynKtbtree->SetOffset(0);
509	mDynKtbtree->FindNearestI_16oneDirNoSSE(rays, offset);
510	#endif // _USE_HAVRAN_SSE
511	for (int i = 0; i < 16; i++) {
512	Intersectable *intersectable
513	= SimpleRay::IntersectionRes[i].intersectable;
514	if (intersectable) {
515	float t = SimpleRay::IntersectionRes[i].tdist;
516	if ( ((objI[i]) && (t < tdist[i])) \|\|
517	(!objI[i]) ) {
518	// There is an intersection closer than the previous one
519	objI[i] = intersectable;
520	tdist[i] = SimpleRay::IntersectionRes[i].tdist;
521	normal[i] = objI[i]->GetNormal(0);
522	// We have to transform the normal
523	normal[i] = TransformNormal(matTr_inv, normal[i]);
524	} // update
525	} // intersection
526	// we have to recover the rays back
527	rays[offset+i].mOrigin = orig[i];
528	rays[offset+i].mDirection = dirs[i];
529	} // for i
530	} // dynamic flag
531	}
532
533	if (dynamicFlag) {
534	for (int i=0, k=offset; i < 16; i++, k++)
535	{
536	Intersection hitA(rays[k].mOrigin), hitB(rays[k].mOrigin);
537
538	#if DEBUG_RAYCAST
539	Debug<<"FH\n"<<flush;
540	#endif
541
542	Intersectable *intersectable = objI[i];
543	// For visualization needs only - forward rays
544	SimpleRay::IntersectionRes[i].intersectable = objI[i];
545	SimpleRay::IntersectionRes[i].tdist = tdist[i];
546	if (intersectable)
547	{
548	hitA.mObject = intersectable;
549	// Get the normal of that face
550	hitA.mNormal = normal[i];
551
552	//-rays[index+i].mDirection; // $$ temporary
553	hitA.mPoint = rays[k].Extrap(tdist[i]);
554	}
555
556	#if DEBUG_RAYCAST
557	Debug<<"BH\n"<<flush;
558	#endif
559
560	if (castDoubleRays)
561	{
562	Intersectable *intersectable = objI[i+16];
563
564	if (intersectable)
565	{
566	hitB.mObject = intersectable;
567	hitB.mNormal = normal[i+16];
568	hitB.mPoint = rays[k].Extrap(-tdist[i+16]);
569	}
570	}
571
572	#if DEBUG_RAYCAST
573	Debug<<"PR\n"<<flush;
574	#endif
575
576	#ifdef _PROCESS_RAY
577	ProcessRay(rays[k],
578	hitA,
579	hitB,
580	vssRays,
581	sbox,
582	castDoubleRays,
583	pruneInvalidRays
584	);
585	#endif
586	} // for
587	}
588	else {
589	// no dynamic objects
590	for (int i=0, k=offset; i < 16; i++, k++)
591	{
592	Intersection hitA(rays[k].mOrigin), hitB(rays[k].mOrigin);
593
594	#if DEBUG_RAYCAST
595	Debug<<"FH\n"<<flush;
596	#endif
597
598	Intersectable *intersectable
599	= SimpleRay::IntersectionRes[i].intersectable;
600
601	if (intersectable)
602	{
603	hitA.mObject = intersectable;
604	// Get the normal of that face
605	hitA.mNormal = intersectable->GetNormal(0);
606
607	//-rays[index+i].mDirection; // $$ temporary
608	float tdist = SimpleRay::IntersectionRes[i].tdist;
609	hitA.mPoint = rays[k].Extrap(tdist);
610	}
611
612	#if DEBUG_RAYCAST
613	Debug<<"BH\n"<<flush;
614	#endif
615
616	if (castDoubleRays)
617	{
618	Intersectable *intersectable =
619	SimpleRay::IntersectionRes[i+16].intersectable;
620
621	if (intersectable)
622	{
623	hitB.mObject = intersectable;
624	hitB.mNormal = intersectable->GetNormal(0);;
625	float tdist = SimpleRay::IntersectionRes[16+i].tdist;
626	hitB.mPoint = rays[k].Extrap(-tdist);
627	}
628	}
629
630	#if DEBUG_RAYCAST
631	Debug<<"PR\n"<<flush;
632	#endif
633
634	#ifdef _PROCESS_RAY
635	ProcessRay(rays[k],
636	hitA,
637	hitB,
638	vssRays,
639	sbox,
640	castDoubleRays,
641	pruneInvalidRays
642	);
643	#endif
644	} // for
645	} // dynamic objects
646
647
648	#if DEBUG_RAYCAST
649	Debug<<"C16F\n"<<flush;
650	#endif
651
652	#endif // USE_HAVRAN_RAYCASTER
653	}
654
655
656
657	void
658	HavranDynRayCaster::CastSimpleForwardRays(
659	SimpleRayContainer &rays,
660	const AxisAlignedBox3 &sbox
661	)
662	{
663	#ifdef USE_HAVRAN_RAYCASTER
664
665	//int hit_triangles[16];
666	//float dist[16];
667	Vector3 normals[16];
668	Vector3 min = sbox.Min();
669	Vector3 max = sbox.Max();
670
671	int packets = (int)rays.size() / 16;
672
673	int i, k = 0;
674	Vector3 dir;
675
676	// By groups of rays
677	for (i=0; i < packets; i++) {
678	int offset = i * 16;
679	mKtbtree->FindNearestI_16oneDir(rays, offset, 0);
680
681	if (dynamicFlag) {
682	for (int i = 0; i < 16; i++) {
683	orig[i] = rays[i].mOrigin;
684	dirs[i] = rays[i].mDirection;
685
686	tdist[i] = SimpleRay::IntersectionRes[i].tdist;
687	objI[i] = SimpleRay::IntersectionRes[i].intersectable;
688	// for dynamic objects
689	ApplyTransform(rays[i]);
690	} // for
691
692	// shoot the rays against dynamic objects
693	mDynKtbtree->FindNearestI_16oneDir(rays, offset, 0);
694	// and combine the results
695	for (int i = 0; i < 16; i++) {
696	float t = SimpleRay::IntersectionRes[i].tdist;
697	if (SimpleRay::IntersectionRes[i].intersectable) {
698	if ( ((objI[i]) && (t < tdist[i])) \|\|
699	(!objI[i]) ) {
700	// There is an intersection closer than the previous one
701	objI[i] = SimpleRay::IntersectionRes[i].intersectable;
702	tdist[i] = SimpleRay::IntersectionRes[i].tdist;
703	} // update
704	} // intersection
705	else {
706	// Only for visualization
707	SimpleRay::IntersectionRes[i].intersectable = objI[i];
708	SimpleRay::IntersectionRes[i].tdist = tdist[i];
709	}
710	// recover ray origin and direction
711	rays[i].mOrigin = orig[i];
712	rays[i].mDirection = dirs[i];
713	} // for
714
715	} // dynamic objects
716
717	// ??? What to do with the results ? These are
718	// not used at the moment also in IntelRayCaster.cpp
719	} // for
720
721
722	i = 0;
723	int k2 = k;
724	for (; k < rays.size(); k++, i++) {
725	//double normal[3];
726	// Intersect with the static scene
727	bool result = mKtbtree->FindNearestI(rays[k]);
728	tdist[i] = SimpleRay::IntersectionRes[0].tdist;
729	objI[i] = SimpleRay::IntersectionRes[0].intersectable;
730
731	if (dynamicFlag) {
732	orig[i] = rays[k].mOrigin;
733	dirs[i] = rays[k].mDirection;
734
735	// Intersect with the dynamic object
736	ApplyTransform(rays[k]);
737	bool result2 = false;
738	if (mDynKtbtree->FindNearestI(rays[k])) {
739	float t = SimpleRay::IntersectionRes[0].tdist;
740	if ( ((objI[i]) && (t < tdist[i])) \|\|
741	(!objI[i]) ) {
742	// There is an intersection closer than the previous one
743	result2 = true;
744	objI[i] = SimpleRay::IntersectionRes[0].intersectable;
745	tdist[i] = t;
746	}
747	}
748
749	// recover ray origin and direction
750	rays[k].mOrigin = orig[i];
751	rays[k].mDirection = dirs[i];
752	} // dynamic objects
753
754	// ??? What to do with the results ? These are
755	// not used at the moment also in IntelRayCaster.cpp
756	}
757	// The result will be in the array
758	i = 0;
759	for (; k2 < rays.size(); k2++, i++) {
760	SimpleRay::IntersectionRes[i].intersectable = objI[i];
761	SimpleRay::IntersectionRes[i].tdist = tdist[i];
762	}
763	#endif // USE_HAVRAN_RAYCASTER
764
765	return;
766	}
767
768	void HavranDynRayCaster::CastRays(
769	SimpleRayContainer &rays,
770	VssRayContainer &vssRays,
771	const AxisAlignedBox3 &sbox,
772	const bool castDoubleRay,
773	const bool pruneInvalidRays )
774	{
775	int buckets = (int)rays.size()/16;
776	int offset = 0;
777
778	#if 0
779	int time = GetTime();
780	CastSimpleForwardRays(rays, sbox);
781	cout<<1e-32rays.size()/TimeDiff(time, GetTime())<<" Mrays/sec"<<endl;
782	#endif
783
784	// Cast only by 16 rays at once
785	for (int i=0; i < buckets; i++, offset+=16) {
786	CastRays16(rays, offset, vssRays, sbox,
787	castDoubleRay, pruneInvalidRays);
788
789	if ((int)rays.size() > 100000 && i % (100000/16) == 0)
790	cout<<"\r"<<offset<<"/"<<(int)rays.size()<<"\r";
791	}
792
793	// Cast the rest of the rays
794	for (; offset < (int)rays.size(); offset++)
795	CastRay(rays[offset], vssRays, sbox, castDoubleRay, pruneInvalidRays);
796
797	return;
798	}
799
800	#ifdef _USE_HAVRAN_SSE
801	// BUG1 41579 196948 1064111
802	// BUG2 254 1672 10869
803
804	// Just for testing concept
805	void
806	HavranDynRayCaster::CastRaysPacket2x2(RayPacket2x2 &raysPack,
807	bool castDoubleRay,
808	const bool pruneInvalidRays)
809	{
810	#ifdef USE_HAVRAN_RAYCASTER
811
812	if (castDoubleRay) {
813	// cast forward rays
814	mKtbtree->FindNearestI(raysPack);
815
816	if (dynamicFlag) {
817	// The ray pack to be transformed
818	raypack_t = raysPack;
819	raypack.ApplyTransform(matTr_inv);
820
821	mDynKtbtree->FindNearestI(raypack_t);
822
823	for (int i = 0; i < 4; i++) {
824	// if ray intersects an object, we set the pointer to
825	// this object
826	Intersectable* intersectable = raypack_t.GetObject(i);
827	if (intersectable) {
828	Intersectable *o = raysPack.GetObject(i);
829	if ( ((o) && (raypack_t.GetT(i) < tdist[i])) \|\|
830	(!o) ) {
831	// update, dynamic object is closer
832	raysPack.SetT(i, raypack_t.GetT(i));
833	raysPack.SetObject(i, raypack_t.GetObject(i));
834	} // if update is required
835	} // if intersectable
836	} // for i
837	} // dynamic object
838
839	// Double (=opposite) direction
840	for (int i = 0; i < 4; i++)
841	raysPack.SetDir(i, -raysPack.GetDir(i));
842	// cast backward rays
843	mKtbtree->FindNearestI(raysPack);
844
845	if (dynamicFlag) {
846
847	// The ray pack to be transformed
848	raypack_t = raysPack;
849	raypack_t.ApplyTransform(matTr_inv);
850
851	mDynKtbtree->FindNearestI(raypack_t);
852
853	for (int i = 0; i < 4; i++) {
854	// if ray intersects an object, we set the pointer to
855	// this object
856	Intersectable* intersectable = raypack_t.GetObject(i);
857	if (intersectable) {
858	Intersectable *o = raysPack.GetObject(i);
859	if ( ((o) && (raypack_t.GetT(i) < tdist[i])) \|\|
860	(!o) ) {
861	// update, dynamic object is closer
862	raysPack.SetT(i, raypack_t.GetT(i));
863	raysPack.SetObject(i, raypack_t.GetObject(i));
864	} // if update is required
865	} // if intersectable
866	} // for i
867	} // dynamic object
868
869	// reverse the rays back
870	for (int i = 0; i < 4; i++)
871	raysPack.SetDir(i, -raysPack.GetDir(i));
872	}
873	else {
874	// ONLY forward rays - TESTED 21/1/2007 VH
875
876	mKtbtree->FindNearestI(raysPack);
877
878	if (dynamicFlag) {
879	// The ray pack to be transformed
880	raypack_t = raysPack;
881	raypack_t.ApplyTransform(matTr_inv);
882
883	mDynKtbtree->FindNearestI(raypack_t);
884
885	for (int i = 0; i < 4; i++) {
886	// if ray intersects an object, we set the pointer to
887	// this object
888	Intersectable* intersectable = raypack_t.GetObject(i);
889	if (intersectable) {
890	Intersectable *o = raysPack.GetObject(i);
891	if ( ((o) && (raypack_t.GetT(i) < tdist[i])) \|\|
892	(!o) ) {
893	// update, dynamic object is closer
894	raysPack.SetT(i, raypack_t.GetT(i));
895	raysPack.SetObject(i, raypack_t.GetObject(i));
896	} // if update is required
897	} // if intersectable
898	} // for i
899	} // dynamic object
900
901	#if 0
902	// Only verification of correctness by casting single rays
903	static int cntBugs = 0;
904	SimpleRay ray;
905	int cntErrors = 0, cntDistErrors = 0;
906	bool newBug = false;
907	for (int i = 0; i < 4; i++) {
908	ray.mOrigin = raysPack.GetLoc(i);
909	ray.mDirection = raysPack.GetDir(i);
910	mKtbtree->FindNearestI(ray);
911	if (raysPack.GetObject(i) != SimpleRay::IntersectionRes[0].intersectable) {
912	float dist = (raysPack.GetT(i) - SimpleRay::IntersectionRes[0].tdist);
913	if (fabs(dist) > 0.001f) {
914	cntErrors++; newBug = true;
915	cntBugs++;
916	cout << " BUG1 d= " << dist;
917	}
918	}
919	else {
920	float dist = 0.f;
921	if (raysPack.GetObject(i) && SimpleRay::IntersectionRes[0].intersectable)
922	if (fabs((dist=(fabs (raysPack.GetT(i) - SimpleRay::IntersectionRes[0].tdist)))) > 1.f) {
923	cntDistErrors++; newBug = true; cntBugs++;
924	cout << " BUG2 distdf= " << dist ;
925	}
926	}
927	} // for
928	if (newBug) cout << " CB= " << cntBugs << "\n";
929	#endif
930	}
931
932	return;
933
934	#endif // USE_HAVRAN_RAYCASTER
935
936	}
937	#endif // _USE_HAVRAN_SSE
938
939
940	} // the namespace
941

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

Context Navigation

source: GTP/trunk/Lib/Vis/Preprocessing/src/HavranDynRayCaster.cpp @ 2710

Download in other formats: