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.11 by gregl, Tue Dec 9 13:53:21 1997 UTC

# Line 5 | Line 5 | 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         13      /* maximum distance outside section */
17 > #endif
18  
19 + extern GCOORD   *getviewcells();
20 +
21 + static VIEW     dvw;            /* current view corresponding to beam list */
22 +
23   typedef struct {
24 <        int     hd;             /* holodeck section number */
24 >        int     hd;             /* holodeck section number (-1 if inactive) */
25          int     i[3];           /* voxel index (may be outside section) */
26   } VOXL;                 /* a voxel */
27  
# Line 36 | Line 42 | static int     ncbeams = 0;    /* number of sorted beams in c
42   static int      xcbeams = 0;    /* extra (unregistered) beams past ncbeams */
43   static int      maxcbeam = 0;   /* size of cbeam array */
44  
39 –
45   struct cellact {
46          short   vi;             /* voxel index */
47          short   add;            /* zero means delete */
48 +        short   rev;            /* reverse ray direction? */
49   };              /* action for cell */
50  
45 –
51   struct beamact {
52          struct cellact  ca;     /* cell action */
53          GCOORD  gc;             /* grid coordinate */
# Line 157 | Line 162 | int    adopt;
162   }
163  
164  
165 < cbeamadd(bl, n, v, hr, vr)      /* add beams to server list */
161 < register struct beamcomp        *bl;
162 < int     n;
165 > cbeamadj(v, hr, vr)             /* adjust our beam list */
166   VIEW    *v;
167   int     hr, vr;
168   {
169          register PACKHEAD       *pa;
170          register int    i;
171 <
172 <        if (n <= 0)
173 <                return;
174 <        pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
175 <        if (pa == NULL)
176 <                error(SYSTEM, "out of memory in cbeamadd");
177 <        for (i = 0; i < n; i++)
178 <                pa[i].nr = npixels(v, hr, vr,
179 <                                hdlist[pa[i].hd=bl[i].hd],
180 <                                pa[i].bi=bl[i].bi) / 8;
181 <
182 <        serv_request(DR_ADDSET, n*sizeof(PACKHEAD), (char *)pa);
171 >        int     n;
172 >                                        /* first handle additions */
173 >        pa = (PACKHEAD *)malloc(xcbeams*sizeof(PACKHEAD));
174 >        if (xcbeams && pa == NULL)
175 >                goto memerr;
176 >        for (i = xcbeams; i--; ) {
177 >                pa[i].hd = cbeam[ncbeams+i].hd;
178 >                pa[i].bi = cbeam[ncbeams+i].bi;
179 >                pa[i].nr = npixels(v, hr, vr, hdlist[pa[i].hd], pa[i].bi) + 1;
180 >        }
181 >        n = xcbeams;                    /* now sort list for deletions */
182 >        cbeamsort(0);
183 >        pa = (PACKHEAD *)realloc((char *)pa, (n+xcbeams)*sizeof(PACKHEAD));
184 >        if (n+xcbeams && pa == NULL)
185 >                goto memerr;
186 >        for (i = xcbeams; i--; ) {
187 >                pa[n+i].hd = cbeam[ncbeams+i].hd;
188 >                pa[n+i].bi = cbeam[ncbeams+i].bi;
189 >                pa[n+i].nr = 0;
190 >        }
191 >        n += xcbeams;
192 >        xcbeams = 0;                    /* delete orphans */
193 >        serv_request(DR_ADJSET, n*sizeof(PACKHEAD), (char *)pa);
194          free((char *)pa);
195 +        return;
196 + memerr:
197 +        error(SYSTEM, "out of memory in cbeamadj");
198   }
199  
200  
201 < cbeamdel(bl, n)         /* delete unwanted beam requests */
201 > cbeamop(op, bl, n, v, hr, vr)   /* update beams on server list */
202 > int     op;
203   register struct beamcomp        *bl;
204   int     n;
205 + VIEW    *v;
206 + int     hr, vr;
207   {
208          register PACKHEAD       *pa;
209          register int    i;
# Line 192 | Line 212 | int    n;
212                  return;
213          pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
214          if (pa == NULL)
215 <                error(SYSTEM, "out of memory in cbeamdel");
215 >                error(SYSTEM, "out of memory in cbeamadd");
216          for (i = 0; i < n; i++) {
217                  pa[i].hd = bl[i].hd;
218                  pa[i].bi = bl[i].bi;
219 <                pa[i].nr = 0;           /* removes any request */
219 >                pa[i].nr = v==NULL ? 0 :
220 >                                npixels(v, hr, vr, hdlist[bl[i].hd], bl[i].bi);
221          }
222 <        serv_request(DR_DELSET, n*sizeof(PACKHEAD), (char *)pa);
222 >        serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
223          free((char *)pa);
224   }
225  
# Line 247 | Line 268 | get_voxels(vl, vp)     /* find voxels corresponding to vie
268   VOXL    vl[8];
269   FVECT   vp;
270   {
271 +        static int      lastn = 0, lastd = -1;
272          int     n = 0;
273          FVECT   gp;
274          double  d;
# Line 277 | Line 299 | FVECT  vp;
299                          n++;
300                  }
301          }
302 <        return(n);
302 >                                        /* check for really stupid move */
303 >        if (bestd > MAXDIST) {
304 >                error(COMMAND, "move past outer limits");
305 >                return(0);
306 >        }
307 >                                        /* warn of dangerous moves */
308 >        if (n < lastn && bestd >= lastd)
309 >                error(WARNING, "moving outside holodeck section");
310 >        else if (n > lastn && bestd <= lastd)
311 >                error(WARNING, "moving inside holodeck section");
312 >        lastd = bestd;
313 >        return(lastn = n);
314   }
315  
316  
# Line 289 | Line 322 | register struct beamact        *bp;
322          GCOORD  gc[2];
323          int     bi, i;
324                                          /* compute beam index */
325 <        copystruct(gc, gcp);
326 <        copystruct(gc+1, &bp->gc);
325 >        if (bp->ca.rev) {
326 >                copystruct(gc, &bp->gc);
327 >                copystruct(gc+1, gcp);
328 >        } else {
329 >                copystruct(gc, gcp);
330 >                copystruct(gc+1, &bp->gc);
331 >        }
332          if ((bi = hdbindex(hdlist[voxel[bp->ca.vi].hd], gc)) <= 0)
333 <                return(0);              /* should report an error? */
333 >                error(CONSISTENCY, "bad grid coordinate in dobeam");
334          if (bp->ca.add) {               /* add it in */
335                  i = getcbeam(voxel[bp->ca.vi].hd, bi);
336                  cbeam[i].wants |= 1<<bp->ca.vi; /* say we want it */
# Line 314 | Line 352 | docell(gcp, cap)       /* find beams corresponding to cell a
352   GCOORD  *gcp;
353   register struct cellact *cap;
354   {
355 +        register HOLO   *hp = hdlist[voxel[cap->vi].hd];
356          FVECT   org, dir[4];
357 <        FVECT   gp, cv[4], vc;
357 >        FVECT   vgp, cgp, vc;
358 >        FVECT   v1, v2;
359          struct beamact  bo;
360 +        int     axmax, j;
361 +        double  d, avmax;
362          register int    i;
363 <                                /* compute cell vertices */
364 <        hdcell(cv, hdlist[voxel[cap->vi].hd], gcp);
365 <                                /* compute cell and voxel centers */
366 <        for (i = 0; i < 3; i++) {
367 <                org[i] = 0.5*(cv[0][i] + cv[2][i]);
368 <                gp[i] = voxel[cap->vi].i[i] + 0.5;
369 <        }
370 <        hdworld(vc, hdlist[voxel[cap->vi].hd], gp);
371 <                                /* compute voxel pyramid using vector trick */
372 <        for (i = 0; i < 3; i++) {
373 <                dir[0][i] = vc[i] - cv[0][i];           /* to 3 */
374 <                dir[2][i] = vc[i] - cv[3][i];           /* to 0 */
375 <                if (gcp->w & 1) {       /* watch vertex order! */
376 <                        dir[1][i] = vc[i] - cv[2][i];   /* to 1 */
377 <                        dir[3][i] = vc[i] - cv[1][i];   /* to 2 */
378 <                } else {
379 <                        dir[1][i] = vc[i] - cv[1][i];   /* to 2 */
380 <                        dir[3][i] = vc[i] - cv[2][i];   /* to 1 */
363 >                                /* compute cell center */
364 >        cgp[gcp->w>>1] = gcp->w&1 ? hp->grid[gcp->w>>1] : 0 ;
365 >        cgp[((gcp->w>>1)+1)%3] = gcp->i[0] + .5;
366 >        cgp[((gcp->w>>1)+2)%3] = gcp->i[1] + .5;
367 >        hdworld(org, hp, cgp);
368 >                                /* compute direction to voxel center */
369 >        for (i = 3; i--; )
370 >                vgp[i] = voxel[cap->vi].i[i] + .5;
371 >        hdworld(vc, hp, vgp);
372 >        for (i = 3; i--; )
373 >                vc[i] -= org[i];
374 >                                /* compute maximum area axis */
375 >        axmax = -1; avmax = 0;
376 >        for (i = 3; i--; ) {
377 >                d = vgp[i] - cgp[i];
378 >                if (d < 0) d = -d;
379 >                if (d > avmax) {
380 >                        avmax = d;
381 >                        axmax = i;
382                  }
383          }
384 + #ifdef DEBUG
385 +        if (axmax < 0)
386 +                error(CONSISTENCY, "botched axis computation in docell");
387 + #endif
388 +                                /* compute offset vectors */
389 +        d = 0.5/hp->grid[j=(axmax+1)%3];
390 +        for (i = 3; i--; )
391 +                v1[i] = hp->xv[j][i] * d;
392 +        d = 0.5/hp->grid[j=(axmax+2)%3];
393 +        if (DOT(hp->wn[axmax], vc) < 0)
394 +                d = -d; /* reverse vertex ordering */
395 +        for (i = 3; i--; )
396 +                v2[i] = hp->xv[j][i] * d;
397 +                                /* compute voxel pyramid */
398 +        for (i = 3; i--; ) {
399 +                dir[0][i] = vc[i] - v1[i] - v2[i];
400 +                dir[1][i] = vc[i] + v1[i] - v2[i];
401 +                dir[2][i] = vc[i] + v1[i] + v2[i];
402 +                dir[3][i] = vc[i] - v1[i] + v2[i];
403 +        }
404                                  /* visit beams for opposite cells */
405          copystruct(&bo.ca, cap);
406          copystruct(&bo.gc, gcp);
407 <        return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], dobeam, &bo));
407 >        return(visit_cells(org, dir, hp, dobeam, &bo));
408   }
409  
410  
# Line 350 | Line 413 | doview(cap, vp)                        /* visit cells for a given view */
413   struct cellact  *cap;
414   VIEW    *vp;
415   {
416 +        int     orient;
417          FVECT   org, dir[4];
418                                          /* compute view pyramid */
419 <        if (vp->type == VT_PAR) goto viewerr;
420 <        if (viewray(org, dir[0], vp, 0., 0.) < -FTINY) goto viewerr;
421 <        if (viewray(org, dir[1], vp, 0., 1.) < -FTINY) goto viewerr;
422 <        if (viewray(org, dir[2], vp, 1., 1.) < -FTINY) goto viewerr;
359 <        if (viewray(org, dir[3], vp, 1., 0.) < -FTINY) goto viewerr;
419 >        orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], vp);
420 >        if (!orient)
421 >                error(INTERNAL, "unusable view in doview");
422 >        cap->rev = orient < 0;
423                                          /* visit cells within pyramid */
424          return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], docell, cap));
362 – viewerr:
363 –        error(INTERNAL, "unusable view in doview");
425   }
426  
427  
# Line 369 | Line 430 | int    voxi;
430   VIEW    *vold, *vnew;
431   {
432          int     netchange = 0;
433 <        int     *ocl, *ncl;
373 <        struct cellact  ca;
433 >        struct cellact  oca, nca;
434          int     ocnt, ncnt;
435          int     c;
436 +        GCOORD  *ogcl, *ngcl;
437          register GCOORD *ogcp, *ngcp;
438                                  /* get old and new cell lists */
439 <        ocl = getviewcells(hdlist[voxel[voxi].hd], vold);
440 <        ncl = getviewcells(hdlist[voxel[voxi].hd], vnew);
441 <        if (ocl != NULL) {
442 <                ocnt = *ocl; ogcp = (GCOORD *)(ocl+1);
443 <        } else {
444 <                ocnt = 0; ogcp = NULL;
445 <        }
446 <        if (ncl != NULL) {
447 <                ncnt = *ncl; ngcp = (GCOORD *)(ncl+1);
448 <        } else {
449 <                ncnt = 0; ngcp = NULL;
450 <        }
451 <        ca.vi = voxi;           /* add and delete cells */
452 <        while (ocnt > 0 & ncnt > 0)
453 <                if ((c = cellcmp(ogcp, ngcp)) > 0) {
454 <                        ca.add = 1;             /* new cell */
455 <                        netchange += docell(ngcp++, &ca);
456 <                        ncnt--;
457 <                } else if (c < 0) {
458 <                        ca.add = 0;             /* obsolete cell */
459 <                        netchange -= docell(ogcp++, &ca);
399 <                        ocnt--;
400 <                } else {
401 <                        ogcp++; ocnt--;         /* unchanged cell */
402 <                        ngcp++; ncnt--;
403 <                }
439 >        ogcp = ogcl = getviewcells(&ocnt, hdlist[voxel[voxi].hd], vold);
440 >        ngcp = ngcl = getviewcells(&ncnt, hdlist[voxel[voxi].hd], vnew);
441 >                                /* set up actions */
442 >        oca.vi = nca.vi = voxi;
443 >        oca.add = 0; nca.add = 1;
444 >        if ((oca.rev = ocnt < 0))
445 >                ocnt = -ocnt;
446 >        if ((nca.rev = ncnt < 0))
447 >                ncnt = -ncnt;
448 >        if (nca.rev == oca.rev)         /* add and delete cells in order */
449 >                while (ocnt > 0 & ncnt > 0)
450 >                        if ((c = cellcmp(ogcp, ngcp)) > 0) {    /* new cell */
451 >                                netchange += docell(ngcp++, &nca);
452 >                                ncnt--;
453 >                        } else if (c < 0) {                     /* old cell */
454 >                                netchange -= docell(ogcp++, &oca);
455 >                                ocnt--;
456 >                        } else {                                /* same cell */
457 >                                ogcp++; ocnt--;
458 >                                ngcp++; ncnt--;
459 >                        }
460                                  /* take care of list tails */
461 <        for (ca.add = 1; ncnt > 0; ncnt--)
462 <                docell(ngcp++, &ca);
463 <        for (ca.add = 0; ocnt > 0; ocnt--)
464 <                docell(ogcp++, &ca);
461 >        for ( ; ncnt > 0; ncnt--)
462 >                netchange += docell(ngcp++, &nca);
463 >        for ( ; ocnt > 0; ocnt--)
464 >                netchange -= docell(ogcp++, &oca);
465                                  /* clean up */
466 <        if (ocl != NULL) free((char *)ocl);
467 <        if (ncl != NULL) free((char *)ncl);
466 >        if (ogcl != NULL) free((char *)ogcl);
467 >        if (ngcl != NULL) free((char *)ngcl);
468          return(netchange);
469   }
470  
471  
472 < beam_view(vo, vn)       /* change beam view */
417 < VIEW    *vo, *vn;
472 > beam_sync()             /* synchronize beams on server */
473   {
474 +        cbeamop(DR_NEWSET, cbeam, ncbeams, &odev.v, odev.hres, odev.vres);
475 + }
476 +
477 +
478 + beam_view(vn)                   /* change beam view (if advisable) */
479 + VIEW    *vn;
480 + {
481          struct cellact  ca;
482          VOXL    vlnew[8];
483          int     n, comn;
484  
485          if (!vn->type) {                /* clear our beam list */
486                  set_voxels(vlnew, 0);
487 <                cbeamdel(cbeam, ncbeams);
487 >                cbeamop(DR_DELSET, cbeam, ncbeams, NULL, 0, 0);
488                  ncbeams = 0;
489 <                return;
489 >                copystruct(&dvw, vn);
490 >                return(1);
491          }
492                                          /* find our new voxels */
493          n = get_voxels(vlnew, vn->vp);
494 +        if (dvw.type && !n) {
495 +                copystruct(vn, &dvw);           /* cancel move */
496 +                return(0);
497 +        }
498                                          /* set the new voxels */
499          comn = set_voxels(vlnew, n);
500 <        if (!vo->type)
500 >        if (!dvw.type)
501                  comn = 0;
502          ca.add = 1;                     /* update our beam list */
503          for (ca.vi = n; ca.vi--; )
504                  if (comn & 1<<ca.vi)    /* change which cells we see */
505 <                        mvview(ca.vi, vo, vn);
505 >                        mvview(ca.vi, &dvw, vn);
506                  else                    /* else add all new cells */
507                          doview(&ca, vn);
508 + #if 1
509 +        cbeamadj(vn, odev.hres, odev.vres);
510 + #else
511                                          /* inform server of new beams */
512 <        cbeamadd(cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
512 >        cbeamop(DR_ADDSET, cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
513                                          /* sort list to put orphans at end */
514          cbeamsort(0);
515                                          /* tell server to delete orphans */
516 <        cbeamdel(cbeam+ncbeams, xcbeams);
516 >        cbeamop(DR_DELSET, cbeam+ncbeams, xcbeams, NULL, 0, 0);
517          xcbeams = 0;                    /* truncate our list */
518 + #endif
519 +        copystruct(&dvw, vn);           /* record new view */
520 +        return(1);
521   }

Diff Legend

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