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.26 by gwlarson, Tue Nov 24 17:05:36 1998 UTC vs.
Revision 3.37 by schorsch, Thu Jan 1 11:21:55 2004 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 < int
26 < newcbeam()              /* allocate new entry at end of cbeam array */
25 > static int newcbeam(void);
26 > static int cbeamcmp(const void *cb1, const void *cb2);
27 > static int cbeamcmp2(const void *cb1, const void *cb2);
28 > static int findcbeam(int hd, int bi);
29 > static int getcbeam(int hd, int bi);
30 > static void cbeamsort(int adopt);
31 >
32 >
33 > static int
34 > newcbeam(void)          /* allocate new entry at end of cbeam array */
35   {
36          int     i;
37  
38          if ((i = ncbeams + xcbeams++) >= maxcbeam) {    /* grow array */
39                  maxcbeam += CBEAMBLK;
40                  if (cbeam == NULL)
41 <                        cbeam = (struct beamcomp *)malloc(
42 <                                        maxcbeam*sizeof(struct beamcomp) );
41 >                        cbeam = (PACKHEAD *)malloc(
42 >                                        maxcbeam*sizeof(PACKHEAD) );
43                  else
44 <                        cbeam = (struct beamcomp *)realloc( (char *)cbeam,
45 <                                        maxcbeam*sizeof(struct beamcomp) );
44 >                        cbeam = (PACKHEAD *)realloc((void *)cbeam,
45 >                                        maxcbeam*sizeof(PACKHEAD) );
46                  if (cbeam == NULL)
47                          error(SYSTEM, "out of memory in newcbeam");
48          }
# Line 64 | Line 50 | newcbeam()             /* allocate new entry at end of cbeam arra
50   }
51  
52  
53 < int
54 < cbeamcmp(cb1, cb2)      /* compare two cbeam entries for sort: keep orphans */
55 < register struct beamcomp        *cb1, *cb2;
53 > static int
54 > cbeamcmp(       /* compare two cbeam entries for sort: keep orphans */
55 >        const void      *cb1,
56 >        const void      *cb2
57 > )
58   {
59          register int    c;
60  
61 <        if ((c = cb1->bi - cb2->bi))    /* sort on beam index first */
61 >        if ((c = ((PACKHEAD*)cb1)->bi - ((PACKHEAD*)cb2)->bi))  /* sort on beam index first */
62                  return(c);
63 <        return(cb1->hd - cb2->hd);      /* use hd to resolve matches */
63 >        return(((PACKHEAD*)cb1)->hd - ((PACKHEAD*)cb2)->hd);    /* use hd to resolve matches */
64   }
65  
66  
67 < int
68 < cbeamcmp2(cb1, cb2)     /* compare two cbeam entries for sort: no orphans */
69 < register struct beamcomp        *cb1, *cb2;
67 > static int
68 > cbeamcmp2(      /* compare two cbeam entries for sort: no orphans */
69 >        const void      *cb1,
70 >        const void      *cb2
71 > )
72   {
73          register int    c;
74  
75 <        if (!cb1->nr)                   /* put orphans at the end, unsorted */
76 <                return(cb2->nr);
77 <        if (!cb2->nr)
75 >        if (!((PACKHEAD*)cb1)->nr)                      /* put orphans at the end, unsorted */
76 >                return(((PACKHEAD*)cb2)->nr);
77 >        if (!((PACKHEAD*)cb2)->nr)
78                  return(-1);
79 <        if ((c = cb1->bi - cb2->bi))    /* sort on beam index first */
79 >        if ((c = ((PACKHEAD*)cb1)->bi - ((PACKHEAD*)cb2)->bi))  /* sort on beam index first */
80                  return(c);
81 <        return(cb1->hd - cb2->hd);      /* use hd to resolve matches */
81 >        return(((PACKHEAD*)cb1)->hd - ((PACKHEAD*)cb2)->hd);    /* use hd to resolve matches */
82   }
83  
84  
85 < int
86 < findcbeam(hd, bi)       /* find the specified beam in our sorted list */
87 < int     hd, bi;
85 > static int
86 > findcbeam(      /* find the specified beam in our sorted list */
87 >        int     hd,
88 >        int     bi
89 > )
90   {
91 <        struct beamcomp cb;
92 <        register struct beamcomp        *p;
91 >        PACKHEAD        cb;
92 >        register PACKHEAD       *p;
93  
94          if (ncbeams <= 0)
95                  return(-1);
96 <        cb.hd = hd; cb.bi = bi; cb.nr = 0;
97 <        p = (struct beamcomp *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
98 <                        sizeof(struct beamcomp), cbeamcmp);
96 >        cb.hd = hd; cb.bi = bi; cb.nr = cb.nc = 0;
97 >        p = (PACKHEAD *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
98 >                        sizeof(PACKHEAD), cbeamcmp);
99          if (p == NULL)
100                  return(-1);
101          return(p - cbeam);
102   }
103  
104  
105 < int
106 < getcbeam(hd, bi)        /* get the specified beam, allocating as necessary */
107 < register int    hd;
108 < int     bi;
105 > static int
106 > getcbeam(       /* get the specified beam, allocating as necessary */
107 >        register int    hd,
108 >        int     bi
109 > )
110   {
111          register int    n;
112                                  /* first, look in sorted list */
# Line 124 | Line 117 | int    bi;
117                  if (cbeam[n].bi == bi && cbeam[n].hd == hd)
118                          return(n);
119                                  /* check legality */
120 <        if (hd < 0 | hd >= HDMAX || hdlist[hd] == NULL)
120 >        if ((hd < 0) | (hd >= HDMAX) || hdlist[hd] == NULL)
121                  error(INTERNAL, "illegal holodeck number in getcbeam");
122 <        if (bi < 1 | bi > nbeams(hdlist[hd]))
122 >        if ((bi < 1) | (bi > nbeams(hdlist[hd])))
123                  error(INTERNAL, "illegal beam index in getcbeam");
124          n = newcbeam();         /* allocate and assign */
125 <        cbeam[n].nr = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
125 >        cbeam[n].hd = hd; cbeam[n].bi = bi; cbeam[n].nr = cbeam[n].nc = 0;
126          return(n);
127   }
128  
129  
130 < cbeamsort(adopt)        /* sort our beam list, possibly turning out orphans */
131 < int     adopt;
130 > static void
131 > cbeamsort(      /* sort our beam list, possibly turning out orphans */
132 >        int     adopt
133 > )
134   {
135          register int    i;
136  
137          if (!(ncbeams += xcbeams))
138                  return;
139          xcbeams = 0;
140 <        qsort((char *)cbeam, ncbeams, sizeof(struct beamcomp),
140 >        qsort((char *)cbeam, ncbeams, sizeof(PACKHEAD),
141                          adopt ? cbeamcmp : cbeamcmp2);
142          if (adopt)
143                  return;
# Line 154 | Line 149 | int    adopt;
149   }
150  
151  
152 < cbeamop(op, bl, n)              /* update beams on server list */
153 < int     op;
154 < register struct beamcomp        *bl;
155 < int     n;
152 > extern void
153 > beam_init(              /* clear beam list for new view(s) */
154 >        int     fresh
155 > )
156   {
162 –        register PACKHEAD       *pa;
157          register int    i;
158  
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 –
257 – beam_init(fresh)                /* clear beam list for new view(s) */
258 – int     fresh;
259 – {
260 –        register int    i;
261 –
159          if (fresh)                      /* discard old beams? */
160                  ncbeams = xcbeams = 0;
161          else                            /* else clear sample requests */
# Line 268 | Line 165 | int    fresh;
165   }
166  
167  
168 < beam_view(vn, hr, vr)           /* add beam view (if advisable) */
169 < VIEW    *vn;
170 < int     hr, vr;
168 > extern int16 *
169 > beam_view(              /* add beam view (if advisable) */
170 >        VIEW    *vn,
171 >        int     hr,
172 >        int     vr
173 > )
174   {
175 <        int     todo[MAXTODO+1], n;
176 <        double  hdgsiz, d;
175 >        int16   *slist;
176 >        BEAMLIST        blist;
177 >        double  eravg, d;
178          register HOLO   *hp;
179 <        register int    i;
180 <                                        /* sort our list */
179 >        register int    i, n;
180 >                                        /* compute beams for view */
181 >        slist = viewbeams(vn, hr, vr, &blist);
182 >        if (*slist < 0) {
183 >                error(COMMAND, "no sections visible from this view");
184 >                return(NULL);
185 >        }
186 >                                        /* sort current beam list */
187          cbeamsort(1);
188 <                                        /* add view to nearby sections */
189 <        if (!(n = comptodo(todo, vn)))
190 <                return(0);
191 <        for (i = 0; i < n; i++)
192 <                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] ) ;
188 >                                        /* add new beams to list */
189 >        for (i = blist.nb; i--; ) {
190 >                n = getcbeam(blist.bl[i].hd, blist.bl[i].bi);
191 >                if (blist.bl[i].nr > cbeam[n].nr)
192 >                        cbeam[n].nr = blist.bl[i].nr;
193          }
194 +        free((void *)blist.bl);         /* free list */
195 +        if (MEYERNG <= FTINY)
196 +                return(slist);
197 +                                        /* compute average eye range */
198 +        eravg = 0.;
199 +        for (n = 0; slist[n] >= 0; n++) {
200 +                hp = hdlist[slist[n]];
201 +                eravg +=        MEYERNG/3. / VLEN(hp->wg[0]) +
202 +                                MEYERNG/3. / VLEN(hp->wg[1]) +
203 +                                MEYERNG/3. / VLEN(hp->wg[2]) ;
204 +        }
205 +        eravg /= (double)n;
206                                          /* add to current eye position */
207          if (cureye.rng <= FTINY) {
208                  VCOPY(cureye.vpt, vn->vp);
209 <                cureye.rng = MEYERNG * hdgsiz;
210 <        } else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + MEYERNG*hdgsiz >
300 <                        cureye.rng) {
209 >                cureye.rng = eravg;
210 >        } else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + eravg > cureye.rng) {
211                  for (i = 3; i--; )
212                          cureye.vpt[i] = 0.5*(cureye.vpt[i] + vn->vp[i]);
213 <                cureye.rng = 0.5*(cureye.rng + MEYERNG*hdgsiz + d);
213 >                cureye.rng = 0.5*(cureye.rng + eravg + d);
214          }
215 <        return(1);
215 >        return(slist);
216   }
217  
218  
219 < int
220 < beam_sync(all)                  /* update beam list on server */
221 < int     all;
219 > extern int
220 > beam_sync(                      /* update beam list on server */
221 >        int     all
222 > )
223   {
224                                          /* set new eye position */
225          serv_request(DR_VIEWPOINT, sizeof(VIEWPOINT), (char *)&cureye);
226                                          /* sort list (put orphans at end) */
227          cbeamsort(all < 0);
228                                          /* send beam request */
229 <        if (all)
230 <                cbeamop(DR_NEWSET, cbeam, ncbeams);
231 <        else
232 <                cbeamop(DR_ADJSET, cbeam, ncbeams+xcbeams);
229 >        if (all) {
230 >                if (ncbeams > 0)
231 >                        serv_request(DR_NEWSET,
232 >                                        ncbeams*sizeof(PACKHEAD), (char *)cbeam);
233 >        } else {
234 >                if (ncbeams+xcbeams > 0)
235 >                        serv_request(DR_ADJSET,
236 >                                (ncbeams+xcbeams)*sizeof(PACKHEAD), (char *)cbeam);
237 >        }
238          xcbeams = 0;                    /* truncate our list */
239          return(ncbeams);
240 + }
241 +
242 +
243 + extern void
244 + gridlines(                      /* run through holodeck section grid lines */
245 +        void    (*f)(FVECT wp[2])
246 + )
247 + {
248 +        register int    hd, w, i;
249 +        int     g0, g1;
250 +        FVECT   wp[2], mov;
251 +        double  d;
252 +                                        /* do each wall on each section */
253 +        for (hd = 0; hdlist[hd] != NULL; hd++)
254 +                for (w = 0; w < 6; w++) {
255 +                        g0 = hdwg0[w];
256 +                        g1 = hdwg1[w];
257 +                        d = 1.0/hdlist[hd]->grid[g0];
258 +                        mov[0] = d * hdlist[hd]->xv[g0][0];
259 +                        mov[1] = d * hdlist[hd]->xv[g0][1];
260 +                        mov[2] = d * hdlist[hd]->xv[g0][2];
261 +                        if (w & 1) {
262 +                                VSUM(wp[0], hdlist[hd]->orig,
263 +                                                hdlist[hd]->xv[w>>1], 1.);
264 +                                VSUM(wp[0], wp[0], mov, 1.);
265 +                        } else
266 +                                VCOPY(wp[0], hdlist[hd]->orig);
267 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g1], 1.);
268 +                        for (i = hdlist[hd]->grid[g0]; ; ) {    /* g0 lines */
269 +                                (*f)(wp);
270 +                                if (!--i) break;
271 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
272 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
273 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
274 +                        }
275 +                        d = 1.0/hdlist[hd]->grid[g1];
276 +                        mov[0] = d * hdlist[hd]->xv[g1][0];
277 +                        mov[1] = d * hdlist[hd]->xv[g1][1];
278 +                        mov[2] = d * hdlist[hd]->xv[g1][2];
279 +                        if (w & 1)
280 +                                VSUM(wp[0], hdlist[hd]->orig,
281 +                                                hdlist[hd]->xv[w>>1], 1.);
282 +                        else
283 +                                VSUM(wp[0], hdlist[hd]->orig, mov, 1.);
284 +                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g0], 1.);
285 +                        for (i = hdlist[hd]->grid[g1]; ; ) {    /* g1 lines */
286 +                                (*f)(wp);
287 +                                if (!--i) break;
288 +                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
289 +                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
290 +                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
291 +                        }
292 +                }
293   }

Diff Legend

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