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.4 by gregl, Fri Nov 21 16:10:17 1997 UTC vs.
Revision 3.9 by gregl, Fri Dec 5 15:50:43 1997 UTC

# 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         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 (-1 if inactive) */
25          int     i[3];           /* voxel index (may be outside section) */
# Line 39 | Line 45 | static int     maxcbeam = 0;   /* size of cbeam array */
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  
51   struct beamact {
# Line 155 | Line 162 | int    adopt;
162   }
163  
164  
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 +        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);
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   cbeamop(op, bl, n, v, hr, vr)   /* update beams on server list */
202   int     op;
203   register struct beamcomp        *bl;
# Line 256 | Line 299 | FVECT  vp;
299                          n++;
300                  }
301          }
302 +                                        /* check for really stupid move */
303 +        if (bestd > MAXDIST) {
304 +                error(WARNING, "move to outer solar system");
305 +                return(0);
306 +        }
307                                          /* warn of dangerous moves */
308          if (n < lastn && bestd >= lastd)
309                  error(WARNING, "moving outside holodeck section");
# Line 274 | 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                  error(CONSISTENCY, "bad grid coordinate in dobeam");
334          if (bp->ca.add) {               /* add it in */
# Line 335 | Line 388 | doview(cap, vp)                        /* visit cells for a given view */
388   struct cellact  *cap;
389   VIEW    *vp;
390   {
391 +        int     orient;
392          FVECT   org, dir[4];
393                                          /* compute view pyramid */
394 <        if (vp->type == VT_PAR) goto viewerr;
395 <        if (viewray(org, dir[0], vp, 0., 0.) < -FTINY) goto viewerr;
396 <        if (viewray(org, dir[1], vp, 0., 1.) < -FTINY) goto viewerr;
397 <        if (viewray(org, dir[2], vp, 1., 1.) < -FTINY) goto viewerr;
344 <        if (viewray(org, dir[3], vp, 1., 0.) < -FTINY) goto viewerr;
394 >        orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], vp);
395 >        if (!orient)
396 >                error(INTERNAL, "unusable view in doview");
397 >        cap->rev = orient < 0;
398                                          /* visit cells within pyramid */
399          return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], docell, cap));
347 – viewerr:
348 –        error(INTERNAL, "unusable view in doview");
400   }
401  
402  
# Line 354 | Line 405 | int    voxi;
405   VIEW    *vold, *vnew;
406   {
407          int     netchange = 0;
408 <        int     *ocl, *ncl;
358 <        struct cellact  ca;
408 >        struct cellact  oca, nca;
409          int     ocnt, ncnt;
410          int     c;
411 +        GCOORD  *ogcl, *ngcl;
412          register GCOORD *ogcp, *ngcp;
413                                  /* get old and new cell lists */
414 <        ocl = getviewcells(hdlist[voxel[voxi].hd], vold);
415 <        ncl = getviewcells(hdlist[voxel[voxi].hd], vnew);
416 <        if (ocl != NULL) {
417 <                ocnt = *ocl; ogcp = (GCOORD *)(ocl+1);
418 <        } else {
419 <                ocnt = 0; ogcp = NULL;
420 <        }
421 <        if (ncl != NULL) {
422 <                ncnt = *ncl; ngcp = (GCOORD *)(ncl+1);
423 <        } else {
424 <                ncnt = 0; ngcp = NULL;
425 <        }
426 <        ca.vi = voxi;           /* add and delete cells */
427 <        while (ocnt > 0 & ncnt > 0)
428 <                if ((c = cellcmp(ogcp, ngcp)) > 0) {
429 <                        ca.add = 1;             /* new cell */
430 <                        netchange += docell(ngcp++, &ca);
431 <                        ncnt--;
432 <                } else if (c < 0) {
433 <                        ca.add = 0;             /* obsolete cell */
434 <                        netchange -= docell(ogcp++, &ca);
435 <                        ocnt--;
385 <                } else {
386 <                        ogcp++; ocnt--;         /* unchanged cell */
387 <                        ngcp++; ncnt--;
388 <                }
414 >        ogcp = ogcl = getviewcells(&ocnt, hdlist[voxel[voxi].hd], vold);
415 >        ngcp = ngcl = getviewcells(&ncnt, hdlist[voxel[voxi].hd], vnew);
416 >                                /* set up actions */
417 >        oca.vi = nca.vi = voxi;
418 >        oca.rev = nca.rev = 0;
419 >        oca.add = 0; nca.add = 1;
420 >        if ((oca.rev = ocnt < 0))
421 >                ocnt = -ocnt;
422 >        if ((nca.rev = ncnt < 0))
423 >                ncnt = -ncnt;
424 >        if (nca.rev == oca.rev)         /* add and delete cells in order */
425 >                while (ocnt > 0 & ncnt > 0)
426 >                        if ((c = cellcmp(ogcp, ngcp)) > 0) {    /* new cell */
427 >                                netchange += docell(ngcp++, &nca);
428 >                                ncnt--;
429 >                        } else if (c < 0) {                     /* old cell */
430 >                                netchange -= docell(ogcp++, &oca);
431 >                                ocnt--;
432 >                        } else {                                /* same cell */
433 >                                ogcp++; ocnt--;
434 >                                ngcp++; ncnt--;
435 >                        }
436                                  /* take care of list tails */
437 <        for (ca.add = 1; ncnt > 0; ncnt--)
438 <                netchange += docell(ngcp++, &ca);
439 <        for (ca.add = 0; ocnt > 0; ocnt--)
440 <                netchange -= docell(ogcp++, &ca);
437 >        for ( ; ncnt > 0; ncnt--)
438 >                netchange += docell(ngcp++, &nca);
439 >        for ( ; ocnt > 0; ocnt--)
440 >                netchange -= docell(ogcp++, &oca);
441                                  /* clean up */
442 <        if (ocl != NULL) free((char *)ocl);
443 <        if (ncl != NULL) free((char *)ncl);
442 >        if (ogcl != NULL) free((char *)ogcl);
443 >        if (ngcl != NULL) free((char *)ngcl);
444          return(netchange);
445   }
446  
# Line 404 | Line 451 | beam_sync()            /* synchronize beams on server */
451   }
452  
453  
454 < beam_view(vo, vn)       /* change beam view */
455 < VIEW    *vo, *vn;
454 > beam_view(vn)                   /* change beam view (if advisable) */
455 > VIEW    *vn;
456   {
457          struct cellact  ca;
458          VOXL    vlnew[8];
# Line 415 | Line 462 | VIEW   *vo, *vn;
462                  set_voxels(vlnew, 0);
463                  cbeamop(DR_DELSET, cbeam, ncbeams, NULL, 0, 0);
464                  ncbeams = 0;
465 <                return;
465 >                copystruct(&dvw, vn);
466 >                return(1);
467          }
468                                          /* find our new voxels */
469          n = get_voxels(vlnew, vn->vp);
470 +        if (dvw.type && !n) {
471 +                copystruct(vn, &dvw);           /* cancel move */
472 +                return(0);
473 +        }
474                                          /* set the new voxels */
475          comn = set_voxels(vlnew, n);
476 <        if (!vo->type)
476 >        if (!dvw.type)
477                  comn = 0;
478          ca.add = 1;                     /* update our beam list */
479          for (ca.vi = n; ca.vi--; )
480                  if (comn & 1<<ca.vi)    /* change which cells we see */
481 <                        mvview(ca.vi, vo, vn);
481 >                        mvview(ca.vi, &dvw, vn);
482                  else                    /* else add all new cells */
483                          doview(&ca, vn);
484 + #if 1
485 +        cbeamadj(vn, odev.hres, odev.vres);
486 + #else
487                                          /* inform server of new beams */
488          cbeamop(DR_ADDSET, cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
489                                          /* sort list to put orphans at end */
# Line 436 | Line 491 | VIEW   *vo, *vn;
491                                          /* tell server to delete orphans */
492          cbeamop(DR_DELSET, cbeam+ncbeams, xcbeams, NULL, 0, 0);
493          xcbeams = 0;                    /* truncate our list */
494 + #endif
495 +        copystruct(&dvw, vn);           /* record new view */
496 +        return(1);
497   }

Diff Legend

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