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.19 by gregl, Wed Jan 7 16:04:14 1998 UTC vs.
Revision 3.21 by gwlarson, Thu May 14 13:23:00 1998 UTC

# Line 16 | Line 16 | static char SCCSid[] = "$SunId$ SGI";
16   #define MAXDIST         42      /* maximum distance outside section */
17   #endif
18  
19 < extern GCOORD   *getviewcells();
19 > #define MAXVOXEL        16      /* maximum number of active voxels */
20  
21 – static VIEW     dvw;            /* current view corresponding to beam list */
22 –
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 */
29 <        {-1}, {-1}, {-1}, {-1},
30 <        {-1}, {-1}, {-1}, {-1}
31 < };
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 */
# Line 46 | Line 42 | 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  
49   struct beamact {
# Line 111 | 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 139 | 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 164 | Line 162 | int    adopt;
162   }
163  
164  
165 < cbeamop(op, bl, n, v, hr, vr)   /* update beams on server list */
165 > cbeamop(op, bl, n)              /* update beams on server list */
166   int     op;
167   register struct beamcomp        *bl;
168   int     n;
171 – VIEW    *v;
172 – int     hr, vr;
169   {
170          register PACKHEAD       *pa;
171          register int    i;
# Line 178 | 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");
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 = v==NULL ? 0 :
186 <                                npixels(v, hr, vr, hdlist[bl[i].hd], bl[i].bi);
181 >                pa[i].nr = bl[i].nr;
182                  pa[i].nc = 0;
183          }
184          serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
# Line 191 | Line 186 | int    hr, vr;
186   }
187  
188  
189 < int
195 < set_voxels(vl, n)       /* set new voxel array */
196 < VOXL    vl[8];
197 < int     n;
198 < {
199 <        short   wmap[256];
200 <        int     vmap[8];
201 <        int     comn = 0;
202 <        int     no;
203 <        register int    i, j;
204 <                                        /* find common voxels */
205 <        for (j = 0; j < 8 && voxel[j].hd >= 0; j++) {
206 <                vmap[j] = -1;
207 <                for (i = n; i--; )
208 <                        if (!bcmp((char *)(vl+i), (char *)(voxel+j),
209 <                                        sizeof(VOXL))) {
210 <                                vmap[j] = i;
211 <                                comn |= 1<<i;
212 <                                break;
213 <                        }
214 <        }
215 <        no = comn ? j : 0;              /* compute flag mapping */
216 <        for (i = 256; i--; ) {
217 <                wmap[i] = 0;
218 <                for (j = no; j--; )
219 <                        if (vmap[j] >= 0 && i & 1<<j)
220 <                                wmap[i] |= 1<<vmap[j];
221 <        }
222 <                                        /* fix cbeam flags */
223 <        for (i = ncbeams; i--; )
224 <                cbeam[i].wants = wmap[cbeam[i].wants];
225 <                                        /* update our voxel list */
226 <        bcopy((char *)vl, (char *)voxel, n*sizeof(VOXL));
227 <        for (j = n; j < 8; j++)
228 <                voxel[j].hd = -1;
229 <        return(comn);                   /* return bit array of common voxels */
230 < }
231 <
232 <
233 < int
234 < get_voxels(vl, vp)      /* find voxels corresponding to view point */
235 < 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 257 | 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                                          /* check for really stupid move */
# Line 270 | Line 239 | FVECT  vp;
239                  error(COMMAND, "move past outer limits");
240                  return(0);
241          }
242 <        return(n);
242 >        if (n < MAXVOXEL)
243 >                voxel[n].hd = -1;
244 >        return(rfl);
245   }
246  
247  
# Line 280 | 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          if (bp->ca.rev) {
257                  copystruct(gc, &bp->gc);
# Line 294 | Line 265 | register struct beamact        *bp;
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 369 | Line 346 | register struct cellact        *cap;
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;
374 – VIEW    *vp;
351   {
352          int     orient;
353          FVECT   org, dir[4];
354                                          /* compute view pyramid */
355 <        orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], vp);
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;
# Line 385 | Line 361 | VIEW   *vp;
361   }
362  
363  
364 < mvview(voxi, vold, vnew)        /* move view for a voxel */
389 < int     voxi;
390 < VIEW    *vold, *vnew;
364 > beam_init()                     /* clear beam list for new view(s) */
365   {
366 <        int     netchange = 0;
367 <        struct cellact  oca, nca;
368 <        int     ocnt, ncnt;
369 <        int     nmatch = 0;
370 <        GCOORD  *ogcl, *ngcl;
397 <        register int    c;
398 <        register GCOORD *ogcp, *ngcp;
399 <                                /* get old and new cell lists */
400 <        ogcp = ogcl = getviewcells(&ocnt, hdlist[voxel[voxi].hd], vold);
401 <        ngcp = ngcl = getviewcells(&ncnt, hdlist[voxel[voxi].hd], vnew);
402 <                                /* set up actions */
403 <        oca.vi = nca.vi = voxi;
404 <        oca.add = 0; nca.add = 1;
405 <        if ((oca.rev = ocnt < 0))
406 <                ocnt = -ocnt;
407 <        if ((nca.rev = ncnt < 0))
408 <                ncnt = -ncnt;
409 <        if (oca.rev == nca.rev) {       /* count matches */
410 <                int     oc = ocnt, nc = ncnt;
411 <                while (oc > 0 & nc > 0) {
412 <                        c = cellcmp(ogcp, ngcp);
413 <                        if (c >= 0) { ngcp++; nc--; }
414 <                        if (c <= 0) { ogcp++; oc--; }
415 <                        nmatch += c==0;
416 <                }
417 <                ogcp = ogcl; ngcp = ngcl;
418 <        }
419 <        if (nmatch < ocnt>>1) {         /* faster to just delete old cells? */
420 <                for (c = ncbeams; c--; )
421 <                        if (cbeam[c].wants & 1<<voxi) {
422 <                                cbeam[c].wants &= ~(1<<voxi);
423 <                                netchange--;
424 <                        }
425 <                free((char *)ogcl);
426 <                ogcl = NULL; ocnt = 0;
427 <        }
428 <                                /* add and delete cells in order */
429 <        while (ocnt > 0 & ncnt > 0)
430 <                if ((c = cellcmp(ogcp, ngcp)) > 0) {    /* new cell */
431 <                        netchange += docell(ngcp++, &nca);
432 <                        ncnt--;
433 <                } else if (c < 0) {                     /* old cell */
434 <                        netchange -= docell(ogcp++, &oca);
435 <                        ocnt--;
436 <                } else {                                /* same cell */
437 <                        ogcp++; ocnt--;
438 <                        ngcp++; ncnt--;
439 <                }
440 <                                /* take care of list tails */
441 <        for ( ; ncnt > 0; ncnt--)
442 <                netchange += docell(ngcp++, &nca);
443 <        for ( ; ocnt > 0; ocnt--)
444 <                netchange -= docell(ogcp++, &oca);
445 <                                /* clean up */
446 <        if (ogcl != NULL) free((char *)ogcl);
447 <        if (ngcl != NULL) free((char *)ngcl);
448 <        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 < int
453 < beam_sync()             /* synchronize beams on server */
454 < {
455 <        cbeamop(DR_NEWSET, cbeam, ncbeams, &odev.v, odev.hres, odev.vres);
456 <        return(ncbeams);
457 < }
458 <
459 <
460 < beam_view(vn)                   /* change beam view (if advisable) */
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 == NULL || !vn->type) {  /* clear our beam list */
383 <                set_voxels(vlnew, 0);
384 <                cbeamop(DR_DELSET, cbeam, ncbeams, NULL, 0, 0);
470 <                ncbeams = 0;
471 <                dvw.type = 0;
472 <                return(1);
473 <        }
474 <                                        /* find our new voxels */
475 <        n = get_voxels(vlnew, vn->vp);
476 <        if (dvw.type && !n) {
477 <                copystruct(vn, &dvw);           /* cancel move */
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 <        }
480 <                                        /* set the new voxels */
481 <        comn = set_voxels(vlnew, n);
482 <        if (!dvw.type)
483 <                comn = 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, &dvw, vn);
391 <                else                    /* else add all new cells */
392 <                        doview(&ca, vn);
393 <                                        /* inform server of new beams */
394 <        cbeamop(DR_ADDSET, 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 <        cbeamop(DR_DELSET, cbeam+ncbeams, xcbeams, NULL, 0, 0);
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 <        copystruct(&dvw, vn);           /* record new view */
498 <        return(1);
406 >        return(ncbeams);
407   }

Diff Legend

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