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.25 by gwlarson, Tue Nov 24 12:01:17 1998 UTC vs.
Revision 3.32 by gwlarson, Thu Mar 4 10:29:22 1999 UTC

# Line 11 | Line 11 | static char SCCSid[] = "$SunId$ SGI";
11   #include "rholo.h"
12   #include "rhdisp.h"
13   #include "rhdriver.h"
14 – #include "random.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
19 – #ifndef NVSAMPS
20 – #define NVSAMPS         4096    /* number of ray samples per view */
21 – #endif
18  
23 – #define MAXTODO         3       /* maximum sections to look at */
24 – #define MAXDRAT         3.0     /* maximum distance ratio */
25 –
19   #define CBEAMBLK        1024    /* cbeam allocation block size */
20  
21 < static struct beamcomp {
29 <        int     hd;             /* holodeck section number */
30 <        int     bi;             /* beam index */
31 <        int4    nr;             /* number of samples desired */
32 < } *cbeam = NULL;        /* current beam list */
33 <
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 + VIEWPOINT       cureye;         /* current eye position */
27  
28 +
29   int
30   newcbeam()              /* allocate new entry at end of cbeam array */
31   {
# Line 44 | 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 58 | 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 70 | 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 88 | 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 121 | 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 134 | 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 146 | Line 136 | int    adopt;
136   }
137  
138  
149 – cbeamop(op, bl, n)              /* update beams on server list */
150 – int     op;
151 – register struct beamcomp        *bl;
152 – int     n;
153 – {
154 –        register PACKHEAD       *pa;
155 –        register int    i;
156 –
157 –        if (n <= 0)
158 –                return;
159 –        pa = (PACKHEAD *)malloc(n*sizeof(PACKHEAD));
160 –        if (pa == NULL)
161 –                error(SYSTEM, "out of memory in cbeamop");
162 –        for (i = 0; i < n; i++) {
163 –                pa[i].hd = bl[i].hd;
164 –                pa[i].bi = bl[i].bi;
165 –                pa[i].nr = bl[i].nr;
166 –                pa[i].nc = 0;
167 –        }
168 –        serv_request(op, n*sizeof(PACKHEAD), (char *)pa);
169 –        free((char *)pa);
170 – }
171 –
172 –
173 – int
174 – comptodo(tdl, vw)               /* compute holodeck sections in view */
175 – int     tdl[MAXTODO+1];
176 – VIEW    *vw;
177 – {
178 –        int     n = 0;
179 –        FVECT   gp, dv;
180 –        double  dist2[MAXTODO+1], thisdist2;
181 –        register int    i, j;
182 –                                        /* find closest MAXTODO sections */
183 –        for (i = 0; hdlist[i]; i++) {
184 –                hdgrid(gp, hdlist[i], vw->vp);
185 –                for (j = 0; j < 3; j++)
186 –                        if (gp[j] < 0.)
187 –                                dv[j] = -gp[j];
188 –                        else if (gp[j] > hdlist[i]->grid[j])
189 –                                dv[j] = gp[j] - hdlist[i]->grid[j];
190 –                        else
191 –                                dv[j] = 0.;
192 –                thisdist2 = DOT(dv,dv);
193 –                for (j = n; j > 0 && thisdist2 < dist2[j-1]; j--) {
194 –                        tdl[j] = tdl[j-1];
195 –                        dist2[j] = dist2[j-1];
196 –                }
197 –                tdl[j] = i;
198 –                dist2[j] = thisdist2;
199 –                if (n < MAXTODO)
200 –                        n++;
201 –        }
202 –                                        /* watch for bad move */
203 –        if (n && dist2[0] > MAXDIST*MAXDIST) {
204 –                error(COMMAND, "move past outer limits");
205 –                return(0);
206 –        }
207 –                                        /* avoid big differences */
208 –        for (j = 1; j < n; j++)
209 –                if (dist2[j] > MAXDRAT*MAXDRAT*dist2[j-1])
210 –                        n = j;
211 –        tdl[n] = -1;
212 –        return(n);
213 – }
214 –
215 –
216 – addview(hd, vw, hres, vres)     /* add view for section */
217 – int     hd;
218 – VIEW    *vw;
219 – int     hres, vres;
220 – {
221 –        int     sampquant;
222 –        int     h, v, shr, svr;
223 –        GCOORD  gc[2];
224 –        FVECT   rorg, rdir;
225 –                                /* compute sampling grid */
226 –        if (hres|vres && hres*vres <= NVSAMPS) {
227 –                shr = hres; svr = vres;
228 –                sampquant = 1;
229 –        } else {
230 –                shr = sqrt(NVSAMPS/viewaspect(vw)) + .5;
231 –                svr = (NVSAMPS + shr/2)/shr;
232 –                sampquant = (hres*vres + shr*svr/2)/(shr*svr);
233 –        }
234 –                                /* intersect sample rays with section */
235 –        for (v = svr; v--; )
236 –                for (h = shr; h--; ) {
237 –                        if (viewray(rorg, rdir, vw, (v+frandom())/svr,
238 –                                                (h+frandom())/shr) < -FTINY)
239 –                                continue;
240 –                        if (hdinter(gc, NULL, NULL, hdlist[hd], rorg, rdir)
241 –                                                >= FHUGE)
242 –                                continue;
243 –                        cbeam[getcbeam(hd,hdbindex(hdlist[hd],gc))].nr +=
244 –                                        sampquant;
245 –                }
246 – }
247 –
248 –
139   beam_init(fresh)                /* clear beam list for new view(s) */
140   int     fresh;
141   {
# Line 256 | Line 146 | int    fresh;
146          else                            /* else clear sample requests */
147                  for (i = ncbeams+xcbeams; i--; )
148                          cbeam[i].nr = 0;
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 <        int     todo[MAXTODO+1];
159 <        int     n;
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 view to nearby sections */
172 <        if (!(n = comptodo(todo, vn)))
173 <                return(0);
174 <        while (n--)
175 <                addview(todo[n], vn, hr, vr);
176 <        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 280 | 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