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.24 by gwlarson, Tue Sep 15 15:59:31 1998 UTC vs.
Revision 3.34 by greg, Wed Apr 23 00:52:33 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Holodeck beam tracking for display process
6   */
# Line 12 | Line 9 | static char SCCSid[] = "$SunId$ SGI";
9   #include "rhdisp.h"
10   #include "rhdriver.h"
11  
12 < #ifndef MAXDIST
13 < #define MAXDIST         42      /* maximum distance outside section */
12 > #ifndef MEYERNG
13 > #define MEYERNG         0.2     /* target mean eye range (rel. to grid) */
14   #endif
15  
19 – #define MAXVOXEL        32      /* maximum number of active voxels */
20 –
21 – typedef struct {
22 –        int     hd;             /* holodeck section number (-1 if inactive) */
23 –        int     i[3];           /* voxel index (may be outside section) */
24 – } VOXL;                 /* a voxel */
25 –
26 – static VOXL voxel[MAXVOXEL] = {{-1}};   /* current voxel list */
27 –
16   #define CBEAMBLK        1024    /* cbeam allocation block size */
17  
18 < static struct beamcomp {
31 <        int     hd;             /* holodeck section number */
32 <        int     bi;             /* beam index */
33 <        int4    nr;             /* number of samples desired */
34 < } *cbeam = NULL;        /* current beam list */
35 <
18 > static PACKHEAD *cbeam = NULL;  /* current beam list */
19   static int      ncbeams = 0;    /* number of sorted beams in cbeam */
20   static int      xcbeams = 0;    /* extra (unregistered) beams past ncbeams */
21   static int      maxcbeam = 0;   /* size of cbeam array */
22  
23 < struct cellact {
41 <        short   vi;             /* voxel index */
42 <        short   rev;            /* reverse ray direction? */
43 <        VIEW    *vp;            /* view for image */
44 <        short   hr, vr;         /* image resolution */
45 < };              /* action for cell */
23 > VIEWPOINT       cureye;         /* current eye position */
24  
47 – struct beamact {
48 –        struct cellact  ca;     /* cell action */
49 –        GCOORD  gc;             /* grid coordinate */
50 – };              /* beam origin and action */
25  
52 –
26   int
27   newcbeam()              /* allocate new entry at end of cbeam array */
28   {
# Line 58 | Line 31 | newcbeam()             /* allocate new entry at end of cbeam arra
31          if ((i = ncbeams + xcbeams++) >= maxcbeam) {    /* grow array */
32                  maxcbeam += CBEAMBLK;
33                  if (cbeam == NULL)
34 <                        cbeam = (struct beamcomp *)malloc(
35 <                                        maxcbeam*sizeof(struct beamcomp) );
34 >                        cbeam = (PACKHEAD *)malloc(
35 >                                        maxcbeam*sizeof(PACKHEAD) );
36                  else
37 <                        cbeam = (struct beamcomp *)realloc( (char *)cbeam,
38 <                                        maxcbeam*sizeof(struct beamcomp) );
37 >                        cbeam = (PACKHEAD *)realloc((void *)cbeam,
38 >                                        maxcbeam*sizeof(PACKHEAD) );
39                  if (cbeam == NULL)
40                          error(SYSTEM, "out of memory in newcbeam");
41          }
# Line 72 | Line 45 | newcbeam()             /* allocate new entry at end of cbeam arra
45  
46   int
47   cbeamcmp(cb1, cb2)      /* compare two cbeam entries for sort: keep orphans */
48 < register struct beamcomp        *cb1, *cb2;
48 > register PACKHEAD       *cb1, *cb2;
49   {
50          register int    c;
51  
# Line 84 | Line 57 | register struct beamcomp       *cb1, *cb2;
57  
58   int
59   cbeamcmp2(cb1, cb2)     /* compare two cbeam entries for sort: no orphans */
60 < register struct beamcomp        *cb1, *cb2;
60 > register PACKHEAD       *cb1, *cb2;
61   {
62          register int    c;
63  
# Line 102 | Line 75 | int
75   findcbeam(hd, bi)       /* find the specified beam in our sorted list */
76   int     hd, bi;
77   {
78 <        struct beamcomp cb;
79 <        register struct beamcomp        *p;
78 >        PACKHEAD        cb;
79 >        register PACKHEAD       *p;
80  
81          if (ncbeams <= 0)
82                  return(-1);
83 <        cb.hd = hd; cb.bi = bi; cb.nr = 0;
84 <        p = (struct beamcomp *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
85 <                        sizeof(struct beamcomp), cbeamcmp);
83 >        cb.hd = hd; cb.bi = bi; cb.nr = cb.nc = 0;
84 >        p = (PACKHEAD *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
85 >                        sizeof(PACKHEAD), cbeamcmp);
86          if (p == NULL)
87                  return(-1);
88          return(p - cbeam);
# Line 135 | Line 108 | int    bi;
108          if (bi < 1 | bi > nbeams(hdlist[hd]))
109                  error(INTERNAL, "illegal beam index in getcbeam");
110          n = newcbeam();         /* allocate and assign */
111 <        cbeam[n].nr = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
111 >        cbeam[n].hd = hd; cbeam[n].bi = bi; cbeam[n].nr = cbeam[n].nc = 0;
112          return(n);
113   }
114  
# Line 148 | Line 121 | int    adopt;
121          if (!(ncbeams += xcbeams))
122                  return;
123          xcbeams = 0;
124 <        qsort((char *)cbeam, ncbeams, sizeof(struct beamcomp),
124 >        qsort((char *)cbeam, ncbeams, sizeof(PACKHEAD),
125                          adopt ? cbeamcmp : cbeamcmp2);
126          if (adopt)
127                  return;
# Line 160 | Line 133 | int    adopt;
133   }
134  
135  
163 – cbeamop(op, bl, n)              /* update beams on server list */
164 – int     op;
165 – register struct beamcomp        *bl;
166 – int     n;
167 – {
168 –        register PACKHEAD       *pa;
169 –        register int    i;
170 –
171 –        if (n <= 0)
172 –                return;
173 –        pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
174 –        if (pa == NULL)
175 –                error(SYSTEM, "out of memory in cbeamop");
176 –        for (i = 0; i < n; i++) {
177 –                pa[i].hd = bl[i].hd;
178 –                pa[i].bi = bl[i].bi;
179 –                pa[i].nr = bl[i].nr;
180 –                pa[i].nc = 0;
181 –        }
182 –        serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
183 –        free((char *)pa);
184 – }
185 –
186 –
187 – unsigned int4
188 – add_voxels(vp)          /* add voxels corresponding to view point */
189 – FVECT   vp;
190 – {
191 –        int     first, n, rfl = 0;
192 –        FVECT   gp;
193 –        double  d;
194 –        int     dist, bestd = 0x7fff;
195 –        VOXL    vox;
196 –        register int    i, j, k;
197 –                                        /* count voxels in list already */
198 –        for (first = 0; first < MAXVOXEL && voxel[first].hd >= 0; first++)
199 –                ;
200 –                                        /* find closest voxels */
201 –        for (n = first, i = 0; n < MAXVOXEL && hdlist[i]; i++) {
202 –                hdgrid(gp, hdlist[i], vp);
203 –                for (j = 0; n < MAXVOXEL && j < 8; j++) {
204 –                        dist = 0;
205 –                        for (k = 0; k < 3; k++) {
206 –                                d = gp[k] - .5 + (j>>k & 1);
207 –                                if (d < 0.)
208 –                                        dist += -(vox.i[k] = (int)d - 1);
209 –                                else if ((vox.i[k] = d) >= hdlist[i]->grid[k])
210 –                                        dist += vox.i[k] -
211 –                                                        hdlist[i]->grid[k] + 1;
212 –                        }
213 –                        if (dist > bestd)       /* others were closer */
214 –                                continue;
215 –                        if (dist < bestd) {     /* start closer list */
216 –                                n = first;
217 –                                bestd = dist;
218 –                                rfl = 0;
219 –                        }
220 –                                                /* check if already in list */
221 –                        for (k = first; k--; )
222 –                                if (voxel[k].hd == i &&
223 –                                                voxel[k].i[0] == vox.i[0] &&
224 –                                                voxel[k].i[1] == vox.i[1] &&
225 –                                                voxel[k].i[2] == vox.i[2])
226 –                                        break;
227 –                        if (k >= 0) {
228 –                                rfl |= 1<<k;
229 –                                continue;
230 –                        }
231 –                        vox.hd = i;             /* add this voxel */
232 –                        copystruct(&voxel[n], &vox);
233 –                        rfl |= 1<<n++;
234 –                }
235 –        }
236 –                                        /* check for really stupid move */
237 –        if (bestd > MAXDIST) {
238 –                error(COMMAND, "move past outer limits");
239 –                return(0);
240 –        }
241 –        if (n < MAXVOXEL)
242 –                voxel[n].hd = -1;
243 –        return(rfl);
244 – }
245 –
246 –
247 – int
248 – dobeam(gcp, bp)         /* express interest in a beam */
249 – GCOORD  *gcp;
250 – register struct beamact *bp;
251 – {
252 –        GCOORD  gc[2];
253 –        int     bi, i, n;
254 –                                        /* compute beam index */
255 –        if (bp->ca.rev) {
256 –                copystruct(gc, &bp->gc);
257 –                copystruct(gc+1, gcp);
258 –        } else {
259 –                copystruct(gc, gcp);
260 –                copystruct(gc+1, &bp->gc);
261 –        }
262 –        if ((bi = hdbindex(hdlist[voxel[bp->ca.vi].hd], gc)) <= 0)
263 –                error(CONSISTENCY, "bad grid coordinate in dobeam");
264 –                                        /* add it in */
265 –        i = getcbeam(voxel[bp->ca.vi].hd, bi);
266 –        n = npixels(bp->ca.vp, bp->ca.hr, bp->ca.vr,
267 –                        hdlist[cbeam[i].hd], cbeam[i].bi);
268 –        if (n > cbeam[i].nr)
269 –                cbeam[i].nr = n;
270 –        return(i == ncbeams+xcbeams-1); /* return 1 if totally new */
271 – }
272 –
273 –
274 –
275 – int
276 – docell(gcp, cap)        /* find beams corresponding to cell and voxel */
277 – GCOORD  *gcp;
278 – register struct cellact *cap;
279 – {
280 –        register HOLO   *hp = hdlist[voxel[cap->vi].hd];
281 –        FVECT   org, dir[4];
282 –        FVECT   vgp, cgp, vc;
283 –        FVECT   v1, v2;
284 –        struct beamact  bo;
285 –        int     axmax, j;
286 –        double  d, avmax;
287 –        register int    i;
288 –                                /* compute cell center */
289 –        cgp[gcp->w>>1] = gcp->w&1 ? hp->grid[gcp->w>>1] : 0 ;
290 –        cgp[hdwg0[gcp->w]] = gcp->i[0] + .5;
291 –        cgp[hdwg1[gcp->w]] = gcp->i[1] + .5;
292 –        hdworld(org, hp, cgp);
293 –                                /* compute direction to voxel center */
294 –        for (i = 3; i--; )
295 –                vgp[i] = voxel[cap->vi].i[i] + .5;
296 –        hdworld(vc, hp, vgp);
297 –        for (i = 3; i--; )
298 –                vc[i] -= org[i];
299 –                                /* compute maximum area axis */
300 –        axmax = -1; avmax = 0;
301 –        for (i = 3; i--; ) {
302 –                d = vgp[i] - cgp[i];
303 –                if (d < 0.) d = -d;
304 –                if (d > avmax) {
305 –                        avmax = d;
306 –                        axmax = i;
307 –                }
308 –        }
309 – #ifdef DEBUG
310 –        if (axmax < 0)
311 –                error(CONSISTENCY, "botched axis computation in docell");
312 – #endif
313 –                                /* compute offset vectors */
314 –        d = 0.5/hp->grid[j=(axmax+1)%3];
315 –        for (i = 3; i--; )
316 –                v1[i] = hp->xv[j][i] * d;
317 –        d = 0.5/hp->grid[j=(axmax+2)%3];
318 –        if (DOT(hp->wg[axmax], vc) < 0.)
319 –                d = -d; /* reverse vertex order */
320 –        for (i = 3; i--; )
321 –                v2[i] = hp->xv[j][i] * d;
322 –                                /* compute voxel pyramid */
323 –        for (i = 3; i--; ) {
324 –                dir[0][i] = vc[i] - v1[i] - v2[i];
325 –                dir[1][i] = vc[i] + v1[i] - v2[i];
326 –                dir[2][i] = vc[i] + v1[i] + v2[i];
327 –                dir[3][i] = vc[i] - v1[i] + v2[i];
328 –        }
329 –                                /* visit beams for opposite cells */
330 –        copystruct(&bo.ca, cap);
331 –        copystruct(&bo.gc, gcp);
332 –        return(visit_cells(org, dir, hp, dobeam, &bo));
333 – }
334 –
335 –
336 – int
337 – doview(cap)                     /* visit cells for a given view */
338 – struct cellact  *cap;
339 – {
340 –        int     orient;
341 –        FVECT   org, dir[4];
342 –                                        /* compute view pyramid */
343 –        orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], cap->vp);
344 –        if (!orient)
345 –                error(INTERNAL, "unusable view in doview");
346 –        cap->rev = orient < 0;
347 –                                        /* visit cells within pyramid */
348 –        return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], docell, cap));
349 – }
350 –
351 –
136   beam_init(fresh)                /* clear beam list for new view(s) */
137   int     fresh;
138   {
# Line 359 | Line 143 | int    fresh;
143          else                            /* else clear sample requests */
144                  for (i = ncbeams+xcbeams; i--; )
145                          cbeam[i].nr = 0;
146 <        voxel[0].hd = -1;               /* clear voxel list */
146 >        cureye.rng = 0.;
147   }
148  
149  
150 + int2 *
151   beam_view(vn, hr, vr)           /* add beam view (if advisable) */
152   VIEW    *vn;
153   int     hr, vr;
154   {
155 <        struct cellact  ca;
156 <        unsigned int4   vfl;
157 <                                        /* sort our list */
155 >        int2    *slist;
156 >        BEAMLIST        blist;
157 >        double  eravg, d;
158 >        register HOLO   *hp;
159 >        register int    i, n;
160 >                                        /* compute beams for view */
161 >        slist = viewbeams(vn, hr, vr, &blist);
162 >        if (*slist < 0) {
163 >                error(COMMAND, "no sections visible from this view");
164 >                return(NULL);
165 >        }
166 >                                        /* sort current beam list */
167          cbeamsort(1);
168 <                                        /* add new voxels */
169 <        vfl = add_voxels(vn->vp);
170 <        if (!vfl)
171 <                return(0);
172 <        ca.vp = vn; ca.hr = hr; ca.vr = vr;
173 <                                        /* update our beam list */
174 <        for (ca.vi = 0; vfl; vfl >>= 1, ca.vi++)
175 <                if (vfl & 1)
176 <                        doview(&ca);
177 <        return(1);
168 >                                        /* add new beams to list */
169 >        for (i = blist.nb; i--; ) {
170 >                n = getcbeam(blist.bl[i].hd, blist.bl[i].bi);
171 >                if (blist.bl[i].nr > cbeam[n].nr)
172 >                        cbeam[n].nr = blist.bl[i].nr;
173 >        }
174 >        free((void *)blist.bl);         /* free list */
175 >        if (MEYERNG <= FTINY)
176 >                return(slist);
177 >                                        /* compute average eye range */
178 >        eravg = 0.;
179 >        for (n = 0; slist[n] >= 0; n++) {
180 >                hp = hdlist[slist[n]];
181 >                eravg +=        MEYERNG/3. / VLEN(hp->wg[0]) +
182 >                                MEYERNG/3. / VLEN(hp->wg[1]) +
183 >                                MEYERNG/3. / VLEN(hp->wg[2]) ;
184 >        }
185 >        eravg /= (double)n;
186 >                                        /* add to current eye position */
187 >        if (cureye.rng <= FTINY) {
188 >                VCOPY(cureye.vpt, vn->vp);
189 >                cureye.rng = eravg;
190 >        } else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + eravg > cureye.rng) {
191 >                for (i = 3; i--; )
192 >                        cureye.vpt[i] = 0.5*(cureye.vpt[i] + vn->vp[i]);
193 >                cureye.rng = 0.5*(cureye.rng + eravg + d);
194 >        }
195 >        return(slist);
196   }
197  
198  
# Line 388 | Line 200 | int
200   beam_sync(all)                  /* update beam list on server */
201   int     all;
202   {
203 +                                        /* set new eye position */
204 +        serv_request(DR_VIEWPOINT, sizeof(VIEWPOINT), (char *)&cureye);
205                                          /* sort list (put orphans at end) */
206          cbeamsort(all < 0);
207 <        if (all)
208 <                cbeamop(DR_NEWSET, cbeam, ncbeams);
209 <        else
210 <                cbeamop(DR_ADJSET, cbeam, ncbeams+xcbeams);
207 >                                        /* send beam request */
208 >        if (all) {
209 >                if (ncbeams > 0)
210 >                        serv_request(DR_NEWSET,
211 >                                        ncbeams*sizeof(PACKHEAD), cbeam);
212 >        } else {
213 >                if (ncbeams+xcbeams > 0)
214 >                        serv_request(DR_ADJSET,
215 >                                (ncbeams+xcbeams)*sizeof(PACKHEAD), cbeam);
216 >        }
217          xcbeams = 0;                    /* truncate our list */
218          return(ncbeams);
219 + }
220 +
221 +
222 + gridlines(f)                    /* run through holodeck section grid lines */
223 + int     (*f)();
224 + {
225 +        register int    hd, w, i;
226 +        int     g0, g1;
227 +        FVECT   wp[2], mov;
228 +        double  d;
229 +                                        /* do each wall on each section */
230 +        for (hd = 0; hdlist[hd] != NULL; hd++)
231 +                for (w = 0; w < 6; w++) {
232 +                        g0 = hdwg0[w];
233 +                        g1 = hdwg1[w];
234 +                        d = 1.0/hdlist[hd]->grid[g0];
235 +                        mov[0] = d * hdlist[hd]->xv[g0][0];
236 +                        mov[1] = d * hdlist[hd]->xv[g0][1];
237 +                        mov[2] = d * hdlist[hd]->xv[g0][2];
238 +                        if (w & 1) {
239 +                                VSUM(wp[0], hdlist[hd]->orig,
240 +                                                hdlist[hd]->xv[w>>1], 1.);
241 +                                VSUM(wp[0], wp[0], mov, 1.);
242 +                        } else
243 +                                VCOPY(wp[0], hdlist[hd]->orig);
244 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g1], 1.);
245 +                        for (i = hdlist[hd]->grid[g0]; ; ) {    /* g0 lines */
246 +                                (*f)(wp);
247 +                                if (!--i) break;
248 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
249 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
250 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
251 +                        }
252 +                        d = 1.0/hdlist[hd]->grid[g1];
253 +                        mov[0] = d * hdlist[hd]->xv[g1][0];
254 +                        mov[1] = d * hdlist[hd]->xv[g1][1];
255 +                        mov[2] = d * hdlist[hd]->xv[g1][2];
256 +                        if (w & 1)
257 +                                VSUM(wp[0], hdlist[hd]->orig,
258 +                                                hdlist[hd]->xv[w>>1], 1.);
259 +                        else
260 +                                VSUM(wp[0], hdlist[hd]->orig, mov, 1.);
261 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g0], 1.);
262 +                        for (i = hdlist[hd]->grid[g1]; ; ) {    /* g1 lines */
263 +                                (*f)(wp);
264 +                                if (!--i) break;
265 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
266 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
267 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
268 +                        }
269 +                }
270   }

Diff Legend

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