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.26 by gwlarson, Tue Nov 24 17:05:36 1998 UTC vs.
Revision 3.36 by schorsch, Sun Jul 27 22:12:02 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 11 | Line 8 | static char SCCSid[] = "$SunId$ SGI";
8   #include "rholo.h"
9   #include "rhdisp.h"
10   #include "rhdriver.h"
14 – #include "random.h"
11  
16 – #ifndef MAXDIST
17 – #define MAXDIST         42      /* maximum distance outside section */
18 – #endif
19 – #ifndef NVSAMPS
20 – #define NVSAMPS         4096    /* number of ray samples per view */
21 – #endif
12   #ifndef MEYERNG
13   #define MEYERNG         0.2     /* target mean eye range (rel. to grid) */
14   #endif
25 – #ifndef MAXTODO
26 – #define MAXTODO         3       /* maximum sections to look at */
27 – #endif
28 – #ifndef MAXDRAT
29 – #define MAXDRAT         3.0     /* maximum distance ratio btwn. cand. sect. */
30 – #endif
15  
16   #define CBEAMBLK        1024    /* cbeam allocation block size */
17  
18 < static struct beamcomp {
35 <        int     hd;             /* holodeck section number */
36 <        int     bi;             /* beam index */
37 <        int4    nr;             /* number of samples desired */
38 < } *cbeam = NULL;        /* current beam list */
39 <
40 < VIEWPOINT       cureye;         /* current eye position */
41 <
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 + VIEWPOINT       cureye;         /* current eye position */
24  
25 +
26   int
27   newcbeam()              /* allocate new entry at end of cbeam array */
28   {
# Line 52 | 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 66 | 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 78 | 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 96 | 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 124 | Line 103 | int    bi;
103                  if (cbeam[n].bi == bi && cbeam[n].hd == hd)
104                          return(n);
105                                  /* check legality */
106 <        if (hd < 0 | hd >= HDMAX || hdlist[hd] == NULL)
106 >        if ((hd < 0) | (hd >= HDMAX) || hdlist[hd] == NULL)
107                  error(INTERNAL, "illegal holodeck number in getcbeam");
108 <        if (bi < 1 | bi > nbeams(hdlist[hd]))
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 142 | 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 154 | Line 133 | int    adopt;
133   }
134  
135  
157 – cbeamop(op, bl, n)              /* update beams on server list */
158 – int     op;
159 – register struct beamcomp        *bl;
160 – int     n;
161 – {
162 –        register PACKHEAD       *pa;
163 –        register int    i;
164 –
165 –        if (n <= 0)
166 –                return;
167 –        pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
168 –        if (pa == NULL)
169 –                error(SYSTEM, "out of memory in cbeamop");
170 –        for (i = 0; i < n; i++) {
171 –                pa[i].hd = bl[i].hd;
172 –                pa[i].bi = bl[i].bi;
173 –                pa[i].nr = bl[i].nr;
174 –                pa[i].nc = 0;
175 –        }
176 –        serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
177 –        free((char *)pa);
178 – }
179 –
180 –
181 – int
182 – comptodo(tdl, vw)               /* compute holodeck sections in view */
183 – int     tdl[MAXTODO+1];
184 – VIEW    *vw;
185 – {
186 –        int     n = 0;
187 –        FVECT   gp, dv;
188 –        double  dist2[MAXTODO+1], thisdist2;
189 –        register int    i, j;
190 –                                        /* find closest MAXTODO sections */
191 –        for (i = 0; hdlist[i]; i++) {
192 –                hdgrid(gp, hdlist[i], vw->vp);
193 –                for (j = 0; j < 3; j++)
194 –                        if (gp[j] < 0.)
195 –                                dv[j] = -gp[j];
196 –                        else if (gp[j] > hdlist[i]->grid[j])
197 –                                dv[j] = gp[j] - hdlist[i]->grid[j];
198 –                        else
199 –                                dv[j] = 0.;
200 –                thisdist2 = DOT(dv,dv);
201 –                for (j = n; j > 0 && thisdist2 < dist2[j-1]; j--) {
202 –                        tdl[j] = tdl[j-1];
203 –                        dist2[j] = dist2[j-1];
204 –                }
205 –                tdl[j] = i;
206 –                dist2[j] = thisdist2;
207 –                if (n < MAXTODO)
208 –                        n++;
209 –        }
210 –                                        /* watch for bad move */
211 –        if (n && dist2[0] > MAXDIST*MAXDIST) {
212 –                error(COMMAND, "move past outer limits");
213 –                return(0);
214 –        }
215 –                                        /* avoid big differences */
216 –        for (j = 1; j < n; j++)
217 –                if (dist2[j] > MAXDRAT*MAXDRAT*dist2[j-1])
218 –                        n = j;
219 –        tdl[n] = -1;
220 –        return(n);
221 – }
222 –
223 –
224 – addview(hd, vw, hres, vres)     /* add view for section */
225 – int     hd;
226 – VIEW    *vw;
227 – int     hres, vres;
228 – {
229 –        int     sampquant;
230 –        int     h, v, shr, svr;
231 –        GCOORD  gc[2];
232 –        FVECT   rorg, rdir;
233 –                                /* compute sampling grid */
234 –        if (hres|vres && hres*vres <= NVSAMPS) {
235 –                shr = hres; svr = vres;
236 –                sampquant = 1;
237 –        } else {
238 –                shr = sqrt(NVSAMPS/viewaspect(vw)) + .5;
239 –                svr = (NVSAMPS + shr/2)/shr;
240 –                sampquant = (hres*vres + shr*svr/2)/(shr*svr);
241 –        }
242 –                                /* intersect sample rays with section */
243 –        for (v = svr; v--; )
244 –                for (h = shr; h--; ) {
245 –                        if (viewray(rorg, rdir, vw, (v+frandom())/svr,
246 –                                                (h+frandom())/shr) < -FTINY)
247 –                                continue;
248 –                        if (hdinter(gc, NULL, NULL, hdlist[hd], rorg, rdir)
249 –                                                >= FHUGE)
250 –                                continue;
251 –                        cbeam[getcbeam(hd,hdbindex(hdlist[hd],gc))].nr +=
252 –                                        sampquant;
253 –                }
254 – }
255 –
256 –
136   beam_init(fresh)                /* clear beam list for new view(s) */
137   int     fresh;
138   {
# Line 268 | Line 147 | int    fresh;
147   }
148  
149  
150 + int16 *
151   beam_view(vn, hr, vr)           /* add beam view (if advisable) */
152   VIEW    *vn;
153   int     hr, vr;
154   {
155 <        int     todo[MAXTODO+1], n;
156 <        double  hdgsiz, d;
155 >        int16   *slist;
156 >        BEAMLIST        blist;
157 >        double  eravg, d;
158          register HOLO   *hp;
159 <        register int    i;
160 <                                        /* sort our list */
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 view to nearby sections */
169 <        if (!(n = comptodo(todo, vn)))
170 <                return(0);
171 <        for (i = 0; i < n; i++)
172 <                addview(todo[i], vn, hr, vr);
286 <        if (MEYERNG <= FTINY || vn->type == VT_PAR)
287 <                return(1);
288 <        hdgsiz = 0.; d = 1./3. / n;     /* compute mean grid size */
289 <        for (i = 0; i < n; i++) {
290 <                hp = hdlist[todo[i]];
291 <                hdgsiz += d * ( VLEN(hp->xv[0])/hp->grid[0] +
292 <                                VLEN(hp->xv[1])/hp->grid[1] +
293 <                                VLEN(hp->xv[2])/hp->grid[2] ) ;
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 = MEYERNG * hdgsiz;
190 <        } else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + MEYERNG*hdgsiz >
300 <                        cureye.rng) {
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 + MEYERNG*hdgsiz + d);
193 >                cureye.rng = 0.5*(cureye.rng + eravg + d);
194          }
195 <        return(1);
195 >        return(slist);
196   }
197  
198  
# Line 315 | Line 205 | int    all;
205                                          /* sort list (put orphans at end) */
206          cbeamsort(all < 0);
207                                          /* send beam request */
208 <        if (all)
209 <                cbeamop(DR_NEWSET, cbeam, ncbeams);
210 <        else
211 <                cbeamop(DR_ADJSET, cbeam, ncbeams+xcbeams);
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