src/hd/rhdisp2.c

/* Copyright (c) 1998 Silicon Graphics, Inc. */

#ifndef lint
static char SCCSid[] = "$SunId$ SGI";
#endif

/*
 * Holodeck beam tracking for display process
 */

#include "rholo.h"
#include "rhdisp.h"
#include "rhdriver.h"

#ifndef MEYERNG
#define MEYERNG         0.2     /* target mean eye range (rel. to grid) */
#endif

#define CBEAMBLK        1024    /* cbeam allocation block size */

static PACKHEAD *cbeam = NULL;  /* current beam list */
static int      ncbeams = 0;    /* number of sorted beams in cbeam */
static int      xcbeams = 0;    /* extra (unregistered) beams past ncbeams */
static int      maxcbeam = 0;   /* size of cbeam array */

VIEWPOINT       cureye;         /* current eye position */


int
newcbeam()              /* allocate new entry at end of cbeam array */
{
        int     i;

        if ((i = ncbeams + xcbeams++) >= maxcbeam) {    /* grow array */
                maxcbeam += CBEAMBLK;
                if (cbeam == NULL)
                        cbeam = (PACKHEAD *)malloc(
                                        maxcbeam*sizeof(PACKHEAD) );
                else
                        cbeam = (PACKHEAD *)realloc( (char *)cbeam,
                                        maxcbeam*sizeof(PACKHEAD) );
                if (cbeam == NULL)
                        error(SYSTEM, "out of memory in newcbeam");
        }
        return(i);
}


int
cbeamcmp(cb1, cb2)      /* compare two cbeam entries for sort: keep orphans */
register PACKHEAD       *cb1, *cb2;
{
        register int    c;

        if ((c = cb1->bi - cb2->bi))    /* sort on beam index first */
                return(c);
        return(cb1->hd - cb2->hd);      /* use hd to resolve matches */
}


int
cbeamcmp2(cb1, cb2)     /* compare two cbeam entries for sort: no orphans */
register PACKHEAD       *cb1, *cb2;
{
        register int    c;

        if (!cb1->nr)                   /* put orphans at the end, unsorted */
                return(cb2->nr);
        if (!cb2->nr)
                return(-1);
        if ((c = cb1->bi - cb2->bi))    /* sort on beam index first */
                return(c);
        return(cb1->hd - cb2->hd);      /* use hd to resolve matches */
}


int
findcbeam(hd, bi)       /* find the specified beam in our sorted list */
int     hd, bi;
{
        PACKHEAD        cb;
        register PACKHEAD       *p;

        if (ncbeams <= 0)
                return(-1);
        cb.hd = hd; cb.bi = bi; cb.nr = cb.nc = 0;
        p = (PACKHEAD *)bsearch((char *)&cb, (char *)cbeam, ncbeams,
                        sizeof(PACKHEAD), cbeamcmp);
        if (p == NULL)
                return(-1);
        return(p - cbeam);
}


int
getcbeam(hd, bi)        /* get the specified beam, allocating as necessary */
register int    hd;
int     bi;
{
        register int    n;
                                /* first, look in sorted list */
        if ((n = findcbeam(hd, bi)) >= 0)
                return(n);
                                /* linear search through xcbeams to be sure */
        for (n = ncbeams+xcbeams; n-- > ncbeams; )
                if (cbeam[n].bi == bi && cbeam[n].hd == hd)
                        return(n);
                                /* check legality */
        if (hd < 0 | hd >= HDMAX || hdlist[hd] == NULL)
                error(INTERNAL, "illegal holodeck number in getcbeam");
        if (bi < 1 | bi > nbeams(hdlist[hd]))
                error(INTERNAL, "illegal beam index in getcbeam");
        n = newcbeam();         /* allocate and assign */
        cbeam[n].hd = hd; cbeam[n].bi = bi; cbeam[n].nr = cbeam[n].nc = 0;
        return(n);
}


cbeamsort(adopt)        /* sort our beam list, possibly turning out orphans */
int     adopt;
{
        register int    i;

        if (!(ncbeams += xcbeams))
                return;
        xcbeams = 0;
        qsort((char *)cbeam, ncbeams, sizeof(PACKHEAD),
                        adopt ? cbeamcmp : cbeamcmp2);
        if (adopt)
                return;
        for (i = ncbeams; i--; )        /* identify orphans */
                if (cbeam[i].nr)
                        break;
        xcbeams = ncbeams - ++i;        /* put orphans after ncbeams */
        ncbeams = i;
}


