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

Comparing ray/src/rt/srcdraw.c (file contents):
Revision 2.13 by greg, Thu Sep 2 16:02:56 2004 UTC vs.
Revision 2.20 by greg, Tue Nov 13 19:58:33 2018 UTC

# Line 11 | Line 11 | static const char      RCSid[] = "$Id$";
11  
12   #include  "ray.h"
13   #include  "view.h"
14 + #include  "otypes.h"
15 + #include  "otspecial.h"
16   #include  "source.h"
17  
18  
# Line 69 | Line 71 | inregion(                      /* check if vertex is in region */
71  
72   static void
73   clipregion(             /* find intersection with boundary */
74 <        register RREAL  a[2],
75 <        register RREAL  b[2],
74 >        RREAL   a[2],
75 >        RREAL   b[2],
76          double  cv,
77          int     crit,
78          RREAL   r[2]    /* return value */
# Line 101 | Line 103 | hp_clip_poly(  /* clip polygon to half-plane */
103   )
104   {
105          RREAL   *s, *p;
106 <        register int    j, nvo;
106 >        int     j, nvo;
107  
108          s = vl[nv-1];
109          nvo = 0;
# Line 150 | Line 152 | minw2(                 /* compute square of minimum width */
152   )
153   {
154          double  d2, w2, w2min, w2max;
155 <        register RREAL  *p0, *p1, *p2;
155 >        RREAL   *p0, *p1, *p2;
156          int     i, j;
157                                  /* find minimum for all widths */
158          w2min = FHUGE;
# Line 178 | Line 180 | minw2(                 /* compute square of minimum width */
180  
181   static void
182   convex_center(          /* compute center of convex polygon */
183 <        register RREAL  vl[][2],
183 >        RREAL   vl[][2],
184          int     nv,
185          RREAL   cv[2]           /* return value */
186   )
187   {
188 <        register int    i;
188 >        int     i;
189                                          /* simple average (suboptimal) */
190          cv[0] = cv[1] = 0.;
191          for (i = 0; i < nv; i++) {
# Line 197 | Line 199 | convex_center(         /* compute center of convex polygon */
199  
200   static double
201   poly_area(                      /* compute area of polygon */
202 <        register RREAL  vl[][2],
202 >        RREAL   vl[][2],
203          int     nv
204   )
205   {
206          double  a;
207          RREAL   v0[2], v1[2];
208 <        register int    i;
208 >        int     i;
209  
210          a = 0.;
211          v0[0] = vl[1][0] - vl[0][0];
# Line 228 | Line 230 | convex_hull(           /* compute polygon's convex hull */
230          int     nvo, nvt;
231          RREAL   vlt[MAXVERT][2];
232          double  voa, vta;
233 <        register int    i, j;
233 >        int     i, j;
234                                          /* start with original polygon */
235          for (i = nvo = nv; i--; ) {
236                  vlo[i][0] = vl[i][0]; vlo[i][1] = vl[i][1];
# Line 262 | Line 264 | spinsert(                      /* insert new source polygon */
264          int     nv
265   )
266   {
267 <        register SPLIST *spn;
268 <        register int    i;
267 >        SPLIST  *spn;
268 >        int     i;
269  
270          if (nv < 3)
271                  return;
# Line 292 | Line 294 | sourcepoly(                    /* compute image polygon for source */
294                                           {0,1,3,7,6,4},{0,1,5,7,6,2},
295                                           {0,2,6,7,5,1},{0,4,6,7,3,1},
296                                           {0,2,3,7,5,4},{1,5,4,6,2,3}};
297 <        register SRCREC *s = source + sn;
297 >        SRCREC  *s = source + sn;
298          FVECT   ap, ip;
299          RREAL   pt[6][2];
300          int     dir;
301 <        register int    i, j;
301 >        int     i, j;
302  
303          if (s->sflags & (SDISTANT|SFLAT)) {
304                  if (s->sflags & SDISTANT) {
# Line 323 | Line 325 | sourcepoly(                    /* compute image polygon for source */
325                                          ap[i] += ourview.vp[i];
326                                  }
327                          }
328 <                        viewloc(ip, &ourview, ap);      /* find image point */
329 <                        if (ip[2] <= 0.)
328 >                                                        /* find image point */
329 >                        if (viewloc(ip, &ourview, ap) <= 0)
330                                  return(0);              /* in front of view */
331                          sp[j][0] = ip[0]; sp[j][1] = ip[1];
332                  }
# Line 347 | Line 349 | sourcepoly(                    /* compute image polygon for source */
349                          if (cubeord[dir][j] & 4) ap[i] += s->ss[SW][i];
350                          else ap[i] -= s->ss[SW][i];
351                  }
352 <                viewloc(ip, &ourview, ap);      /* find image point */
353 <                if (ip[2] <= 0.)
352 >                                                /* find image point */
353 >                if (viewloc(ip, &ourview, ap) <= 0)
354                          return(0);              /* in front of view */
355                  pt[j][0] = ip[0]; pt[j][1] = ip[1];
356          }
# Line 357 | Line 359 | sourcepoly(                    /* compute image polygon for source */
359  
360  
361                          /* initialize by finding sources smaller than rad */
362 < extern void
362 > void
363   init_drawsources(
364          int     rad                             /* source sample size */
365   )
366   {
367          RREAL   spoly[MAXVERT][2];
368          int     nsv;
369 <        register SPLIST *sp;
370 <        register int    i;
369 >        SPLIST  *sp;
370 >        int     i;
371                                          /* free old source list if one */
372          for (sp = sphead; sp != NULL; sp = sphead) {
373                  sphead = sp->next;
# Line 373 | Line 375 | init_drawsources(
375          }
376                                          /* loop through all sources */
377          for (i = nsources; i--; ) {
378 +                                        /* skip illum's */
379 +                if (findmaterial(source[i].so)->otype == MAT_ILLUM)
380 +                        continue;
381                                          /* compute image polygon for source */
382                  if (!(nsv = sourcepoly(i, spoly)))
383                          continue;
# Line 388 | Line 393 | init_drawsources(
393          }
394   }
395  
396 < extern void                     /* add sources smaller than rad to computed subimage */
396 > void                            /* add sources smaller than rad to computed subimage */
397   drawsources(
398          COLOR   *pic[],                         /* subimage pixel value array */
399          float   *zbf[],                         /* subimage distance array (opt.) */
# Line 404 | Line 409 | drawsources(
409          RREAL   cxy[2];
410          double  w;
411          RAY     sr;
412 <        register SPLIST *sp;
413 <        register int    i;
412 >        SPLIST  *sp;
413 >        int     i;
414                                          /* check each source in our list */
415          for (sp = sphead; sp != NULL; sp = sp->next) {
416                                          /* clip source poly to subimage */
# Line 444 | Line 449 | drawsources(
449                                  if (source[sp->sn].sflags & SSPOT &&
450                                                  spotout(&sr, source[sp->sn].sl.s))
451                                          continue;       /* outside spot */
452 <                                w = poly_area(ppoly, npv) * hres * vres;
453 <                                if (w < .95) {          /* subpixel source */
449 <                                        rayorigin(&sr, NULL, SHADOW, 1.0);
450 <                                        sr.rsrc = sp->sn;
451 <                                } else
452 <                                        rayorigin(&sr, NULL, PRIMARY, 1.0);
452 >                                rayorigin(&sr, SHADOW, NULL, NULL);
453 >                                sr.rsrc = sp->sn;
454                                  rayvalue(&sr);          /* compute value */
455                                  if (bright(sr.rcol) <= FTINY)
456                                          continue;       /* missed/blocked */
457                                                          /* modify pixel */
458 +                                w = poly_area(ppoly, npv) * hres * vres;
459                                  if (zbf[y-y0] != NULL &&
460 <                                                sr.rt < 0.99*zbf[y-y0][x-x0]) {
461 <                                        zbf[y-y0][x-x0] = sr.rt;
460 >                                                sr.rxt < 0.99*zbf[y-y0][x-x0]) {
461 >                                        zbf[y-y0][x-x0] = sr.rxt;
462                                  } else if (!bigdiff(sr.rcol, pic[y-y0][x-x0],
463                                                  0.01)) { /* source sample */
464                                          scalecolor(pic[y-y0][x-x0], w);

Diff Legend

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