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.32 by gwlarson, Thu Mar 4 10:29:22 1999 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         42      /* maximum distance outside section */
15 > #ifndef MEYERNG
16 > #define MEYERNG         0.2     /* target mean eye range (rel. to grid) */
17   #endif
18  
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 –
19   #define CBEAMBLK        1024    /* cbeam allocation block size */
20  
21 < 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 <
21 > static PACKHEAD *cbeam = NULL;  /* current beam list */
22   static int      ncbeams = 0;    /* number of sorted beams in cbeam */
23   static int      xcbeams = 0;    /* extra (unregistered) beams past ncbeams */
24   static int      maxcbeam = 0;   /* size of cbeam array */
25  
26 < 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 */
26 > VIEWPOINT       cureye;         /* current eye position */
27  
47 – struct beamact {
48 –        struct cellact  ca;     /* cell action */
49 –        GCOORD  gc;             /* grid coordinate */
50 – };              /* beam origin and action */
28  
52 –
29   int
30   newcbeam()              /* allocate new entry at end of cbeam array */
31   {
# Line 58 | Line 34 | newcbeam()             /* allocate new entry at end of cbeam arra
34          if ((i = ncbeams + xcbeams++) >= maxcbeam) {    /* grow array */
35                  maxcbeam += CBEAMBLK;
36                  if (cbeam == NULL)
37 <                        cbeam = (struct beamcomp *)malloc(
38 <                                        maxcbeam*sizeof(struct beamcomp) );
37 >                        cbeam = (PACKHEAD *)malloc(
38 >                                        maxcbeam*sizeof(PACKHEAD) );
39                  else
40 <                        cbeam = (struct beamcomp *)realloc( (char *)cbeam,
41 <                                        maxcbeam*sizeof(struct beamcomp) );
40 >                        cbeam = (PACKHEAD *)realloc( (char *)cbeam,
41 >                                        maxcbeam*sizeof(PACKHEAD) );
42                  if (cbeam == NULL)
43                          error(SYSTEM, "out of memory in newcbeam");
44          }
# Line 72 | Line 48 | newcbeam()             /* allocate new entry at end of cbeam arra
48  
49   int
50   cbeamcmp(cb1, cb2)      /* compare two cbeam entries for sort: keep orphans */
51 < register struct beamcomp        *cb1, *cb2;
51 > register PACKHEAD       *cb1, *cb2;
52   {
53          register int    c;
54  
# Line 84 | Line 60 | register struct beamcomp       *cb1, *cb2;
60  
61   int
62   cbeamcmp2(cb1, cb2)     /* compare two cbeam entries for sort: no orphans */
63 < register struct beamcomp        *cb1, *cb2;
63 > register PACKHEAD       *cb1, *cb2;
64   {
65          register int    c;
66  
# Line 102 | Line 78 | int
78   findcbeam(hd, bi)       /* find the specified beam in our sorted list */
79   int     hd, bi;
80   {
81 <        struct beamcomp cb;
82 <        register struct beamcomp        *p;
81 >        PACKHEAD        cb;
82 >        register PACKHEAD       *p;
83  
84          if (ncbeams <= 0)
85                  return(-1);
86 <        cb.hd = hd; cb.bi = bi; cb.nr = 0;
87 <        p = (struct beamcomp *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
88 <                        sizeof(struct beamcomp), cbeamcmp);
86 >        cb.hd = hd; cb.bi = bi; cb.nr = cb.nc = 0;
87 >        p = (PACKHEAD *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
88 >                        sizeof(PACKHEAD), cbeamcmp);
89          if (p == NULL)
90                  return(-1);
91          return(p - cbeam);
# Line 135 | Line 111 | int    bi;
111          if (bi < 1 | bi > nbeams(hdlist[hd]))
112                  error(INTERNAL, "illegal beam index in getcbeam");
113          n = newcbeam();         /* allocate and assign */
114 <        cbeam[n].nr = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
114 >        cbeam[n].hd = hd; cbeam[n].bi = bi; cbeam[n].nr = cbeam[n].nc = 0;
115          return(n);
116   }
117  
# Line 148 | Line 124 | int    adopt;
124          if (!(ncbeams += xcbeams))
125                  return;
126          xcbeams = 0;
127 <        qsort((char *)cbeam, ncbeams, sizeof(struct beamcomp),
127 >        qsort((char *)cbeam, ncbeams, sizeof(PACKHEAD),
128                          adopt ? cbeamcmp : cbeamcmp2);
129          if (adopt)
130                  return;
# Line 160 | Line 136 | int    adopt;
136   }
137  
138  
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 –
139   beam_init(fresh)                /* clear beam list for new view(s) */
140   int     fresh;
141   {
# Line 359 | Line 146 | int    fresh;
146          else                            /* else clear sample requests */
147                  for (i = ncbeams+xcbeams; i--; )
148                          cbeam[i].nr = 0;
149 <        voxel[0].hd = -1;               /* clear voxel list */
149 >        cureye.rng = 0.;
150   }
151  
152  
153 + int2 *
154   beam_view(vn, hr, vr)           /* add beam view (if advisable) */
155   VIEW    *vn;
156   int     hr, vr;
157   {
158 <        struct cellact  ca;
159 <        unsigned int4   vfl;
160 <                                        /* sort our list */
158 >        int2    *slist;
159 >        BEAMLIST        blist;
160 >        double  eravg, d;
161 >        register HOLO   *hp;
162 >        register int    i, n;
163 >                                        /* compute beams for view */
164 >        slist = viewbeams(vn, hr, vr, &blist);
165 >        if (*slist < 0) {
166 >                error(COMMAND, "no sections visible from this view");
167 >                return(NULL);
168 >        }
169 >                                        /* sort current beam list */
170          cbeamsort(1);
171 <                                        /* add new voxels */
172 <        vfl = add_voxels(vn->vp);
173 <        if (!vfl)
174 <                return(0);
175 <        ca.vp = vn; ca.hr = hr; ca.vr = vr;
176 <                                        /* update our beam list */
177 <        for (ca.vi = 0; vfl; vfl >>= 1, ca.vi++)
178 <                if (vfl & 1)
179 <                        doview(&ca);
180 <        return(1);
171 >                                        /* add new beams to list */
172 >        for (i = blist.nb; i--; ) {
173 >                n = getcbeam(blist.bl[i].hd, blist.bl[i].bi);
174 >                if (blist.bl[i].nr > cbeam[n].nr)
175 >                        cbeam[n].nr = blist.bl[i].nr;
176 >        }
177 >        free((char *)blist.bl);         /* free list */
178 >        if (MEYERNG <= FTINY)
179 >                return(slist);
180 >                                        /* compute average eye range */
181 >        eravg = 0.;
182 >        for (n = 0; slist[n] >= 0; n++) {
183 >                hp = hdlist[slist[n]];
184 >                eravg +=        MEYERNG/3. / VLEN(hp->wg[0]) +
185 >                                MEYERNG/3. / VLEN(hp->wg[1]) +
186 >                                MEYERNG/3. / VLEN(hp->wg[2]) ;
187 >        }
188 >        eravg /= (double)n;
189 >                                        /* add to current eye position */
190 >        if (cureye.rng <= FTINY) {
191 >                VCOPY(cureye.vpt, vn->vp);
192 >                cureye.rng = eravg;
193 >        } else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + eravg > cureye.rng) {
194 >                for (i = 3; i--; )
195 >                        cureye.vpt[i] = 0.5*(cureye.vpt[i] + vn->vp[i]);
196 >                cureye.rng = 0.5*(cureye.rng + eravg + d);
197 >        }
198 >        return(slist);
199   }
200  
201  
# Line 388 | Line 203 | int
203   beam_sync(all)                  /* update beam list on server */
204   int     all;
205   {
206 +                                        /* set new eye position */
207 +        serv_request(DR_VIEWPOINT, sizeof(VIEWPOINT), (char *)&cureye);
208                                          /* sort list (put orphans at end) */
209          cbeamsort(all < 0);
210 <        if (all)
211 <                cbeamop(DR_NEWSET, cbeam, ncbeams);
212 <        else
213 <                cbeamop(DR_ADJSET, cbeam, ncbeams+xcbeams);
210 >                                        /* send beam request */
211 >        if (all) {
212 >                if (ncbeams > 0)
213 >                        serv_request(DR_NEWSET,
214 >                                        ncbeams*sizeof(PACKHEAD), cbeam);
215 >        } else {
216 >                if (ncbeams+xcbeams > 0)
217 >                        serv_request(DR_ADJSET,
218 >                                (ncbeams+xcbeams)*sizeof(PACKHEAD), cbeam);
219 >        }
220          xcbeams = 0;                    /* truncate our list */
221          return(ncbeams);
222 + }
223 +
224 +
225 + gridlines(f)                    /* run through holodeck section grid lines */
226 + int     (*f)();
227 + {
228 +        register int    hd, w, i;
229 +        int     g0, g1;
230 +        FVECT   wp[2], mov;
231 +        double  d;
232 +                                        /* do each wall on each section */
233 +        for (hd = 0; hdlist[hd] != NULL; hd++)
234 +                for (w = 0; w < 6; w++) {
235 +                        g0 = hdwg0[w];
236 +                        g1 = hdwg1[w];
237 +                        d = 1.0/hdlist[hd]->grid[g0];
238 +                        mov[0] = d * hdlist[hd]->xv[g0][0];
239 +                        mov[1] = d * hdlist[hd]->xv[g0][1];
240 +                        mov[2] = d * hdlist[hd]->xv[g0][2];
241 +                        if (w & 1) {
242 +                                VSUM(wp[0], hdlist[hd]->orig,
243 +                                                hdlist[hd]->xv[w>>1], 1.);
244 +                                VSUM(wp[0], wp[0], mov, 1.);
245 +                        } else
246 +                                VCOPY(wp[0], hdlist[hd]->orig);
247 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g1], 1.);
248 +                        for (i = hdlist[hd]->grid[g0]; ; ) {    /* g0 lines */
249 +                                (*f)(wp);
250 +                                if (!--i) break;
251 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
252 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
253 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
254 +                        }
255 +                        d = 1.0/hdlist[hd]->grid[g1];
256 +                        mov[0] = d * hdlist[hd]->xv[g1][0];
257 +                        mov[1] = d * hdlist[hd]->xv[g1][1];
258 +                        mov[2] = d * hdlist[hd]->xv[g1][2];
259 +                        if (w & 1)
260 +                                VSUM(wp[0], hdlist[hd]->orig,
261 +                                                hdlist[hd]->xv[w>>1], 1.);
262 +                        else
263 +                                VSUM(wp[0], hdlist[hd]->orig, mov, 1.);
264 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g0], 1.);
265 +                        for (i = hdlist[hd]->grid[g1]; ; ) {    /* g1 lines */
266 +                                (*f)(wp);
267 +                                if (!--i) break;
268 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
269 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
270 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
271 +                        }
272 +                }
273   }

Diff Legend

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