beam_init(fresh)                /* clear beam list for new view(s) */
int     fresh;
{
        register int    i;

        if (fresh)                      /* discard old beams? */
                ncbeams = xcbeams = 0;
        else                            /* else clear sample requests */
                for (i = ncbeams+xcbeams; i--; )
                        cbeam[i].nr = 0;
        cureye.rng = 0.;
}


int2 *
beam_view(vn, hr, vr)           /* add beam view (if advisable) */
VIEW    *vn;
int     hr, vr;
{
        int2    *slist;
        BEAMLIST        blist;
        double  eravg, d;
        register HOLO   *hp;
        register int    i, n;
                                        /* compute beams for view */
        slist = viewbeams(vn, hr, vr, &blist);
        if (*slist < 0) {
                error(COMMAND, "no sections visible from this view");
                return(NULL);
        }
                                        /* sort current beam list */
        cbeamsort(1);
                                        /* add new beams to list */
        for (i = blist.nb; i--; ) {
                n = getcbeam(blist.bl[i].hd, blist.bl[i].bi);
                if (blist.bl[i].nr > cbeam[n].nr)
                        cbeam[n].nr = blist.bl[i].nr;
        }
        free((char *)blist.bl);         /* free list */
        if (MEYERNG <= FTINY)
                return(slist);
                                        /* compute average eye range */
        eravg = 0.;
        for (n = 0; slist[n] >= 0; n++) {
                hp = hdlist[slist[n]];
                eravg +=        MEYERNG/3. / VLEN(hp->wg[0]) +
                                MEYERNG/3. / VLEN(hp->wg[1]) +
                                MEYERNG/3. / VLEN(hp->wg[2]) ;
        }
        eravg /= (double)n;
                                        /* add to current eye position */
        if (cureye.rng <= FTINY) {
                VCOPY(cureye.vpt, vn->vp);
                cureye.rng = eravg;
        } else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + eravg > cureye.rng) {
                for (i = 3; i--; )
                        cureye.vpt[i] = 0.5*(cureye.vpt[i] + vn->vp[i]);
                cureye.rng = 0.5*(cureye.rng + eravg + d);
        }
        return(slist);
}


int
beam_sync(all)                  /* update beam list on server */
int     all;
{
                                        /* set new eye position */
        serv_request(DR_VIEWPOINT, sizeof(VIEWPOINT), (char *)&cureye);
                                        /* sort list (put orphans at end) */
        cbeamsort(all < 0);
                                        /* send beam request */
        if (all) {
                if (ncbeams > 0)
                        serv_request(DR_NEWSET,
                                        ncbeams*sizeof(PACKHEAD), cbeam);
        } else {
                if (ncbeams+xcbeams > 0)
                        serv_request(DR_ADJSET,
                                (ncbeams+xcbeams)*sizeof(PACKHEAD), cbeam);
        }
        xcbeams = 0;                    /* truncate our list */
        return(ncbeams);
}


