ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/src/hd/rhdisp2.c
(Generate patch)

Comparing src/hd/rhdisp2.c (file contents):
Revision 3.6 by gregl, Mon Nov 24 15:17:28 1997 UTC vs.
Revision 3.12 by gregl, Thu Dec 11 09:36:59 1997 UTC

# Line 12 | Line 12 | static char SCCSid[] = "$SunId$ SGI";
12   #include "rhdisp.h"
13   #include "rhdriver.h"
14  
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 156 | 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) + 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   cbeamop(op, bl, n, v, hr, vr)   /* update beams on server list */
202   int     op;
203   register struct beamcomp        *bl;
# Line 257 | Line 299 | FVECT  vp;
299                          n++;
300                  }
301          }
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");
# Line 305 | 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 361 | Line 433 | VIEW   *vold, *vnew;
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 <        ogcp = getviewcells(&ocnt, hdlist[voxel[voxi].hd], vold);
440 <        ngcp = getviewcells(&ncnt, hdlist[voxel[voxi].hd], vnew);
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;
370 –        oca.rev = nca.rev = 0;
443          oca.add = 0; nca.add = 1;
444          if ((oca.rev = ocnt < 0))
445                  ocnt = -ocnt;
# Line 391 | Line 463 | VIEW   *vold, *vnew;
463          for ( ; ocnt > 0; ocnt--)
464                  netchange -= docell(ogcp++, &oca);
465                                  /* clean up */
466 <        if (ogcp != NULL) free((char *)ogcp);
467 <        if (ngcp != NULL) free((char *)ngcp);
466 >        if (ogcl != NULL) free((char *)ogcl);
467 >        if (ngcl != NULL) free((char *)ngcl);
468          return(netchange);
469   }
470  
471  
472 + int
473   beam_sync()             /* synchronize beams on server */
474   {
475          cbeamop(DR_NEWSET, cbeam, ncbeams, &odev.v, odev.hres, odev.vres);
476 +        return(ncbeams);
477   }
478  
479  
480 < beam_view(vo, vn)       /* change beam view */
481 < VIEW    *vo, *vn;
480 > beam_view(vn)                   /* change beam view (if advisable) */
481 > VIEW    *vn;
482   {
483          struct cellact  ca;
484          VOXL    vlnew[8];
# Line 414 | Line 488 | VIEW   *vo, *vn;
488                  set_voxels(vlnew, 0);
489                  cbeamop(DR_DELSET, cbeam, ncbeams, NULL, 0, 0);
490                  ncbeams = 0;
491 <                return;
491 >                copystruct(&dvw, vn);
492 >                return(1);
493          }
494                                          /* find our new voxels */
495          n = get_voxels(vlnew, vn->vp);
496 +        if (dvw.type && !n) {
497 +                copystruct(vn, &dvw);           /* cancel move */
498 +                return(0);
499 +        }
500                                          /* set the new voxels */
501          comn = set_voxels(vlnew, n);
502 <        if (!vo->type)
502 >        if (!dvw.type)
503                  comn = 0;
504          ca.add = 1;                     /* update our beam list */
505          for (ca.vi = n; ca.vi--; )
506                  if (comn & 1<<ca.vi)    /* change which cells we see */
507 <                        mvview(ca.vi, vo, vn);
507 >                        mvview(ca.vi, &dvw, vn);
508                  else                    /* else add all new cells */
509                          doview(&ca, vn);
510 + #if 1
511 +        cbeamadj(vn, odev.hres, odev.vres);
512 + #else
513                                          /* inform server of new beams */
514          cbeamop(DR_ADDSET, cbeam+ncbeams, xcbeams, vn, odev.hres, odev.vres);
515                                          /* sort list to put orphans at end */
# Line 435 | Line 517 | VIEW   *vo, *vn;
517                                          /* tell server to delete orphans */
518          cbeamop(DR_DELSET, cbeam+ncbeams, xcbeams, NULL, 0, 0);
519          xcbeams = 0;                    /* truncate our list */
520 + #endif
521 +        copystruct(&dvw, vn);           /* record new view */
522 +        return(1);
523   }

Diff Legend

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