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

Comparing ray/src/rt/rv3.c (file contents):
Revision 2.27 by greg, Fri Sep 5 19:45:41 2008 UTC vs.
Revision 2.46 by greg, Tue Dec 3 19:36:58 2024 UTC

# Line 13 | Line 13 | static const char      RCSid[] = "$Id$";
13  
14   #include  "ray.h"
15   #include  "rpaint.h"
16 + #include  "otypes.h"
17 + #include  "otspecial.h"
18   #include  "random.h"
19  
20   #ifndef WFLUSH
21 < #define WFLUSH          64              /* flush after this many rays */
21 > #define WFLUSH          64              /* flush after this many primary rays */
22   #endif
23 + #ifndef WFLUSH1
24 + #define WFLUSH1         512             /* or this many total rays */
25 + #endif
26  
27 +
28   #ifdef  SMLFLT
29   #define  sscanvec(s,v)  (sscanf(s,"%f %f %f",v,v+1,v+2)==3)
30   #else
31   #define  sscanvec(s,v)  (sscanf(s,"%lf %lf %lf",v,v+1,v+2)==3)
32   #endif
33  
34 < static unsigned long  niflush;          /* flushes since newimage() */
34 > extern int      ray_pnprocs;
35  
36 + static RNUMBER  niflush;                /* flushes since newimage() */
37 +
38   int
39   getrect(                                /* get a box */
40          char  *s,
# Line 83 | Line 91 | getinterest(           /* get area of interest */
91          double  *mp
92   )
93   {
86 –        int  x, y;
87 –        RAY  thisray;
88 –        int  i;
89 –
94          if (sscanf(s, "%lf", mp) != 1)
95                  *mp = 1.0;
96          else if (*mp < -FTINY)          /* negative zoom is reduction */
# Line 96 | Line 100 | getinterest(           /* get area of interest */
100                  return(-1);
101          }
102          if (!sscanvec(sskip(s), vec)) {
103 +                RAY  thisray;
104 +                int  x, y;
105                  if (dev->getcur == NULL)
106                          return(-1);
107                  (*dev->comout)("Pick view center\n");
# Line 106 | Line 112 | getinterest(           /* get area of interest */
112                          error(COMMAND, "not on image");
113                          return(-1);
114                  }
115 <                if (!direc || ourview.type == VT_PAR) {
115 >                if (!direc | (ourview.type == VT_PAR)) {
116 >                        int     weakhit = 0;
117 >                        FVECT   weakpt;
118                          rayorigin(&thisray, PRIMARY, NULL, NULL);
119 <                        if (!localhit(&thisray, &thescene)) {
120 <                                error(COMMAND, "not a local object");
121 <                                return(-1);
119 >                        while (localhit(&thisray, &thescene)) {
120 >                                OBJREC  *m = NULL;
121 >                                if (thisray.clipset == NULL ||
122 >                                                !inset(thisray.clipset,
123 >                                                            thisray.ro->omod))
124 >                                        m = findmaterial(thisray.ro);
125 >                                if ((m != NULL) & !weakhit &&
126 >                                                istransp(m->otype) &&
127 >                                                m->otype != MAT_MIST) {
128 >                                        weakhit = 1;
129 >                                        VCOPY(weakpt, thisray.rop);
130 >                                } else if (m != NULL && !istransp(m->otype) &&
131 >                                                !isBSDFproxy(m))
132 >                                        break;          /* something solid */
133 >                                VCOPY(thisray.rorg, thisray.rop);
134 >                                rayclear(&thisray);     /* skip invisible */
135                          }
136 +                        if ((thisray.ro == NULL) | (thisray.ro == &Aftplane)) {
137 +                                if (!weakhit) {
138 +                                        error(COMMAND, "not a local object");
139 +                                        return(-1);
140 +                                }                       /* else use weak obj. */
141 +                                VCOPY(thisray.rop, weakpt);
142 +                        }
143                  }
144                  if (direc)
145                          if (ourview.type == VT_PAR)
146 <                                for (i = 0; i < 3; i++)
119 <                                        vec[i] = thisray.rop[i] - ourview.vp[i];
146 >                                VSUB(vec, thisray.rop, ourview.vp);
147                          else
148                                  VCOPY(vec, thisray.rdir);
149                  else
150                          VCOPY(vec, thisray.rop);
151          } else if (direc) {
152 <                for (i = 0; i < 3; i++)
126 <                        vec[i] -= ourview.vp[i];
152 >                VSUB(vec, vec, ourview.vp);
153                  if (normalize(vec) == 0.0) {
154                          error(COMMAND, "point at view origin");
155                          return(-1);
# Line 133 | Line 159 | getinterest(           /* get area of interest */
159   }
160  
161  
162 < float *         /* keep consistent with COLOR typedef */
162 > COLORV *
163   greyof(                         /* convert color to greyscale */
164          COLOR  col
165   )
# Line 172 | Line 198 | paint(                 /* compute and paint a rectangle */
198          PNODE  *p
199   )
200   {
175 –        extern int  ray_pnprocs;
176 –        static unsigned long  lastflush = 0;
201          static RAY  thisray;
178 –        int     flushintvl;
202          double  h, v;
203  
204 <        if (p->xmax - p->xmin <= 0 || p->ymax - p->ymin <= 0) { /* empty */
204 >        if ((p->xmax <= p->xmin) | (p->ymax <= p->ymin)) {      /* empty */
205                  p->x = p->xmin;
206                  p->y = p->ymin;
207                  setcolor(p->v, 0.0, 0.0, 0.0);
# Line 190 | Line 213 | paint(                 /* compute and paint a rectangle */
213          
214          if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir, &ourview,
215                          h/hresolu, v/vresolu)) < -FTINY) {
216 <                setcolor(thisray.rcol, 0.0, 0.0, 0.0);
217 <        } else {
218 <                int  rval;
216 >                scolorblack(thisray.rcol);
217 >        } else if (!ray_pnprocs) {              /* immediate mode */
218 >                ray_trace(&thisray);
219 >        } else {                                /* queuing mode */
220 >                int     rval;
221                  rayorigin(&thisray, PRIMARY, NULL, NULL);
222 <                thisray.rno = (unsigned long)p;
222 >                thisray.rno = (RNUMBER)p;
223                  rval = ray_pqueue(&thisray);
224                  if (!rval)
225                          return(0);
226                  if (rval < 0)
227                          return(-1);
228 +                                                /* get node for returned ray */
229                  p = (PNODE *)thisray.rno;
230          }
231  
232 <        copycolor(p->v, thisray.rcol);
232 >        scolor_rgb(p->v, thisray.rcol);
233          scalecolor(p->v, exposure);
234  
235          recolor(p);                             /* paint it */
236  
237 <        if (ambounce <= 0)                      /* shall we check for input? */
238 <                flushintvl = ray_pnprocs*WFLUSH;
239 <        else if (niflush < WFLUSH)
240 <                flushintvl = ray_pnprocs*niflush/(ambounce+1);
241 <        else
242 <                flushintvl = ray_pnprocs*WFLUSH/(ambounce+1);
237 >        if (dev->flush != NULL) {               /* shall we check for input? */
238 >                static RNUMBER  lastflush = 0;
239 >                RNUMBER         counter = raynum;
240 >                int             flushintvl;
241 >                if (!ray_pnprocs) {
242 >                        counter = nrays;
243 >                        flushintvl = WFLUSH1;
244 >                } else if (ambounce == 0)
245 >                        flushintvl = ray_pnprocs*WFLUSH;
246 >                else if (niflush < WFLUSH)
247 >                        flushintvl = ray_pnprocs*niflush/(ambounce*(ambounce>0)+1);
248 >                else
249 >                        flushintvl = ray_pnprocs*WFLUSH/(ambounce*(ambounce>0)+1);
250 >                if (lastflush > counter)
251 >                        lastflush = 0;          /* counter wrapped */
252  
253 <        if (dev->flush != NULL && raynum - lastflush >= flushintvl) {
254 <                lastflush = raynum;
255 <                (*dev->flush)();
256 <                niflush++;
253 >                if (counter - lastflush >= flushintvl) {
254 >                        lastflush = counter;
255 >                        (*dev->flush)();
256 >                        niflush++;
257 >                }
258          }
259          return(1);
260   }
# Line 230 | Line 266 | waitrays(void)                                 /* finish up pending rays */
266          int     nwaited = 0;
267          int     rval;
268          RAY     raydone;
269 <        
269 >
270 >        if (!ray_pnprocs)                       /* immediate mode? */
271 >                return(0);
272          while ((rval = ray_presult(&raydone, 0)) > 0) {
273                  PNODE  *p = (PNODE *)raydone.rno;
274 <                copycolor(p->v, raydone.rcol);
274 >                scolor_rgb(p->v, raydone.rcol);
275                  scalecolor(p->v, exposure);
276                  recolor(p);
277                  nwaited++;
# Line 249 | Line 287 | newimage(                                      /* start a new image */
287          char *s
288   )
289   {
290 <        int     newnp;
291 <                                                /* change in nproc? */
292 <        if (s != NULL && sscanf(s, "%d", &newnp) == 1 && newnp > 0) {
293 <                if (!newparam) {
256 <                        if (newnp < nproc)
257 <                                ray_pclose(nproc - newnp);
258 <                        else
259 <                                ray_popen(newnp - nproc);
260 <                }
261 <                nproc = newnp;
262 <        }
290 >        int             newnp = 0;
291 >                                                /* # rendering procs arg? */
292 >        if (s != NULL)
293 >                sscanf(s, "%d", &newnp);
294                                                  /* free old image */
295          freepkids(&ptrunk);
296                                                  /* compute resolution */
# Line 274 | Line 305 | newimage(                                      /* start a new image */
305          (*dev->clear)(hresolu, vresolu);
306  
307          if (newparam) {                         /* (re)start rendering procs */
308 <                ray_pclose(0);
309 <                ray_popen(nproc);
308 >                if (ray_pnprocs)
309 >                        ray_pclose(0);          /* should already be closed */
310 >                if (newnp > 0)
311 >                        nproc = newnp;
312 >                if (nproc > 1)
313 >                        ray_popen(nproc);
314                  newparam = 0;
315 +        } else if ((newnp > 0) & (newnp != nproc)) {
316 +                if (newnp == 1)                 /* change # rendering procs */
317 +                        ray_pclose(0);
318 +                else if (newnp < ray_pnprocs)
319 +                        ray_pclose(ray_pnprocs - newnp);
320 +                else
321 +                        ray_popen(newnp - ray_pnprocs);
322 +                nproc = newnp;
323          }
324          niflush = 0;                            /* get first value */
325          paint(&ptrunk);
# Line 318 | Line 361 | paintrect(                             /* paint picture rectangle */
361   {
362          int  mx, my;
363  
364 <        if (p->xmax - p->xmin <= 0 || p->ymax - p->ymin <= 0)
364 >        if ((p->xmax <= p->xmin) | (p->ymax <= p->ymin))
365                  return;
366  
367          if (p->kid == NULL) {
# Line 381 | Line 424 | compavg(                               /* recompute averages */
424          PNODE   *p
425   )
426   {
427 +        int     i, navg;
428 +        
429          if (p->kid == NULL)
430                  return;
431 <        compavg(p->kid+DL);
387 <        compavg(p->kid+DR);
388 <        compavg(p->kid+UL);
389 <        compavg(p->kid+UR);
431 >
432          setcolor(p->v, .0, .0, .0);
433 <        addcolor(p->v, p->kid[DL].v);
434 <        addcolor(p->v, p->kid[DR].v);
435 <        addcolor(p->v, p->kid[UL].v);
436 <        addcolor(p->v, p->kid[UR].v);
437 <        scalecolor(p->v, 0.25);
433 >        navg = 0;
434 >        for (i = 0; i < 4; i++) {
435 >                if (p->kid[i].xmin >= p->kid[i].xmax) continue;
436 >                if (p->kid[i].ymin >= p->kid[i].ymax) continue;
437 >                compavg(p->kid+i);
438 >                addcolor(p->v, p->kid[i].v);
439 >                navg++;
440 >        }
441 >        if (navg > 1)
442 >                scalecolor(p->v, 1./navg);
443   }
444  
445  
# Line 490 | Line 537 | moveview(                                      /* move viewpoint */
537   )
538   {
539          double  d;
493 –        FVECT  v1;
540          VIEW  nv = ourview;
541          int  i;
542  
543          spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
544 <        if (elev != 0.0) {
545 <                fcross(v1, ourview.vup, nv.vdir);
546 <                normalize(v1);
501 <                spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
502 <        }
544 >        if (elev != 0.0)
545 >                geodesic(nv.vdir, nv.vdir, nv.vup, elev*(-PI/180.), GEOD_RAD);
546 >
547          if (nv.type == VT_PAR) {
548                  nv.horiz /= mag;
549                  nv.vert /= mag;

Diff Legend

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