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

Comparing ray/src/rt/source.c (file contents):
Revision 2.8 by greg, Sat Nov 14 13:58:23 1992 UTC vs.
Revision 2.17 by greg, Thu Nov 2 17:37:58 1995 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1992 Regents of the University of California */
1 > /* Copyright (c) 1995 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 68 | Line 68 | marksources()                  /* find and mark source objects */
68                                  o->otype != OBJ_SOURCE &&
69                                  m->oargs.farg[3] <= FTINY)
70                          continue;                       /* don't bother */
71 +                if (m->oargs.farg[0] <= FTINY && m->oargs.farg[1] <= FTINY &&
72 +                                m->oargs.farg[2] <= FTINY)
73 +                        continue;                       /* don't bother */
74  
75                  if (sfun[o->otype].of == NULL ||
76                                  sfun[o->otype].of->setsrc == NULL)
# Line 152 | Line 155 | SRCINDEX  *si;                 /* source sample index */
155  
156  
157   srcvalue(r)                     /* punch ray to source and compute value */
158 < RAY  *r;
158 > register RAY  *r;
159   {
160          register SRCREC  *sp;
161  
# Line 161 | Line 164 | RAY  *r;
164                                          /* check intersection */
165                  if (!(*ofun[sp->so->otype].funp)(sp->so, r))
166                          return;
167 <                raycont(r);             /* compute contribution */
167 >                if (!rayshade(r, r->ro->omod))  /* compute contribution */
168 >                        goto nomat;
169                  return;
170          }
171                                          /* compute intersection */
# Line 169 | Line 173 | RAY  *r;
173                          (*ofun[sp->so->otype].funp)(sp->so, r)) {
174                  if (sp->sa.success >= 0)
175                          sp->sa.success++;
176 <                raycont(r);             /* compute contribution */
176 >                if (!rayshade(r, r->ro->omod))  /* compute contribution */
177 >                        goto nomat;
178                  return;
179          }
180 +                                        /* we missed our mark! */
181          if (sp->sa.success < 0)
182                  return;                 /* bitched already */
183          sp->sa.success -= AIMREQT;
# Line 180 | Line 186 | RAY  *r;
186          sprintf(errmsg, "aiming failure for light source \"%s\"",
187                          sp->so->oname);
188          error(WARNING, errmsg);         /* issue warning */
189 +        return;
190 + nomat:
191 +        objerror(r->ro, USER, "material not found");
192   }
193  
194  
# Line 299 | Line 308 | char  *p;                      /* data for f */
308                                                  /* modify threshold */
309          ourthresh = shadthresh / r->rweight;
310                                                  /* test for shadows */
311 <        nhits = 0;
312 <        for (sn = 0; sn < ncnts; sn++) {
311 >        for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
312 >                        hwt += (double)source[scp->sno].nhits /
313 >                                (double)source[scp->sno].ntests,
314 >                        sn++) {
315                                                  /* check threshold */
316                  if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
317                                  cntord[sn].brt-cntord[sn+nshadcheck].brt)
# Line 316 | Line 327 | char  *p;                      /* data for f */
327                                  ( sr.ro != source[scp->sno].so ||
328                                  source[scp->sno].sflags & SFOLLOW )) {
329                                                  /* follow entire path */
330 <                        raycont(&sr);
330 >                        if (!raycont(&sr))
331 >                                objerror(sr.ro, USER, "material not found");
332                          if (trace != NULL)
333                                  (*trace)(&sr);  /* trace execution */
334                          if (bright(sr.rcol) <= FTINY)
# Line 329 | Line 341 | char  *p;                      /* data for f */
341                  nhits++;
342                  source[scp->sno].nhits++;
343          }
344 <                                        /* surface hit rate */
345 <        if (sn > 0)
346 <                hwt = (double)nhits / (double)sn;
344 >                                        /* source hit rate */
345 >        if (hwt > FTINY)
346 >                hwt = (double)nhits / hwt;
347          else
348                  hwt = 0.5;
349   #ifdef DEBUG
350 <        sprintf(errmsg, "%d tested, %d untested, %f hit rate\n",
350 >        sprintf(errmsg, "%d tested, %d untested, %f conditional hit rate\n",
351                          sn, ncnts-sn, hwt);
352          eputs(errmsg);
353   #endif
# Line 344 | Line 356 | char  *p;                      /* data for f */
356                  scp = srccnt + cntord[sn].sndx;
357                  prob = hwt * (double)source[scp->sno].nhits /
358                                  (double)source[scp->sno].ntests;
359 +                if (prob > 1.0)
360 +                        prob = 1.0;
361                  scalecolor(scp->val, prob);
362                  addcolor(r->rcol, scp->val);
363          }
# Line 355 | Line 369 | char  *p;                      /* data for f */
369   * because they are very nasty and difficult to understand.
370   */
371  
372 < /* wrongillum *
372 > /* illumblock *
373   *
374   * We cannot allow an illum to pass to another illum, because that
375   * would almost certainly constitute overcounting.
376   * However, we do allow an illum to pass to another illum
377   * that is actually going to relay to a virtual light source.
378 + * We also prevent an illum from passing to a glow; this provides a
379 + * convenient mechanism for defining detailed light source
380 + * geometry behind (or inside) an effective radiator.
381   */
382  
383 < #define  wrongillum(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
384 <                        objptr(source[r->rsrc].so->omod)->otype==MAT_ILLUM)
383 > static int weaksrcmod(obj) int obj;     /* efficiency booster function */
384 > {register OBJREC *o = objptr(obj);
385 > return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
386  
387 + #define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
388 +                                r->rod > 0.0 && \
389 +                                weaksrcmod(source[r->rsrc].so->omod))
390 +
391   /* wrongsource *
392   *
393   * This source is the wrong source (ie. overcounted) if we are
394   * aimed to a different source than the one we hit and the one
395 < * we hit is not an illum which should be passed.
395 > * we hit is not an illum that should be passed.
396   */
397  
398   #define  wrongsource(m, r)      (r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
399 <                                (m->otype!=MAT_ILLUM || wrongillum(m,r)))
399 >                                (m->otype!=MAT_ILLUM || illumblock(m,r)))
400  
401   /* distglow *
402   *
403   * A distant glow is an object that sometimes acts as a light source,
404   * but is too far away from the test point to be one in this case.
405 + * (Glows with negative radii should NEVER participate in illumination.)
406   */
407  
408 < #define  distglow(m, r)         (m->otype==MAT_GLOW && \
409 <                                r->rot > m->oargs.farg[3])
408 > #define  distglow(m, r, d)      (m->otype==MAT_GLOW && \
409 >                                m->oargs.farg[3] >= -FTINY && \
410 >                                d > m->oargs.farg[3])
411  
412   /* badcomponent *
413   *
# Line 396 | Line 420 | char  *p;                      /* data for f */
420  
421   #define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
422                                  !(r->crtype&SHADOW || r->rod < 0.0 || \
423 <                                        distglow(m, r)))
423 >                /* not 100% correct */  distglow(m, r, r->rot)))
424  
401 – /* overcount *
402 – *
403 – * All overcounting possibilities are contained here.
404 – */
405 –
406 – #define  overcount(m, r)        (badcomponent(m,r) || wrongsource(m,r))
407 –
425   /* passillum *
426   *
427   * An illum passes to another material type when we didn't hit it
# Line 418 | Line 435 | char  *p;                      /* data for f */
435  
436   /* srcignore *
437   *
438 < * The -di flag renders light sources invisible, and here is the test.
438 > * The -dv flag is normally on for sources to be visible.
439   */
440  
441 < #define  srcignore(m, r)        (directinvis && !(r->crtype&SHADOW) && \
442 <                                !distglow(m, r))
441 > #define  srcignore(m, r)        !(directvis || r->crtype&SHADOW || \
442 >                                distglow(m, r, raydist(r,PRIMARY)))
443  
444  
445   m_light(m, r)                   /* ray hit a light source */
# Line 430 | Line 447 | register OBJREC  *m;
447   register RAY  *r;
448   {
449                                                  /* check for over-counting */
450 <        if (overcount(m, r))
451 <                return;
450 >        if (badcomponent(m, r))
451 >                return(1);
452 >        if (wrongsource(m, r))
453 >                return(1);
454                                                  /* check for passed illum */
455          if (passillum(m, r)) {
456 <                if (m->oargs.nsargs < 1 || !strcmp(m->oargs.sarg[0], VOIDID))
457 <                        raytrans(r);
458 <                else
459 <                        rayshade(r, modifier(m->oargs.sarg[0]));
441 <                return;
456 >                if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
457 >                        return(rayshade(r, modifier(m->oargs.sarg[0])));
458 >                raytrans(r);
459 >                return(1);
460          }
461                                          /* otherwise treat as source */
462                                                  /* check for behind */
463          if (r->rod < 0.0)
464 <                return;
464 >                return(1);
465                                                  /* check for invisibility */
466          if (srcignore(m, r))
467 <                return;
467 >                return(1);
468                                                  /* check for outside spot */
469          if (m->otype==MAT_SPOT && spotout(r, makespot(m), r->rot>=FHUGE))
470 <                return;
470 >                return(1);
471                                                  /* get distribution pattern */
472          raytexture(r, m->omod);
473                                                  /* get source color */
# Line 458 | Line 476 | register RAY  *r;
476                            m->oargs.farg[2]);
477                                                  /* modify value */
478          multcolor(r->rcol, r->pcol);
479 +        return(1);
480   }

Diff Legend

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