ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/hd/rhdisp2.c

Comparing ray/src/hd/rhdisp2.c (file contents):
Revision 3.21 by gwlarson, Thu May 14 13:23:00 1998 UTC vs.
Revision 3.25 by gwlarson, Tue Nov 24 12:01:17 1998 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"
15
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
22
23	<	#define MAXVOXEL        16      /* maximum number of active voxels */
23	>	#define MAXTODO         3       /* maximum sections to look at */
24	>	#define MAXDRAT         3.0     /* maximum distance ratio */
25
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	–
26		#define CBEAMBLK        1024    /* cbeam allocation block size */
27
28		static struct beamcomp {
29	<	unsigned int2   wants;  /* flags telling which voxels want us */
30	<	unsigned int2   hd;     /* holodeck section number */
33	<	int4    bi;             /* beam index */
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
#	Line 38 | Line 35 | static int     ncbeams = 0;    /* number of sorted beams in c
35		static int      xcbeams = 0;    /* extra (unregistered) beams past ncbeams */
36		static int      maxcbeam = 0;   /* size of cbeam array */
37
41	–	struct cellact {
42	–	short   vi;             /* voxel index */
43	–	short   add;            /* zero means delete */
44	–	short   rev;            /* reverse ray direction? */
45	–	VIEW    *vp;            /* view for image */
46	–	short   hr, vr;         /* image resolution */
47	–	};              /* action for cell */
38
49	–	struct beamact {
50	–	struct cellact  ca;     /* cell action */
51	–	GCOORD  gc;             /* grid coordinate */
52	–	};              /* beam origin and action */
53	–
54	–
39		int
40		newcbeam()              /* allocate new entry at end of cbeam array */
41		{
#	Line 90 | Line 74 | register struct beamcomp       *cb1, *cb2;
74		{
75		register int    c;
76
77	<	if (!cb1->wants)                /* put orphans at the end, unsorted */
78	<	return(cb2->wants);
79	<	if (!cb2->wants)
77	>	if (!cb1->nr)                   /* put orphans at the end, unsorted */
78	>	return(cb2->nr);
79	>	if (!cb2->nr)
80		return(-1);
81		if ((c = cb1->bi - cb2->bi))    /* sort on beam index first */
82		return(c);
#	Line 109 | Line 93 | int    hd, bi;
93
94		if (ncbeams <= 0)
95		return(-1);
96	<	cb.wants = 0; cb.hd = hd; cb.bi = bi; cb.nr = 0;
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);
99		if (p == NULL)
#	Line 137 | Line 121 | int    bi;
121		if (bi < 1 | bi > nbeams(hdlist[hd]))
122		error(INTERNAL, "illegal beam index in getcbeam");
123		n = newcbeam();         /* allocate and assign */
124	<	cbeam[n].wants = cbeam[n].nr = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
124	>	cbeam[n].nr = 0; cbeam[n].hd = hd; cbeam[n].bi = bi;
125		return(n);
126		}
127
#	Line 155 | Line 139 | int    adopt;
139		if (adopt)
140		return;
141		for (i = ncbeams; i--; )        /* identify orphans */
142	<	if (cbeam[i].wants)
142	>	if (cbeam[i].nr)
143		break;
144		xcbeams = ncbeams - ++i;        /* put orphans after ncbeams */
145		ncbeams = i;
#	Line 186 | Line 170 | int    n;
170		}
171
172
173	<	add_voxels(vp)          /* add voxels corresponding to view point */
174	<	FVECT   vp;
173	>	int
174	>	comptodo(tdl, vw)               /* compute holodeck sections in view */
175	>	int     tdl[MAXTODO+1];
176	>	VIEW    *vw;
177		{
178	<	int     first, n, rfl = 0;
179	<	FVECT   gp;
180	<	double  d;
181	<	int     dist, bestd = 0x7fff;
182	<	VOXL    vox;
183	<	register int    i, j, k;
184	<	/* count voxels in list already */
185	<	for (first = 0; first < MAXVOXEL && voxel[first].hd >= 0; first++)
186	<	;
187	<	/* find closest voxels */
188	<	for (n = first, i = 0; n < MAXVOXEL && hdlist[i]; i++) {
189	<	hdgrid(gp, hdlist[i], vp);
190	<	for (j = 0; n < MAXVOXEL && j < 8; j++) {
191	<	dist = 0;
192	<	for (k = 0; k < 3; k++) {
193	<	d = gp[k] - .5 + (j>>k & 1);
194	<	if (d < 0.)
195	<	dist += -(vox.i[k] = (int)d - 1);
210	<	else if ((vox.i[k] = d) >= hdlist[i]->grid[k])
211	<	dist += vox.i[k] -
212	<	hdlist[i]->grid[k] + 1;
213	<	}
214	<	if (dist > bestd)       /* others were closer */
215	<	continue;
216	<	if (dist < bestd) {     /* start closer list */
217	<	n = first;
218	<	bestd = dist;
219	<	rfl = 0;
220	<	}
221	<	/* check if already in list */
222	<	for (k = first; k--; )
223	<	if (voxel[k].hd == i &&
224	<	voxel[k].i[0] == vox.i[0] &&
225	<	voxel[k].i[1] == vox.i[1] &&
226	<	voxel[k].i[2] == vox.i[2])
227	<	break;
228	<	if (k >= 0) {
229	<	rfl |= 1<<k;
230	<	continue;
231	<	}
232	<	vox.hd = i;             /* add this voxel */
233	<	copystruct(&voxel[n], &vox);
234	<	rfl |= 1<<n++;
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	<	/* check for really stupid move */
203	<	if (bestd > MAXDIST) {
202	>	/* watch for bad move */
203	>	if (n && dist2[0] > MAXDIST*MAXDIST) {
204		error(COMMAND, "move past outer limits");
205		return(0);
206		}
207	<	if (n < MAXVOXEL)
208	<	voxel[n].hd = -1;
209	<	return(rfl);
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	<	int
217	<	dobeam(gcp, bp)         /* express interest or disintrest in a beam */
218	<	GCOORD  *gcp;
219	<	register struct beamact *bp;
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	<	int     bi, i, n;
225	<	/* compute beam index */
226	<	if (bp->ca.rev) {
227	<	copystruct(gc, &bp->gc);
228	<	copystruct(gc+1, gcp);
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	<	copystruct(gc, gcp);
231	<	copystruct(gc+1, &bp->gc);
230	>	shr = sqrt(NVSAMPS/viewaspect(vw)) + .5;
231	>	svr = (NVSAMPS + shr/2)/shr;
232	>	sampquant = (hres*vres + shr*svr/2)/(shr*svr);
233		}
234	<	if ((bi = hdbindex(hdlist[voxel[bp->ca.vi].hd], gc)) <= 0)
235	<	error(CONSISTENCY, "bad grid coordinate in dobeam");
236	<	if (bp->ca.add) {               /* add it in */
237	<	i = getcbeam(voxel[bp->ca.vi].hd, bi);
238	<	cbeam[i].wants |= 1<<bp->ca.vi; /* say we want it */
239	<	n = npixels(bp->ca.vp, bp->ca.hr, bp->ca.vr,
240	<	hdlist[cbeam[i].hd], cbeam[i].bi);
241	<	if (n > cbeam[i].nr)
242	<	cbeam[i].nr = n;
243	<	return(i == ncbeams+xcbeams-1); /* return 1 if totally new */
244	<	}
245	<	/* else delete it */
275	<	i = findcbeam(voxel[bp->ca.vi].hd, bi);
276	<	if (i >= 0 && cbeam[i].wants & 1<<bp->ca.vi) {
277	<	cbeam[i].wants &= ~(1<<bp->ca.vi);      /* we don't want it */
278	<	if (!cbeam[i].wants)
279	<	cbeam[i].nr = 0;
280	<	return(1);                      /* indicate change */
281	<	}
282	<	return(0);
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
249	<
250	<	int
288	<	docell(gcp, cap)        /* find beams corresponding to cell and voxel */
289	<	GCOORD  *gcp;
290	<	register struct cellact *cap;
249	>	beam_init(fresh)                /* clear beam list for new view(s) */
250	>	int     fresh;
251		{
292	–	register HOLO   *hp = hdlist[voxel[cap->vi].hd];
293	–	FVECT   org, dir[4];
294	–	FVECT   vgp, cgp, vc;
295	–	FVECT   v1, v2;
296	–	struct beamact  bo;
297	–	int     axmax, j;
298	–	double  d, avmax;
252		register int    i;
300	–	/* compute cell center */
301	–	cgp[gcp->w>>1] = gcp->w&1 ? hp->grid[gcp->w>>1] : 0 ;
302	–	cgp[hdwg0[gcp->w]] = gcp->i[0] + .5;
303	–	cgp[hdwg1[gcp->w]] = gcp->i[1] + .5;
304	–	hdworld(org, hp, cgp);
305	–	/* compute direction to voxel center */
306	–	for (i = 3; i--; )
307	–	vgp[i] = voxel[cap->vi].i[i] + .5;
308	–	hdworld(vc, hp, vgp);
309	–	for (i = 3; i--; )
310	–	vc[i] -= org[i];
311	–	/* compute maximum area axis */
312	–	axmax = -1; avmax = 0;
313	–	for (i = 3; i--; ) {
314	–	d = vgp[i] - cgp[i];
315	–	if (d < 0.) d = -d;
316	–	if (d > avmax) {
317	–	avmax = d;
318	–	axmax = i;
319	–	}
320	–	}
321	–	#ifdef DEBUG
322	–	if (axmax < 0.)
323	–	error(CONSISTENCY, "botched axis computation in docell");
324	–	#endif
325	–	/* compute offset vectors */
326	–	d = 0.5/hp->grid[j=(axmax+1)%3];
327	–	for (i = 3; i--; )
328	–	v1[i] = hp->xv[j][i] * d;
329	–	d = 0.5/hp->grid[j=(axmax+2)%3];
330	–	if (DOT(hp->wg[axmax], vc) < 0.)
331	–	d = -d; /* reverse vertex order */
332	–	for (i = 3; i--; )
333	–	v2[i] = hp->xv[j][i] * d;
334	–	/* compute voxel pyramid */
335	–	for (i = 3; i--; ) {
336	–	dir[0][i] = vc[i] - v1[i] - v2[i];
337	–	dir[1][i] = vc[i] + v1[i] - v2[i];
338	–	dir[2][i] = vc[i] + v1[i] + v2[i];
339	–	dir[3][i] = vc[i] - v1[i] + v2[i];
340	–	}
341	–	/* visit beams for opposite cells */
342	–	copystruct(&bo.ca, cap);
343	–	copystruct(&bo.gc, gcp);
344	–	return(visit_cells(org, dir, hp, dobeam, &bo));
345	–	}
253
254	<
255	<	int
256	<	doview(cap)                     /* visit cells for a given view */
257	<	struct cellact  *cap;
258	<	{
352	<	int     orient;
353	<	FVECT   org, dir[4];
354	<	/* compute view pyramid */
355	<	orient = viewpyramid(org, dir, hdlist[voxel[cap->vi].hd], cap->vp);
356	<	if (!orient)
357	<	error(INTERNAL, "unusable view in doview");
358	<	cap->rev = orient < 0;
359	<	/* visit cells within pyramid */
360	<	return(visit_cells(org, dir, hdlist[voxel[cap->vi].hd], docell, cap));
254	>	if (fresh)                      /* discard old beams? */
255	>	ncbeams = xcbeams = 0;
256	>	else                            /* else clear sample requests */
257	>	for (i = ncbeams+xcbeams; i--; )
258	>	cbeam[i].nr = 0;
259		}
260
261
364	–	beam_init()                     /* clear beam list for new view(s) */
365	–	{
366	–	register int    i;
367	–	/* clear desire flags */
368	–	for (i = ncbeams+xcbeams; i--; )
369	–	cbeam[i].wants = cbeam[i].nr = 0;
370	–	voxel[0].hd = -1;               /* clear voxel list */
371	–	}
372	–
373	–
262		beam_view(vn, hr, vr)           /* add beam view (if advisable) */
263		VIEW    *vn;
264		int     hr, vr;
265		{
266	<	struct cellact  ca;
267	<	int     vfl;
266	>	int     todo[MAXTODO+1];
267	>	int     n;
268		/* sort our list */
269		cbeamsort(1);
270	<	/* add new voxels */
271	<	vfl = add_voxels(vn->vp);
384	<	if (!vfl)
270	>	/* add view to nearby sections */
271	>	if (!(n = comptodo(todo, vn)))
272		return(0);
273	<	ca.vp = vn; ca.hr = hr; ca.vr = vr;
274	<	ca.add = 1;                     /* update our beam list */
388	<	for (ca.vi = 0; vfl; vfl >>= 1, ca.vi++)
389	<	if (vfl & 1)
390	<	doview(&ca);
273	>	while (n--)
274	>	addview(todo[n], vn, hr, vr);
275		return(1);
276		}
277
#	Line 396 | Line 280 | int
280		beam_sync(all)                  /* update beam list on server */
281		int     all;
282		{
283	<	/* sort list to put orphans at end */
284	<	cbeamsort(0);
283	>	/* sort list (put orphans at end) */
284	>	cbeamsort(all < 0);
285		if (all)
286		cbeamop(DR_NEWSET, cbeam, ncbeams);
287		else

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)