ViewVC Help

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

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

Comparing ray/src/hd/rhdisp3.c (file contents):
Revision 3.9 by gregl, Tue Jan 6 15:08:50 1998 UTC vs.
Revision 3.18 by greg, Fri Oct 5 19:19:16 2018 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1997 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 support for display process
6		*/
7
8		#include "rholo.h"
9		#include "rhdisp.h"
13	–	#include "view.h"
10
11		struct cellist {
12		GCOORD  *cl;
#	Line 19 | Line 15 | struct cellist {
15
16
17		int
18	<	npixels(vp, hr, vr, hp, bi)     /* compute appropriate number to evaluate */
19	<	register VIEW   *vp;
18	>	npixels(vp, hr, vr, hp, bi)     /* compute appropriate nrays to evaluate */
19	>	VIEW    *vp;
20		int     hr, vr;
21		HOLO    *hp;
22		int     bi;
23		{
24		VIEW    vrev;
25		GCOORD  gc[2];
26	<	FVECT   cp[4], ip[4];
27	<	double  af, ab;
28	<	register int    i;
26	>	FVECT   cp[4], ip[4], pf, pb;
27	>	double  af, ab, sf2, sb2, dfb2, df2, db2, penalty;
28	>	int     i;
29	>	/* special case */
30	>	if (hr <= 0 | vr <= 0)
31	>	return(0);
32		/* compute cell corners in image */
33		if (!hdbcoord(gc, hp, bi))
34		error(CONSISTENCY, "bad beam index in npixels");
35		hdcell(cp, hp, gc+1);           /* find cell on front image */
36	<	for (i = 0; i < 4; i++) {
37	<	viewloc(ip[i], vp, cp[i]);
38	<	if (ip[i][2] < 0.) {
36	>	for (i = 3; i--; )              /* compute front center */
37	>	pf[i] = 0.5*(cp[0][i] + cp[2][i]);
38	>	sf2 = 0.25*dist2(cp[0], cp[2]); /* compute half diagonal length */
39	>	for (i = 0; i < 4; i++) {       /* compute visible quad */
40	>	if (viewloc(ip[i], vp, cp[i]) <= 0) {
41		af = 0;
42		goto getback;
43		}
#	Line 48 | Line 49 | int    bi;
49		(ip[2][0]-ip[0][0])*(ip[1][1]-ip[0][1]);
50		af += (ip[2][0]-ip[3][0])*(ip[1][1]-ip[3][1]) -
51		(ip[1][0]-ip[3][0])*(ip[2][1]-ip[3][1]);
52	<	if (af >= 0) af *= 0.5;
52	<	else af *= -0.5;
52	>	af *= af >= 0 ? 0.5 : -0.5;
53		getback:
54	<	copystruct(&vrev, vp);          /* compute reverse view */
54	>	vrev = *vp;             /* compute reverse view */
55		for (i = 0; i < 3; i++) {
56		vrev.vdir[i] = -vp->vdir[i];
57		vrev.vup[i] = -vp->vup[i];
#	Line 59 | Line 59 | getback:
59		vrev.vvec[i] = -vp->vvec[i];
60		}
61		hdcell(cp, hp, gc);             /* find cell on back image */
62	<	for (i = 0; i < 4; i++) {
63	<	viewloc(ip[i], &vrev, cp[i]);
64	<	if (ip[i][2] < 0.)
65	<	return((int)(af + 0.5));
62	>	for (i = 3; i--; )              /* compute rear center */
63	>	pb[i] = 0.5*(cp[0][i] + cp[2][i]);
64	>	sb2 = 0.25*dist2(cp[0], cp[2]); /* compute half diagonal length */
65	>	for (i = 0; i < 4; i++) {       /* compute visible quad */
66	>	if (viewloc(ip[i], &vrev, cp[i]) <= 0) {
67	>	ab = 0;
68	>	goto finish;
69	>	}
70		ip[i][0] *= (double)hr; /* scale by resolution */
71		ip[i][1] *= (double)vr;
72		}
#	Line 71 | Line 75 | getback:
75		(ip[2][0]-ip[0][0])*(ip[1][1]-ip[0][1]);
76		ab += (ip[2][0]-ip[3][0])*(ip[1][1]-ip[3][1]) -
77		(ip[1][0]-ip[3][0])*(ip[2][1]-ip[3][1]);
78	<	if (ab >= 0) ab *= 0.5;
79	<	else ab *= -0.5;
80	<	/* round off smaller area */
81	<	if (af <= ab)
82	<	return((int)(af + 0.5));
83	<	return((int)(ab + 0.5));
78	>	ab *= ab >= 0 ? 0.5 : -0.5;
79	>	finish:         /* compute penalty based on dist. sightline - viewpoint */
80	>	df2 = dist2(vp->vp, pf);
81	>	db2 = dist2(vp->vp, pb);
82	>	dfb2 = dist2(pf, pb);
83	>	penalty = dfb2 + df2 - db2;
84	>	penalty = df2 - 0.25*penalty*penalty/dfb2;
85	>	if (df2 > db2)  penalty /= df2 <= dfb2 ? sb2 : sb2*df2/dfb2;
86	>	else            penalty /= db2 <= dfb2 ? sf2 : sf2*db2/dfb2;
87	>	if (penalty < 1.) penalty = 1.;
88	>	/* round off smaller non-zero area */
89	>	if (ab <= FTINY || (af > FTINY && af <= ab))
90	>	return((int)(af/penalty + 0.5));
91	>	return((int)(ab/penalty + 0.5));
92		}
93
94
#	Line 89 | Line 101 | getback:
101		int
102		visit_cells(orig, pyrd, hp, vf, dp)     /* visit cells within a pyramid */
103		FVECT   orig, pyrd[4];          /* pyramid ray directions in clockwise order */
104	<	register HOLO   *hp;
104	>	HOLO    *hp;
105		int     (*vf)();
106		char    *dp;
107		{
#	Line 98 | Line 110 | char   *dp;
110		FVECT   gp, pn[4], lo, ld;
111		double  po[4], lbeg, lend, d, t;
112		GCOORD  gc, gc2[2];
113	<	register int    i;
113	>	int     i;
114		/* figure out whose side we're on */
115		hdgrid(gp, hp, orig);
116		for (i = 0; i < 3; i++) {
#	Line 167 | Line 179 | char   *dp;
179
180
181		sect_behind(hp, vp)             /* check if section is "behind" viewpoint */
182	<	register HOLO   *hp;
183	<	register VIEW   *vp;
182	>	HOLO    *hp;
183	>	VIEW    *vp;
184		{
185		FVECT   hcent;
186		/* compute holodeck section center */
#	Line 185 | Line 197 | FVECT  org, dir[4];
197		HOLO    *hp;
198		VIEW    *vp;
199		{
200	<	register int    i;
200	>	int     i;
201		/* check view type */
202		if (vp->type == VT_PAR)
203		return(0);
#	Line 222 | Line 234 | VIEW   *vp;
234		int
235		addcell(gcp, cl)                /* add a cell to a list */
236		GCOORD  *gcp;
237	<	register struct cellist *cl;
237	>	struct cellist  *cl;
238		{
239	<	copystruct(cl->cl+cl->n, gcp);
239	>	*(cl->cl+cl->n) = *gcp;
240		cl->n++;
241		return(1);
242		}
#	Line 232 | Line 244 | register struct cellist        *cl;
244
245		int
246		cellcmp(gcp1, gcp2)             /* visit_cells() cell ordering */
247	<	register GCOORD *gcp1, *gcp2;
247	>	GCOORD  *gcp1, *gcp2;
248		{
249	<	register int    c;
249	>	int     c;
250
251		if ((c = gcp1->w - gcp2->w))
252		return(c);
#	Line 247 | Line 259 | register GCOORD        *gcp1, *gcp2;
259		GCOORD *
260		getviewcells(np, hp, vp)        /* get ordered cell list for section view */
261		int     *np;            /* returned number of cells (negative if reversed) */
262	<	register HOLO   *hp;
262	>	HOLO    *hp;
263		VIEW    *vp;
264		{
265		FVECT   org, dir[4];
#	Line 266 | Line 278 | VIEW   *vp;
278		if (cl.cl == NULL)
279		goto memerr;
280		cl.n = 0;                       /* add cells within pyramid */
281	<	visit_cells(org, dir, hp, addcell, &cl);
281	>	visit_cells(org, dir, hp, addcell, (char *)&cl);
282		if (!cl.n) {
283	<	free((char *)cl.cl);
283	>	free((void *)cl.cl);
284		return(NULL);
285		}
286		*np = cl.n * orient;
#	Line 277 | Line 289 | VIEW   *vp;
289		* sorted automatically by visit_cells(), so we don't need this.
290		*/
291		/* optimize memory use */
292	<	cl.cl = (GCOORD *)realloc((char *)cl.cl, cl.n*sizeof(GCOORD));
292	>	cl.cl = (GCOORD *)realloc((void *)cl.cl, cl.n*sizeof(GCOORD));
293		if (cl.cl == NULL)
294		goto memerr;
295		/* sort the list */
#	Line 289 | Line 301 | memerr:
301		}
302
303
304	<	gridlines(f)                    /* run through holodeck section grid lines */
305	<	int     (*f)();
304	>	void
305	>	gridlines(                      /* run through holodeck section grid lines */
306	>	void    (*f)(FVECT wp[2])
307	>	)
308		{
309	<	register int    hd, w, i;
309	>	int     hd, w, i;
310		int     g0, g1;
311		FVECT   wp[2], mov;
312		double  d;

Diff Legend

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