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

Comparing ray/src/hd/rhdisp2.c (file contents):
Revision 3.2 by gregl, Thu Nov 20 14:46:07 1997 UTC vs.
Revision 3.22 by gwlarson, Fri May 22 15:12:36 1998 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1997 Silicon Graphics, Inc. */
1 > /* Copyright (c) 1998 Silicon Graphics, Inc. */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ SGI";
# Line 12 | Line 12 | static char SCCSid[] = "$SunId$ SGI";
12   #include "rhdisp.h"
13   #include "rhdriver.h"
14  
15 < extern int      *getviewcells();
15 > #ifndef MAXDIST
16 > #define MAXDIST         42      /* maximum distance outside section */
17 > #endif
18  
19 + #define MAXVOXEL        32      /* maximum number of active voxels */
20 +
21   typedef struct {
22          int     hd;             /* holodeck section number (-1 if inactive) */
23          int     i[3];           /* voxel index (may be outside section) */
24   } VOXL;                 /* a voxel */
25  
26 < static VOXL voxel[8] = {        /* current voxel list */
23 <        {-1}, {-1}, {-1}, {-1},
24 <        {-1}, {-1}, {-1}, {-1}
25 < };
26 > static VOXL voxel[MAXVOXEL] = {{-1}};   /* current voxel list */
27  
28   #define CBEAMBLK        1024    /* cbeam allocation block size */
29  
30   static struct beamcomp {
31 <        short   wants;          /* flags telling which voxels want us */
32 <        short   hd;             /* holodeck section number */
33 <        int     bi;             /* beam index */
31 >        int     hd;             /* holodeck section number */
32 >        int4    bi;             /* beam index */
33 >        int4    nr;             /* number of samples desired */
34   } *cbeam = NULL;        /* current beam list */
35  
36   static int      ncbeams = 0;    /* number of sorted beams in cbeam */
# Line 38 | Line 39 | static int     maxcbeam = 0;   /* size of cbeam array */
39  
40   struct cellact {
41          short   vi;             /* voxel index */
42 <        short   add;            /* zero means delete */
42 >        short   rev;            /* reverse ray direction? */
43 >        VIEW    *vp;            /* view for image */
44 >        short   hr, vr;         /* image resolution */
45   };              /* action for cell */
46  
47   struct beamact {
# Line 85 | Line 88 | register struct beamcomp       *cb1, *cb2;
88   {
89          register int    c;
90  
91 <        if (!cb1->wants)                /* put orphans at the end, unsorted */
92 <                return(cb2->wants);
91 >        if (!cb1->nr)                   /* put orphans at the end, unsorted */
92 >                return(cb2->nr);
93 >        if (!cb2->nr)
94 >                return(-1);
95          if ((c = cb1->bi - cb2->bi))    /* sort on beam index first */
96                  return(c);
97          return(cb1->hd - cb2->hd);      /* use hd to resolve matches */
# Line 102 | Line 107 | int    hd, bi;
107  
108          if (ncbeams <= 0)
109                  return(-1);
110 <        cb.wants = 0; cb.hd = hd; cb.bi = bi;
110 >        cb.hd = hd; cb.bi = bi; cb.nr = 0;
111          p = (struct beamcomp *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
112                          sizeof(struct beamcomp), cbeamcmp);
113          if (p == NULL)
# Line 130 | Line 135 | int    bi;
135          if (bi < 1 | bi > nbeams(hdlist[hd]))
136                  error(INTERNAL, "illegal beam index in getcbeam");
137          n = newcbeam();         /* allocate and assign */
138 <        cbeam[n].wants = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
138 >        cbeam[n].nr = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
139          return(n);
140   }
141  
# Line 148 | Line 153 | int    adopt;
153          if (adopt)
154                  return;
155          for (i = ncbeams; i--; )        /* identify orphans */
156 <                if (cbeam[i].wants)
156 >                if (cbeam[i].nr)
157                          break;
158          xcbeams = ncbeams - ++i;        /* put orphans after ncbeams */
159          ncbeams = i;
160   }
161  
162  
163 < cbeamadd(bl, n, v, hr, vr)      /* add beams to server list */
163 > cbeamop(op, bl, n)              /* update beams on server list */
164 > int     op;
165   register struct beamcomp        *bl;
166   int     n;
161 – VIEW    *v;
162 – int     hr, vr;
167   {
168          register PACKHEAD       *pa;
169          register int    i;
# Line 168 | Line 172 | int    hr, vr;
172                  return;
173          pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
174          if (pa == NULL)
175 <                error(SYSTEM, "out of memory in cbeamadd");
172 <        for (i = 0; i < n; i++)
173 <                pa[i].nr = npixels(v, hr, vr,
174 <                                hdlist[pa[i].hd=bl[i].hd],
175 <                                pa[i].bi=bl[i].bi) / 8;
176 <
177 <        serv_request(DR_ADDSET, n*sizeof(PACKHEAD), (char *)pa);
178 <        free((char *)pa);
179 < }
180 <
181 <
182 < cbeamdel(bl, n)         /* delete unwanted beam requests */
183 < register struct beamcomp        *bl;
184 < int     n;
185 < {
186 <        register PACKHEAD       *pa;
187 <        register int    i;
188 <
189 <        if (n <= 0)
190 <                return;
191 <        pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
192 <        if (pa == NULL)
193 <                error(SYSTEM, "out of memory in cbeamdel");
175 >                error(SYSTEM, "out of memory in cbeamop");
176          for (i = 0; i < n; i++) {
177                  pa[i].hd = bl[i].hd;
178                  pa[i].bi = bl[i].bi;
179 <                pa[i].nr = 0;           /* removes any request */
179 >                pa[i].nr = bl[i].nr;
180 >                pa[i].nc = 0;
181          }
182 <        serv_request(DR_DELSET, n*sizeof(PACKHEAD), (char *)pa);
182 >        serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
183          free((char *)pa);
184   }
185  
186  
187 < int
188 < set_voxels(vl, n)       /* set new voxel array */
206 < VOXL    vl[8];
207 < int     n;
208 < {
209 <        short   wmap[256];
210 <        int     vmap[8];
211 <        int     comn = 0;
212 <        int     no;
213 <        register int    i, j;
214 <                                        /* find common voxels */
215 <        for (j = 0; j < 8 && voxel[j].hd >= 0; j++) {
216 <                vmap[j] = -1;
217 <                for (i = n; i--; )
218 <                        if (!bcmp((char *)(vl+i), (char *)(voxel+j),
219 <                                        sizeof(VOXL))) {
220 <                                vmap[j] = i;
221 <                                comn |= 1<<i;
222 <                                break;
223 <                        }
224 <        }
225 <        no = comn ? j : 0;              /* compute flag mapping */
226 <        for (i = 256; i--; ) {
227 <                wmap[i] = 0;
228 <                for (j = no; j--; )
229 <                        if (vmap[j] >= 0 && i & 1<<j)
230 <                                wmap[i] |= 1<<vmap[j];
231 <        }
232 <                                        /* fix cbeam flags */
233 <        for (i = ncbeams; i--; )
234 <                cbeam[i].wants = wmap[cbeam[i].wants];
235 <                                        /* update our voxel list */
236 <        bcopy((char *)vl, (char *)voxel, n*sizeof(VOXL));
237 <        for (j = n; j < 8; j++)
238 <                voxel[j].hd = -1;
239 <        return(comn);                   /* return bit array of common voxels */
240 < }
241 <
242 <
243 < int
244 < get_voxels(vl, vp)      /* find voxels corresponding to view point */
245 < VOXL    vl[8];
187 > unsigned int4
188 > add_voxels(vp)          /* add voxels corresponding to view point */
189   FVECT   vp;
190   {
191 <        int     n = 0;
191 >        int     first, n, rfl = 0;
192          FVECT   gp;
193          double  d;
194          int     dist, bestd = 0x7fff;
195          VOXL    vox;
196          register int    i, j, k;
197 +                                        /* count voxels in list already */
198 +        for (first = 0; first < MAXVOXEL && voxel[first].hd >= 0; first++)
199 +                ;
200                                          /* find closest voxels */
201 <        for (i = 0; n < 8 && hdlist[i]; i++) {
201 >        for (n = first, i = 0; n < MAXVOXEL && hdlist[i]; i++) {
202                  hdgrid(gp, hdlist[i], vp);
203 <                for (j = 0; n < 8 && j < 8; j++) {
203 >                for (j = 0; n < MAXVOXEL && j < 8; j++) {
204                          dist = 0;
205                          for (k = 0; k < 3; k++) {
206                                  d = gp[k] - .5 + (j>>k & 1);
# Line 267 | Line 213 | FVECT  vp;
213                          if (dist > bestd)       /* others were closer */
214                                  continue;
215                          if (dist < bestd) {     /* start closer list */
216 <                                n = 0;
216 >                                n = first;
217                                  bestd = dist;
218 +                                rfl = 0;
219                          }
220 +                                                /* check if already in list */
221 +                        for (k = first; k--; )
222 +                                if (voxel[k].hd == i &&
223 +                                                voxel[k].i[0] == vox.i[0] &&
224 +                                                voxel[k].i[1] == vox.i[1] &&
225 +                                                voxel[k].i[2] == vox.i[2])
226 +                                        break;
227 +                        if (k >= 0) {
228 +                                rfl |= 1<<k;
229 +                                continue;
230 +                        }
231                          vox.hd = i;             /* add this voxel */
232 <                        copystruct(&vl[n], &vox);
233 <                        n++;
232 >                        copystruct(&voxel[n], &vox);
233 >                        rfl |= 1<<n++;
234                  }
235          }
236 <        return(n);
236 >                                        /* check for really stupid move */
237 >        if (bestd > MAXDIST) {
238 >                error(COMMAND, "move past outer limits");
239 >                return(0);
240 >        }
241 >        if (n < MAXVOXEL)
242 >                voxel[n].hd = -1;
243 >        return(rfl);
244   }
245  
246  
# Line 285 | Line 250 | GCOORD *gcp;
250   register struct beamact *bp;
251   {
252          GCOORD  gc[2];
253 <        int     bi, i;
253 >        int     bi, i, n;
254                                          /* compute beam index */
255 <        copystruct(gc, gcp);
256 <        copystruct(gc+1, &bp->gc);
255 >        if (bp->ca.rev) {
256 >                copystruct(gc, &bp->gc);
257 >                copystruct(gc+1, gcp);
258 >        } else {
259 >                copystruct(gc, gcp);
260 >                copystruct(gc+1, &bp->gc);
261 >        }
262          if ((bi = hdbindex(hdlist[voxel[bp->ca.vi].hd], gc)) <= 0)
263                  error(CONSISTENCY, "bad grid coordinate in dobeam");
264 <        if (bp->ca.add) {               /* add it in */
265 <                i = getcbeam(voxel[bp->ca.vi].hd, bi);
266 <                cbeam[i].wants |= 1<<bp->ca.vi; /* say we want it */
267 <                return(i == ncbeams+xcbeams-1); /* return 1 if totally new */
268 <        }
269 <                                        /* else delete it */
270 <        i = findcbeam(voxel[bp->ca.vi].hd, bi);
301 <        if (i >= 0 && cbeam[i].wants & 1<<bp->ca.vi) {
302 <                cbeam[i].wants &= ~(1<<bp->ca.vi);      /* we don't want it */
303 <                return(1);                      /* indicate change */
304 <        }
305 <        return(0);
264 >                                        /* add it in */
265 >        i = getcbeam(voxel[bp->ca.vi].hd, bi);
266 >        n = npixels(bp->ca.vp, bp->ca.hr, bp->ca.vr,
267 >                        hdlist[cbeam[i].hd], cbeam[i].bi);
268 >        if (n > cbeam[i].nr)
269 >                cbeam[i].nr = n;
270 >        return(i == ncbeams+xcbeams-1); /* return 1 if totally new */
271   }
272  
273  
# Line 312 | Line 277 | docell(gcp, cap)       /* find beams corresponding to cell a
277   GCOORD  *gcp;
278   register struct cellact *cap;
279   {
280 +        register HOLO   *hp = hdlist[voxel[cap->vi].hd];
281          FVECT   org, dir[4];
282 <        FVECT   gp, cv[4], vc;
282 >        FVECT   vgp, cgp, vc;
283 >        FVECT   v1, v2;
284          struct beamact  bo;
285 +        int     axmax, j;
286 +        double  d, avmax;
287          register int    i;
288 <                                /* compute cell vertices */
289 <        hdcell(cv, hdlist[voxel[cap->vi].hd], gcp);
290 <                                /* compute cell and voxel centers */
291 <        for (i = 0; i < 3; i++) {
292 <                org[i] = 0.5*(cv[0][i] + cv[2][i]);
293 <                gp[i] = voxel[cap->vi].i[i] + 0.5;
294 <        }
295 <        hdworld(vc, hdlist[voxel[cap->vi].hd], gp);
296 <                                /* compute voxel pyramid using vector trick */
297 <        for (i = 0; i < 3; i++) {
298 <                dir[0][i] = vc[i] - cv[0][i];           /* to 3 */
299 <                dir[2][i] = vc[i] - cv[3][i];           /* to 0 */
300 <                if (gcp->w & 1) {       /* watch vertex order! */
301 <                        dir[1][i] = vc[i] - cv[2][i];   /* to 1 */
302 <                        dir[3][i] = vc[i] - cv[1][i];   /* to 2 */
303 <                } else {
304 <                        dir[1][i] = vc[i] - cv[1][i];   /* to 2 */
305 <                        dir[3][i] = vc[i] - cv[2][i];   /* to 1 */
288 >                                /* compute cell center */
289 >        cgp[gcp->w>>1] = gcp->w&1 ? hp->grid[gcp->w>>1] : 0 ;
290 >        cgp[hdwg0[gcp->w]] = gcp->i[0] + .5;
291 >        cgp[hdwg1[gcp->w]] = gcp->i[1] + .5;
292 >        hdworld(org, hp, cgp);
293 >                                /* compute direction to voxel center */
294 >        for (i = 3; i--; )
295 >                vgp[i] = voxel[cap->vi].i[i] + .5;
296 >        hdworld(vc, hp, vgp);
297 >        for (i = 3; i--; )
298 >                vc[i] -= org[i];
299 >                                /* compute maximum area axis */
300 >        axmax = -1; avmax = 0;
301 >        for (i = 3; i--; ) {
302 >                d = vgp[i] - cgp[i];
303 >                if (d < 0.) d = -d;
304 >                if (d > avmax) {
305 >                        avmax = d;
306 >                        axmax = i;
307                  }
308          }
309 + #ifdef DEBUG
310 +        if (axmax < 0.)
311 +                error(CONSISTENCY, "botched axis computation in docell");
312 + #endif
313 +                                /* compute offset vectors */
314 +        d = 0.5/hp->grid[j=(axmax+1)%3];
315 +        for (i = 3; i--; )
316 +                v1[i] = hp->xv[j][i] * d;
317 +        d = 0.5/hp->grid[j=(axmax+2)%3];
318 +        if (DOT(hp->wg[axmax], vc) < 0.)
319 +                d = -d; /* reverse vertex order */
320 +        for (i = 3; i--; )
321 +                v2[i] = hp->xv[j][i] * d;
322 +                                /* compute voxel pyramid */
323 +        for (i = 3; i--; ) {
324 +                dir[0][i] = vc[i] - v1[i] - v2[i];
325 +                dir[1][i] = vc[i] + v1[i] - v2[i];
326 +                dir[2][i] = vc[i] + v1[i] + v2[i];
327 +                dir[3][i] = vc[i] - v1[i] + v2[i];
328 +        }
329                                  /* visit beams for opposite cells */
330          copystruct(&bo.ca, cap);
331          copystruct(&bo.gc, gcp);
332 <        return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], dobeam, &bo));
332 >        return(visit_cells(org, dir, hp, dobeam, &bo));
333   }
334  
335  
336   int
337 < doview(cap, vp)                 /* visit cells for a given view */
337 > doview(cap)                     /* visit cells for a given view */
338   struct cellact  *cap;
349 – VIEW    *vp;
339   {
340 +        int     orient;
341          FVECT   org, dir[4];
342                                          /* compute view pyramid */
343 <        if (vp->type == VT_PAR) goto viewerr;
344 <        if (viewray(org, dir[0], vp, 0., 0.) < -FTINY) goto viewerr;
345 <        if (viewray(org, dir[1], vp, 0., 1.) < -FTINY) goto viewerr;
346 <        if (viewray(org, dir[2], vp, 1., 1.) < -FTINY) goto viewerr;
357 <        if (viewray(org, dir[3], vp, 1., 0.) < -FTINY) goto viewerr;
343 >        orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], cap->vp);
344 >        if (!orient)
345 >                error(INTERNAL, "unusable view in doview");
346 >        cap->rev = orient < 0;
347                                          /* visit cells within pyramid */
348          return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], docell, cap));
360 – viewerr:
361 –        error(INTERNAL, "unusable view in doview");
349   }
350  
351  
352 < mvview(voxi, vold, vnew)        /* move view for a voxel */
366 < int     voxi;
367 < VIEW    *vold, *vnew;
352 > beam_init()                     /* clear beam list for new view(s) */
353   {
354 <        int     netchange = 0;
355 <        int     *ocl, *ncl;
356 <        struct cellact  ca;
357 <        int     ocnt, ncnt;
358 <        int     c;
374 <        register GCOORD *ogcp, *ngcp;
375 <                                /* get old and new cell lists */
376 <        ocl = getviewcells(hdlist[voxel[voxi].hd], vold);
377 <        ncl = getviewcells(hdlist[voxel[voxi].hd], vnew);
378 <        if (ocl != NULL) {
379 <                ocnt = *ocl; ogcp = (GCOORD *)(ocl+1);
380 <        } else {
381 <                ocnt = 0; ogcp = NULL;
382 <        }
383 <        if (ncl != NULL) {
384 <                ncnt = *ncl; ngcp = (GCOORD *)(ncl+1);
385 <        } else {
386 <                ncnt = 0; ngcp = NULL;
387 <        }
388 <        ca.vi = voxi;           /* add and delete cells */
389 <        while (ocnt > 0 & ncnt > 0)
390 <                if ((c = cellcmp(ogcp, ngcp)) > 0) {
391 <                        ca.add = 1;             /* new cell */
392 <                        netchange += docell(ngcp++, &ca);
393 <                        ncnt--;
394 <                } else if (c < 0) {
395 <                        ca.add = 0;             /* obsolete cell */
396 <                        netchange -= docell(ogcp++, &ca);
397 <                        ocnt--;
398 <                } else {
399 <                        ogcp++; ocnt--;         /* unchanged cell */
400 <                        ngcp++; ncnt--;
401 <                }
402 <                                /* take care of list tails */
403 <        for (ca.add = 1; ncnt > 0; ncnt--)
404 <                netchange += docell(ngcp++, &ca);
405 <        for (ca.add = 0; ocnt > 0; ocnt--)
406 <                netchange -= docell(ogcp++, &ca);
407 <                                /* clean up */
408 <        if (ocl != NULL) free((char *)ocl);
409 <        if (ncl != NULL) free((char *)ncl);
410 <        return(netchange);
354 >        register int    i;
355 >                                        /* clear desire flags */
356 >        for (i = ncbeams+xcbeams; i--; )
357 >                cbeam[i].nr = 0;
358 >        voxel[0].hd = -1;               /* clear voxel list */
359   }
360  
361  
362 < beam_view(vo, vn)       /* change beam view */
363 < VIEW    *vo, *vn;
362 > beam_view(vn, hr, vr)           /* add beam view (if advisable) */
363 > VIEW    *vn;
364 > int     hr, vr;
365   {
366          struct cellact  ca;
367 <        VOXL    vlnew[8];
368 <        int     n, comn;
367 >        unsigned int4   vfl;
368 >                                        /* sort our list */
369 >        cbeamsort(1);
370 >                                        /* add new voxels */
371 >        vfl = add_voxels(vn->vp);
372 >        if (!vfl)
373 >                return(0);
374 >        ca.vp = vn; ca.hr = hr; ca.vr = vr;
375 >                                        /* update our beam list */
376 >        for (ca.vi = 0; vfl; vfl >>= 1, ca.vi++)
377 >                if (vfl & 1)
378 >                        doview(&ca);
379 >        return(1);
380 > }
381  
382 <        if (!vn->type) {                /* clear our beam list */
383 <                set_voxels(vlnew, 0);
384 <                cbeamdel(cbeam, ncbeams);
385 <                ncbeams = 0;
386 <                return;
426 <        }
427 <                                        /* find our new voxels */
428 <        n = get_voxels(vlnew, vn->vp);
429 <                                        /* set the new voxels */
430 <        comn = set_voxels(vlnew, n);
431 <        if (!vo->type)
432 <                comn = 0;
433 <        ca.add = 1;                     /* update our beam list */
434 <        for (ca.vi = n; ca.vi--; )
435 <                if (comn & 1<<ca.vi)    /* change which cells we see */
436 <                        mvview(ca.vi, vo, vn);
437 <                else                    /* else add all new cells */
438 <                        doview(&ca, vn);
439 <                                        /* inform server of new beams */
440 <        cbeamadd(cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
382 >
383 > int
384 > beam_sync(all)                  /* update beam list on server */
385 > int     all;
386 > {
387                                          /* sort list to put orphans at end */
388          cbeamsort(0);
389 <                                        /* tell server to delete orphans */
390 <        cbeamdel(cbeam+ncbeams, xcbeams);
389 >        if (all)
390 >                cbeamop(DR_NEWSET, cbeam, ncbeams);
391 >        else
392 >                cbeamop(DR_ADJSET, cbeam, ncbeams+xcbeams);
393          xcbeams = 0;                    /* truncate our list */
394 +        return(ncbeams);
395   }

Diff Legend

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