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.8 by gregl, Tue Dec 2 15:02:37 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 > extern GCOORD   *getviewcells();
16  
17 + static VIEW     dvw;            /* current view corresponding to beam list */
18 +
19   typedef struct {
20 <        int     hd;             /* holodeck section number */
20 >        int     hd;             /* holodeck section number (-1 if inactive) */
21          int     i[3];           /* voxel index (may be outside section) */
22   } VOXL;                 /* a voxel */
23  
# Line 36 | Line 38 | static int     ncbeams = 0;    /* number of sorted beams in c
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   };              /* action for cell */
46  
45 –
47   struct beamact {
48          struct cellact  ca;     /* cell action */
49          GCOORD  gc;             /* grid coordinate */
# Line 157 | Line 158 | int    adopt;
158   }
159  
160  
161 < cbeamadd(bl, n, v, hr, vr)      /* add beams to server list */
161 < register struct beamcomp        *bl;
162 < int     n;
161 > cbeamadj(v, hr, vr)             /* adjust our beam list */
162   VIEW    *v;
163   int     hr, vr;
164   {
165          register PACKHEAD       *pa;
166          register int    i;
167 <
168 <        if (n <= 0)
169 <                return;
170 <        pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
171 <        if (pa == NULL)
172 <                error(SYSTEM, "out of memory in cbeamadd");
173 <        for (i = 0; i < n; i++)
174 <                pa[i].nr = npixels(v, hr, vr,
175 <                                hdlist[pa[i].hd=bl[i].hd],
176 <                                pa[i].bi=bl[i].bi) / 8;
177 <
178 <        serv_request(DR_ADDSET, n*sizeof(PACKHEAD), (char *)pa);
167 >        int     n;
168 >                                        /* first handle additions */
169 >        pa = (PACKHEAD *)malloc(xcbeams*sizeof(PACKHEAD));
170 >        if (xcbeams && pa == NULL)
171 >                goto memerr;
172 >        for (i = xcbeams; i--; ) {
173 >                pa[i].hd = cbeam[ncbeams+i].hd;
174 >                pa[i].bi = cbeam[ncbeams+i].bi;
175 >                pa[i].nr = npixels(v, hr, vr, hdlist[pa[i].hd], pa[i].bi);
176 >        }
177 >        n = xcbeams;                    /* now sort list for deletions */
178 >        cbeamsort(0);
179 >        pa = (PACKHEAD *)realloc((char *)pa, (n+xcbeams)*sizeof(PACKHEAD));
180 >        if (n+xcbeams && pa == NULL)
181 >                goto memerr;
182 >        for (i = xcbeams; i--; ) {
183 >                pa[n+i].hd = cbeam[ncbeams+i].hd;
184 >                pa[n+i].bi = cbeam[ncbeams+i].bi;
185 >                pa[n+i].nr = 0;
186 >        }
187 >        n += xcbeams;
188 >        xcbeams = 0;                    /* delete orphans */
189 >        serv_request(DR_ADJSET, n*sizeof(PACKHEAD), (char *)pa);
190          free((char *)pa);
191 +        return;
192 + memerr:
193 +        error(SYSTEM, "out of memory in cbeamadj");
194   }
195  
196  
197 < cbeamdel(bl, n)         /* delete unwanted beam requests */
197 > cbeamop(op, bl, n, v, hr, vr)   /* update beams on server list */
198 > int     op;
199   register struct beamcomp        *bl;
200   int     n;
201 + VIEW    *v;
202 + int     hr, vr;
203   {
204          register PACKHEAD       *pa;
205          register int    i;
# Line 192 | Line 208 | int    n;
208                  return;
209          pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
210          if (pa == NULL)
211 <                error(SYSTEM, "out of memory in cbeamdel");
211 >                error(SYSTEM, "out of memory in cbeamadd");
212          for (i = 0; i < n; i++) {
213                  pa[i].hd = bl[i].hd;
214                  pa[i].bi = bl[i].bi;
215 <                pa[i].nr = 0;           /* removes any request */
215 >                pa[i].nr = v==NULL ? 0 :
216 >                                npixels(v, hr, vr, hdlist[bl[i].hd], bl[i].bi);
217          }
218 <        serv_request(DR_DELSET, n*sizeof(PACKHEAD), (char *)pa);
218 >        serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
219          free((char *)pa);
220   }
221  
# Line 247 | Line 264 | get_voxels(vl, vp)     /* find voxels corresponding to vie
264   VOXL    vl[8];
265   FVECT   vp;
266   {
267 +        static int      lastn = 0, lastd = -1;
268          int     n = 0;
269          FVECT   gp;
270          double  d;
# Line 277 | Line 295 | FVECT  vp;
295                          n++;
296                  }
297          }
298 <        return(n);
298 >                                        /* warn of dangerous moves */
299 >        if (n < lastn && bestd >= lastd)
300 >                error(WARNING, "moving outside holodeck section");
301 >        else if (n > lastn && bestd <= lastd)
302 >                error(WARNING, "moving inside holodeck section");
303 >        lastd = bestd;
304 >        return(lastn = n);
305   }
306  
307  
# Line 289 | Line 313 | register struct beamact        *bp;
313          GCOORD  gc[2];
314          int     bi, i;
315                                          /* compute beam index */
316 <        copystruct(gc, gcp);
317 <        copystruct(gc+1, &bp->gc);
316 >        if (bp->ca.rev) {
317 >                copystruct(gc, &bp->gc);
318 >                copystruct(gc+1, gcp);
319 >        } else {
320 >                copystruct(gc, gcp);
321 >                copystruct(gc+1, &bp->gc);
322 >        }
323          if ((bi = hdbindex(hdlist[voxel[bp->ca.vi].hd], gc)) <= 0)
324 <                return(0);              /* should report an error? */
324 >                error(CONSISTENCY, "bad grid coordinate in dobeam");
325          if (bp->ca.add) {               /* add it in */
326                  i = getcbeam(voxel[bp->ca.vi].hd, bi);
327                  cbeam[i].wants |= 1<<bp->ca.vi; /* say we want it */
# Line 350 | Line 379 | doview(cap, vp)                        /* visit cells for a given view */
379   struct cellact  *cap;
380   VIEW    *vp;
381   {
382 +        int     orient;
383          FVECT   org, dir[4];
384                                          /* compute view pyramid */
385 <        if (vp->type == VT_PAR) goto viewerr;
386 <        if (viewray(org, dir[0], vp, 0., 0.) < -FTINY) goto viewerr;
387 <        if (viewray(org, dir[1], vp, 0., 1.) < -FTINY) goto viewerr;
388 <        if (viewray(org, dir[2], vp, 1., 1.) < -FTINY) goto viewerr;
359 <        if (viewray(org, dir[3], vp, 1., 0.) < -FTINY) goto viewerr;
385 >        orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], vp);
386 >        if (!orient)
387 >                error(INTERNAL, "unusable view in doview");
388 >        cap->rev = orient < 0;
389                                          /* visit cells within pyramid */
390          return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], docell, cap));
362 – viewerr:
363 –        error(INTERNAL, "unusable view in doview");
391   }
392  
393  
# Line 369 | Line 396 | int    voxi;
396   VIEW    *vold, *vnew;
397   {
398          int     netchange = 0;
399 <        int     *ocl, *ncl;
373 <        struct cellact  ca;
399 >        struct cellact  oca, nca;
400          int     ocnt, ncnt;
401          int     c;
402 +        GCOORD  *ogcl, *ngcl;
403          register GCOORD *ogcp, *ngcp;
404                                  /* get old and new cell lists */
405 <        ocl = getviewcells(hdlist[voxel[voxi].hd], vold);
406 <        ncl = getviewcells(hdlist[voxel[voxi].hd], vnew);
407 <        if (ocl != NULL) {
408 <                ocnt = *ocl; ogcp = (GCOORD *)(ocl+1);
409 <        } else {
410 <                ocnt = 0; ogcp = NULL;
411 <        }
412 <        if (ncl != NULL) {
413 <                ncnt = *ncl; ngcp = (GCOORD *)(ncl+1);
414 <        } else {
415 <                ncnt = 0; ngcp = NULL;
416 <        }
417 <        ca.vi = voxi;           /* add and delete cells */
418 <        while (ocnt > 0 & ncnt > 0)
419 <                if ((c = cellcmp(ogcp, ngcp)) > 0) {
420 <                        ca.add = 1;             /* new cell */
421 <                        netchange += docell(ngcp++, &ca);
422 <                        ncnt--;
423 <                } else if (c < 0) {
424 <                        ca.add = 0;             /* obsolete cell */
425 <                        netchange -= docell(ogcp++, &ca);
426 <                        ocnt--;
400 <                } else {
401 <                        ogcp++; ocnt--;         /* unchanged cell */
402 <                        ngcp++; ncnt--;
403 <                }
405 >        ogcp = ogcl = getviewcells(&ocnt, hdlist[voxel[voxi].hd], vold);
406 >        ngcp = ngcl = getviewcells(&ncnt, hdlist[voxel[voxi].hd], vnew);
407 >                                /* set up actions */
408 >        oca.vi = nca.vi = voxi;
409 >        oca.rev = nca.rev = 0;
410 >        oca.add = 0; nca.add = 1;
411 >        if ((oca.rev = ocnt < 0))
412 >                ocnt = -ocnt;
413 >        if ((nca.rev = ncnt < 0))
414 >                ncnt = -ncnt;
415 >        if (nca.rev == oca.rev)         /* add and delete cells in order */
416 >                while (ocnt > 0 & ncnt > 0)
417 >                        if ((c = cellcmp(ogcp, ngcp)) > 0) {    /* new cell */
418 >                                netchange += docell(ngcp++, &nca);
419 >                                ncnt--;
420 >                        } else if (c < 0) {                     /* old cell */
421 >                                netchange -= docell(ogcp++, &oca);
422 >                                ocnt--;
423 >                        } else {                                /* same cell */
424 >                                ogcp++; ocnt--;
425 >                                ngcp++; ncnt--;
426 >                        }
427                                  /* take care of list tails */
428 <        for (ca.add = 1; ncnt > 0; ncnt--)
429 <                docell(ngcp++, &ca);
430 <        for (ca.add = 0; ocnt > 0; ocnt--)
431 <                docell(ogcp++, &ca);
428 >        for ( ; ncnt > 0; ncnt--)
429 >                netchange += docell(ngcp++, &nca);
430 >        for ( ; ocnt > 0; ocnt--)
431 >                netchange -= docell(ogcp++, &oca);
432                                  /* clean up */
433 <        if (ocl != NULL) free((char *)ocl);
434 <        if (ncl != NULL) free((char *)ncl);
433 >        if (ogcl != NULL) free((char *)ogcl);
434 >        if (ngcl != NULL) free((char *)ngcl);
435          return(netchange);
436   }
437  
438  
439 < beam_view(vo, vn)       /* change beam view */
417 < VIEW    *vo, *vn;
439 > beam_sync()             /* synchronize beams on server */
440   {
441 +        cbeamop(DR_NEWSET, cbeam, ncbeams, &odev.v, odev.hres, odev.vres);
442 + }
443 +
444 +
445 + beam_view(vn)                   /* change beam view */
446 + VIEW    *vn;
447 + {
448          struct cellact  ca;
449          VOXL    vlnew[8];
450          int     n, comn;
451  
452          if (!vn->type) {                /* clear our beam list */
453                  set_voxels(vlnew, 0);
454 <                cbeamdel(cbeam, ncbeams);
454 >                cbeamop(DR_DELSET, cbeam, ncbeams, NULL, 0, 0);
455                  ncbeams = 0;
456 +                copystruct(&dvw, vn);
457                  return;
458          }
459                                          /* find our new voxels */
460          n = get_voxels(vlnew, vn->vp);
461                                          /* set the new voxels */
462          comn = set_voxels(vlnew, n);
463 <        if (!vo->type)
463 >        if (!dvw.type)
464                  comn = 0;
465          ca.add = 1;                     /* update our beam list */
466          for (ca.vi = n; ca.vi--; )
467                  if (comn & 1<<ca.vi)    /* change which cells we see */
468 <                        mvview(ca.vi, vo, vn);
468 >                        mvview(ca.vi, &dvw, vn);
469                  else                    /* else add all new cells */
470                          doview(&ca, vn);
471 + #if 1
472 +        cbeamadj(vn, odev.hres, odev.vres);
473 + #else
474                                          /* inform server of new beams */
475 <        cbeamadd(cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
475 >        cbeamop(DR_ADDSET, cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
476                                          /* sort list to put orphans at end */
477          cbeamsort(0);
478                                          /* tell server to delete orphans */
479 <        cbeamdel(cbeam+ncbeams, xcbeams);
479 >        cbeamop(DR_DELSET, cbeam+ncbeams, xcbeams, NULL, 0, 0);
480          xcbeams = 0;                    /* truncate our list */
481 + #endif
482 +        copystruct(&dvw, vn);           /* record new view */
483   }

Diff Legend

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