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 1.46 by greg, Mon Oct 21 14:23:36 1991 UTC vs.
Revision 2.16 by greg, Tue Apr 25 19:51:38 1995 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1991 Regents of the University of California */
1 > /* Copyright (c) 1993 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 41 | Line 41 | static int  maxcntr = 0;               /* size of contribution arra
41  
42   marksources()                   /* find and mark source objects */
43   {
44 +        int  foundsource = 0;
45          int  i;
46          register OBJREC  *o, *m;
47          register int  ns;
# Line 67 | 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 80 | Line 84 | marksources()                  /* find and mark source objects */
84                  if (m->otype == MAT_GLOW) {
85                          source[ns].sflags |= SPROX;
86                          source[ns].sl.prox = m->oargs.farg[3];
87 <                        if (o->otype == OBJ_SOURCE)
87 >                        if (source[ns].sflags & SDISTANT)
88                                  source[ns].sflags |= SSKIP;
89                  } else if (m->otype == MAT_SPOT) {
90                          source[ns].sflags |= SSPOT;
# Line 93 | Line 97 | marksources()                  /* find and mark source objects */
97                                  source[ns].sflags |= SSKIP;
98                          }
99                  }
100 +                if (!(source[ns].sflags & SSKIP))
101 +                        foundsource++;
102          }
103 <        if (nsources <= 0) {
103 >        if (!foundsource) {
104                  error(WARNING, "no light sources found");
105                  return;
106          }
107          markvirtuals();                 /* find and add virtual sources */
108                                  /* allocate our contribution arrays */
109 <        maxcntr = nsources + MAXSPART*2;        /* start with this many */
109 >        maxcntr = nsources + MAXSPART;  /* start with this many */
110          srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
111          cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
112 <        if (srccnt == NULL || cntord == NULL)
112 >        if (srccnt == NULL | cntord == NULL)
113                  goto memerr;
114          return;
115   memerr:
# Line 117 | Line 123 | RAY  *r;                       /* ray which hit object */
123   SRCINDEX  *si;                  /* source sample index */
124   {
125      double  d;                          /* distance to source */
120 –    FVECT  vd;
126      register SRCREC  *srcp;
122 –    register int  i;
127  
128      rayorigin(sr, r, SHADOW, 1.0);              /* ignore limits */
129  
130 <    while ((d = nextssamp(sr->rorg, sr->rdir, si)) != 0.0) {
130 >    while ((d = nextssamp(sr, si)) != 0.0) {
131          sr->rsrc = si->sn;                      /* remember source */
132          srcp = source + si->sn;
133          if (srcp->sflags & SDISTANT) {
134 <                if (srcp->sflags & SSPOT) {     /* check location */
135 <                        for (i = 0; i < 3; i++)
132 <                            vd[i] = srcp->sl.s->aim[i] - sr->rorg[i];
133 <                        d = DOT(sr->rdir,vd);
134 <                        if (d <= FTINY)
135 <                                continue;
136 <                        d = DOT(vd,vd) - d*d;
137 <                        if (PI*d > srcp->sl.s->siz)
138 <                                continue;
139 <                }
134 >                if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s, 1))
135 >                        continue;
136                  return(1);              /* sample OK */
137          }
138                                  /* local source */
# Line 145 | Line 141 | SRCINDEX  *si;                 /* source sample index */
141                  continue;
142                                                  /* check angle */
143          if (srcp->sflags & SSPOT) {
144 <                if (srcp->sl.s->siz < 2.0*PI *
149 <                                (1.0 + DOT(srcp->sl.s->aim,sr->rdir)))
144 >                if (spotout(sr, srcp->sl.s, 0))
145                          continue;
146                                          /* adjust solid angle */
147                  si->dom *= d*d;
# Line 160 | 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 169 | 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 177 | 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 188 | 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  
195 + sourcehit(r)                    /* check to see if ray hit distant source */
196 + register RAY  *r;
197 + {
198 +        int  first, last;
199 +        register int  i;
200 +
201 +        if (r->rsrc >= 0) {             /* check only one if aimed */
202 +                first = last = r->rsrc;
203 +        } else {                        /* otherwise check all */
204 +                first = 0; last = nsources-1;
205 +        }
206 +        for (i = first; i <= last; i++)
207 +                if ((source[i].sflags & (SDISTANT|SVIRTUAL)) == SDISTANT)
208 +                        /*
209 +                         * Check to see if ray is within
210 +                         * solid angle of source.
211 +                         */
212 +                        if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
213 +                                        <= source[i].ss2) {
214 +                                r->ro = source[i].so;
215 +                                if (!(source[i].sflags & SSKIP))
216 +                                        break;
217 +                        }
218 +
219 +        if (r->ro != NULL) {
220 +                for (i = 0; i < 3; i++)
221 +                        r->ron[i] = -r->rdir[i];
222 +                r->rod = 1.0;
223 +                r->rox = NULL;
224 +                return(1);
225 +        }
226 +        return(0);
227 + }
228 +
229 +
230   static int
231   cntcmp(sc1, sc2)                        /* contribution compare (descending) */
232   register CNTPTR  *sc1, *sc2;
# Line 209 | Line 245 | int  (*f)();                   /* direct component coefficient functio
245   char  *p;                       /* data for f */
246   {
247          extern int  (*trace)();
212 –        extern double  pow();
248          register int  sn;
249 +        register CONTRIB  *scp;
250          SRCINDEX  si;
251          int  nshadcheck, ncnts;
252          int  nhits;
# Line 228 | Line 264 | char  *p;                      /* data for f */
264                                          maxcntr*sizeof(CONTRIB));
265                          cntord = (CNTPTR *)realloc((char *)cntord,
266                                          maxcntr*sizeof(CNTPTR));
267 <                        if (srccnt == NULL || cntord == NULL)
267 >                        if (srccnt == NULL | cntord == NULL)
268                                  error(SYSTEM, "out of memory in direct");
269                  }
270                  cntord[sn].sndx = sn;
271 <                srccnt[sn].sno = sr.rsrc;
271 >                scp = srccnt + sn;
272 >                scp->sno = sr.rsrc;
273                                                  /* compute coefficient */
274 <                (*f)(srccnt[sn].coef, p, sr.rdir, si.dom);
275 <                cntord[sn].brt = bright(srccnt[sn].coef);
274 >                (*f)(scp->coef, p, sr.rdir, si.dom);
275 >                cntord[sn].brt = bright(scp->coef);
276                  if (cntord[sn].brt <= 0.0)
277                          continue;
278 <                VCOPY(srccnt[sn].dir, sr.rdir);
278 >                VCOPY(scp->dir, sr.rdir);
279                                                  /* compute potential */
280                  sr.revf = srcvalue;
281                  rayvalue(&sr);
282 <                copycolor(srccnt[sn].val, sr.rcol);
283 <                multcolor(srccnt[sn].val, srccnt[sn].coef);
284 <                cntord[sn].brt = bright(srccnt[sn].val);
282 >                copycolor(scp->val, sr.rcol);
283 >                multcolor(scp->val, scp->coef);
284 >                cntord[sn].brt = bright(scp->val);
285          }
286                                                  /* sort contributions */
287          qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
# Line 261 | Line 298 | char  *p;                      /* data for f */
298                          l = m;
299                  }
300          }
301 +        if (ncnts == 0)
302 +                return;         /* no contributions! */
303                                                  /* accumulate tail */
304          for (sn = ncnts-1; sn > 0; sn--)
305                  cntord[sn-1].brt += cntord[sn].brt;
# Line 269 | 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)
318                                  < ourthresh*bright(r->rcol))
319                          break;
320 +                scp = srccnt + cntord[sn].sndx;
321                                                  /* test for hit */
322                  rayorigin(&sr, r, SHADOW, 1.0);
323 <                VCOPY(sr.rdir, srccnt[cntord[sn].sndx].dir);
324 <                sr.rsrc = srccnt[cntord[sn].sndx].sno;
325 <                source[sr.rsrc].ntests++;       /* keep statistics */
323 >                VCOPY(sr.rdir, scp->dir);
324 >                sr.rsrc = scp->sno;
325 >                source[scp->sno].ntests++;      /* keep statistics */
326                  if (localhit(&sr, &thescene) &&
327 <                                ( sr.ro != source[sr.rsrc].so ||
328 <                                source[sr.rsrc].sflags & SFOLLOW )) {
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)
335                                  continue;       /* missed! */
336 <                        copycolor(srccnt[cntord[sn].sndx].val, sr.rcol);
337 <                        multcolor(srccnt[cntord[sn].sndx].val,
295 <                                        srccnt[cntord[sn].sndx].coef);
336 >                        copycolor(scp->val, sr.rcol);
337 >                        multcolor(scp->val, scp->coef);
338                  }
339                                                  /* add contribution if hit */
340 <                addcolor(r->rcol, srccnt[cntord[sn].sndx].val);
340 >                addcolor(r->rcol, scp->val);
341                  nhits++;
342 <                source[sr.rsrc].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
354                                          /* add in untested sources */
355          for ( ; sn < ncnts; sn++) {
356 <                sr.rsrc = srccnt[cntord[sn].sndx].sno;
357 <                prob = hwt * (double)source[sr.rsrc].nhits /
358 <                                (double)source[sr.rsrc].ntests;
359 <                scalecolor(srccnt[cntord[sn].sndx].val, prob);
360 <                addcolor(r->rcol, srccnt[cntord[sn].sndx].val);
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          }
364 + }
365 +
366 +
367 + /****************************************************************
368 + * The following macros were separated from the m_light() routine
369 + * because they are very nasty and difficult to understand.
370 + */
371 +
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 + 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 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 || 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 +                                m->oargs.farg[3] >= -FTINY && \
410 +                                r->rot > m->oargs.farg[3])
411 +
412 + /* badcomponent *
413 + *
414 + * We must avoid counting light sources in the ambient calculation,
415 + * since the direct component is handled separately.  Therefore, any
416 + * ambient ray which hits an active light source must be discarded.
417 + * The same is true for stray specular samples, since the specular
418 + * contribution from light sources is calculated separately.
419 + */
420 +
421 + #define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
422 +                                !(r->crtype&SHADOW || r->rod < 0.0 || \
423 +                                        distglow(m, r)))
424 +
425 + /* passillum *
426 + *
427 + * An illum passes to another material type when we didn't hit it
428 + * on purpose (as part of a direct calculation), or it is relaying
429 + * a virtual light source.
430 + */
431 +
432 + #define  passillum(m, r)        (m->otype==MAT_ILLUM && \
433 +                                (r->rsrc<0 || source[r->rsrc].so!=r->ro || \
434 +                                source[r->rsrc].sflags&SVIRTUAL))
435 +
436 + /* srcignore *
437 + *
438 + * The -dv flag is normally on for sources to be visible.
439 + */
440 +
441 + #define  srcignore(m, r)        (!directvis && !(r->crtype&SHADOW) && \
442 +                                !distglow(m, r))
443 +
444 +
445 + m_light(m, r)                   /* ray hit a light source */
446 + register OBJREC  *m;
447 + register RAY  *r;
448 + {
449 +                                                /* check for over-counting */
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 && 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(1);
465 +                                                /* check for invisibility */
466 +        if (srcignore(m, r))
467 +                return(1);
468 +                                                /* check for outside spot */
469 +        if (m->otype==MAT_SPOT && spotout(r, makespot(m), r->rot>=FHUGE))
470 +                return(1);
471 +                                                /* get distribution pattern */
472 +        raytexture(r, m->omod);
473 +                                                /* get source color */
474 +        setcolor(r->rcol, m->oargs.farg[0],
475 +                          m->oargs.farg[1],
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