[ViewVC] Diff of: radiance/ray/src/hd/rhd

Comparing ray/src/hd/rhd_ogl.c (file contents):
Revision 3.4 by gwlarson, Mon Dec 21 15:10:13 1998 UTC vs.
Revision 3.32 by greg, Thu Apr 28 16:28:20 2016 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1998 Silicon Graphics, Inc. */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ SGI";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* OpenGL driver for holodeck display.
6		* Based on GLX driver using T-mesh.
#	Line 20 \| Line 17 \| static char SCCSid[] = "$SunId$ SGI";
17		#endif
18		#endif
19
23	–	#include "standard.h"
20
21	<	#include <sys/types.h>
21	>	#include <time.h>
22		#include <GL/glx.h>
23		#include <GL/glu.h>
24		#ifdef STEREO
25		#include <X11/extensions/SGIStereo.h>
26		#endif
27
28	+	#include "standard.h"
29		#include "rhd_odraw.h"
30	+	#include "rhdisp.h"
31	+	#include "paths.h"
32		#ifdef DOBJ
33		#include "rhdobj.h"
34		#endif
#	Line 37 \| Line 36 \| static char SCCSid[] = "$SunId$ SGI";
36		#include "x11icon.h"
37
38		#ifndef RAYQLEN
39	<	#define RAYQLEN 10240 /* max. rays to queue before flush */
39	>	#define RAYQLEN 0 /* max. rays to queue before flush */
40		#endif
41	<
42	<	#ifndef PORTALP
43	<	#define PORTRED 2 /* portal red color */
45	<	#define PORTGRN -1 /* portal green left alone */
46	<	#define PORTBLU 128 /* portal blue color */
47	<	#define PORTALP -1 /* don't use alpha channel */
41	>	#ifndef MINWIDTH
42	>	#define MINWIDTH 480 /* minimum graphics window width */
43	>	#define MINHEIGHT 400 /* minimum graphics window height */
44		#endif
45	<	#define isportal(c) ((PORTRED<0 \|\| (c)[0]==PORTRED) && \
46	<	(PORTGRN<0 \|\| (c)[1]==PORTGRN) && \
47	<	(PORTBLU<0 \|\| (c)[2]==PORTBLU) && \
48	<	(PORTALP<0 \|\| (c)[3]==PORTALP))
45	>	#ifndef VIEWDIST
46	>	#define VIEWDIST 356 /* assumed viewing distance (mm) */
47	>	#endif
48	>	#ifndef BORWIDTH
49	>	#define BORWIDTH 5 /* border width */
50	>	#endif
51
52		#ifndef FEQ
53		#define FEQ(a,b) ((a)-(b) <= FTINY && (a)-(b) >= -FTINY)
54		#endif
55
56	+	#define VWHEADLOCK 01 /* head position is locked flag */
57	+	#define VWPERSP 02 /* perspective view is set */
58	+	#define VWORTHO 04 /* orthographic view is set */
59	+	#define VWCHANGE 010 /* view has changed */
60	+	#define VWSTEADY 020 /* view is now steady */
61	+	#define VWMAPPED 040 /* window is mapped */
62	+
63		#define GAMMA 1.4 /* default gamma correction */
64
65		#define FRAMESTATE(s) (((s)&(ShiftMask\|ControlMask))==(ShiftMask\|ControlMask))
#	Line 64 \| Line 69 \| static char SCCSid[] = "$SunId$ SGI";
69		#define MOVDEG (-5) /* degrees to orbit CW/down /frame */
70		#define MOVORB(s) ((s)&ShiftMask ? 1 : (s)&ControlMask ? -1 : 0)
71
67	–	#define MINWIDTH 480 /* minimum graphics window width */
68	–	#define MINHEIGHT 400 /* minimum graphics window height */
69	–
70	–	#define VIEWDIST 356 /* assumed viewing distance (mm) */
71	–
72	–	#define BORWIDTH 5 /* border width */
73	–
72		#define setstereobuf(bid) (glXWaitGL(), \
73		XSGISetStereoBuffer(ourdisplay, gwind, bid), \
74		glXWaitX())
#	Line 84 \| Line 82 \| static char SCCSid[] = "$SunId$ SGI";
82
83		struct driver odev; /* global device driver structure */
84
85	+	TMstruct tmGlobal; / global tone-mapping structure */
86	+
87		char odev_args[64]; /* command arguments */
88
89		static GLfloat depthbuffer = NULL; / depth buffer */
#	Line 97 \| Line 97 \| *static int rayqleft = 0; / rays left to queue before**
97
98		static XEvent currentevent; /* current event */
99
100	–	static int mapped = 0; /* window is mapped? */
100		static unsigned long ourblack=0, ourwhite=~0;
101
102		static Display ourdisplay = NULL; / our display */
#	Line 115 \| Line 114 \| static double dev_zrat; /* (1. - dev_zmin/dev_zmax) *
114
115		static int inpresflags; /* input result flags */
116
117	<	static int headlocked; /* lock vertical motion */
117	>	static int viewflags; /* what's happening with view */
118
119	<	static int isperspective; /* perspective/ortho view */
121	<
122	<	static int viewsteady; /* is view steady? */
123	<
119	>	/*
120		static int resizewindow(), getevent(), getkey(), moveview(), wipeclean(),
121		xferdepth(), freedepth(), setglortho(),
122		setglpersp(), getframe(), getmove(), fixwindow(), mytmflags();
123
124		static double getdistance();
125	+	*/
126	+	static void checkglerr(char *where);
127	+	static void xferdepth(void);
128	+	static void freedepth(void);
129	+	static double getdistance(int dx, int dy, FVECT direc);
130	+	static int mytmflags(void);
131	+	static void getevent(void);
132	+	static void draw3dline(FVECT wp[2]);
133	+	static void draw_grids(int fore);
134	+	static int moveview(int dx, int dy, int mov, int orb);
135	+	static void getframe(XButtonPressedEvent *ebut);
136	+	static void getmove(XButtonPressedEvent *ebut);
137	+	static void getkey(XKeyPressedEvent *ekey);
138	+	static void fixwindow(XExposeEvent *eexp);
139	+	static void resizewindow(XConfigureEvent *ersz);
140	+	static void waitabit(void);
141	+	static void setglpersp(void);
142	+	static void setglortho(void);
143	+	static void wipeclean(void);
144
145	+
146		#ifdef STEREO
147	<	static int pushright(), popright();
147	>	static void pushright(void);
148	>	static void popright(void);
149		#endif
150
151		extern int gmPortals; /* GL portal list id */
#	Line 136 \| Line 153 \| *extern int gmPortals; / GL portal list id /*
153		extern time_t time();
154
155
156	+	extern void
157		dev_open(id) /* initialize GLX driver */
158		char *id;
159		{
160		extern char *getenv();
161		static RGBPRIMS myprims = STDPRIMS;
162	<	#if (PORTALP<0)
163	<	static int atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
164	<	GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
165	<	GLX_DEPTH_SIZE,15, None};
166	<	#else
167	<	static int atlBest[] = {GLX_RGBA, GLX_RED_SIZE,8,
150	<	GLX_GREEN_SIZE,8, GLX_BLUE_SIZE,8,
151	<	GLX_ALPHA_SIZE,2, GLX_DEPTH_SIZE,15, None};
152	<	#endif
162	>	static int atlBest[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
163	>	GLX_RED_SIZE,8, GLX_GREEN_SIZE,8,
164	>	GLX_BLUE_SIZE,8, GLX_DEPTH_SIZE,15, None};
165	>	static int atlOK[] = {GLX_RGBA, GLX_DOUBLEBUFFER,
166	>	GLX_RED_SIZE,4, GLX_GREEN_SIZE,4,
167	>	GLX_BLUE_SIZE,4, GLX_DEPTH_SIZE,15, None};
168		char *ev;
169		double gamval = GAMMA;
170		RGBPRIMP dpri = stdprims;
#	Line 162 \| Line 177 \| *char id;**
177		#endif
178		/* open display server */
179		ourdisplay = XOpenDisplay(NULL);
180	<	if (ourdisplay == NULL)
181	<	error(USER, "cannot open X-windows; DISPLAY variable set?\n");
180	>	CHECK(ourdisplay==NULL, USER,
181	>	"cannot open X-windows; DISPLAY variable set?");
182		#ifdef STEREO
183		switch (XSGIQueryStereoMode(ourdisplay, ourroot)) {
184		case STEREO_TOP:
#	Line 171 \| Line 186 \| *char id;**
186		break;
187		case STEREO_OFF:
188		error(USER,
189	<	"wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
189	>	"wrong video mode: run \"/usr/gfx/setmon -n STR_TOP\" first");
190		case X_STEREO_UNSUPPORTED:
191		error(USER, "stereo mode not supported on this screen");
192		default:
#	Line 181 \| Line 196 \| *char id;**
196		/* find a usable visual */
197		ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlBest);
198		if (ourvinf == NULL)
199	<	error(USER, "no suitable visuals available");
199	>	ourvinf = glXChooseVisual(ourdisplay, ourscreen, atlOK);
200	>	CHECK(ourvinf==NULL, USER, "no suitable visuals available");
201		/* get a context */
202		gctx = glXCreateContext(ourdisplay, ourvinf, NULL, GL_TRUE);
203		/* set gamma and tone mapping */
#	Line 195 \| Line 211 \| *char id;**
211		&myprims[BLU][CIEX],&myprims[BLU][CIEY],
212		&myprims[WHT][CIEX],&myprims[WHT][CIEY]) >= 6)
213		dpri = myprims;
214	<	if (tmInit(mytmflags(), dpri, gamval) == NULL)
214	>	tmGlobal = tmInit(mytmflags(), dpri, gamval);
215	>	if (tmGlobal == NULL)
216		error(SYSTEM, "not enough memory in dev_open");
217		/* open window */
218		ourwinattr.background_pixel = ourblack;
#	Line 213 \| Line 230 \| *char id;**
230		#endif
231		BORWIDTH, ourvinf->depth, InputOutput, ourvinf->visual,
232		CWBackPixel\|CWBorderPixel\|CWColormap\|CWEventMask, &ourwinattr);
233	<	if (gwind == 0)
217	<	error(SYSTEM, "cannot create window\n");
233	>	CHECK(gwind==0, SYSTEM, "cannot create window");
234		XStoreName(ourdisplay, gwind, id);
235		/* set window manager hints */
236		ourxwmhints.flags = InputHint\|IconPixmapHint;
237		ourxwmhints.input = True;
238	<	ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay,
239	<	gwind, x11icon_bits, x11icon_width, x11icon_height);
238	>	ourxwmhints.icon_pixmap = XCreateBitmapFromData(ourdisplay, gwind,
239	>	(char *)x11icon_bits, x11icon_width, x11icon_height);
240		XSetWMHints(ourdisplay, gwind, &ourxwmhints);
241		oursizhints.min_width = MINWIDTH;
242		#ifdef STEREO
#	Line 238 \| Line 254 \| *char id;**
254		glXMakeCurrent(ourdisplay, gwind, gctx);
255		glEnable(GL_DEPTH_TEST);
256		glDepthFunc(GL_LEQUAL);
257	<	glDisable(GL_DITHER);
257	>	glClearColor(0, 0, 0, 0);
258		glFrontFace(GL_CCW);
259		glDisable(GL_CULL_FACE);
260		glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
261		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
262	+	glPixelStorei(GL_PACK_ALIGNMENT, 1);
263	+	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
264		/* figure out sensible view */
265		pwidth = (double)DisplayWidthMM(ourdisplay, ourscreen) /
266		DisplayWidth(ourdisplay, ourscreen);
#	Line 253 \| Line 271 \| *char id;**
271		setstereobuf(STEREO_BUFFER_LEFT);
272		#endif
273		checkglerr("setting rendering parameters");
274	<	copystruct(&odev.v, &stdview);
274	>	odev.v = stdview;
275		odev.v.type = VT_PER;
276	<	headlocked = 0; /* free up head movement */
259	<	viewsteady = 1; /* view starts static */
260	<	isperspective = -1; /* but no view set, yet */
276	>	viewflags = VWSTEADY; /* view starts static */
277		/* map the window */
278		XMapWindow(ourdisplay, gwind);
279		dev_input(); /* sets size and view angles */
280		if (!odInit(DisplayWidth(ourdisplay,ourscreen) *
281	<	DisplayHeight(ourdisplay,ourscreen) / 4))
281	>	DisplayHeight(ourdisplay,ourscreen) / 3))
282		error(SYSTEM, "insufficient memory for value storage");
283		odev.name = id;
284		odev.firstuse = 1; /* can't recycle samples */
#	Line 270 \| Line 286 \| *char id;**
286		}
287
288
289	<	dev_close() /* close our display and free resources */
289	>	extern void
290	>	dev_close(void) /* close our display and free resources */
291		{
292		#ifdef DOBJ
293		dobj_cleanup();
#	Line 285 \| Line 302 \| *dev_close() / close our display and free resources**
302		gwind = 0;
303		XCloseDisplay(ourdisplay);
304		ourdisplay = NULL;
305	<	tmDone(NULL);
305	>	tmDone(tmGlobal);
306		odev.v.type = 0;
307		odev.hres = odev.vres = 0;
308		odev.ifd = -1;
309		}
310
311
312	<	dev_clear() /* clear our representation */
312	>	extern void
313	>	dev_clear(void) /* clear our representation */
314		{
315	<	wipeclean();
315	>	viewflags \|= VWCHANGE; /* pretend our view has changed */
316	>	wipeclean(); /* clean off display and samples */
317	>	dev_flush(); /* redraw geometry & get depth */
318		rayqleft = 0; /* hold off update */
319		}
320
321
322	<	int
323	<	dev_view(nv) /* assign new driver view */
324	<	register VIEW *nv;
322	>	extern int
323	>	dev_view( /* assign new driver view */
324	>	VIEW *nv
325	>	)
326		{
327	+	#ifdef STEREO
328		double d;
329	<
329	>	#endif
330		if (nv->type != VT_PER \|\| /* check view legality */
331		nv->horiz > 160. \|\| nv->vert > 160.) {
332		error(COMMAND, "illegal view type/angle");
#	Line 340 \| Line 362 \| *register VIEW nv;**
362		XResizeWindow(ourdisplay, gwind, odev.hres, odev.vres);
363		dev_input(); /* get resize event */
364		}
365	<	copystruct(&odev.v, nv); /* setview() already called */
365	>	odev.v = nv; / setview() already called */
366	>	viewflags \|= VWCHANGE;
367	>	}
368		#ifdef STEREO
369	<	copystruct(&vwright, nv);
370	<	d = eyesepdist / sqrt(nv->hn2);
371	<	VSUM(vwright.vp, nv->vp, nv->hvec, d);
372	<	/* setview(&vwright); -- Unnecessary */
369	>	vwright = *nv;
370	>	d = eyesepdist / sqrt(nv->hn2);
371	>	VSUM(vwright.vp, nv->vp, nv->hvec, d);
372	>	/* setview(&vwright); -- Unnecessary */
373		#endif
350	–	} else
351	–	viewsteady = 1;
374		wipeclean();
375		return(1);
376		}
377
378
379	<	dev_section(gfn, pfn) /* add octree for geometry rendering */
380	<	char gfn, pfn;
379	>	extern void
380	>	dev_section( /* add octree for geometry rendering */
381	>	char *gfn,
382	>	char *pfn
383	>	)
384		{
360	–	extern char *index();
361	–	char *cp;
362	–
385		if (gfn == NULL) {
386		gmEndGeom();
387		gmEndPortal();
#	Line 379 \| Line 401 \| *char gfn, pfn;*
401		}
402
403
404	<	dev_auxcom(cmd, args) /* process an auxiliary command */
405	<	char cmd, args;
404	>	extern void
405	>	dev_auxcom( /* process an auxiliary command */
406	>	char *cmd,
407	>	char *args
408	>	)
409		{
410		#ifdef DOBJ
411	<	if (dobj_command(cmd, args) >= 0)
411	>	int vischange;
412	>
413	>	if ((vischange = dobj_command(cmd, args)) >= 0) {
414	>	if (vischange) {
415	>	imm_mode = beam_sync(1) > 0;
416	>	dev_clear();
417	>	}
418		return;
419	+	}
420		#endif
421		sprintf(errmsg, "%s: unknown command", cmd);
422		error(COMMAND, errmsg);
423		}
424
425
426	<	VIEW *
427	<	dev_auxview(n, hvres) /* return nth auxiliary view */
428	<	int n;
429	<	int hvres[2];
426	>	extern VIEW *
427	>	dev_auxview( /* return nth auxiliary view */
428	>	int n,
429	>	int hvres[2]
430	>	)
431		{
432		hvres[0] = odev.hres; hvres[1] = odev.vres;
433		if (n == 0)
#	Line 407 \| Line 440 \| int hvres[2];
440		}
441
442
443	<	int
444	<	dev_input() /* get X11 input */
443	>	extern int
444	>	dev_input(void) /* get X11 input */
445		{
446		inpresflags = 0;
447
#	Line 423 \| Line 456 \| *dev_input() / get X11 input /*
456		}
457
458
459	<	dev_value(c, d, p) /* add a pixel value to our texture */
460	<	COLR c;
461	<	FVECT d, p;
459	>	extern void
460	>	dev_value( /* add a pixel value to our texture */
461	>	COLR c,
462	>	FVECT d,
463	>	FVECT p
464	>	)
465		{
466		#ifdef DOBJ
467		if (dobj_lightsamp != NULL) { /* in light source sampling */
#	Line 439 \| Line 475 \| FVECT d, p;
475		}
476
477
478	<	int
479	<	dev_flush() /* flush output as appropriate */
478	>	extern int
479	>	dev_flush(void) /* flush output as appropriate */
480		{
481		int ndrawn;
482
483	<	if (mapped && isperspective > 0) {
483	>	if ((viewflags&(VWMAPPED\|VWPERSP)) == (VWMAPPED\|VWPERSP)) {
484		#ifdef STEREO
485		pushright(); /* draw right eye */
486		ndrawn = gmDrawGeom();
487		#ifdef DOBJ
488		ndrawn += dobj_render();
489		#endif
454	–	if (ndrawn)
455	–	gmDrawPortals(PORTRED, PORTGRN, PORTBLU, PORTALP);
490		checkglerr("rendering right eye");
491		popright(); /* draw left eye */
492		#endif
#	Line 460 \| Line 494 \| *dev_flush() / flush output as appropriate /*
494		#ifdef DOBJ
495		ndrawn += dobj_render();
496		#endif
497	<	if (ndrawn)
464	<	gmDrawPortals(PORTRED, PORTGRN, PORTBLU, PORTALP);
497	>	glXSwapBuffers(ourdisplay, gwind);
498		checkglerr("rendering base view");
499		}
500	<	if (mapped && viewsteady)
501	<	if (isperspective > 0) { /* first time after steady */
502	<	if (ndrawn)
503	<	xferdepth(); /* transfer and clear depth */
504	<	setglortho(); /* set orthographic view */
505	<	} else if (!isperspective) {
500	>	if ((viewflags&(VWMAPPED\|VWSTEADY\|VWPERSP\|VWORTHO)) ==
501	>	(VWMAPPED\|VWSTEADY\|VWPERSP)) {
502	>	/* first time after steady */
503	>	if (ndrawn)
504	>	xferdepth(); /* transfer and clear depth */
505	>	setglortho(); /* set orthographic view */
506	>
507	>	}
508	>	if ((viewflags&(VWMAPPED\|VWSTEADY\|VWPERSP\|VWORTHO)) ==
509	>	(VWMAPPED\|VWSTEADY\|VWORTHO)) {
510	>	/* else update cones */
511		#ifdef STEREO
512	<	pushright();
513	<	odUpdate(1); /* draw right eye */
514	<	popright();
512	>	pushright();
513	>	odUpdate(1); /* draw right eye */
514	>	popright();
515		#endif
516	<	odUpdate(0); /* draw left eye */
517	<	}
518	<	glFlush(); /* flush OpenGL */
516	>	odUpdate(0); /* draw left eye */
517	>	glFlush(); /* flush OpenGL */
518	>	}
519		rayqleft = RAYQLEN;
520		/* flush X11 and return # pending */
521		return(odev.inpready = XPending(ourdisplay));
522		}
523
524
525	<	checkglerr(where) /* check for GL or GLU error */
526	<	char *where;
525	>	static void
526	>	checkglerr( /* check for GL or GLU error */
527	>	char *where
528	>	)
529		{
530	<	register GLenum errcode;
530	>	GLenum errcode;
531
532		while ((errcode = glGetError()) != GL_NO_ERROR) {
533		sprintf(errmsg, "OpenGL error %s: %s",
#	Line 497 \| Line 537 \| *char where;**
537		}
538
539
540	<	static
541	<	xferdepth() /* load and clear depth buffer */
540	>	static void
541	>	xferdepth(void) /* load and clear depth buffer */
542		{
543	<	register GLfloat *dbp;
544	<	register GLubyte *cbuf;
543	>	GLfloat *dbp;
544	>	GLubyte *pbuf;
545
546		if (depthbuffer == NULL) { /* allocate private depth buffer */
547		#ifdef STEREO
#	Line 510 \| Line 550 \| *xferdepth() / load and clear depth buffer /*
550		#endif
551		depthbuffer = (GLfloat *)malloc(
552		odev.hresodev.vressizeof(GLfloat));
553	<	if (depthbuffer == NULL)
514	<	error(SYSTEM, "out of memory in xferdepth");
553	>	CHECK(depthbuffer==NULL, SYSTEM, "out of memory in xferdepth");
554		}
555		/* allocate alpha buffer for portals */
556		if (gmPortals)
557	<	cbuf = (GLubyte )malloc(odev.hresodev.vres*
519	<	(4*sizeof(GLubyte)));
557	>	pbuf = (GLubyte )malloc(odev.hresodev.vres*sizeof(GLubyte));
558		else
559	<	cbuf = NULL;
559	>	pbuf = NULL;
560		#ifdef STEREO
561	<	setstereobuf(STEREO_BUFFER_RIGHT);
561	>	pushright();
562		glReadPixels(0, 0, odev.hres, odev.vres,
563		GL_DEPTH_COMPONENT, GL_FLOAT, depthright);
564	<	if (cbuf != NULL)
564	>	if (pbuf != NULL) {
565	>	glClear(GL_COLOR_BUFFER_BIT);
566	>	gmDrawPortals(0xff, -1, -1, -1);
567		glReadPixels(0, 0, odev.hres, odev.vres,
568	<	GL_RGBA, GL_UNSIGNED_BYTE, cbuf);
568	>	GL_RED, GL_UNSIGNED_BYTE, pbuf);
569	>	}
570		for (dbp = depthright + odev.hres*odev.vres; dbp-- > depthright; )
571	<	if (cbuf != NULL && isportal(cbuf+4*(dbp-depthright)))
571	>	if (pbuf != NULL && pbuf[dbp-depthright]&0x40)
572		*dbp = FHUGE;
573		else
574		dbp = mapdepth(dbp);
575		glClear(GL_DEPTH_BUFFER_BIT);
535	–	setstereobuf(STEREO_BUFFER_LEFT);
576		odDepthMap(1, depthright);
577	+	popright();
578		#endif
579		/* read back depth buffer */
580		glReadPixels(0, 0, odev.hres, odev.vres,
581		GL_DEPTH_COMPONENT, GL_FLOAT, depthbuffer);
582	<	if (cbuf != NULL)
582	>	if (pbuf != NULL) {
583	>	glClear(GL_COLOR_BUFFER_BIT); /* find portals */
584	>	gmDrawPortals(0xff, -1, -1, -1);
585		glReadPixels(0, 0, odev.hres, odev.vres,
586	<	GL_RGBA, GL_UNSIGNED_BYTE, cbuf);
586	>	GL_RED, GL_UNSIGNED_BYTE, pbuf);
587	>	#ifdef DEBUG
588	>	glXSwapBuffers(ourdisplay, gwind);
589	>	#endif
590	>	}
591		for (dbp = depthbuffer + odev.hres*odev.vres; dbp-- > depthbuffer; )
592	<	if (cbuf != NULL && isportal(cbuf+4*(dbp-depthbuffer)))
592	>	if (pbuf != NULL && pbuf[dbp-depthbuffer]&0x40)
593		*dbp = FHUGE;
594		else
595		dbp = mapdepth(dbp);
596		glClear(GL_DEPTH_BUFFER_BIT); /* clear system depth buffer */
550	–	if (cbuf != NULL)
551	–	free((char )cbuf); / free our color buffer */
597		odDepthMap(0, depthbuffer); /* transfer depth data */
598	+	if (pbuf != NULL)
599	+	free((void )pbuf); / free our portal buffer */
600		}
601
602
603	<	static
604	<	freedepth() /* free recorded depth buffer */
603	>	static void
604	>	freedepth(void) /* free recorded depth buffer */
605		{
606		if (depthbuffer == NULL)
607		return;
608		#ifdef STEREO
609		odDepthMap(1, NULL);
610	<	free((char *)depthright);
610	>	free((void *)depthright);
611		depthright = NULL;
612		#endif
613		odDepthMap(0, NULL);
614	<	free((char *)depthbuffer);
614	>	free((void *)depthbuffer);
615		depthbuffer = NULL;
616		}
617
618
619		static double
620	<	getdistance(dx, dy, direc) /* distance from fore plane along view ray */
621	<	int dx, dy;
622	<	FVECT direc;
620	>	getdistance( /* distance from fore plane along view ray */
621	>	int dx,
622	>	int dy,
623	>	FVECT direc
624	>	)
625		{
626		GLfloat gldepth;
578	–	GLubyte glcolor[4];
627		double dist;
628
629	<	if (dx<0 \| dx>=odev.hres \| dy<0 \| dy>=odev.vres)
629	>	if ((dx<0) \| (dx>=odev.hres) \| (dy<0) \| (dy>=odev.vres))
630		return(FHUGE);
631		if (depthbuffer != NULL)
632		dist = depthbuffer[dy*odev.hres + dx];
633		else {
634		glReadPixels(dx,dy, 1,1, GL_DEPTH_COMPONENT,
635		GL_FLOAT, &gldepth);
636	<	if (gmPortals) {
637	<	glReadPixels(dx,dy, 1,1, GL_RGBA,
590	<	GL_UNSIGNED_BYTE, glcolor);
591	<	if (isportal(glcolor))
592	<	return(FHUGE);
593	<	}
636	>	if (gldepth <= FTINY)
637	>	return (FHUGE); /* call failed */
638		dist = mapdepth(gldepth);
639		}
640		if (dist >= .99*FHUGE)
#	Line 600 \| Line 644 \| FVECT direc;
644
645
646		#ifdef STEREO
647	<	static
648	<	pushright() /* push on right view & buffer */
647	>	static void
648	>	pushright(void) /* push on right view & buffer */
649		{
650		double d;
651
652		setstereobuf(STEREO_BUFFER_RIGHT);
653	<	if (isperspective > 0) {
653	>	if (viewflags & VWPERSP) {
654		glMatrixMode(GL_MODELVIEW);
655		glPushMatrix();
656		d = -eyesepdist / sqrt(odev.v.hn2);
#	Line 617 \| Line 661 \| *pushright() / push on right view & buffer /*
661		}
662
663
664	<	static
665	<	popright() /* pop off right view & buffer */
664	>	static void
665	>	popright(void) /* pop off right view & buffer */
666		{
667	<	if (isperspective > 0) {
667	>	if (viewflags & VWPERSP) {
668		glMatrixMode(GL_MODELVIEW);
669		glPopMatrix();
670		}
#	Line 630 \| Line 674 \| *popright() / pop off right view & buffer /*
674
675
676		static int
677	<	mytmflags() /* figure out tone mapping flags */
677	>	mytmflags(void) /* figure out tone mapping flags */
678		{
679		extern char *progname;
680	<	register char cp, tail;
680	>	char cp, tail;
681		/* find basic name */
682		for (cp = tail = progname; *cp; cp++)
683		if (*cp == '/')
#	Line 654 \| Line 698 \| *mytmflags() / figure out tone mapping flags /*
698		}
699
700
701	<	static
702	<	getevent() /* get next event */
701	>	static void
702	>	getevent(void) /* get next event */
703		{
704		XNextEvent(ourdisplay, levptr(XEvent));
705		switch (levptr(XEvent)->type) {
#	Line 663 \| Line 707 \| *getevent() / get next event /*
707		resizewindow(levptr(XConfigureEvent));
708		break;
709		case UnmapNotify:
710	<	mapped = 0;
710	>	viewflags &= ~VWMAPPED;
711		break;
712		case MapNotify:
713		odRemap(0);
714	<	mapped = 1;
714	>	viewflags \|= VWMAPPED;
715		break;
716		case Expose:
717		fixwindow(levptr(XExposeEvent));
#	Line 676 \| Line 720 \| *getevent() / get next event /*
720		getkey(levptr(XKeyPressedEvent));
721		break;
722		case ButtonPress:
723	<	if (FRAMESTATE(levptr(XButtonPressedEvent)->state))
724	<	getframe(levptr(XButtonPressedEvent));
723	>	if (FRAMESTATE(levptr(XButtonPressedEvent)->state))
724	>	getframe(levptr(XButtonPressedEvent));
725		else
726	<	getmove(levptr(XButtonPressedEvent));
726	>	switch (levptr(XButtonPressedEvent)->button) {
727	>	case Button4: /* wheel up */
728	>	case Button5: /* wheel down */
729	>	break;
730	>	default:
731	>	getmove(levptr(XButtonPressedEvent));
732	>	break;
733	>	}
734		break;
735		}
736		}
737
738
739	<	static
740	<	draw3dline(wp) /* draw 3d line in world coordinates */
741	<	register FVECT wp[2];
739	>	static void
740	>	draw3dline( /* draw 3d line in world coordinates */
741	>	FVECT wp[2]
742	>	)
743		{
744		glVertex3d(wp[0][0], wp[0][1], wp[0][2]);
745		glVertex3d(wp[1][0], wp[1][1], wp[1][2]);
746		}
747
748
749	<	static
750	<	draw_grids(fore) /* draw holodeck section grids */
751	<	int fore;
749	>	static void
750	>	draw_grids( /* draw holodeck section grids */
751	>	int fore
752	>	)
753		{
754		glPushAttrib(GL_LIGHTING_BIT\|GL_ENABLE_BIT);
755		glDisable(GL_LIGHTING);
756		if (fore)
757	<	glColor3ub(0, 255, 255);
757	>	glColor3ub(4, 250, 250);
758		else
759		glColor3ub(0, 0, 0);
760		glBegin(GL_LINES); /* draw each grid line */
#	Line 712 \| Line 765 \| int fore;
765		}
766
767
768	<	static
769	<	moveview(dx, dy, mov, orb) /* move our view */
770	<	int dx, dy, mov, orb;
768	>	static int
769	>	moveview( /* move our view */
770	>	int dx,
771	>	int dy,
772	>	int mov,
773	>	int orb
774	>	)
775		{
776		VIEW nv;
777		FVECT odir, v1, wip;
778	<	double d, d1;
779	<	register int li;
778	>	double d;
779	>	#ifdef DOBJ
780	>	double d1;
781	>	#endif
782		/* start with old view */
783	<	copystruct(&nv, &odev.v);
783	>	nv = odev.v;
784		/* orient our motion */
785		if (viewray(v1, odir, &odev.v,
786		(dx+.5)/odev.hres, (dy+.5)/odev.vres) < -FTINY)
#	Line 744 \| Line 803 \| int dx, dy, mov, orb;
803		VSUM(nv.vp, wip, odir, -1.);
804		spinvector(nv.vdir, nv.vdir, nv.vup, d);
805		} else if (orb) { /* orbit up/down */
806	<	fcross(v1, odir, nv.vup);
807	<	if (normalize(v1) == 0.)
806	>	if (geodesic(odir, odir, nv.vup,
807	>	d=MOVDEGPI/180.orb, GEOD_RAD) == 0.0)
808		return(0);
750	–	spinvector(odir, odir, v1, d=MOVDEGPI/180.orb);
809		VSUM(nv.vp, wip, odir, -1.);
810	<	spinvector(nv.vdir, nv.vdir, v1, d);
810	>	geodesic(nv.vdir, nv.vdir, nv.vup, d, GEOD_RAD);
811		} else if (mov) { /* move forward/backward */
812		d = MOVPCT/100. * mov;
813		VSUM(nv.vp, nv.vp, odir, d);
814		}
815	<	if (!mov ^ !orb && headlocked) { /* restore head height */
815	>	if (!mov ^ !orb && viewflags&VWHEADLOCK) { /* restore height */
816		VSUM(v1, odev.v.vp, nv.vp, -1.);
817		d = DOT(v1, nv.vup);
818		VSUM(nv.vp, nv.vp, odev.v.vup, d);
#	Line 767 \| Line 825 \| int dx, dy, mov, orb;
825		}
826
827
828	<	static
829	<	getframe(ebut) /* get focus frame */
830	<	XButtonPressedEvent *ebut;
828	>	static void
829	>	getframe( /* get focus frame */
830	>	XButtonPressedEvent *ebut
831	>	)
832		{
833		int startx = ebut->x, starty = ebut->y;
834	<	int endx, endy;
835	<
834	>	int endx, endy, midx, midy;
835	>	FVECT odir, v1;
836	>	double d;
837	>	#ifdef DOBJ
838	>	double d1;
839	>	#endif
840	>	/* get mouse drag */
841		XMaskEvent(ourdisplay, ButtonReleaseMask, levptr(XEvent));
842		endx = levptr(XButtonReleasedEvent)->x;
843		endy = levptr(XButtonReleasedEvent)->y;
844	<	if (endx == startx \| endy == starty) {
845	<	XBell(ourdisplay, 0);
844	>	midx = (startx + endx) >> 1;
845	>	midy = (starty + endy) >> 1;
846	>	/* set focus distance */
847	>	if (viewray(v1, odir, &odev.v,
848	>	(midx+.5)/odev.hres, (midy+.5)/odev.vres) < -FTINY)
849		return;
850	<	}
851	<	if (endx < startx) {register int c = endx; endx = startx; startx = c;}
852	<	if (endy < starty) {register int c = endy; endy = starty; starty = c;}
850	>	d = getdistance(midx, midy, odir); /* distance from front plane */
851	>	#ifdef DOBJ
852	>	d1 = dobj_trace(NULL, v1, odir);
853	>	if (d1 < d)
854	>	d = d1;
855	>	#endif
856	>	if (d < .99*FHUGE)
857	>	odev.v.vdist = d + sqrt(dist2(v1, odev.v.vp));
858	>	/* set frame for rendering */
859	>	if ((endx == startx) \| (endy == starty))
860	>	return;
861	>	if (endx < startx) {int c = endx; endx = startx; startx = c;}
862	>	if (endy < starty) {int c = endy; endy = starty; starty = c;}
863		sprintf(odev_args, "%.3f %.3f %.3f %.3f",
864		(startx+.5)/odev.hres, 1.-(endy+.5)/odev.vres,
865		(endx+.5)/odev.hres, 1.-(starty+.5)/odev.vres);
#	Line 790 \| Line 867 \| *XButtonPressedEvent ebut;**
867		}
868
869
870	<	static
871	<	getmove(ebut) /* get view change */
795	<	XButtonPressedEvent *ebut;
870	>	static void
871	>	waitabit(void) /* pause a moment */
872		{
873	+	struct timespec ts;
874	+	ts.tv_sec = 0;
875	+	ts.tv_nsec = 100000000L;
876	+	nanosleep(&ts, NULL);
877	+	}
878	+
879	+
880	+	static void
881	+	getmove( /* get view change */
882	+	XButtonPressedEvent *ebut
883	+	)
884	+	{
885		int movdir = MOVDIR(ebut->button);
886		int movorb = MOVORB(ebut->state);
887		int ndrawn;
#	Line 803 \| Line 891 \| *XButtonPressedEvent ebut;**
891
892		XNoOp(ourdisplay); /* makes sure we're not idle */
893
894	<	viewsteady = 0; /* flag moving view */
895	<	setglpersp(&odev.v); /* start us off in perspective */
894	>	viewflags &= ~VWSTEADY; /* flag moving view */
895	>	setglpersp(); /* start us off in perspective */
896		while (!XCheckMaskEvent(ourdisplay,
897		ButtonReleaseMask, levptr(XEvent))) {
898	+	/* pause so as not to move too fast */
899	+	waitabit();
900		/* get cursor position */
901		if (!XQueryPointer(ourdisplay, gwind, &rootw, &childw,
902		&rootx, &rooty, &wx, &wy, &statemask))
#	Line 824 \| Line 914 \| *XButtonPressedEvent ebut;**
914		#ifdef DOBJ
915		ndrawn += dobj_render();
916		#endif
827	–	if (ndrawn)
828	–	gmDrawPortals(PORTRED, PORTGRN, PORTBLU, PORTALP);
917		popright();
918		#endif
919		/* redraw octrees */
#	Line 833 \| Line 921 \| *XButtonPressedEvent ebut;**
921		#ifdef DOBJ
922		ndrawn += dobj_render(); /* redraw objects */
923		#endif
924	<	if (ndrawn)
925	<	gmDrawPortals(PORTRED, PORTGRN, PORTBLU, PORTALP);
838	<	glFlush();
839	<	if (!ndrawn) {
924	>	glXSwapBuffers(ourdisplay, gwind);
925	>	if (!ndrawn)
926		sleep(1); /* for reasonable interaction */
841	–	#ifdef STEREO
842	–	pushright();
843	–	draw_grids(0);
844	–	popright();
845	–	#endif
846	–	draw_grids(0);
847	–	}
927		}
928		if (!(inpresflags & DFL(DC_SETVIEW))) { /* do final motion */
929		movdir = MOVDIR(levptr(XButtonReleasedEvent)->button);
#	Line 852 \| Line 931 \| *XButtonPressedEvent ebut;**
931		wy = levptr(XButtonReleasedEvent)->y;
932		moveview(wx, odev.vres-1-wy, movdir, movorb);
933		}
934	+	viewflags \|= VWSTEADY; /* done goofing around */
935		}
936
937
938	<	static
939	<	setglpersp(vp) /* set perspective view in GL */
860	<	register VIEW *vp;
938	>	static void
939	>	setglpersp(void) /* set perspective view in GL */
940		{
941		double d, xmin, xmax, ymin, ymax;
942		GLfloat vec[4];
#	Line 869 \| Line 948 \| *register VIEW vp;**
948		dev_zmax = 100.;
949		} else {
950		dev_zmin = 0.5*depthlim[0];
951	<	dev_zmax = 1.75*depthlim[1];
951	>	dev_zmax = 1.25*depthlim[1];
952		if (dev_zmin > dev_zmax/5.)
953		dev_zmin = dev_zmax/5.;
954		}
#	Line 877 \| Line 956 \| *register VIEW vp;**
956		dev_zmin = odev.v.vfore;
957		if (odev.v.vaft > FTINY)
958		dev_zmax = odev.v.vaft;
959	<	if (dev_zmin < dev_zmax/100.)
960	<	dev_zmin = dev_zmax/100.;
959	>	if (dev_zmin*500. < dev_zmax)
960	>	dev_zmin = dev_zmax/500.;
961		setzrat();
962		xmax = dev_zmin * tan(PI/180./2. * odev.v.horiz);
963		xmin = -xmax;
#	Line 898 \| Line 977 \| *register VIEW vp;**
977		odev.v.vp[2] + odev.v.vdir[2],
978		odev.v.vup[0], odev.v.vup[1], odev.v.vup[2]);
979		checkglerr("setting perspective view");
901	–	isperspective = 1;
980		vec[0] = vec[1] = vec[2] = 0.; vec[3] = 1.;
981		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, vec);
982		vec[0] = -odev.v.vdir[0];
#	Line 914 \| Line 992 \| *register VIEW vp;**
992		glEnable(GL_LIGHT0);
993		glEnable(GL_LIGHTING); /* light our GL objects */
994		glShadeModel(GL_SMOOTH);
995	+	viewflags &= ~VWORTHO;
996	+	viewflags \|= VWPERSP;
997		}
998
999
1000	<	static
1001	<	setglortho() /* set up orthographic view for cone drawing */
1000	>	static void
1001	>	setglortho(void) /* set up orthographic view for cone drawing */
1002		{
1003	+	glDrawBuffer(GL_FRONT); /* use single-buffer mode */
1004		/* set view matrix */
1005		glMatrixMode(GL_PROJECTION);
1006		glLoadIdentity();
1007		glOrtho(0., (double)odev.hres, 0., (double)odev.vres,
1008		0.001OMAXDEPTH, 1.001(-OMAXDEPTH));
1009		checkglerr("setting orthographic view");
929	–	isperspective = 0;
1010		glDisable(GL_LIGHTING); /* cones are constant color */
1011		glShadeModel(GL_FLAT);
1012	+	viewflags &= ~VWPERSP;
1013	+	viewflags \|= VWORTHO;
1014		}
1015
1016
1017	<	static
1018	<	wipeclean() /* prepare for redraw */
1017	>	static void
1018	>	wipeclean(void) /* prepare for redraw */
1019		{
1020	<	/* clear depth buffer */
1020	>	glDrawBuffer(GL_BACK); /* use double-buffer mode */
1021	>	glReadBuffer(GL_BACK);
1022	>	/* clear buffers */
1023		#ifdef STEREO
1024		setstereobuf(STEREO_BUFFER_RIGHT);
1025	<	glClear(GL_DEPTH_BUFFER_BIT);
1025	>	glClear(GL_DEPTH_BUFFER_BIT\|GL_COLOR_BUFFER_BIT);
1026		setstereobuf(STEREO_BUFFER_LEFT);
1027		#endif
1028	<	glClear(GL_DEPTH_BUFFER_BIT);
945	<	if (viewsteady) /* clear samples if steady */
946	<	odClean();
1028	>	glClear(GL_DEPTH_BUFFER_BIT\|GL_COLOR_BUFFER_BIT);
1029		freedepth();
1030	<	setglpersp(&odev.v); /* reset view & clipping planes */
1030	>	if ((viewflags&(VWCHANGE\|VWSTEADY)) ==
1031	>	(VWCHANGE\|VWSTEADY)) { /* clear samples if new */
1032	>	odClean();
1033	>	viewflags &= ~VWCHANGE; /* change noted */
1034	>	} else if (viewflags & VWSTEADY)
1035	>	odRedrawAll();
1036	>	setglpersp(); /* reset view & clipping planes */
1037		}
1038
1039
1040	<	static
1041	<	getkey(ekey) /* get input key */
1042	<	register XKeyPressedEvent *ekey;
1040	>	static void
1041	>	getkey( /* get input key */
1042	>	XKeyPressedEvent *ekey
1043	>	)
1044		{
1045		Window rootw, childw;
1046		int rootx, rooty, wx, wy;
#	Line 964 \| Line 1053 \| *register XKeyPressedEvent ekey;**
1053		return;
1054		switch (buf[0]) {
1055		case 'h': /* turn on height motion lock */
1056	<	headlocked = 1;
1056	>	viewflags \|= VWHEADLOCK;
1057		return;
1058		case 'H': /* turn off height motion lock */
1059	<	headlocked = 0;
1059	>	viewflags &= ~VWHEADLOCK;
1060		return;
1061		case 'l': /* retrieve last view */
1062		inpresflags \|= DFL(DC_LASTVIEW);
#	Line 995 \| Line 1084 \| *register XKeyPressedEvent ekey;**
1084		inpresflags \|= DFL(DC_RESUME);
1085		return;
1086		case CTRL('R'): /* redraw screen */
1087	<	odRemap(0);
1088	<	glClear(GL_COLOR_BUFFER_BIT\|GL_DEPTH_BUFFER_BIT);
1087	>	odRemap(0); /* new tone mapping */
1088	>	glClear(GL_DEPTH_BUFFER_BIT);
1089		#ifdef STEREO
1090		setstereobuf(STEREO_BUFFER_RIGHT);
1091	<	glClear(GL_COLOR_BUFFER_BIT\|GL_DEPTH_BUFFER_BIT);
1091	>	glClear(GL_DEPTH_BUFFER_BIT);
1092		setstereobuf(STEREO_BUFFER_LEFT);
1093		#endif
1094		return;
1095		case CTRL('L'): /* refresh from server */
1096		if (inpresflags & DFL(DC_REDRAW))
1097	<	return;
1097	>	return; /* already called */
1098		XRaiseWindow(ourdisplay, gwind);
1099	<	XFlush(ourdisplay);
1100	<	sleep(1);
1101	<	wipeclean(); /* fresh display */
1102	<	odRemap(1); /* fresh tone mapping */
1014	<	dev_flush(); /* draw octrees */
1099	>	XFlush(ourdisplay); /* raise up window */
1100	>	sleep(1); /* wait for restacking */
1101	>	dev_clear(); /* clear buffer and samples */
1102	>	odRemap(1); /* start fresh histogram */
1103		inpresflags \|= DFL(DC_REDRAW); /* resend values from server */
1016	–	rayqleft = 0; /* hold off update */
1104		return;
1105		case 'K': /* kill rtrace process(es) */
1106		inpresflags \|= DFL(DC_KILL);
#	Line 1034 \| Line 1121 \| *register XKeyPressedEvent ekey;**
1121		}
1122
1123
1124	<	static
1125	<	fixwindow(eexp) /* repair damage to window */
1126	<	register XExposeEvent *eexp;
1124	>	static void
1125	>	fixwindow( /* repair damage to window */
1126	>	XExposeEvent *eexp
1127	>	)
1128		{
1129		int xmin, ymin, xmax, ymax;
1130
1131	<	if (odev.hres == 0 \| odev.vres == 0) { /* first exposure */
1131	>	if ((odev.hres == 0) \| (odev.vres == 0)) { /* first exposure */
1132		resizewindow((XConfigureEvent *)eexp);
1133		return;
1134		}
1135		xmin = eexp->x; xmax = eexp->x + eexp->width;
1136		ymin = odev.vres - eexp->y - eexp->height; ymax = odev.vres - eexp->y;
1137	+
1138	+	if (xmin <= 0 && xmax >= odev.hres-1 &&
1139	+	ymin <= 0 && ymax >= odev.vres) {
1140	+	DCHECK(eexp->count, WARNING, "multiple clear in fixwindow");
1141	+	wipeclean(); /* make sure we're go */
1142	+	return;
1143	+	}
1144		/* clear portion of depth */
1145		glPushAttrib(GL_DEPTH_BUFFER_BIT\|GL_COLOR_BUFFER_BIT);
1146		glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
#	Line 1072 \| Line 1167 \| *register XExposeEvent eexp;**
1167		}
1168
1169
1170	<	static
1171	<	resizewindow(ersz) /* resize window */
1172	<	register XConfigureEvent *ersz;
1170	>	static void
1171	>	resizewindow( /* resize window */
1172	>	XConfigureEvent *ersz
1173	>	)
1174		{
1175		glViewport(0, 0, ersz->width, ersz->height);
1176
#	Line 1088 \| Line 1184 \| *register XConfigureEvent ersz;**
1184		odev.v.vert = 2.180./PI atan(0.5/VIEWDISTpheightodev.vres);
1185
1186		inpresflags \|= DFL(DC_SETVIEW);
1187	+	viewflags \|= VWCHANGE;
1188		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/hd/rhd_ogl.c (file contents): Revision 3.4 by gwlarson, Mon Dec 21 15:10:13 1998 UTC vs. Revision 3.32 by greg, Thu Apr 28 16:28:20 2016 UTC

Diff Legend

Comparing ray/src/hd/rhd_ogl.c (file contents):
Revision 3.4 by gwlarson, Mon Dec 21 15:10:13 1998 UTC vs.
Revision 3.32 by greg, Thu Apr 28 16:28:20 2016 UTC