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

Diff Legend

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