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.15 by greg, Tue Oct 26 19:04:32 2004 UTC vs.
Revision 2.27 by greg, Mon Aug 12 18:57:00 2024 UTC

# Line 12 | Line 12 | static const char      RCSid[] = "$Id$";
12   #include  "ray.h"
13   #include  "view.h"
14   #include  "otypes.h"
15 + #include  "otspecial.h"
16   #include  "source.h"
17  
18  
# Line 70 | 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 102 | 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 151 | 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 179 | 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 198 | 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 229 | 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 263 | 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 293 | 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 324 | 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) != VL_GOOD)
330                                  return(0);              /* in front of view */
331                          sp[j][0] = ip[0]; sp[j][1] = ip[1];
332                  }
# Line 348 | 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) != VL_GOOD)
354                          return(0);              /* in front of view */
355                  pt[j][0] = ip[0]; pt[j][1] = ip[1];
356          }
# Line 358 | 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 392 | 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 */
398 >        COLORV  *pic[],                         /* subimage pixel value array */
399 >        RGBPRIMP primp,                         /* output primaries */
400          float   *zbf[],                         /* subimage distance array (opt.) */
401          int     x0,                             /* origin and size of subimage */
402          int     xsiz,
# Line 402 | Line 404 | drawsources(
404          int     ysiz
405   )
406   {
407 <        RREAL   spoly[MAXVERT][2], ppoly[MAXVERT][2];
408 <        int     nsv, npv;
409 <        int     xmin, xmax, ymin, ymax, x, y;
410 <        RREAL   cxy[2];
411 <        double  w;
412 <        RAY     sr;
413 <        register SPLIST *sp;
414 <        register int    i;
407 >        const int       NC = primp ? 3 : NCSAMP;
408 >        RREAL           spoly[MAXVERT][2], ppoly[MAXVERT][2];
409 >        int             nsv, npv;
410 >        int             xmin, xmax, ymin, ymax, x, y;
411 >        RREAL           cxy[2];
412 >        COLOR           rcol;
413 >        double          w;
414 >        RAY             sr;
415 >        SPLIST          *sp;
416 >        int             i;
417                                          /* check each source in our list */
418          for (sp = sphead; sp != NULL; sp = sp->next) {
419                                          /* clip source poly to subimage */
# Line 432 | Line 436 | drawsources(
436                                  ymax = spoly[i][1]*vres - FTINY;
437                  }
438                                          /* evaluate each pixel in BBox */
439 <                for (y = ymin; y <= ymax; y++)
440 <                        for (x = xmin; x <= xmax; x++) {
439 >                for (y = ymin; y <= ymax; y++) {
440 >                        COLORV  *pp = pic[y-y0] + (xmin-x0)*NC;
441 >                        for (x = xmin; x <= xmax; x++, pp += NC) {
442                                                          /* subarea for pixel */
443                                  npv = box_clip_poly(spoly, nsv,
444                                                  (double)x/hres, (x+1.)/hres,
# Line 448 | Line 453 | drawsources(
453                                  if (source[sp->sn].sflags & SSPOT &&
454                                                  spotout(&sr, source[sp->sn].sl.s))
455                                          continue;       /* outside spot */
456 <                                rayorigin(&sr, NULL, SHADOW, 1.0);
456 >                                rayorigin(&sr, SHADOW, NULL, NULL);
457                                  sr.rsrc = sp->sn;
458                                  rayvalue(&sr);          /* compute value */
459 <                                if (bright(sr.rcol) <= FTINY)
459 >                                if (sintens(sr.rcol) <= FTINY)
460                                          continue;       /* missed/blocked */
461 +                                if (NC == 3)
462 +                                        scolor_out(rcol, primp, sr.rcol);
463                                                          /* modify pixel */
464                                  w = poly_area(ppoly, npv) * hres * vres;
465                                  if (zbf[y-y0] != NULL &&
466 <                                                sr.rt < 0.99*zbf[y-y0][x-x0]) {
467 <                                        zbf[y-y0][x-x0] = sr.rt;
468 <                                } else if (!bigdiff(sr.rcol, pic[y-y0][x-x0],
469 <                                                0.01)) { /* source sample */
470 <                                        scalecolor(pic[y-y0][x-x0], w);
466 >                                                sr.rxt < 0.99*zbf[y-y0][x-x0]) {
467 >                                        zbf[y-y0][x-x0] = sr.rxt;
468 >                                } else if (NC == 3) {
469 >                                        if (!bigdiff(rcol, pp, 0.07)) {
470 >                                                scalecolor(pp, w);
471 >                                                continue;
472 >                                        }
473 >                                } else if (!sbigsdiff(sr.rcol, pp, 0.07)) {
474 >                                        scalescolor(pp, w);
475                                          continue;
476                                  }
477 <                                scalecolor(sr.rcol, w);
478 <                                scalecolor(pic[y-y0][x-x0], 1.-w);
479 <                                addcolor(pic[y-y0][x-x0], sr.rcol);
477 >                                if (NC == 3) {
478 >                                        scalecolor(rcol, w);
479 >                                        scalecolor(pp, 1.-w);
480 >                                        addcolor(pp, rcol);
481 >                                } else {
482 >                                        scalescolor(sr.rcol, w);
483 >                                        scalescolor(pp, 1.-w);
484 >                                        saddscolor(pp, sr.rcol);
485 >                                }
486                          }
487 +                }
488          }
489   }

Diff Legend

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