8 |
|
* sm.c |
9 |
|
*/ |
10 |
|
#include "standard.h" |
11 |
– |
|
12 |
– |
#include "object.h" |
13 |
– |
|
11 |
|
#include "sm_list.h" |
12 |
|
#include "sm_geom.h" |
13 |
|
#include "sm.h" |
17 |
|
double smDist_sum=0; |
18 |
|
int smNew_tri_cnt=0; |
19 |
|
|
20 |
+ |
static int smBase_nbrs[4][3] = { {3,2,1},{3,0,2},{3,1,0},{1,2,0}}; |
21 |
+ |
|
22 |
|
#ifdef TEST_DRIVER |
24 |
– |
VIEW View = {0,{0,0,0},{0,0,-1},{0,1,0},60,60,0}; |
23 |
|
VIEW Current_View = {0,{0,0,0},{0,0,-1},{0,1,0},60,60,0}; |
24 |
|
int Pick_cnt =0; |
25 |
< |
int Pick_tri = -1,Picking = FALSE; |
25 |
> |
int Pick_tri = -1,Picking = FALSE,Pick_samp=-1; |
26 |
|
FVECT Pick_point[500],Pick_origin,Pick_dir; |
27 |
|
FVECT Pick_v0[500], Pick_v1[500], Pick_v2[500]; |
28 |
|
FVECT P0,P1,P2; |
40 |
|
VCOPY(p,SM_NTH_WV(sm,id)); |
41 |
|
point_on_sphere(ps,p,SM_VIEW_CENTER(sm)); |
42 |
|
} |
43 |
+ |
smDir_in_cone(sm,ps,id) |
44 |
+ |
SM *sm; |
45 |
+ |
FVECT ps; |
46 |
+ |
int id; |
47 |
+ |
{ |
48 |
+ |
FVECT p; |
49 |
+ |
|
50 |
+ |
VCOPY(p,SM_NTH_WV(sm,id)); |
51 |
+ |
point_on_sphere(ps,p,SM_VIEW_CENTER(sm)); |
52 |
+ |
} |
53 |
|
|
54 |
|
smClear_mesh(sm) |
55 |
|
SM *sm; |
234 |
|
{ |
235 |
|
int max_vertices; |
236 |
|
|
229 |
– |
sleep(10); |
230 |
– |
|
237 |
|
/* If n <=0, Just clear the existing structures */ |
238 |
|
if(n <= 0) |
239 |
|
{ |
261 |
|
} |
262 |
|
|
263 |
|
|
264 |
< |
int |
265 |
< |
smLocator_apply_func(sm,v0,v1,v2,func,arg) |
266 |
< |
SM *sm; |
267 |
< |
FVECT v0,v1,v2; |
268 |
< |
int (*func)(); |
269 |
< |
char *arg; |
264 |
> |
smLocator_apply_func(sm,v0,v1,v2,edge_func,interior_func,arg1,arg2) |
265 |
> |
SM *sm; |
266 |
> |
FVECT v0,v1,v2; |
267 |
> |
int (*edge_func)(); |
268 |
> |
int (*interior_func)(); |
269 |
> |
int *arg1,arg2; |
270 |
|
{ |
271 |
|
STREE *st; |
266 |
– |
char found; |
272 |
|
FVECT p0,p1,p2; |
273 |
|
|
274 |
|
st = SM_LOCATOR(sm); |
275 |
|
|
276 |
< |
point_on_sphere(p0,v0,SM_VIEW_CENTER(sm)); |
277 |
< |
point_on_sphere(p1,v1,SM_VIEW_CENTER(sm)); |
278 |
< |
point_on_sphere(p2,v2,SM_VIEW_CENTER(sm)); |
276 |
> |
VSUB(p0,v0,SM_VIEW_CENTER(sm)); |
277 |
> |
VSUB(p1,v1,SM_VIEW_CENTER(sm)); |
278 |
> |
VSUB(p2,v2,SM_VIEW_CENTER(sm)); |
279 |
|
|
280 |
< |
found = stApply_to_tri_cells(st,p0,p1,p2,func,arg); |
280 |
> |
stApply_to_tri(st,p0,p1,p2,edge_func,interior_func,arg1,arg2); |
281 |
|
|
277 |
– |
return(found); |
282 |
|
} |
283 |
|
|
284 |
|
|
285 |
|
int |
286 |
< |
smLocator_add_tri(sm,t_id,v0_id,v1_id,v2_id) |
286 |
> |
add_tri_expand(qtptr,q0,q1,q2,t0,t1,t2,n,arg,t_id,del_set) |
287 |
> |
QUADTREE *qtptr; |
288 |
> |
FVECT q0,q1,q2; |
289 |
> |
FVECT t0,t1,t2; |
290 |
> |
int n; |
291 |
> |
int *arg; |
292 |
> |
int t_id; |
293 |
> |
OBJECT *del_set; |
294 |
> |
{ |
295 |
> |
OBJECT t_set[QT_MAXSET+1],*optr,*tptr,r_set[QT_MAXSET+1]; |
296 |
> |
int i,id,found; |
297 |
> |
FVECT v0,v1,v2; |
298 |
> |
TRI *tri; |
299 |
> |
|
300 |
> |
#ifdef DEBUG_TEST_DRIVER |
301 |
> |
Pick_tri = t_id; |
302 |
> |
Picking = TRUE; |
303 |
> |
#endif |
304 |
> |
|
305 |
> |
if(QT_IS_EMPTY(*qtptr)) |
306 |
> |
{ |
307 |
> |
*qtptr = qtaddelem(*qtptr,t_id); |
308 |
> |
return(TRUE); |
309 |
> |
} |
310 |
> |
|
311 |
> |
optr = qtqueryset(*qtptr); |
312 |
> |
if(del_set) |
313 |
> |
{ |
314 |
> |
setintersect(r_set,del_set,optr); |
315 |
> |
if(QT_SET_CNT(r_set) > 0) |
316 |
> |
{ |
317 |
> |
qtgetset(t_set,*qtptr); |
318 |
> |
optr = QT_SET_PTR(r_set); |
319 |
> |
for(i = QT_SET_CNT(r_set); i > 0; i--) |
320 |
> |
{ |
321 |
> |
id = QT_SET_NEXT_ELEM(optr); |
322 |
> |
deletelem(t_set,id); |
323 |
> |
} |
324 |
> |
qtfreeleaf(*qtptr); |
325 |
> |
*qtptr = qtnewleaf(t_set); |
326 |
> |
optr = t_set; |
327 |
> |
} |
328 |
> |
} |
329 |
> |
if(!inset(optr,t_id)) |
330 |
> |
{ |
331 |
> |
if(QT_SET_CNT(optr) < QT_MAXSET) |
332 |
> |
*qtptr = qtaddelem(*qtptr,t_id); |
333 |
> |
else |
334 |
> |
{ |
335 |
> |
#ifdef DEBUG |
336 |
> |
eputs("add_tri_expand():no room in set\n"); |
337 |
> |
#endif |
338 |
> |
return(FALSE); |
339 |
> |
} |
340 |
> |
} |
341 |
> |
optr = qtqueryset(*qtptr); |
342 |
> |
if(QT_SET_CNT(optr) >= QT_SET_THRESHOLD) |
343 |
> |
if (n < QT_MAX_LEVELS) |
344 |
> |
{ |
345 |
> |
qtgetset(t_set,*qtptr); |
346 |
> |
/* If set size exceeds threshold: subdivide cell and reinsert tris*/ |
347 |
> |
qtfreeleaf(*qtptr); |
348 |
> |
qtSubdivide(qtptr); |
349 |
> |
|
350 |
> |
for(optr = QT_SET_PTR(t_set),i=QT_SET_CNT(t_set); i > 0; i--) |
351 |
> |
{ |
352 |
> |
id = QT_SET_NEXT_ELEM(optr); |
353 |
> |
tri = SM_NTH_TRI(smMesh,id); |
354 |
> |
VSUB(v0,SM_T_NTH_WV(smMesh,tri,0),SM_VIEW_CENTER(smMesh)); |
355 |
> |
VSUB(v1,SM_T_NTH_WV(smMesh,tri,1),SM_VIEW_CENTER(smMesh)); |
356 |
> |
VSUB(v2,SM_T_NTH_WV(smMesh,tri,2),SM_VIEW_CENTER(smMesh)); |
357 |
> |
found = qtAdd_tri(qtptr,q0,q1,q2,v0,v1,v2,id,n); |
358 |
> |
#ifdef DEBUG |
359 |
> |
if(!found) |
360 |
> |
eputs("add_tri_expand():Reinsert\n"); |
361 |
> |
#endif |
362 |
> |
} |
363 |
> |
return(QT_MODIFIED); |
364 |
> |
} |
365 |
> |
else |
366 |
> |
if(QT_SET_CNT(optr) < QT_MAXSET) |
367 |
> |
{ |
368 |
> |
#ifdef DEBUG_TEST_DRIVER |
369 |
> |
eputs("add_tri_expand():too many levels:can't expand\n"); |
370 |
> |
#endif |
371 |
> |
return(TRUE); |
372 |
> |
} |
373 |
> |
else |
374 |
> |
{ |
375 |
> |
#ifdef DEBUG |
376 |
> |
eputs("add_tri_expand():too many tris inset:can't add\n"); |
377 |
> |
#endif |
378 |
> |
return(FALSE); |
379 |
> |
} |
380 |
> |
} |
381 |
> |
|
382 |
> |
|
383 |
> |
int |
384 |
> |
add_tri(qtptr,fptr,t_id,del_set) |
385 |
> |
QUADTREE *qtptr; |
386 |
> |
int *fptr; |
387 |
> |
int t_id; |
388 |
> |
OBJECT *del_set; |
389 |
> |
{ |
390 |
> |
|
391 |
> |
OBJECT *optr,*tptr; |
392 |
> |
OBJECT t_set[QT_MAXSET +1],r_set[QT_MAXSET +1]; |
393 |
> |
int i,id,found; |
394 |
> |
#ifdef DEBUG_TEST_DRIVER |
395 |
> |
Pick_tri = t_id; |
396 |
> |
Picking = TRUE; |
397 |
> |
#endif |
398 |
> |
if(QT_IS_EMPTY(*qtptr)) |
399 |
> |
{ |
400 |
> |
*qtptr = qtaddelem(*qtptr,t_id); |
401 |
> |
if(!QT_FLAG_FILL_TRI(*fptr)) |
402 |
> |
(*fptr)++; |
403 |
> |
} |
404 |
> |
else |
405 |
> |
{ |
406 |
> |
optr = qtqueryset(*qtptr); |
407 |
> |
if(del_set) |
408 |
> |
{ |
409 |
> |
setintersect(r_set,del_set,optr); |
410 |
> |
if(QT_SET_CNT(r_set) > 0) |
411 |
> |
{ |
412 |
> |
qtgetset(t_set,*qtptr); |
413 |
> |
optr = QT_SET_PTR(r_set); |
414 |
> |
for(i = QT_SET_CNT(r_set); i > 0; i--) |
415 |
> |
{ |
416 |
> |
id = QT_SET_NEXT_ELEM(optr); |
417 |
> |
deletelem(t_set,id); |
418 |
> |
} |
419 |
> |
qtfreeleaf(*qtptr); |
420 |
> |
*qtptr = qtnewleaf(t_set); |
421 |
> |
optr = t_set; |
422 |
> |
} |
423 |
> |
} |
424 |
> |
if(!inset(optr,t_id)) |
425 |
> |
{ |
426 |
> |
if(QT_SET_CNT(optr) < QT_MAXSET) |
427 |
> |
{ |
428 |
> |
if(QT_SET_CNT(optr) >= QT_SET_THRESHOLD) |
429 |
> |
(*fptr) |= QT_EXPAND; |
430 |
> |
if(!QT_FLAG_FILL_TRI(*fptr)) |
431 |
> |
(*fptr)++; |
432 |
> |
*qtptr = qtaddelem(*qtptr,t_id); |
433 |
> |
} |
434 |
> |
else |
435 |
> |
{ |
436 |
> |
#ifdef DEBUG_TESTDRIVER |
437 |
> |
eputs("add_tri():exceeded set size\n"); |
438 |
> |
#endif |
439 |
> |
return(FALSE); |
440 |
> |
} |
441 |
> |
} |
442 |
> |
} |
443 |
> |
return(TRUE); |
444 |
> |
} |
445 |
> |
|
446 |
> |
|
447 |
> |
smLocator_add_tri(sm,t_id,v0_id,v1_id,v2_id,del_set) |
448 |
|
SM *sm; |
449 |
|
int t_id; |
450 |
< |
int v0_id,v1_id,v2_id; |
450 |
> |
int v0_id,v1_id,v2_id; |
451 |
> |
OBJECT *del_set; |
452 |
|
{ |
453 |
|
STREE *st; |
454 |
< |
FVECT p0,p1,p2; |
454 |
> |
FVECT v0,v1,v2; |
455 |
|
|
456 |
|
st = SM_LOCATOR(sm); |
457 |
|
|
458 |
< |
smDir(sm,p0,v0_id); |
459 |
< |
smDir(sm,p1,v1_id); |
460 |
< |
smDir(sm,p2,v2_id); |
458 |
> |
VSUB(v0,SM_NTH_WV(sm,v0_id),SM_VIEW_CENTER(sm)); |
459 |
> |
VSUB(v1,SM_NTH_WV(sm,v1_id),SM_VIEW_CENTER(sm)); |
460 |
> |
VSUB(v2,SM_NTH_WV(sm,v2_id),SM_VIEW_CENTER(sm)); |
461 |
|
|
462 |
< |
stAdd_tri(st,t_id,p0,p1,p2); |
462 |
> |
qtClearAllFlags(); |
463 |
> |
|
464 |
> |
stApply_to_tri(st,v0,v1,v2,add_tri,add_tri_expand,t_id,del_set); |
465 |
|
|
298 |
– |
return(1); |
466 |
|
} |
467 |
|
|
468 |
|
/* Add a triangle to the base array with vertices v1-v2-v3 */ |
510 |
|
SM_NTH_VERT(sm,v1_id) = t_id; |
511 |
|
SM_NTH_VERT(sm,v2_id) = t_id; |
512 |
|
|
346 |
– |
/* Add triangle to the locator */ |
347 |
– |
smLocator_add_tri(sm,t_id,v0_id,v1_id,v2_id); |
513 |
|
if(t) |
514 |
|
*tptr = t; |
515 |
|
/* return initialized triangle */ |
550 |
|
} |
551 |
|
} |
552 |
|
else |
553 |
< |
if(d1 < d2) |
553 |
> |
if(d1 < d0) |
554 |
|
{ |
555 |
|
if((eps < 0) || d1 < eps) |
556 |
|
{ |
558 |
|
d = d1; |
559 |
|
} |
560 |
|
} |
561 |
< |
else |
397 |
< |
if((eps < 0) || d2 < eps) |
398 |
< |
{ |
399 |
< |
closest = v2_id; |
400 |
< |
d = d2; |
401 |
< |
} |
402 |
< |
} |
561 |
> |
} |
562 |
|
if(v2_id != -1) |
563 |
|
{ |
564 |
|
smDir(sm,v,v2_id); |
565 |
|
d2 = DIST(p,v); |
566 |
|
if((eps < 0) || d2 < eps) |
567 |
< |
if(closest== -1 ||(d2 < d)) |
567 |
> |
if(closest == -1 ||(d2 < d)) |
568 |
|
return(v2_id); |
569 |
|
} |
570 |
|
return(closest); |
587 |
|
|
588 |
|
VCOPY(v,SM_NTH_WV(sm,v1_id)); |
589 |
|
d1 = DIST(p,v); |
590 |
< |
if(d1 < d2) |
590 |
> |
if(d1 < d0) |
591 |
|
{ |
592 |
|
closest = v1_id; |
593 |
|
d = d1; |
601 |
|
} |
602 |
|
|
603 |
|
void |
604 |
< |
smTris_swap_edge(sm,t_id,t1_id,e,e1,tn_id,tn1_id) |
604 |
> |
smTris_swap_edge(sm,t_id,t1_id,e,e1,tn_id,tn1_id,add_ptr,del_set) |
605 |
|
SM *sm; |
606 |
|
int t_id,t1_id; |
607 |
|
int e,e1; |
608 |
< |
int **tn_id,**tn1_id; |
608 |
> |
int *tn_id,*tn1_id; |
609 |
> |
LIST **add_ptr; |
610 |
> |
OBJECT *del_set; |
611 |
|
|
612 |
|
{ |
613 |
|
TRI *t,*t1; |
630 |
|
verts[enext] = T_NTH_V(t1,e1prev); |
631 |
|
verts[eprev] = T_NTH_V(t,eprev); |
632 |
|
ta_id = smAdd_tri(sm,verts[0],verts[1],verts[2],&ta); |
633 |
< |
|
633 |
> |
*add_ptr = push_data(*add_ptr,ta_id); |
634 |
|
verts[e1] = T_NTH_V(t1,e1); |
635 |
|
verts[e1next] = T_NTH_V(t,eprev); |
636 |
|
verts[e1prev] = T_NTH_V(t1,e1prev); |
637 |
|
tb_id = smAdd_tri(sm,verts[0],verts[1],verts[2],&tb); |
638 |
< |
|
638 |
> |
*add_ptr = push_data(*add_ptr,tb_id); |
639 |
> |
|
640 |
|
/* set the neighbors */ |
641 |
|
T_NTH_NBR(ta,e) = T_NTH_NBR(t1,e1next); |
642 |
|
T_NTH_NBR(tb,e1) = T_NTH_NBR(t,enext); |
657 |
|
T_NTH_NBR(n,T_NTH_NBR_PTR(t1_id,n)) = tb_id; |
658 |
|
|
659 |
|
/* Delete two parent triangles */ |
660 |
< |
smDelete_tri(sm,t_id); |
661 |
< |
smDelete_tri(sm,t1_id); |
660 |
> |
if(remove_from_list(t_id,add_ptr)) |
661 |
> |
smDelete_tri(sm,t_id); |
662 |
> |
else |
663 |
> |
insertelem(del_set,t_id); |
664 |
> |
|
665 |
> |
if(remove_from_list(t1_id,add_ptr)) |
666 |
> |
smDelete_tri(sm,t1_id); |
667 |
> |
else |
668 |
> |
insertelem(del_set,t1_id); |
669 |
> |
|
670 |
|
*tn_id = ta_id; |
671 |
|
*tn1_id = tb_id; |
672 |
|
} |
673 |
|
|
674 |
+ |
smUpdate_locator(sm,add_list,del_set) |
675 |
+ |
SM *sm; |
676 |
+ |
LIST *add_list; |
677 |
+ |
OBJECT *del_set; |
678 |
+ |
{ |
679 |
+ |
int t_id,i; |
680 |
+ |
TRI *t; |
681 |
+ |
OBJECT *optr; |
682 |
+ |
|
683 |
+ |
while(add_list) |
684 |
+ |
{ |
685 |
+ |
t_id = pop_list(&add_list); |
686 |
+ |
t = SM_NTH_TRI(sm,t_id); |
687 |
+ |
smLocator_add_tri(sm,t_id,T_NTH_V(t,0),T_NTH_V(t,1),T_NTH_V(t,2),del_set); |
688 |
+ |
} |
689 |
+ |
|
690 |
+ |
optr = QT_SET_PTR(del_set); |
691 |
+ |
for(i = QT_SET_CNT(del_set); i > 0; i--) |
692 |
+ |
{ |
693 |
+ |
t_id = QT_SET_NEXT_ELEM(optr); |
694 |
+ |
smDelete_tri(sm,t_id); |
695 |
+ |
} |
696 |
+ |
} |
697 |
|
/* MUST add check for constrained edges */ |
698 |
< |
char |
699 |
< |
smFix_tris(sm,id,tlist) |
698 |
> |
int |
699 |
> |
smFix_tris(sm,id,tlist,add_list,del_set) |
700 |
|
SM *sm; |
701 |
|
int id; |
702 |
|
LIST *tlist; |
703 |
+ |
LIST *add_list; |
704 |
+ |
OBJECT *del_set; |
705 |
|
{ |
706 |
|
TRI *t,*t_opp; |
707 |
< |
FVECT p,p1,np,p2,p3; |
708 |
< |
int swapped = 0; |
514 |
< |
int e,e1,e_id; |
515 |
< |
char debug = 0; |
707 |
> |
FVECT p,p1,p2,p3; |
708 |
> |
int e,e1,swapped = 0; |
709 |
|
int t_id,t_opp_id; |
710 |
< |
|
711 |
< |
VCOPY(p,SM_NTH_WV(sm,id)); |
712 |
< |
VSUB(p,p,SM_VIEW_CENTER(sm)); |
710 |
> |
|
711 |
> |
|
712 |
> |
VSUB(p,SM_NTH_WV(sm,id),SM_VIEW_CENTER(sm)); |
713 |
|
while(tlist) |
714 |
|
{ |
715 |
< |
t_id = (int)pop_list(&tlist); |
715 |
> |
t_id = pop_list(&tlist); |
716 |
|
t = SM_NTH_TRI(sm,t_id); |
717 |
|
e = (T_WHICH_V(t,id)+1)%3; |
718 |
|
t_opp_id = T_NTH_NBR(t,e); |
719 |
|
t_opp = SM_NTH_TRI(sm,t_opp_id); |
720 |
< |
|
721 |
< |
smDir(sm,p1,T_NTH_V(t_opp,0)); |
722 |
< |
smDir(sm,p2,T_NTH_V(t_opp,1)); |
723 |
< |
smDir(sm,p3,T_NTH_V(t_opp,2)); |
720 |
> |
/* |
721 |
> |
VSUB(p1,SM_T_NTH_WV(sm,t_opp,0),SM_VIEW_CENTER(sm)); |
722 |
> |
VSUB(p2,SM_T_NTH_WV(sm,t_opp,1),SM_VIEW_CENTER(sm)); |
723 |
> |
VSUB(p3,SM_T_NTH_WV(sm,t_opp,2),SM_VIEW_CENTER(sm)); |
724 |
> |
*/ |
725 |
> |
smDir_in_cone(sm,p1,T_NTH_V(t_opp,0)); |
726 |
> |
smDir_in_cone(sm,p2,T_NTH_V(t_opp,1)); |
727 |
> |
smDir_in_cone(sm,p3,T_NTH_V(t_opp,2)); |
728 |
|
if(point_in_cone(p,p1,p2,p3)) |
729 |
|
{ |
730 |
|
swapped = 1; |
731 |
|
e1 = T_NTH_NBR_PTR(t_id,t_opp); |
732 |
|
/* check list for t_opp and Remove if there */ |
733 |
|
remove_from_list(t_opp_id,&tlist); |
734 |
< |
|
735 |
< |
smTris_swap_edge(sm,t_id,t_opp_id,e,e1,&t_id,&t_opp_id); |
734 |
> |
smTris_swap_edge(sm,t_id,t_opp_id,e,e1,&t_id,&t_opp_id, |
735 |
> |
&add_list,del_set); |
736 |
|
tlist = push_data(tlist,t_id); |
737 |
|
tlist = push_data(tlist,t_opp_id); |
738 |
|
} |
739 |
|
} |
740 |
+ |
smUpdate_locator(sm,add_list,del_set); |
741 |
|
return(swapped); |
742 |
|
} |
743 |
|
|
770 |
|
|
771 |
|
T_NTH_V(tri,T_WHICH_V(tri,id)) = nid; |
772 |
|
|
773 |
< |
t_id = smTri_next_ccw_nbr(sm,t,nid); |
774 |
< |
while((t= SM_NTH_TRI(sm,t_id)) != tri) |
773 |
> |
t_id = smTri_next_ccw_nbr(sm,tri,nid); |
774 |
> |
while((t = SM_NTH_TRI(sm,t_id)) != tri) |
775 |
|
{ |
776 |
|
T_NTH_V(t,T_WHICH_V(t,id)) = nid; |
777 |
|
t_id = smTri_next_ccw_nbr(sm,t,nid); |
797 |
|
COLR c; |
798 |
|
FVECT dir,p; |
799 |
|
int tri_id,snew_id; |
800 |
< |
char type,which; |
800 |
> |
int type,which; |
801 |
|
{ |
802 |
|
int n_id,s_id; |
803 |
|
TRI *tri; |
846 |
|
TRI *tri,*t0,*t1,*t2,*nbr; |
847 |
|
int v0_id,v1_id,v2_id,n_id; |
848 |
|
int t0_id,t1_id,t2_id; |
849 |
< |
LIST *tlist; |
849 |
> |
LIST *tlist,*add_list; |
850 |
> |
OBJECT del_set[QT_MAXSET+1]; |
851 |
|
FVECT npt; |
852 |
|
|
853 |
+ |
add_list = NULL; |
854 |
+ |
QT_CLEAR_SET(del_set); |
855 |
|
if(s_id == SM_INVALID) |
856 |
|
s_id = smAdd_sample_point(sm,c,dir,p); |
857 |
|
|
871 |
|
n_id = smClosest_vertex_in_tri(sm,t0_id,t1_id,t2_id,npt,P_REPLACE_EPS); |
872 |
|
} |
873 |
|
t0_id = smAdd_tri(sm,s_id,v0_id,v1_id,&t0); |
874 |
+ |
/* Add triangle to the locator */ |
875 |
+ |
|
876 |
+ |
add_list = push_data(add_list,t0_id); |
877 |
+ |
|
878 |
|
t1_id = smAdd_tri(sm,s_id,v1_id,v2_id,&t1); |
879 |
+ |
add_list = push_data(add_list,t1_id); |
880 |
+ |
|
881 |
|
t2_id = smAdd_tri(sm,s_id,v2_id,v0_id,&t2); |
882 |
< |
|
882 |
> |
add_list = push_data(add_list,t2_id); |
883 |
> |
|
884 |
|
/* Set the neighbor pointers for the new tris */ |
885 |
|
T_NTH_NBR(t0,0) = t2_id; |
886 |
|
T_NTH_NBR(t0,1) = T_NTH_NBR(tri,0); |
900 |
|
nbr = SM_NTH_TRI(sm,T_NTH_NBR(tri,2)); |
901 |
|
T_NTH_NBR(nbr,T_NTH_NBR_PTR(tri_id,nbr)) = t2_id; |
902 |
|
|
903 |
< |
smDelete_tri(sm,tri_id); |
904 |
< |
|
903 |
> |
insertelem(del_set,tri_id); |
904 |
> |
|
905 |
|
/* Fix up the new triangles*/ |
906 |
|
tlist = push_data(NULL,t0_id); |
907 |
|
tlist = push_data(tlist,t1_id); |
908 |
|
tlist = push_data(tlist,t2_id); |
909 |
|
|
910 |
< |
smFix_tris(sm,s_id,tlist); |
910 |
> |
smFix_tris(sm,s_id,tlist,add_list,del_set); |
911 |
|
|
912 |
|
if(n_id != -1) |
913 |
|
smDelete_point(sm,n_id); |
917 |
|
|
918 |
|
|
919 |
|
int |
920 |
< |
smPointLocate(sm,pt,type,which,norm) |
920 |
> |
smPointLocate(sm,pt,norm) |
921 |
|
SM *sm; |
922 |
|
FVECT pt; |
923 |
< |
char *type,*which; |
716 |
< |
char norm; |
923 |
> |
int norm; |
924 |
|
{ |
925 |
|
STREE *st; |
926 |
|
int tri; |
929 |
|
st = SM_LOCATOR(sm); |
930 |
|
if(norm) |
931 |
|
{ |
932 |
< |
point_on_sphere(npt,pt,SM_VIEW_CENTER(sm)); |
933 |
< |
tri = stPoint_locate(st,npt,type,which); |
932 |
> |
VSUB(npt,pt,SM_VIEW_CENTER(sm)); |
933 |
> |
tri = stPoint_locate(st,npt); |
934 |
|
} |
935 |
|
else |
936 |
< |
tri = stPoint_locate(st,pt,type,which); |
936 |
> |
tri = stPoint_locate(st,pt); |
937 |
|
return(tri); |
938 |
|
} |
939 |
|
|
940 |
|
QUADTREE |
941 |
< |
smPointLocateCell(sm,pt,v0,v1,v2,type,which,norm) |
941 |
> |
smPointLocateCell(sm,pt,norm,v0,v1,v2) |
942 |
|
SM *sm; |
943 |
< |
FVECT pt,v0,v1,v2; |
944 |
< |
char *type,*which; |
945 |
< |
char norm; |
943 |
> |
FVECT pt; |
944 |
> |
int norm; |
945 |
> |
FVECT v0,v1,v2; |
946 |
|
{ |
947 |
|
STREE *st; |
948 |
< |
QUADTREE qt; |
948 |
> |
QUADTREE *qtptr; |
949 |
|
FVECT npt; |
950 |
|
|
951 |
|
st = SM_LOCATOR(sm); |
952 |
|
if(norm) |
953 |
|
{ |
954 |
< |
point_on_sphere(npt,pt,SM_VIEW_CENTER(sm)); |
954 |
> |
VSUB(npt,pt,SM_VIEW_CENTER(sm)); |
955 |
|
|
956 |
< |
qt = stPoint_locate_cell(st,npt,v0,v1,v2,type,which); |
956 |
> |
qtptr = stPoint_locate_cell(st,npt,v0,v1,v2); |
957 |
|
} |
958 |
|
else |
959 |
< |
qt = stPoint_locate_cell(st,pt,v0,v1,v2,type,which); |
959 |
> |
qtptr = stPoint_locate_cell(st,pt,v0,v1,v2); |
960 |
|
|
961 |
< |
return(qt); |
961 |
> |
if(qtptr) |
962 |
> |
return(*qtptr); |
963 |
> |
else |
964 |
> |
return(EMPTY); |
965 |
|
} |
966 |
|
|
967 |
|
int |
972 |
|
int s_id; |
973 |
|
{ |
974 |
|
int t_id; |
765 |
– |
char type,which; |
975 |
|
double d; |
976 |
|
FVECT p; |
977 |
|
|
982 |
|
d = DIST(pt,SM_VIEW_CENTER(smMesh)); |
983 |
|
smDist_sum += 1.0/d; |
984 |
|
/************************************/ |
985 |
< |
t_id = smPointLocate(smMesh,pt,&type,&which,TRUE); |
986 |
< |
if(type==GT_FACE) |
985 |
> |
t_id = smPointLocate(smMesh,pt,TRUE); |
986 |
> |
if(t_id >= 0) |
987 |
|
s_id = smInsert_point_in_tri(smMesh,c,dir,pt,s_id,t_id); |
779 |
– |
else |
780 |
– |
if(type==GT_VERTEX) |
781 |
– |
s_id = smReplace_vertex(smMesh,c,dir,pt,t_id,s_id,type,which); |
988 |
|
#ifdef DEBUG |
989 |
|
else |
990 |
< |
eputs("smAdd_sample_to_mesh(): unrecognized type\n"); |
990 |
> |
{ |
991 |
> |
c[0] = 255;c[1]=0;c[2]=0; |
992 |
> |
s_id = smAdd_sample_point(sm,c,dir,pt); |
993 |
> |
eputs("smAdd_sample_to_mesh(): not found fg\n"); |
994 |
> |
} |
995 |
|
#endif |
996 |
|
} |
997 |
|
else if(s_id != -1) |
1004 |
|
smDist_sum += 1.0/d; |
1005 |
|
/************************************/ |
1006 |
|
} |
1007 |
< |
t_id = smPointLocate(smMesh,p,&type,&which,TRUE); |
1008 |
< |
if(type==GT_FACE) |
1007 |
> |
t_id = smPointLocate(smMesh,p,TRUE); |
1008 |
> |
if(t_id != -1) |
1009 |
|
s_id = smInsert_point_in_tri(smMesh,c,dir,p,s_id,t_id); |
800 |
– |
else |
801 |
– |
if(type==GT_VERTEX) |
802 |
– |
s_id = smReplace_vertex(smMesh,c,dir,p,t_id,s_id,type,which); |
1010 |
|
#ifdef DEBUG |
1011 |
|
else |
1012 |
< |
eputs("smAdd_sample_to_mesh(): unrecognized type\n"); |
1012 |
> |
eputs("smAdd_sample_to_mesh():not found reinsert\n"); |
1013 |
|
#endif |
1014 |
|
} |
1015 |
|
/* Is a BG(sky point) */ |
1016 |
|
else |
1017 |
|
{ |
1018 |
< |
t_id = smPointLocate(smMesh,dir,&type,&which,FALSE); |
1019 |
< |
if(type==GT_FACE) |
1018 |
> |
t_id = smPointLocate(smMesh,dir,FALSE); |
1019 |
> |
if(t_id != -1) |
1020 |
|
s_id = smInsert_point_in_tri(smMesh,c,dir,NULL,s_id,t_id); |
1021 |
< |
else |
815 |
< |
if(type==GT_VERTEX) |
816 |
< |
s_id = smReplace_vertex(smMesh,c,dir,NULL,t_id,s_id,type,which); |
1021 |
> |
|
1022 |
|
#ifdef DEBUG |
1023 |
|
else |
1024 |
< |
eputs("smAdd_sample_to_mesh(): unrecognized type\n"); |
1024 |
> |
eputs("smAdd_sample_to_mesh(): not found bg\n"); |
1025 |
|
#endif |
1026 |
|
} |
1027 |
|
return(s_id); |
1046 |
|
|
1047 |
|
{ |
1048 |
|
int s_id; |
1049 |
+ |
int debug=0; |
1050 |
|
|
1051 |
|
/* First check if this the first sample: if so initialize mesh */ |
1052 |
|
if(SM_NUM_SAMP(smMesh) == 0) |
847 |
– |
#ifdef TEST_DRIVER |
848 |
– |
smInit_mesh(smMesh,View.vp); |
849 |
– |
#else |
1053 |
|
smInit_mesh(smMesh,odev.v.vp); |
1054 |
< |
#endif |
1055 |
< |
s_id = smAdd_sample_to_mesh(smMesh,c,dir,p,-1); |
853 |
< |
#if 0 |
854 |
< |
{ |
855 |
< |
char buff[100]; |
856 |
< |
sprintf(buff,"Added sample %d\n",s_id); |
857 |
< |
eputs(buff); |
858 |
< |
} |
859 |
< |
#endif |
1054 |
> |
if(!debug) |
1055 |
> |
s_id = smAdd_sample_to_mesh(smMesh,c,dir,p,-1); |
1056 |
|
return(s_id); |
1057 |
|
|
1058 |
|
} |
1126 |
|
SM *sm; |
1127 |
|
int type; |
1128 |
|
{ |
1129 |
< |
int i,id; |
1129 |
> |
int i,id,tri_id,nbr_id; |
1130 |
|
int p[4],ids[4]; |
1131 |
|
int v0_id,v1_id,v2_id; |
1132 |
|
TRI *tris[4]; |
1136 |
|
|
1137 |
|
for(i=0; i < 4; i++) |
1138 |
|
{ |
1139 |
< |
VADD(cntr,stDefault_base[i],SM_VIEW_CENTER(sm)); |
1140 |
< |
point_on_sphere(d,cntr,SM_VIEW_CENTER(sm)); |
1141 |
< |
id = smAdd_base_vertex(sm,cntr,d); |
1139 |
> |
VCOPY(cntr,stDefault_base[i]); |
1140 |
> |
cntr[0] += .01; |
1141 |
> |
cntr[1] += .02; |
1142 |
> |
cntr[2] += .03; |
1143 |
> |
VADD(cntr,cntr,SM_VIEW_CENTER(sm)); |
1144 |
> |
d[0] = -1; |
1145 |
> |
id = smAdd_base_vertex(sm,cntr,d); |
1146 |
|
/* test to make sure vertex allocated */ |
1147 |
|
if(id != -1) |
1148 |
|
p[i] = id; |
1157 |
|
v2_id = p[stTri_verts[i][2]]; |
1158 |
|
if((ids[i] = smAdd_tri(sm, v0_id,v1_id,v2_id,&(tris[i])))== -1) |
1159 |
|
return(0); |
1160 |
+ |
smLocator_add_tri(sm,ids[i],v0_id,v1_id,v2_id,NULL); |
1161 |
|
} |
1162 |
|
/* Set neighbors */ |
1163 |
|
|
1164 |
< |
T_NTH_NBR(tris[0],0) = ids[3]; |
1165 |
< |
T_NTH_NBR(tris[0],1) = ids[2]; |
1166 |
< |
T_NTH_NBR(tris[0],2) = ids[1]; |
1164 |
> |
for(tri_id=0;tri_id < 4; tri_id++) |
1165 |
> |
for(nbr_id=0; nbr_id < 3; nbr_id++) |
1166 |
> |
T_NTH_NBR(tris[tri_id],nbr_id) = smBase_nbrs[tri_id][nbr_id]; |
1167 |
|
|
967 |
– |
T_NTH_NBR(tris[1],0) = ids[3]; |
968 |
– |
T_NTH_NBR(tris[1],1) = ids[0]; |
969 |
– |
T_NTH_NBR(tris[1],2) = ids[2]; |
970 |
– |
|
971 |
– |
T_NTH_NBR(tris[2],0) = ids[3]; |
972 |
– |
T_NTH_NBR(tris[2],1) = ids[1]; |
973 |
– |
T_NTH_NBR(tris[2],2) = ids[0]; |
974 |
– |
|
975 |
– |
T_NTH_NBR(tris[3],0) = ids[1]; |
976 |
– |
T_NTH_NBR(tris[3],1) = ids[2]; |
977 |
– |
T_NTH_NBR(tris[3],2) = ids[0]; |
1168 |
|
return(1); |
1169 |
|
|
1170 |
|
} |
1174 |
|
smNext_tri_flag_set(sm,i,which,b) |
1175 |
|
SM *sm; |
1176 |
|
int i,which; |
1177 |
< |
char b; |
1177 |
> |
int b; |
1178 |
|
{ |
1179 |
|
|
1180 |
|
for(; i < SM_TRI_CNT(sm);i++) |
1181 |
|
{ |
992 |
– |
if(!SM_IS_NTH_T_FLAG(sm,i,which)) |
993 |
– |
continue; |
1182 |
|
|
1183 |
+ |
if(!SM_IS_NTH_T_FLAG(sm,i,which)) |
1184 |
+ |
continue; |
1185 |
|
if(!b) |
1186 |
|
break; |
1187 |
|
if((b==1) && !SM_BG_TRI(sm,i)) |
1208 |
|
|
1209 |
|
|
1210 |
|
|
1211 |
< |
qtTri_verts_from_id(t_id,v0,v1,v2) |
1211 |
> |
qtTri_from_id(t_id,v0,v1,v2,n0,n1,n2,v0_idp,v1_idp,v2_idp) |
1212 |
|
int t_id; |
1213 |
|
FVECT v0,v1,v2; |
1214 |
+ |
FVECT n0,n1,n2; |
1215 |
+ |
int *v0_idp,*v1_idp,*v2_idp; |
1216 |
|
{ |
1217 |
|
TRI *t; |
1218 |
|
int v0_id,v1_id,v2_id; |
1222 |
|
v1_id = T_NTH_V(t,1); |
1223 |
|
v2_id = T_NTH_V(t,2); |
1224 |
|
|
1225 |
< |
smDir(smMesh,v0,v0_id); |
1226 |
< |
smDir(smMesh,v1,v1_id); |
1227 |
< |
smDir(smMesh,v2,v2_id); |
1225 |
> |
if(v0) |
1226 |
> |
{ |
1227 |
> |
VSUB(v0,SM_NTH_WV(smMesh,v0_id),SM_VIEW_CENTER(smMesh)); |
1228 |
> |
VSUB(v1,SM_NTH_WV(smMesh,v1_id),SM_VIEW_CENTER(smMesh)); |
1229 |
> |
VSUB(v2,SM_NTH_WV(smMesh,v2_id),SM_VIEW_CENTER(smMesh)); |
1230 |
> |
} |
1231 |
> |
if(n0) |
1232 |
> |
{ |
1233 |
> |
smDir(smMesh,n0,v0_id); |
1234 |
> |
smDir(smMesh,n1,v1_id); |
1235 |
> |
smDir(smMesh,n2,v2_id); |
1236 |
|
|
1237 |
< |
} |
1237 |
> |
} |
1238 |
> |
if(v0_idp) |
1239 |
> |
{ |
1240 |
> |
*v0_idp = v0_id; |
1241 |
> |
*v1_idp = v1_id; |
1242 |
> |
*v2_idp = v2_id; |
1243 |
> |
} |
1244 |
> |
} |
1245 |
|
|
1246 |
|
|
1247 |
< |
int |
1248 |
< |
smIntersectTriSet(sm,t_set,orig,dir,pt) |
1247 |
> |
/* |
1248 |
> |
* int |
1249 |
> |
* smFindSamp(FVECT orig, FVECT dir) |
1250 |
> |
* |
1251 |
> |
* Find the closest sample to the given ray. Returns sample id, -1 on failure. |
1252 |
> |
* "dir" is assumed to be normalized |
1253 |
> |
*/ |
1254 |
> |
|
1255 |
> |
|
1256 |
> |
|
1257 |
> |
smRebuild_mesh(sm,vp) |
1258 |
|
SM *sm; |
1259 |
+ |
FVECT vp; |
1260 |
+ |
{ |
1261 |
+ |
int i; |
1262 |
+ |
FVECT dir; |
1263 |
+ |
COLR c; |
1264 |
+ |
FVECT p,ov; |
1265 |
+ |
|
1266 |
+ |
/* Clear the mesh- and rebuild using the current sample array */ |
1267 |
+ |
|
1268 |
+ |
VSUB(ov,vp,SM_VIEW_CENTER(sm)); |
1269 |
+ |
smInit_mesh(sm,vp); |
1270 |
+ |
|
1271 |
+ |
SM_FOR_ALL_SAMPLES(sm,i) |
1272 |
+ |
{ |
1273 |
+ |
if(SM_NTH_W_DIR(sm,i)==-1) |
1274 |
+ |
VADD(SM_NTH_WV(sm,i),SM_NTH_WV(sm,i),ov); |
1275 |
+ |
smAdd_sample_to_mesh(sm,NULL,NULL,NULL,i); |
1276 |
+ |
} |
1277 |
+ |
} |
1278 |
+ |
|
1279 |
+ |
int |
1280 |
+ |
intersect_tri_set(t_set,orig,dir,pt) |
1281 |
|
OBJECT *t_set; |
1282 |
|
FVECT orig,dir,pt; |
1283 |
|
{ |
1284 |
|
OBJECT *optr; |
1285 |
< |
int i,t_id,v_id; |
1286 |
< |
TRI *tri; |
1287 |
< |
FVECT p0,p1,p2; |
1288 |
< |
char type,which; |
1051 |
< |
int p0_id,p1_id,p2_id; |
1285 |
> |
int i,t_id,id; |
1286 |
> |
int pid0,pid1,pid2; |
1287 |
> |
FVECT p0,p1,p2,p; |
1288 |
> |
TRI *t; |
1289 |
|
|
1290 |
< |
for(optr = QT_SET_PTR(t_set),i = QT_SET_CNT(t_set); i > 0; i--) |
1290 |
> |
optr = QT_SET_PTR(t_set); |
1291 |
> |
for(i = QT_SET_CNT(t_set); i > 0; i--) |
1292 |
|
{ |
1293 |
|
t_id = QT_SET_NEXT_ELEM(optr); |
1294 |
< |
tri = SM_NTH_TRI(sm,t_id); |
1295 |
< |
p0_id = T_NTH_V(tri,0); |
1296 |
< |
p1_id = T_NTH_V(tri,1); |
1297 |
< |
p2_id = T_NTH_V(tri,2); |
1298 |
< |
VCOPY(p0,SM_NTH_WV(sm,p0_id)); |
1299 |
< |
VCOPY(p1,SM_NTH_WV(sm,p1_id)); |
1300 |
< |
VCOPY(p2,SM_NTH_WV(sm,p2_id)); |
1301 |
< |
if(type = ray_intersect_tri(orig,dir,p0,p1,p2,pt,&which)) |
1294 |
> |
|
1295 |
> |
t = SM_NTH_TRI(smMesh,t_id); |
1296 |
> |
pid0 = T_NTH_V(t,0); |
1297 |
> |
pid1 = T_NTH_V(t,1); |
1298 |
> |
pid2 = T_NTH_V(t,2); |
1299 |
> |
VCOPY(p0,SM_NTH_WV(smMesh,pid0)); |
1300 |
> |
VCOPY(p1,SM_NTH_WV(smMesh,pid1)); |
1301 |
> |
VCOPY(p2,SM_NTH_WV(smMesh,pid2)); |
1302 |
> |
if(ray_intersect_tri(orig,dir,p0,p1,p2,p)) |
1303 |
|
{ |
1304 |
< |
if(type==GT_VERTEX) |
1305 |
< |
return(T_NTH_V(tri,which)); |
1306 |
< |
v_id = smClosest_vertex_in_w_tri(sm,p0_id,p1_id,p2_id,pt); |
1307 |
< |
return(v_id); |
1304 |
> |
id = closest_point_in_tri(p0,p1,p2,p,pid0,pid1,pid2); |
1305 |
> |
|
1306 |
> |
if(pt) |
1307 |
> |
VCOPY(pt,p); |
1308 |
> |
#ifdef DEBUG_TEST_DRIVER |
1309 |
> |
Pick_tri = t_id; |
1310 |
> |
Pick_samp = id; |
1311 |
> |
VCOPY(Pick_point[0],p); |
1312 |
> |
#endif |
1313 |
> |
return(id); |
1314 |
|
} |
1315 |
|
} |
1316 |
|
return(-1); |
1317 |
|
} |
1318 |
|
|
1319 |
< |
/* |
1320 |
< |
* int |
1321 |
< |
* smTraceRay(SM *sm,FVECT orig, FVECT dir,FVECT v0,FVECT v1,FVECT v2,FVECT r) |
1322 |
< |
* |
1323 |
< |
* Intersect the ray with triangle v0v1v2, return intersection point in r |
1324 |
< |
* |
1080 |
< |
* Assumes orig,v0,v1,v2 are in spherical coordinates, and orig is |
1081 |
< |
* unit |
1082 |
< |
*/ |
1083 |
< |
char |
1084 |
< |
smTraceRay(sm,orig,dir,v0,v1,v2,r) |
1085 |
< |
SM *sm; |
1086 |
< |
FVECT orig,dir; |
1087 |
< |
FVECT v0,v1,v2; |
1088 |
< |
FVECT r; |
1319 |
> |
int |
1320 |
> |
ray_trace_check_set(qtptr,orig,dir,tptr,os) |
1321 |
> |
QUADTREE *qtptr; |
1322 |
> |
FVECT orig,dir; |
1323 |
> |
int *tptr; |
1324 |
> |
OBJECT *os; |
1325 |
|
{ |
1326 |
< |
FVECT n,p[3],d; |
1327 |
< |
double pt[3],r_eps; |
1328 |
< |
char i; |
1329 |
< |
int which; |
1330 |
< |
|
1331 |
< |
/* Find the plane equation for the triangle defined by the edge v0v1 and |
1332 |
< |
the view center*/ |
1333 |
< |
VCROSS(n,v0,v1); |
1334 |
< |
/* Intersect the ray with this plane */ |
1335 |
< |
i = intersect_ray_plane(orig,dir,n,0.0,&(pt[0]),p[0]); |
1336 |
< |
if(i) |
1337 |
< |
which = 0; |
1338 |
< |
else |
1339 |
< |
which = -1; |
1340 |
< |
|
1341 |
< |
VCROSS(n,v1,v2); |
1342 |
< |
i = intersect_ray_plane(orig,dir,n,0.0,&(pt[1]),p[1]); |
1343 |
< |
if(i) |
1344 |
< |
if((which==-1) || pt[1] < pt[0]) |
1345 |
< |
which = 1; |
1346 |
< |
|
1111 |
< |
VCROSS(n,v2,v0); |
1112 |
< |
i = intersect_ray_plane(orig,dir,n,0.0,&(pt[2]),p[2]); |
1113 |
< |
if(i) |
1114 |
< |
if((which==-1) || pt[2] < pt[which]) |
1115 |
< |
which = 2; |
1116 |
< |
|
1117 |
< |
if(which != -1) |
1118 |
< |
{ |
1119 |
< |
/* Return point that is K*eps along projection of the ray on |
1120 |
< |
the sphere to push intersection point p[which] into next cell |
1121 |
< |
*/ |
1122 |
< |
normalize(p[which]); |
1123 |
< |
/* Calculate the ray perpendicular to the intersection point: approx |
1124 |
< |
the direction moved along the sphere a distance of K*epsilon*/ |
1125 |
< |
r_eps = -DOT(p[which],dir); |
1126 |
< |
VSUM(n,dir,p[which],r_eps); |
1127 |
< |
/* Calculate the length along ray p[which]-dir needed to move to |
1128 |
< |
cause a move along the sphere of k*epsilon |
1129 |
< |
*/ |
1130 |
< |
r_eps = DOT(n,dir); |
1131 |
< |
VSUM(r,p[which],dir,(20*FTINY)/r_eps); |
1132 |
< |
normalize(r); |
1133 |
< |
return(TRUE); |
1134 |
< |
} |
1135 |
< |
else |
1136 |
< |
{ |
1137 |
< |
/* Unable to find intersection: move along ray and try again */ |
1138 |
< |
r_eps = -DOT(orig,dir); |
1139 |
< |
VSUM(n,dir,orig,r_eps); |
1140 |
< |
r_eps = DOT(n,dir); |
1141 |
< |
VSUM(r,orig,dir,(20*FTINY)/r_eps); |
1142 |
< |
normalize(r); |
1143 |
< |
#ifdef DEBUG |
1144 |
< |
eputs("smTraceRay:Ray does not intersect triangle"); |
1145 |
< |
#endif |
1146 |
< |
return(FALSE); |
1147 |
< |
} |
1326 |
> |
OBJECT tset[QT_MAXSET+1]; |
1327 |
> |
double dt,t; |
1328 |
> |
int found; |
1329 |
> |
FVECT o; |
1330 |
> |
|
1331 |
> |
|
1332 |
> |
if(!QT_IS_EMPTY(*qtptr)) |
1333 |
> |
{ |
1334 |
> |
VADD(o,orig,SM_VIEW_CENTER(smMesh)); |
1335 |
> |
qtgetset(tset,*qtptr); |
1336 |
> |
/* Check triangles in set against those seen so far(os):only |
1337 |
> |
check new triangles for intersection (t_set') |
1338 |
> |
*/ |
1339 |
> |
check_set(tset,os); |
1340 |
> |
if((found = intersect_tri_set(tset,o,dir,NULL))!= -1) |
1341 |
> |
{ |
1342 |
> |
*tptr = found; |
1343 |
> |
return(QT_DONE); |
1344 |
> |
} |
1345 |
> |
} |
1346 |
> |
return(FALSE); |
1347 |
|
} |
1348 |
|
|
1150 |
– |
|
1151 |
– |
/* |
1152 |
– |
* int |
1153 |
– |
* smFindSamp(FVECT orig, FVECT dir) |
1154 |
– |
* |
1155 |
– |
* Find the closest sample to the given ray. Returns sample id, -1 on failure. |
1156 |
– |
* "dir" is assumed to be normalized |
1157 |
– |
*/ |
1349 |
|
int |
1350 |
|
smFindSamp(orig,dir) |
1351 |
|
FVECT orig,dir; |
1352 |
|
{ |
1353 |
< |
FVECT r,v0,v1,v2,a,b,p; |
1354 |
< |
OBJECT os[MAXCSET+1],t_set[MAXSET+1]; |
1353 |
> |
FVECT b,p,o; |
1354 |
> |
OBJECT *ts; |
1355 |
|
QUADTREE qt; |
1356 |
|
int s_id; |
1357 |
|
double d; |
1371 |
|
either case, do a single test against the cell containing the |
1372 |
|
intersection of "dir" and the sphere |
1373 |
|
*/ |
1374 |
+ |
/* orig will be updated-so preserve original value */ |
1375 |
+ |
if(!smMesh) |
1376 |
+ |
return; |
1377 |
|
point_on_sphere(b,orig,SM_VIEW_CENTER(smMesh)); |
1378 |
|
d = -DOT(b,dir); |
1379 |
|
if(EQUAL_VEC3(orig,SM_VIEW_CENTER(smMesh)) || EQUAL(fabs(d),1.0)) |
1380 |
|
{ |
1381 |
< |
qt = smPointLocateCell(smMesh,dir,v0,v1,v2,NULL,NULL,FALSE); |
1381 |
> |
qt = smPointLocateCell(smMesh,dir,FALSE,NULL,NULL,NULL); |
1382 |
|
/* Test triangles in the set for intersection with Ray:returns |
1383 |
|
first found |
1384 |
|
*/ |
1385 |
< |
qtgetset(t_set,qt); |
1386 |
< |
s_id = smIntersectTriSet(smMesh,t_set,orig,dir,p); |
1387 |
< |
#ifdef TEST_DRIVER |
1385 |
> |
ts = qtqueryset(qt); |
1386 |
> |
s_id = intersect_tri_set(ts,orig,dir,p); |
1387 |
> |
#ifdef DEBUG_TEST_DRIVER |
1388 |
|
VCOPY(Pick_point[0],p); |
1389 |
|
#endif |
1196 |
– |
return(s_id); |
1390 |
|
} |
1391 |
|
else |
1392 |
|
{ |
1393 |
< |
/* Starting with orig, Walk along projection of ray onto sphere */ |
1394 |
< |
point_on_sphere(r,orig,SM_VIEW_CENTER(smMesh)); |
1395 |
< |
qt = smPointLocateCell(smMesh,r,v0,v1,v2,NULL,NULL,FALSE); |
1396 |
< |
qtgetset(t_set,qt); |
1397 |
< |
/* os will contain all triangles seen thus far */ |
1398 |
< |
setcopy(os,t_set); |
1399 |
< |
|
1400 |
< |
/* Calculate ray perpendicular to dir: when projection ray is // to dir, |
1208 |
< |
the dot product will become negative. |
1209 |
< |
*/ |
1210 |
< |
VSUM(a,b,dir,d); |
1211 |
< |
d = DOT(a,b); |
1212 |
< |
while(d > 0) |
1213 |
< |
{ |
1214 |
< |
s_id = smIntersectTriSet(smMesh,t_set,orig,dir,p); |
1215 |
< |
#ifdef TEST_DRIVER |
1216 |
< |
VCOPY(Pick_point[0],p); |
1217 |
< |
#endif |
1218 |
< |
if(s_id != EMPTY) |
1219 |
< |
return(s_id); |
1220 |
< |
/* Find next cell that projection of ray intersects */ |
1221 |
< |
smTraceRay(smMesh,r,dir,v0,v1,v2,r); |
1222 |
< |
qt = smPointLocateCell(smMesh,r,v0,v1,v2,NULL,NULL,FALSE); |
1223 |
< |
qtgetset(t_set,qt); |
1224 |
< |
/* Check triangles in set against those seen so far(os):only |
1225 |
< |
check new triangles for intersection (t_set') |
1226 |
< |
*/ |
1227 |
< |
check_set(t_set,os); |
1228 |
< |
d = DOT(a,r); |
1229 |
< |
} |
1230 |
< |
} |
1231 |
< |
#ifdef DEBUG |
1232 |
< |
eputs("smFindSamp():Pick Ray did not intersect mesh"); |
1233 |
< |
#endif |
1234 |
< |
return(EMPTY); |
1393 |
> |
OBJECT t_set[QT_MAXCSET+1]; |
1394 |
> |
/* Test each of the root triangles against point id */ |
1395 |
> |
QT_CLEAR_SET(t_set); |
1396 |
> |
VSUB(o,orig,SM_VIEW_CENTER(smMesh)); |
1397 |
> |
ST_CLEAR_FLAGS(SM_LOCATOR(smMesh)); |
1398 |
> |
s_id=stTrace_ray(SM_LOCATOR(smMesh),o,dir,ray_trace_check_set,&s_id,t_set); |
1399 |
> |
} |
1400 |
> |
return(s_id); |
1401 |
|
} |
1236 |
– |
|
1402 |
|
|
1238 |
– |
smRebuild_mesh(sm,vptr) |
1239 |
– |
SM *sm; |
1240 |
– |
VIEW *vptr; |
1241 |
– |
{ |
1242 |
– |
int i; |
1243 |
– |
FVECT dir; |
1244 |
– |
COLR c; |
1245 |
– |
FVECT p,ov; |
1403 |
|
|
1247 |
– |
/* Clear the mesh- and rebuild using the current sample array */ |
1248 |
– |
#ifdef TEST_DRIVER |
1249 |
– |
View = *vptr; |
1250 |
– |
#endif |
1404 |
|
|
1405 |
< |
VSUB(ov,vptr->vp,SM_VIEW_CENTER(sm)); |
1406 |
< |
smInit_mesh(sm,vptr->vp); |
1407 |
< |
|
1408 |
< |
SM_FOR_ALL_SAMPLES(sm,i) |
1409 |
< |
{ |
1410 |
< |
if(SM_NTH_W_DIR(sm,i)==-1) |
1411 |
< |
VADD(SM_NTH_WV(sm,i),SM_NTH_WV(sm,i),ov); |
1259 |
< |
smAdd_sample_to_mesh(sm,NULL,NULL,NULL,i); |
1260 |
< |
} |
1261 |
< |
} |
1405 |
> |
|
1406 |
> |
|
1407 |
> |
|
1408 |
> |
|
1409 |
> |
|
1410 |
> |
|
1411 |
> |
|
1412 |
|
|
1413 |
|
|