gridlines(f)                    /* run through holodeck section grid lines */
int     (*f)();
{
        register int    hd, w, i;
        int     g0, g1;
        FVECT   wp[2], mov;
        double  d;
                                        /* do each wall on each section */
        for (hd = 0; hdlist[hd] != NULL; hd++)
                for (w = 0; w < 6; w++) {
                        g0 = hdwg0[w];
                        g1 = hdwg1[w];
                        d = 1.0/hdlist[hd]->grid[g0];
                        mov[0] = d * hdlist[hd]->xv[g0][0];
                        mov[1] = d * hdlist[hd]->xv[g0][1];
                        mov[2] = d * hdlist[hd]->xv[g0][2];
                        if (w & 1) {
                                VSUM(wp[0], hdlist[hd]->orig,
                                                hdlist[hd]->xv[w>>1], 1.);
                                VSUM(wp[0], wp[0], mov, 1.);
                        } else
                                VCOPY(wp[0], hdlist[hd]->orig);
                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g1], 1.);
                        for (i = hdlist[hd]->grid[g0]; ; ) {    /* g0 lines */
                                (*f)(wp);
                                if (!--i) break;
                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
                        }
                        d = 1.0/hdlist[hd]->grid[g1];
                        mov[0] = d * hdlist[hd]->xv[g1][0];
                        mov[1] = d * hdlist[hd]->xv[g1][1];
                        mov[2] = d * hdlist[hd]->xv[g1][2];
                        if (w & 1)
                                VSUM(wp[0], hdlist[hd]->orig,
                                                hdlist[hd]->xv[w>>1], 1.);
                        else
                                VSUM(wp[0], hdlist[hd]->orig, mov, 1.);
                        VSUM(wp[1], wp[0], hdlist[hd]->xv[g0], 1.);
                        for (i = hdlist[hd]->grid[g1]; ; ) {    /* g1 lines */
                                (*f)(wp);
                                if (!--i) break;
                                wp[0][0] += mov[0]; wp[0][1] += mov[1];
                                wp[0][2] += mov[2]; wp[1][0] += mov[0];
                                wp[1][1] += mov[1]; wp[1][2] += mov[2];
                        }
                }
}
Revision:	3.32
Committed:	Thu Mar 4 10:29:22 1999 UTC (25 years, 2 months ago) by gwlarson
Content type:	text/plain
Branch:	MAIN
Changes since 3.31:	+100 -172 lines
Log Message:	created rhpict program and viewbeams.c module to replace rhdisp3.c
#	User	Rev	Content
1	gregl	3.17	/* Copyright (c) 1998 Silicon Graphics, Inc. */
2	gregl	3.1
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ SGI";
5			#endif
6
7			/*
8	gregl	3.2	* Holodeck beam tracking for display process
9	gregl	3.1	*/
10
11			#include "rholo.h"
12			#include "rhdisp.h"
13			#include "rhdriver.h"
14
15	gwlarson	3.26	#ifndef MEYERNG
16	gwlarson	3.30	#define MEYERNG 0.2 /* target mean eye range (rel. to grid) */
17	gwlarson	3.26	#endif
18	gwlarson	3.20
19	gregl	3.1	#define CBEAMBLK 1024 /* cbeam allocation block size */
20
21	gwlarson	3.32	static PACKHEAD cbeam = NULL; / current beam list */
22	gregl	3.1	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	gwlarson	3.32	VIEWPOINT cureye; /* current eye position */
27	gregl	3.1
28	gwlarson	3.32
29	gregl	3.1	int
30			newcbeam() /* allocate new entry at end of cbeam array */
31			{
32			int i;
33
34			if ((i = ncbeams + xcbeams++) >= maxcbeam) { /* grow array */
35			maxcbeam += CBEAMBLK;
36			if (cbeam == NULL)
37	gwlarson	3.32	cbeam = (PACKHEAD *)malloc(
38			maxcbeam*sizeof(PACKHEAD) );
39	gregl	3.1	else
40	gwlarson	3.32	cbeam = (PACKHEAD )realloc( (char )cbeam,
41			maxcbeam*sizeof(PACKHEAD) );
42	gregl	3.1	if (cbeam == NULL)
43			error(SYSTEM, "out of memory in newcbeam");
44			}
45			return(i);
46			}
47
48
49			int
50			cbeamcmp(cb1, cb2) /* compare two cbeam entries for sort: keep orphans */
51	gwlarson	3.32	register PACKHEAD cb1, cb2;
52	gregl	3.1	{
53			register int c;
54
55			if ((c = cb1->bi - cb2->bi)) /* sort on beam index first */
56			return(c);
57			return(cb1->hd - cb2->hd); /* use hd to resolve matches */
58			}
59
60
61			int
62			cbeamcmp2(cb1, cb2) /* compare two cbeam entries for sort: no orphans */
63	gwlarson	3.32	register PACKHEAD cb1, cb2;
64	gregl	3.1	{
65			register int c;
66
67	gwlarson	3.22	if (!cb1->nr) /* put orphans at the end, unsorted */
68			return(cb2->nr);
69			if (!cb2->nr)
70	gregl	3.15	return(-1);
71	gregl	3.1	if ((c = cb1->bi - cb2->bi)) /* sort on beam index first */
72			return(c);
73			return(cb1->hd - cb2->hd); /* use hd to resolve matches */
74			}
75
76
77			int
78			findcbeam(hd, bi) /* find the specified beam in our sorted list */
79			int hd, bi;
80			{
81	gwlarson	3.32	PACKHEAD cb;
82			register PACKHEAD *p;
83	gregl	3.1
84			if (ncbeams <= 0)
85			return(-1);
86	gwlarson	3.32	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	gregl	3.1	if (p == NULL)
90			return(-1);
91			return(p - cbeam);
92			}
93
94
95			int
96			getcbeam(hd, bi) /* get the specified beam, allocating as necessary */
97			register int hd;
98			int bi;
99			{
100			register int n;
101			/* first, look in sorted list */
102			if ((n = findcbeam(hd, bi)) >= 0)
103			return(n);
104			/* linear search through xcbeams to be sure */
105			for (n = ncbeams+xcbeams; n-- > ncbeams; )
106			if (cbeam[n].bi == bi && cbeam[n].hd == hd)
107			return(n);
108			/* check legality */
109			if (hd < 0 \| hd >= HDMAX \|\| hdlist[hd] == NULL)
110			error(INTERNAL, "illegal holodeck number in getcbeam");
111			if (bi < 1 \| bi > nbeams(hdlist[hd]))
112			error(INTERNAL, "illegal beam index in getcbeam");
113			n = newcbeam(); /* allocate and assign */
114	gwlarson	3.32	cbeam[n].hd = hd; cbeam[n].bi = bi; cbeam[n].nr = cbeam[n].nc = 0;
115	gregl	3.1	return(n);
116			}
117
118
119			cbeamsort(adopt) /* sort our beam list, possibly turning out orphans */
120			int adopt;
121			{
122			register int i;
123
124			if (!(ncbeams += xcbeams))
125			return;
126			xcbeams = 0;
127	gwlarson	3.32	qsort((char *)cbeam, ncbeams, sizeof(PACKHEAD),
128	gregl	3.1	adopt ? cbeamcmp : cbeamcmp2);
129			if (adopt)
130			return;
131			for (i = ncbeams; i--; ) /* identify orphans */
132	gwlarson	3.22	if (cbeam[i].nr)
133	gregl	3.1	break;
134			xcbeams = ncbeams - ++i; /* put orphans after ncbeams */
135			ncbeams = i;
136			}
137
138
139	gwlarson	3.24	beam_init(fresh) /* clear beam list for new view(s) */
140			int fresh;
141	gregl	3.1	{
142	gwlarson	3.21	register int i;
143	gwlarson	3.24
144			if (fresh) /* discard old beams? */
145			ncbeams = xcbeams = 0;
146			else /* else clear sample requests */
147			for (i = ncbeams+xcbeams; i--; )
148			cbeam[i].nr = 0;
149	gwlarson	3.26	cureye.rng = 0.;
150	gregl	3.1	}
151
152
153	gwlarson	3.32	int2 *
154	gwlarson	3.21	beam_view(vn, hr, vr) /* add beam view (if advisable) */
155			VIEW *vn;
156			int hr, vr;
157	gregl	3.4	{
158	gwlarson	3.32	int2 *slist;
159			BEAMLIST blist;
160			double eravg, d;
161	gwlarson	3.26	register HOLO *hp;
162	gwlarson	3.32	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	gwlarson	3.29	return(NULL);
168	gwlarson	3.32	}
169	gwlarson	3.30	/* sort current beam list */
170	gwlarson	3.21	cbeamsort(1);
171	gwlarson	3.32	/* 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	gwlarson	3.30	eravg = 0.;
182	gwlarson	3.32	for (n = 0; slist[n] >= 0; n++) {
183			hp = hdlist[slist[n]];
184			eravg += MEYERNG/3. / VLEN(hp->wg[0]) +
185	gwlarson	3.30	MEYERNG/3. / VLEN(hp->wg[1]) +
186			MEYERNG/3. / VLEN(hp->wg[2]) ;
187			}
188			eravg /= (double)n;
189	gwlarson	3.26	/* add to current eye position */
190			if (cureye.rng <= FTINY) {
191			VCOPY(cureye.vpt, vn->vp);
192	gwlarson	3.30	cureye.rng = eravg;
193			} else if ((d = sqrt(dist2(vn->vp,cureye.vpt))) + eravg > cureye.rng) {
194	gwlarson	3.26	for (i = 3; i--; )
195			cureye.vpt[i] = 0.5*(cureye.vpt[i] + vn->vp[i]);
196	gwlarson	3.30	cureye.rng = 0.5*(cureye.rng + eravg + d);
197	gwlarson	3.26	}
198	gwlarson	3.32	return(slist);
199	gregl	3.4	}
200
201
202	gwlarson	3.21	int
203			beam_sync(all) /* update beam list on server */
204			int all;
205	gregl	3.1	{
206	gwlarson	3.26	/* set new eye position */
207			serv_request(DR_VIEWPOINT, sizeof(VIEWPOINT), (char *)&cureye);
208	gwlarson	3.24	/* sort list (put orphans at end) */
209			cbeamsort(all < 0);
210	gwlarson	3.26	/* send beam request */
211	gwlarson	3.32	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	gregl	3.1	xcbeams = 0; /* truncate our list */
221	gwlarson	3.21	return(ncbeams);
222	gwlarson	3.32	}
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	gregl	3.1	}