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.31 by gwlarson, Wed Mar 3 10:25:27 1999 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  
16 – #ifndef MAXDIST
17 – #define MAXDIST         42      /* maximum distance outside section */
18 – #endif
19 – #ifndef NVSAMPS
20 – #define NVSAMPS         16384   /* number of ray samples per view */
21 – #endif
15   #ifndef MEYERNG
16   #define MEYERNG         0.2     /* target mean eye range (rel. to grid) */
17   #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
18  
19   #define CBEAMBLK        1024    /* cbeam allocation block size */
20  
21 < 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 <
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 52 | 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 66 | 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 78 | 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 96 | 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 129 | 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 142 | 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 154 | Line 136 | int    adopt;
136   }
137  
138  
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 – static 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 – int
225 – addview(hd, vw, rad, hres, vres)        /* add view for section */
226 – int     hd;
227 – VIEW    *vw;
228 – double  rad;
229 – int     hres, vres;
230 – {
231 –        int     sampquant, samptot = 0;
232 –        int     h, v, shr, svr;
233 –        GCOORD  gc[2];
234 –        FVECT   rorg, rdir;
235 –                                /* compute sampling grid */
236 –        if (hres|vres && hres*vres <= NVSAMPS) {
237 –                shr = hres; svr = vres;
238 –                sampquant = 1;
239 –        } else {
240 –                shr = sqrt(NVSAMPS/viewaspect(vw)) + .5;
241 –                svr = (NVSAMPS + shr/2)/shr;
242 –                sampquant = (hres*vres + shr*svr/2)/(shr*svr);
243 –        }
244 –                                /* intersect sample rays with section */
245 –        for (v = svr; v--; )
246 –                for (h = shr; h--; ) {
247 –                        if (viewray(rorg, rdir, vw, (h+frandom())/shr,
248 –                                                (v+frandom())/svr) < -FTINY)
249 –                                continue;
250 –                        if (rad > FTINY) {
251 –                                rorg[0] += (1.-2.*frandom())*rad;
252 –                                rorg[1] += (1.-2.*frandom())*rad;
253 –                                rorg[2] += (1.-2.*frandom())*rad;
254 –                        }
255 –                        if (hdinter(gc, NULL, NULL, hdlist[hd], rorg, rdir)
256 –                                                >= 0.99*FHUGE)
257 –                                continue;
258 –                        cbeam[getcbeam(hd,hdbindex(hdlist[hd],gc))].nr +=
259 –                                        sampquant;
260 –                        samptot += sampquant;
261 –                }
262 –        return(samptot);
263 – }
264 –
265 –
139   beam_init(fresh)                /* clear beam list for new view(s) */
140   int     fresh;
141   {
# Line 277 | Line 150 | int    fresh;
150   }
151  
152  
153 < int *
153 > int2 *
154   beam_view(vn, hr, vr)           /* add beam view (if advisable) */
155   VIEW    *vn;
156   int     hr, vr;
157   {
158 <        static int      todo[MAXTODO+1];
159 <        int     n;
160 <        double  er, eravg, d;
158 >        int2    *slist;
159 >        BEAMLIST        blist;
160 >        double  eravg, d;
161          register HOLO   *hp;
162 <        register int    i;
163 <                                        /* find nearby sections */
164 <        if (!(n = comptodo(todo, vn)))
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 */
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 (i = 0; i < n; i++) {
183 <                hp = hdlist[todo[i]];
184 <                if (MEYERNG > FTINY)
300 <                        er =    MEYERNG/3. / VLEN(hp->wg[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]) ;
303 –                else
304 –                        er = 0.;
305 –                if (!addview(todo[i], vn, 0.25*er, hr, vr)) {
306 –                        register int    j;              /* whoops! */
307 –                        n--;                            /* delete from list */
308 –                        for (j = i--; j <= n; j++)
309 –                                todo[j] = todo[j+1];
310 –                } else
311 –                        eravg += er;
187          }
313 –        if (eravg <= FTINY)
314 –                return(todo);
315 –                                        /* compute average eye range */
188          eravg /= (double)n;
189                                          /* add to current eye position */
190          if (cureye.rng <= FTINY) {
# Line 323 | Line 195 | int    hr, vr;
195                          cureye.vpt[i] = 0.5*(cureye.vpt[i] + vn->vp[i]);
196                  cureye.rng = 0.5*(cureye.rng + eravg + d);
197          }
198 <        return(todo);
198 >        return(slist);
199   }
200  
201  
# Line 336 | Line 208 | int    all;
208                                          /* sort list (put orphans at end) */
209          cbeamsort(all < 0);
210                                          /* send beam request */
211 <        if (all)
212 <                cbeamop(DR_NEWSET, cbeam, ncbeams);
213 <        else
214 <                cbeamop(DR_ADJSET, cbeam, ncbeams+xcbeams);
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