ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/sm_ogl.c
(Generate patch)

Comparing ray/src/hd/sm_ogl.c (file contents):
Revision 3.11 by gwlarson, Wed Dec 30 13:44:16 1998 UTC vs.
Revision 3.13 by gwlarson, Sun Jan 10 10:27:48 1999 UTC

# Line 47 | Line 47 | static QT_LUENT        *qt_htbl = NULL;        /* quadtree cache */
47   static int      qt_hsiz = 0;            /* quadtree cache size */
48  
49  
50 + typedef struct _T_DEPTH {
51 +  int tri;
52 +  double depth;
53 + }T_DEPTH;
54 +
55   /*
56 <  * smClean()           : display has been wiped clean
57 <  *
56 >  * smClean(tmflag)     : display has been wiped clean
57 >  *     int tmflag;
58    * Called after display has been effectively cleared, meaning that all
59    * geometry must be resent down the pipeline in the next call to smUpdate().
60 +  * If tmflag is set, tone-mapping should be performed
61    */
62 < smClean()
62 > smClean(tmflag)
63 >   int tmflag;
64   {
65      smClean_notify = TRUE;
66 +    if(tmflag)
67 +       SM_TONE_MAP(smMesh) = 0;
68   }
69  
70   int
# Line 281 | Line 290 | smRender_stree(sm, qual)       /* render some quadtree trian
290   SM *sm;
291   int qual;
292   {
293 <  int i, ntarget;
293 >  int i, n,ntarget;
294    int lvlcnt[QT_MAX_LEVELS];
295    STREE *st;
296 <
296 >  int4 *active_flag;
297    if (qual <= 0)
298      return;
299                                  /* compute rendering target */
300    ntarget = 0;
301 <  SM_FOR_ALL_ACTIVE_TRIS(sm,i)
302 <    ntarget++;
303 <  ntarget = ntarget*qual/100;
301 >
302 >  active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG);
303 >  for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
304 >    if(active_flag[n])
305 >      for(i=0; i < 32; i++)
306 >        if(active_flag[n] & (1L << i))
307 >          ntarget++;
308 >
309 >  ntarget = ntarget*qual/MAXQUALITY;
310    if (!ntarget)
311      return;
312    for (i = QT_MAX_LEVELS; i--; )
# Line 309 | Line 324 | int qual;
324   }
325  
326  
312 – smRender_tri(sm,i,vp,clr)
313 – SM *sm;
314 – int i;
315 – FVECT vp;
316 – int clr;
317 – {
318 –  TRI *tri;
319 –  double ptr[3];
320 –  int j;
327  
328 <  tri = SM_NTH_TRI(sm,i);
329 <  if (clr) SM_CLR_NTH_T_NEW(sm,i);
330 <  for(j=0; j <= 2; j++)
331 <  {
326 < #ifdef DEBUG
327 <    if(SM_BG_SAMPLE(sm,T_NTH_V(tri,j)))
328 <      eputs("SmRenderTri(): shouldnt have bg samples\n");
329 < #endif
330 <    glColor3ub(SM_NTH_RGB(sm,T_NTH_V(tri,j))[0],
331 <               SM_NTH_RGB(sm,T_NTH_V(tri,j))[1],
332 <               SM_NTH_RGB(sm,T_NTH_V(tri,j))[2]);
333 <    VCOPY(ptr,SM_T_NTH_WV(sm,tri,j));
334 <    glVertex3d(ptr[0],ptr[1],ptr[2]);
335 <  }
336 < }
328 > #define render_tri(v0,v1,v2,rgb0,rgb1,rgb2) \
329 >  {glColor3ub(rgb0[0],rgb0[1],rgb0[2]);  glVertex3fv(v0); \
330 >  glColor3ub(rgb1[0],rgb1[1],rgb1[2]);  glVertex3fv(v1); \
331 >  glColor3ub(rgb2[0],rgb2[1],rgb2[2]);  glVertex3fv(v2);} \
332  
333 < smRender_mixed_tri(sm,i,vp,clr)
334 < SM *sm;
335 < int i;
336 < FVECT vp;
337 < int clr;
333 > render_mixed_tri(v0,v1,v2,rgb0,rgb1,rgb2,bg0,bg1,bg2,vp,vc)
334 > float v0[3],v1[3],v2[3];
335 > BYTE rgb0[3],rgb1[3],rgb2[3];
336 > int bg0,bg1,bg2;
337 > FVECT vp,vc;
338   {
344 –  TRI *tri;
339    double p[3],d;
340    int j,ids[3],cnt;
341    int rgb[3];
342  
349 –  tri = SM_NTH_TRI(sm,i);
350 –  if (clr) SM_CLR_NTH_T_NEW(sm,i);
351 –
343    /* NOTE:Triangles are defined clockwise:historical relative to spherical
344       tris: could change
345       */
346 +  if(bg0 && bg1 && bg2)
347 +    return;
348 +
349    cnt = 0;
350    d = 0.0;
351    rgb[0] = rgb[1] = rgb[2] = 0;
352 <  for(j=0;j < 3;j++)
352 >
353 >  if(!bg0)
354    {
355 <      ids[j] = T_NTH_V(tri,j);
356 <      if(!SM_BG_SAMPLE(sm,ids[j]))
357 <      {
358 <          rgb[0] += SM_NTH_RGB(sm,ids[j])[0];
359 <          rgb[1] += SM_NTH_RGB(sm,ids[j])[1];
365 <          rgb[2] += SM_NTH_RGB(sm,ids[j])[2];
366 <          cnt++;
367 <          d += DIST(vp,SM_NTH_WV(sm,ids[j]));
368 <      }
355 >    rgb[0] += rgb0[0];
356 >    rgb[1] += rgb0[1];
357 >    rgb[2] += rgb0[2];
358 >    cnt++;
359 >    d += DIST(vp,v0);
360    }
361 +  if(!bg1)
362 +  {
363 +    rgb[0] += rgb1[0];
364 +    rgb[1] += rgb1[1];
365 +    rgb[2] += rgb1[2];
366 +    cnt++;
367 +    d += DIST(vp,v1);
368 +  }
369 +  if(!bg2)
370 +  {
371 +    rgb[0] += rgb2[0];
372 +    rgb[1] += rgb2[1];
373 +    rgb[2] += rgb2[2];
374 +    cnt++;
375 +    d += DIST(vp,v2);
376 +  }
377    if(cnt > 1)
378    {
379      rgb[0]/=cnt; rgb[1]/=cnt; rgb[2]/=cnt;
380      d /= (double)cnt;
381    }
382 <  for(j=0; j <= 2; j++)
382 >  if(bg0)
383    {
384 <    if(SM_BG_SAMPLE(sm,ids[j]))
385 <    {
386 <        glColor3ub(rgb[0],rgb[1],rgb[2]);
387 <        VSUB(p,SM_NTH_WV(sm,ids[j]),SM_VIEW_CENTER(sm));
388 <        p[0] *= d;
389 <        p[1] *= d;
390 <        p[2] *= d;
391 <        VADD(p,p,SM_VIEW_CENTER(sm));
392 <    }
393 <    else
394 <    {
395 <        glColor3ub(SM_NTH_RGB(sm,ids[j])[0],SM_NTH_RGB(sm,ids[j])[1],
389 <                   SM_NTH_RGB(sm,ids[j])[2]);
390 <        VCOPY(p,SM_NTH_WV(sm,ids[j]));
391 <    }
392 <    glVertex3d(p[0],p[1],p[2]);
384 >    glColor3ub(rgb[0],rgb[1],rgb[2]);
385 >    VSUB(p,v0,vc);
386 >    p[0] *= d;
387 >    p[1] *= d;
388 >    p[2] *= d;
389 >    VADD(p,p,vc);
390 >    glVertex3dv(p);
391 >  }
392 >  else
393 >  {
394 >    glColor3ub(rgb0[0],rgb0[1],rgb0[2]);
395 >    glVertex3fv(v0);
396     }
397 +  if(bg1)
398 +  {
399 +    glColor3ub(rgb[0],rgb[1],rgb[2]);
400 +    VSUB(p,v1,vc);
401 +    p[0] *= d;
402 +    p[1] *= d;
403 +    p[2] *= d;
404 +    VADD(p,p,vc);
405 +    glVertex3dv(p);
406 +  }
407 +  else
408 +  {
409 +    glColor3ub(rgb1[0],rgb1[1],rgb1[2]);
410 +    glVertex3fv(v1);
411 +   }
412 +  if(bg2)
413 +  {
414 +    glColor3ub(rgb[0],rgb[1],rgb[2]);
415 +    VSUB(p,v2,vc);
416 +    p[0] *= d;
417 +    p[1] *= d;
418 +    p[2] *= d;
419 +    VADD(p,p,vc);
420 +    glVertex3dv(p);
421 +  }
422 +  else
423 +  {
424 +    glColor3ub(rgb2[0],rgb2[1],rgb2[2]);
425 +    glVertex3fv(v2);
426 +   }
427 +
428   }
429  
430 < smRender_bg_tri(sm,i,vp,d,clr)
431 < SM *sm;
432 < int i;
433 < FVECT vp;
430 > render_bg_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,vc,d)
431 > float v0[3],v1[3],v2[3];
432 > BYTE rgb0[3],rgb1[3],rgb2[3];
433 > FVECT vp,vc;
434   double d;
401 – int clr;
435   {
436    double p[3];
404 –  int j,id;
405 –  TRI *tri;
437    
438 <  tri = SM_NTH_TRI(sm,i);
439 <  if (clr) SM_CLR_NTH_T_NEW(sm,i);
438 >  glColor3ub(rgb0[0],rgb0[1],rgb0[2]);
439 >  VSUB(p,v0,vc);
440 >  if(dev_zmin >= 0.99)
441 >  {
442 >    p[0] *= d;
443 >    p[1] *= d;
444 >    p[2] *= d;
445 >  }
446 >  VADD(p,p,vp);
447 >  glVertex3dv(p);
448  
449 <  /* NOTE:Triangles are defined clockwise:historical relative to spherical
450 <     tris: could change
451 <     */
413 <  for(j=0; j <= 2; j++)
449 >  glColor3ub(rgb1[0],rgb1[1],rgb1[2]);
450 >  VSUB(p,v1,vc);
451 >  if(dev_zmin >= 0.99)
452    {
453 <      id = T_NTH_V(tri,j);
454 <      glColor3ub(SM_NTH_RGB(sm,id)[0],SM_NTH_RGB(sm,id)[1],
455 <                 SM_NTH_RGB(sm,id)[2]);
418 <      VSUB(p,SM_NTH_WV(sm,id),SM_VIEW_CENTER(sm));
419 <      if(dev_zmin >= 0.99)
420 <       {
421 <           p[0] *= d;
422 <           p[1] *= d;
423 <           p[2] *= d;
424 <       }
425 <      VADD(p,p,vp);
426 <      glVertex3d(p[0],p[1],p[2]);
453 >    p[0] *= d;
454 >    p[1] *= d;
455 >    p[2] *= d;
456    }
457 +  VADD(p,p,vp);
458 +  glVertex3dv(p);
459 +
460 +
461 +  glColor3ub(rgb2[0],rgb2[1],rgb2[2]);
462 +  VSUB(p,v2,vc);
463 +  if(dev_zmin >= 0.99)
464 +  {
465 +    p[0] *= d;
466 +    p[1] *= d;
467 +    p[2] *= d;
468 +  }
469 +  VADD(p,p,vp);
470 +  glVertex3dv(p);
471 +
472   }
473  
474 < smRender_mesh(sm,vp,clr)
474 > smRender_mesh(sm,vp)
475   SM *sm;
476   FVECT vp;
433 – int clr;
477   {
478 <  int i;
478 >  int i,n,bg0,bg1,bg2;
479 >  double d;
480 >  int v0_id,v1_id,v2_id;
481    TRI *tri;
482 <  double ptr[3],d;
483 <  int j;
482 >  float (*wp)[3];
483 >  BYTE  (*rgb)[3];
484 >  int4  *active_flag,*bg_flag;
485  
486 +  wp = SM_WP(sm);
487 +  rgb =SM_RGB(sm);
488    d = (dev_zmin+dev_zmax)/2.0;
489    glPushAttrib(GL_DEPTH_BUFFER_BIT);
490    
491    /* First draw background polygons */
492    glDisable(GL_DEPTH_TEST);
493    glBegin(GL_TRIANGLES);
494 <  SM_FOR_ALL_ACTIVE_BG_TRIS(sm,i)
495 <     smRender_bg_tri(sm,i,vp,d,clr);
494 >
495 >  active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG);
496 >  bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG);
497 >  for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
498 >    if(active_flag[n] & bg_flag[n])
499 >      for(i=0; i < 32; i++)
500 >        if(active_flag[n] & bg_flag[n] & (1L << i))
501 >         {
502 >           tri = SM_NTH_TRI(sm,(n<<5)+i);
503 >           v0_id = T_NTH_V(tri,0);
504 >           v1_id = T_NTH_V(tri,1);
505 >           v2_id = T_NTH_V(tri,2);
506 >           render_bg_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
507 >                         rgb[v2_id],vp,SM_VIEW_CENTER(sm),d);
508 >         }
509    glEnd();
510 +
511    glEnable(GL_DEPTH_TEST);
512    glBegin(GL_TRIANGLES);
513 <  SM_FOR_ALL_ACTIVE_FG_TRIS(sm,i)
514 <  {
515 <      if(!SM_MIXED_TRI(sm,i))
516 <        smRender_tri(sm,i,vp,clr);
517 <   else
518 <        smRender_mixed_tri(sm,i,vp,clr);
519 <  }
513 >  for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
514 >    if(active_flag[n])
515 >      for(i=0; i < 32; i++)
516 >        if((active_flag[n] & (1L << i)) && !(bg_flag[n] & (1L << i)))
517 >         {
518 >           tri = SM_NTH_TRI(sm,(n<<5)+i);
519 >           v0_id = T_NTH_V(tri,0);
520 >           v1_id = T_NTH_V(tri,1);
521 >           v2_id = T_NTH_V(tri,2);
522 >           bg0 = SM_DIR_ID(sm,v0_id) || SM_BASE_ID(sm,v0_id);
523 >           bg1 = SM_DIR_ID(sm,v1_id) || SM_BASE_ID(sm,v1_id);
524 >           bg2 = SM_DIR_ID(sm,v2_id) || SM_BASE_ID(sm,v2_id);
525 >           if(!(bg0 || bg1 || bg2))
526 >             render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
527 >                        rgb[v2_id])
528 >               else
529 >                 render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],
530 >                  rgb[v1_id],rgb[v2_id],bg0,bg1,bg2,vp,SM_VIEW_CENTER(sm));
531 >         }
532    glEnd();
533  
534    glPopAttrib();
535   }
536  
463 – smRender_tri_edges(sm,i)
464 – SM *sm;
465 – int i;
466 – {
467 –  TRI *tri;
468 –  int j;
469 –  double ptr[3];
470 –
471 –
472 –  tri = SM_NTH_TRI(sm,i);
473 –
474 –  for(j=0; j <= 2; j++)
475 –  {
476 –    VCOPY(ptr,SM_NTH_WV(sm,T_NTH_V(tri,j)));
477 –    glVertex3d(ptr[0],ptr[1],ptr[2]);
478 –    VCOPY(ptr,SM_NTH_WV(sm,T_NTH_V(tri,(j+1)%3)));
479 –    glVertex3d(ptr[0],ptr[1],ptr[2]);
480 –  }
481 – }
482 –
537   int
538   compare_tri_depths(T_DEPTH *td1,T_DEPTH *td2)
539   {
# Line 493 | Line 547 | compare_tri_depths(T_DEPTH *td1,T_DEPTH *td2)
547      return(-1);
548    
549    return(0);
550 +
551   }
552  
553 < LIST
554 < *smDepth_sort_tris(sm,vp,td)
553 > #ifdef DEBUG
554 > #define freebuf(b)  tempbuf(-1)
555 > #endif
556 >
557 >
558 > char *
559 > tempbuf(len)                    /* get a temporary buffer */
560 > unsigned  len;
561 > {
562 >        extern char  *malloc(), *realloc();
563 >        static char  *tempbuf = NULL;
564 >        static unsigned  tempbuflen = 0;
565 >
566 > #ifdef DEBUG
567 >        static int in_use=FALSE;
568 >
569 >        if(len == -1)
570 >          {
571 >            in_use = FALSE;
572 >            return(NULL);
573 >          }
574 >        if(in_use)
575 >        {
576 >            eputs("Buffer in use:cannot allocate:tempbuf()\n");
577 >            return(NULL);
578 >        }
579 > #endif
580 >        if (len > tempbuflen) {
581 >                if (tempbuflen > 0)
582 >                        tempbuf = realloc(tempbuf, len);
583 >                else
584 >                        tempbuf = malloc(len);
585 >                tempbuflen = tempbuf==NULL ? 0 : len;
586 >        }
587 > #ifdef DEBUG
588 >        in_use = TRUE;
589 > #endif
590 >        return(tempbuf);
591 > }
592 >
593 > smOrder_new_tris(sm,vp,td)
594   SM *sm;
595   FVECT vp;
596   T_DEPTH *td;
597   {
598 <  int i,j,t_id,v;
598 >  int n,i,j,tcnt,v;
599    TRI *tri;
600    double d,min_d;
601 <  LIST *tlist=NULL;
601 >  FVECT diff;
602 >  int4 *new_flag,*bg_flag;
603  
604 <  i = 0;
605 <  SM_FOR_ALL_NEW_TRIS(sm,t_id)
606 <  {
607 <    if(SM_BG_TRI(sm,t_id))
608 <    {
609 <        tlist = push_data(tlist,t_id);
610 <        continue;
611 <    }
612 <    tri = SM_NTH_TRI(sm,t_id);
613 < #ifdef DEBUG
614 <    if(i >= smNew_tri_cnt)
615 <    {
616 <      eputs("smDepth_sort_tris():More tris than reported by smNew_tri_cnt\n");
617 <      break;
618 <    }
619 < #endif
620 <    td[i].tri = t_id;
621 <    min_d = -1;
622 <    for(j=0;j < 3;j++)
623 <    {
624 <        v = T_NTH_V(tri,j);
625 <        if(!SM_BG_SAMPLE(sm,v))
626 <        {
532 <            d = DIST(vp,SM_NTH_WV(sm,v));
533 <            if(min_d == -1 || d < min_d)
534 <               min_d = d;
535 <        }
536 <    }
537 <    td[i].depth = min_d;
538 <    i++;
604 >  tcnt=0;
605 >  new_flag = SM_NTH_FLAGS(sm,T_NEW_FLAG);
606 >  bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG);
607 >  for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
608 >    if(new_flag[n] & ~bg_flag[n])
609 >      for(i=0; i < 32; i++)
610 >        if(new_flag[n] & (1L << i) & ~bg_flag[n])
611 >         {
612 >           tri = SM_NTH_TRI(sm,(n<<5)+i);
613 >           td[tcnt].tri = (n << 5)+i;
614 >           min_d = -1;
615 >           for(j=0;j < 3;j++)
616 >             {
617 >               v = T_NTH_V(tri,j);
618 >               if(!SM_BG_SAMPLE(sm,v))
619 >                 {
620 >                   VSUB(diff,SM_NTH_WV(sm,v),vp);
621 >                   d = DOT(diff,diff);
622 >                   if(min_d == -1 || d < min_d)
623 >                     min_d = d;
624 >                 }
625 >             }
626 >           td[tcnt++].depth = min_d;
627    }
628 <  td[i].tri = -1;
629 <  if(i)
630 <     qsort((void *)td,i,sizeof(T_DEPTH),compare_tri_depths);
543 <  return(tlist);
628 >  td[tcnt].tri = -1;
629 >  if(tcnt)
630 >      qsort((void *)td,tcnt,sizeof(T_DEPTH),compare_tri_depths);
631   }
632  
633  
# Line 549 | Line 636 | SM *sm;
636   FVECT vp;
637   int clr;
638   {
639 <  static T_DEPTH *td= NULL;
553 <  static int tsize = 0;
554 <  int i;
639 >  int i,n,v0_id,v1_id,v2_id,bg0,bg1,bg2;
640    GLint depth_test;
641    double d;
642 <  LIST *bglist;
642 >  TRI *tri;
643 >  float (*wp)[3];
644 >  BYTE  (*rgb)[3];
645 >  int4  *new_flag,*bg_flag;
646 >  T_DEPTH *td = NULL;
647    /* For all of the NEW triangles (since last update): assume
648       ACTIVE. Go through and sort on depth value (from vp). Turn
649       Depth Buffer test off and render back-front
650       */
651 <  /* NOTE: could malloc each time or hard code */
563 <  if(smNew_tri_cnt > tsize)
651 >  if(!EQUAL_VEC3(SM_VIEW_CENTER(sm),vp))
652    {
653 <    if(td)
654 <      free((char *)td);
655 <    td = (T_DEPTH *)malloc(smNew_tri_cnt*sizeof(T_DEPTH));
656 <    tsize = smNew_tri_cnt;
653 >    /* Must depth sort if view points do not coincide */
654 >    td = (T_DEPTH *)tempbuf(smNew_tri_cnt*sizeof(T_DEPTH));
655 > #ifdef DEBUG
656 >    if(!td)
657 >        eputs("Cant create list:wont depth sort:smUpdate_rendered_mesh\n");
658 > #endif
659 >    smOrder_new_tris(sm,vp,td);
660    }
661 <  if(!td)
662 <  {
572 <    error(SYSTEM,"smUpdate_Rendered_mesh:Cannot allocate memory\n");
573 <  }
574 <  bglist = smDepth_sort_tris(sm,vp,td);
575 <
661 >  wp = SM_WP(sm);
662 >  rgb =SM_RGB(sm);
663    /* Turn Depth Test off -- using Painter's algorithm */
664    glPushAttrib(GL_DEPTH_BUFFER_BIT);
665    glDepthFunc(GL_ALWAYS);
666    d = (dev_zmin+dev_zmax)/2.0;
667 +
668    /* Now render back-to front */
669    /* First render bg triangles */
670 +  new_flag = SM_NTH_FLAGS(sm,T_NEW_FLAG);
671 +  bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG);
672    glBegin(GL_TRIANGLES);
673 <  while(bglist)
674 <     smRender_bg_tri(sm,pop_list(&bglist),vp,d,clr);
673 >  for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
674 >    if(new_flag[n] & bg_flag[n])
675 >      for(i=0; i < 32; i++)
676 >        if(new_flag[n] & (1L << i) & bg_flag[n] )
677 >         {
678 >           tri = SM_NTH_TRI(sm,(n<<5)+i);
679 >           v0_id = T_NTH_V(tri,0);
680 >           v1_id = T_NTH_V(tri,1);
681 >           v2_id = T_NTH_V(tri,2);
682 >           render_bg_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
683 >                         rgb[v2_id],vp,SM_VIEW_CENTER(sm),d);
684 >         }
685    glEnd();
686  
687  
688    glBegin(GL_TRIANGLES);
689 <  i=0;
690 <  while(td[i].tri != -1)
691 <     if(!SM_MIXED_TRI(sm,td[i].tri))
692 <        smRender_tri(sm,td[i++].tri,vp,clr);
693 <     else
694 <        smRender_mixed_tri(sm,td[i++].tri,vp,clr);
689 >  if(!td)
690 >  {
691 >    for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
692 >     if(new_flag[n] & ~bg_flag[n])
693 >      for(i=0; i < 32; i++)
694 >        if(new_flag[n] & (1L << i) & ~bg_flag[n])
695 >         {
696 >           tri = SM_NTH_TRI(sm,(n<<5)+i);
697 >           /* Dont need to check for valid tri because flags are
698 >              cleared on delete
699 >            */
700 >           v0_id = T_NTH_V(tri,0);
701 >           v1_id = T_NTH_V(tri,1);
702 >           v2_id = T_NTH_V(tri,2);
703 >           bg0 = SM_DIR_ID(sm,v0_id) || SM_BASE_ID(sm,v0_id);
704 >           bg1 = SM_DIR_ID(sm,v1_id) || SM_BASE_ID(sm,v1_id);
705 >           bg2 = SM_DIR_ID(sm,v2_id) || SM_BASE_ID(sm,v2_id);
706 >           if(!(bg0 || bg1 || bg2))
707 >             render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
708 >                        rgb[v2_id])
709 >           else
710 >             render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],
711 >                              rgb[v1_id],rgb[v2_id],bg0,bg1,bg2,vp,
712 >                              SM_VIEW_CENTER(sm));
713 >         }
714 >  }
715 >  else
716 >  {
717 >    for(i=0; td[i].tri != -1;i++)
718 >    {
719 >      tri = SM_NTH_TRI(sm,td[i].tri);
720 >      /* Dont need to check for valid tri because flags are
721 >         cleared on delete
722 >         */
723 >      v0_id = T_NTH_V(tri,0);
724 >      v1_id = T_NTH_V(tri,1);
725 >      v2_id = T_NTH_V(tri,2);
726 >      bg0 = SM_DIR_ID(sm,v0_id) || SM_BASE_ID(sm,v0_id);
727 >      bg1 = SM_DIR_ID(sm,v1_id) || SM_BASE_ID(sm,v1_id);
728 >      bg2 = SM_DIR_ID(sm,v2_id) || SM_BASE_ID(sm,v2_id);
729 >      if(!(bg0 || bg1 || bg2))
730 >        render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
731 >                   rgb[v2_id])
732 >          else
733 >            render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],
734 >                             rgb[v1_id],rgb[v2_id],bg0,bg1,bg2,vp,
735 >                             SM_VIEW_CENTER(sm));
736 >    }
737 > #ifdef DEBUG
738 >    freebuf(td);
739 > #endif
740 >  }
741    glEnd();
742  
743    /* Restore Depth Test */
# Line 615 | Line 761 | smUpdate(view,qual)
761     int qual;
762   {
763    double d;
764 <  int last_update;
619 <  int t;
764 >  int last_update,t;
765  
766 +  if(!smMesh)
767 +    return;
768 +
769    /* If view has moved beyond epsilon from canonical: must rebuild -
770       epsilon is calculated as running avg of distance of sample points
771       from canonical view: m = 1/(AVG(1/r)): some fraction of this
772     */
625 –
626 –  if(!smMesh)
627 –    return;
628 –
629 –
630 –
773    d = DIST(view->vp,SM_VIEW_CENTER(smMesh));
774 <  if(qual >= 100 && d > SM_ALLOWED_VIEW_CHANGE(smMesh))
774 >  if(qual >= MAXQUALITY  && d > SM_ALLOWED_VIEW_CHANGE(smMesh))
775    {
776        /* Re-build the mesh */
777   #ifdef TEST_DRIVER
# Line 637 | Line 779 | smUpdate(view,qual)
779   #endif  
780        mark_tris_in_frustum(view);
781        smRebuild_mesh(smMesh,view);
782 +      smClean_notify = TRUE;
783    }
784 <  /* This is our final update iff qual==100 and view==&odev.v */
785 <  last_update = qual>=100 && view==&(odev.v);
784 >  /* This is our final update iff qual==MAXQUALITY and view==&odev.v */
785 >  last_update = qual>=MAXQUALITY && view==&(odev.v);
786    /* Check if we should draw ALL triangles in current frustum */
787 <  if(smClean_notify || smNew_tri_cnt > SM_SAMPLE_TRIS(smMesh)*SM_INC_PERCENT)
787 >  if(smClean_notify || smNew_tri_cnt>SM_SAMPLE_TRIS(smMesh)*SM_INC_PERCENT)
788    {
789   #ifdef TEST_DRIVER
790      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
791   #else
792 <    if ( SM_TONE_MAP(smMesh) < SM_NUM_SAMP(smMesh))
792 >    if (SM_TONE_MAP(smMesh) < SM_NUM_SAMP(smMesh))
793      {
794         tmClearHisto();
795         tmAddHisto(SM_BRT(smMesh),SM_NUM_SAMP(smMesh),1);
796 <       tmComputeMapping(0.,0.,0.);
796 >       if(tmComputeMapping(0.,0.,0.) != TM_E_OK)
797 >         return;
798         tmMapPixels(SM_RGB(smMesh),SM_BRT(smMesh),SM_CHR(smMesh),
799                     SM_NUM_SAMP(smMesh));
800      }
801   #endif
802      mark_tris_in_frustum(view);
803 <    if (qual <= 75)
803 >    if (qual <= (MAXQUALITY*3/4))
804          smRender_stree(smMesh,qual);
805      else
806 <        smRender_mesh(smMesh,view->vp,last_update);
806 >        smRender_mesh(smMesh,view->vp);
807   #ifdef TEST_DRIVER
808      glFlush();
809      glutSwapBuffers();
# Line 681 | Line 825 | smUpdate(view,qual)
825          if(tmComputeMapping(0.,0.,0.) != TM_E_OK)
826             return;
827      }
828 <    tmMapPixels(SM_NTH_RGB(smMesh,t),&SM_NTH_BRT(smMesh,t),
828 >      tmMapPixels(SM_NTH_RGB(smMesh,t),&SM_NTH_BRT(smMesh,t),
829                     SM_NTH_CHR(smMesh,t), SM_NUM_SAMP(smMesh)-t);
830          
831   #endif    
# Line 703 | Line 847 | smUpdate(view,qual)
847    }
848  
849   }
850 +
851 +
852 +
853 +
854 +
855 +
856 +
857 +

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines