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.2 by gregl, Thu Nov 20 14:46:07 1997 UTC vs.
Revision 3.10 by gregl, Mon Dec 8 19:03:01 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 < cbeamadd(bl, n, v, hr, vr)      /* add beams to server list */
159 < register struct beamcomp        *bl;
160 < 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 190 | 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 245 | 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 275 | 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 287 | 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 312 | 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] + 0.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 348 | 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;
357 <        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));
360 – viewerr:
361 –        error(INTERNAL, "unusable view in doview");
425   }
426  
427  
# Line 367 | Line 430 | int    voxi;
430   VIEW    *vold, *vnew;
431   {
432          int     netchange = 0;
433 <        int     *ocl, *ncl;
371 <        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);
460 <                        ocnt--;
398 <                } else {
399 <                        ogcp++; ocnt--;         /* unchanged cell */
400 <                        ngcp++; ncnt--;
401 <                }
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.rev = nca.rev = 0;
444 >        oca.add = 0; nca.add = 1;
445 >        if ((oca.rev = ocnt < 0))
446 >                ocnt = -ocnt;
447 >        if ((nca.rev = ncnt < 0))
448 >                ncnt = -ncnt;
449 >        if (nca.rev == oca.rev)         /* add and delete cells in order */
450 >                while (ocnt > 0 & ncnt > 0)
451 >                        if ((c = cellcmp(ogcp, ngcp)) > 0) {    /* new cell */
452 >                                netchange += docell(ngcp++, &nca);
453 >                                ncnt--;
454 >                        } else if (c < 0) {                     /* old cell */
455 >                                netchange -= docell(ogcp++, &oca);
456 >                                ocnt--;
457 >                        } else {                                /* same cell */
458 >                                ogcp++; ocnt--;
459 >                                ngcp++; ncnt--;
460 >                        }
461                                  /* take care of list tails */
462 <        for (ca.add = 1; ncnt > 0; ncnt--)
463 <                netchange += docell(ngcp++, &ca);
464 <        for (ca.add = 0; ocnt > 0; ocnt--)
465 <                netchange -= docell(ogcp++, &ca);
462 >        for ( ; ncnt > 0; ncnt--)
463 >                netchange += docell(ngcp++, &nca);
464 >        for ( ; ocnt > 0; ocnt--)
465 >                netchange -= docell(ogcp++, &oca);
466                                  /* clean up */
467 <        if (ocl != NULL) free((char *)ocl);
468 <        if (ncl != NULL) free((char *)ncl);
467 >        if (ogcl != NULL) free((char *)ogcl);
468 >        if (ngcl != NULL) free((char *)ngcl);
469          return(netchange);
470   }
471  
472  
473 < beam_view(vo, vn)       /* change beam view */
415 < VIEW    *vo, *vn;
473 > beam_sync()             /* synchronize beams on server */
474   {
475 +        cbeamop(DR_NEWSET, cbeam, ncbeams, &odev.v, odev.hres, odev.vres);
476 + }
477 +
478 +
479 + beam_view(vn)                   /* change beam view (if advisable) */
480 + VIEW    *vn;
481 + {
482          struct cellact  ca;
483          VOXL    vlnew[8];
484          int     n, comn;
485  
486          if (!vn->type) {                /* clear our beam list */
487                  set_voxels(vlnew, 0);
488 <                cbeamdel(cbeam, ncbeams);
488 >                cbeamop(DR_DELSET, cbeam, ncbeams, NULL, 0, 0);
489                  ncbeams = 0;
490 <                return;
490 >                copystruct(&dvw, vn);
491 >                return(1);
492          }
493                                          /* find our new voxels */
494          n = get_voxels(vlnew, vn->vp);
495 +        if (dvw.type && !n) {
496 +                copystruct(vn, &dvw);           /* cancel move */
497 +                return(0);
498 +        }
499                                          /* set the new voxels */
500          comn = set_voxels(vlnew, n);
501 <        if (!vo->type)
501 >        if (!dvw.type)
502                  comn = 0;
503          ca.add = 1;                     /* update our beam list */
504          for (ca.vi = n; ca.vi--; )
505                  if (comn & 1<<ca.vi)    /* change which cells we see */
506 <                        mvview(ca.vi, vo, vn);
506 >                        mvview(ca.vi, &dvw, vn);
507                  else                    /* else add all new cells */
508                          doview(&ca, vn);
509 + #if 1
510 +        cbeamadj(vn, odev.hres, odev.vres);
511 + #else
512                                          /* inform server of new beams */
513 <        cbeamadd(cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
513 >        cbeamop(DR_ADDSET, cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
514                                          /* sort list to put orphans at end */
515          cbeamsort(0);
516                                          /* tell server to delete orphans */
517 <        cbeamdel(cbeam+ncbeams, xcbeams);
517 >        cbeamop(DR_DELSET, cbeam+ncbeams, xcbeams, NULL, 0, 0);
518          xcbeams = 0;                    /* truncate our list */
519 + #endif
520 +        copystruct(&dvw, vn);           /* record new view */
521 +        return(1);
522   }

Diff Legend

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