ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/Development/ray/src/rt/srcsupp.c
(Generate patch)

Comparing ray/src/rt/srcsupp.c (file contents):
Revision 1.14 by greg, Mon Oct 21 12:58:16 1991 UTC vs.
Revision 2.2 by greg, Sat Jan 4 19:54:20 1992 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1991 Regents of the University of California */
1 > /* Copyright (c) 1992 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 174 | Line 174 | register OBJREC  *so;
174          for (i = 0; i < 3; i++)
175                  src->ss[SU][i] = src->ss[SV][i] = src->ss[SW][i] = 0.0;
176          for (i = 0; i < 3; i++)
177 <                src->ss[i][i] = .886227 * so->oargs.farg[3];
177 >                src->ss[i][i] = .7236 * so->oargs.farg[3];
178   }
179  
180  
# Line 212 | Line 212 | OBJREC  *so;
212          co = getcone(so, 0);
213          if (CO_R0(co) > .2*co->al)              /* heuristic constraint */
214                  objerror(so, WARNING, "source aspect too small");
215 +        src->sflags |= SCYL;
216          for (i = 0; i < 3; i++)
217                  src->sloc[i] = .5 * (CO_P1(co)[i] + CO_P0(co)[i]);
218 <        src->srad = co->al;
218 >        src->srad = .5*co->al;
219          src->ss2 = 2.*CO_R0(co)*co->al;
220                                                  /* set sampling vectors */
221          for (i = 0; i < 3; i++)
# Line 227 | Line 228 | OBJREC  *so;
228          fcross(src->ss[SW], src->ss[SV], co->ad);
229          normalize(src->ss[SW]);
230          for (i = 0; i < 3; i++)
231 <                src->ss[SW][i] *= .886227 * CO_R0(co);
231 >                src->ss[SW][i] *= .8559 * CO_R0(co);
232          fcross(src->ss[SV], src->ss[SW], co->ad);
233   }
234  
# Line 499 | Line 500 | register RAY  *r;
500   }
501  
502  
503 < #define  wrongsource(m, r)      (r->rsrc>=0 && \
504 <                                source[r->rsrc].so!=r->ro && \
505 <                                (m->otype!=MAT_ILLUM || \
506 <                        objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM))
503 > /****************************************************************
504 > * The following macros were separated from the m_light() routine
505 > * because they are very nasty and difficult to understand.
506 > */
507  
508 + /* wrongillum *
509 + *
510 + * We cannot allow an illum to pass to another illum, because that
511 + * would almost certainly constitute overcounting.
512 + * However, we do allow an illum to pass to another illum
513 + * that is actually going to relay to a virtual light source.
514 + */
515 +
516 + #define  wrongillum(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
517 +                        objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM)
518 +
519 + /* wrongsource *
520 + *
521 + * This source is the wrong source (ie. overcounted) if we are
522 + * aimed to a different source than the one we hit and the one
523 + * we hit is not an illum which should be passed.
524 + */
525 +
526 + #define  wrongsource(m, r)      (r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
527 +                                (m->otype!=MAT_ILLUM || wrongillum(m,r)))
528 +
529 + /* badspecular *
530 + *
531 + * Any undirected specular ray that hits a light source
532 + * should be discarded.  This is because the source contribution to
533 + * specular components is calculated separately to reduce variance.
534 + */
535 +
536 + #define  badspecular(m, r)      (r->rsrc<0 && r->crtype&SPECULAR)
537 +
538 + /* distglow *
539 + *
540 + * A distant glow is an object that sometimes acts as a light source,
541 + * but is too far away from the test point to be one in this case.
542 + */
543 +
544   #define  distglow(m, r)         (m->otype==MAT_GLOW && \
545                                  r->rot > m->oargs.farg[3])
546  
547 + /* badambient *
548 + *
549 + * We must avoid including counting light sources in the ambient calculation,
550 + * since the direct component is handled separately.  Therefore, any
551 + * ambient ray which hits an active light source must be discarded.
552 + */
553 +
554   #define  badambient(m, r)       ((r->crtype&(AMBIENT|SHADOW))==AMBIENT && \
555                                  !distglow(m, r))
556  
557 + /* overcount *
558 + *
559 + * All overcounting possibilities are contained here.
560 + */
561 +
562 + #define  overcount(m, r)        (badspecular(m,r) || wrongsource(m,r) || \
563 +                                badambient(m,r))
564 +
565 + /* passillum *
566 + *
567 + * An illum passes to another material type when we didn't hit it
568 + * on purpose (as part of a direct calculation), or it is relaying
569 + * a virtual light source.
570 + */
571 +
572   #define  passillum(m, r)        (m->otype==MAT_ILLUM && \
573 <                                !(r->rsrc>=0&&source[r->rsrc].so==r->ro))
573 >                                (r->rsrc<0 || source[r->rsrc].so!=r->ro || \
574 >                                source[r->rsrc].sflags&SVIRTUAL))
575  
576 + /* srcignore *
577 + *
578 + * The -di flag renders light sources invisible, and here is the test.
579 + */
580 +
581   #define  srcignore(m, r)        (directinvis && !(r->crtype&SHADOW) && \
582                                  !distglow(m, r))
583  
# Line 522 | Line 587 | register OBJREC  *m;
587   register RAY  *r;
588   {
589                                                  /* check for over-counting */
590 <        if (wrongsource(m, r) || badambient(m, r))
590 >        if (overcount(m, r))
591                  return;
592                                                  /* check for passed illum */
593          if (passillum(m, r)) {

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)