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

Comparing ray/src/hd/sm_ogl.c (file contents):
Revision 3.7 by gwlarson, Wed Sep 16 18:16:29 1998 UTC vs.
Revision 3.13 by gwlarson, Sun Jan 10 10:27:48 1999 UTC

#	Line 16 \| Line 16 \| static char SCCSid[] = "$SunId$ SGI";
16		#include <GL/glu.h>
17		#include <glut.h>
18		#endif
19	+	#include "sm_flag.h"
20		#include "sm_list.h"
21		#include "sm_geom.h"
22	+	#include "sm_qtree.h"
23	+	#include "sm_stree.h"
24		#include "sm.h"
25
26		#ifdef TEST_DRIVER
#	Line 44 \| Line 47 \| *static QT_LUENT qt_htbl = NULL; /* quadtree cache /*
47		static int qt_hsiz = 0; /* quadtree cache size */
48
49
50	<	int
51	<	mark_active_tris(qtptr,fptr,arg1,arg2)
52	<	QUADTREE *qtptr;
53	<	int fptr,arg1,arg2;
51	<	{
52	<	QUADTREE qt = *qtptr;
53	<	OBJECT os,optr;
54	<	register int i,t_id;
50	>	typedef struct _T_DEPTH {
51	>	int tri;
52	>	double depth;
53	>	}T_DEPTH;
54
55	<	if (!QT_IS_LEAF(qt))
56	<	return(TRUE);
57	<
58	<	if(!QT_FLAG_FILL_TRI(*fptr))
59	<	(*fptr)++;
60	<	/* For each triangle in the set, set the which flag*/
61	<	os = qtqueryset(qt);
62	<
63	<	for (i = QT_SET_CNT(os), optr = QT_SET_PTR(os); i > 0; i--)
65	<	{
66	<	t_id = QT_SET_NEXT_ELEM(optr);
67	<	/* Set the render flag */
68	<	if(SM_IS_NTH_T_BASE(smMesh,t_id))
69	<	continue;
70	<	SM_SET_NTH_T_ACTIVE(smMesh,t_id);
71	<	/* NOTE:Also set the LRU clock bit: MAY WANT TO CHANGE: */
72	<	SM_SET_NTH_T_LRU(smMesh,t_id);
73	<	}
74	<	return(TRUE);
75	<	}
76	<
77	<	int
78	<	mark_active_interior(qtptr,q0,q1,q2,t0,t1,t2,n,arg1,arg2,arg3)
79	<	QUADTREE *qtptr;
80	<	FVECT q0,q1,q2;
81	<	FVECT t0,t1,t2;
82	<	int n;
83	<	int arg1,arg2,arg3;
55	>	/*
56	>	* smClean(tmflag) : display has been wiped clean
57	>	* int tmflag;
58	>	* Called after display has been effectively cleared, meaning that all
59	>	* geometry must be resent down the pipeline in the next call to smUpdate().
60	>	* If tmflag is set, tone-mapping should be performed
61	>	*/
62	>	smClean(tmflag)
63	>	int tmflag;
64		{
85	–	QUADTREE qt = *qtptr;
86	–	OBJECT os,optr;
87	–	register int i,t_id;
88	–
89	–	if (!QT_IS_LEAF(qt))
90	–	return(TRUE);
91	–	/* For each triangle in the set, set the which flag*/
92	–	os = qtqueryset(qt);
93	–
94	–	for (i = QT_SET_CNT(os), optr = QT_SET_PTR(os); i > 0; i--)
95	–	{
96	–	t_id = QT_SET_NEXT_ELEM(optr);
97	–	/* Set the render flag */
98	–	if(SM_IS_NTH_T_BASE(smMesh,t_id))
99	–	continue;
100	–	SM_SET_NTH_T_ACTIVE(smMesh,t_id);
101	–	/* NOTE:Also set the LRU clock bit: MAY WANT TO CHANGE: */
102	–	SM_SET_NTH_T_LRU(smMesh,t_id);
103	–	}
104	–	return(TRUE);
105	–	}
106	–
107	–	mark_tris_in_frustum(view)
108	–	VIEW *view;
109	–	{
110	–	FVECT nr[4],far[4];
111	–
112	–	/* Mark triangles in approx. view frustum as being active:set
113	–	LRU counter: for use in discarding samples when out
114	–	of space
115	–	Radiance often has no far clipping plane: but driver will set
116	–	dev_zmin,dev_zmax to satisfy OGL
117	–	*/
118	–
119	–	/* First clear all the quadtree node and triangle active flags */
120	–	qtClearAllFlags();
121	–	smClear_flags(smMesh,T_ACTIVE_FLAG);
122	–
123	–	/* calculate the world space coordinates of the view frustum */
124	–	calculate_view_frustum(view->vp,view->hvec,view->vvec,view->horiz,
125	–	view->vert, dev_zmin,dev_zmax,nr,far);
126	–
127	–	/* Project the view frustum onto the spherical quadtree */
128	–	/* For every cell intersected by the projection of the faces
129	–	of the frustum: mark all triangles in the cell as ACTIVE-
130	–	Also set the triangles LRU clock counter
131	–	*/
132	–	/* Near face triangles */
133	–	smLocator_apply_func(smMesh,nr[0],nr[2],nr[3],mark_active_tris,
134	–	mark_active_interior,NULL,NULL);
135	–	smLocator_apply_func(smMesh,nr[2],nr[0],nr[1],mark_active_tris,
136	–	mark_active_interior,NULL,NULL);
137	–	/* Right face triangles */
138	–	smLocator_apply_func(smMesh,nr[0],far[3],far[0],mark_active_tris,
139	–	mark_active_interior,NULL,NULL);
140	–	smLocator_apply_func(smMesh,far[3],nr[0],nr[3],mark_active_tris,
141	–	mark_active_interior,NULL,NULL);
142	–	/* Left face triangles */
143	–	smLocator_apply_func(smMesh,nr[1],far[2],nr[2],mark_active_tris,
144	–	mark_active_interior,NULL,NULL);
145	–	smLocator_apply_func(smMesh,far[2],nr[1],far[1],mark_active_tris,
146	–	mark_active_interior,NULL,NULL);
147	–	/* Top face triangles */
148	–	smLocator_apply_func(smMesh,nr[0],far[0],nr[1],mark_active_tris,
149	–	mark_active_interior,NULL,NULL);
150	–	smLocator_apply_func(smMesh,nr[1],far[0],far[1],mark_active_tris,
151	–	mark_active_interior,NULL,NULL);
152	–	/* Bottom face triangles */
153	–	smLocator_apply_func(smMesh,nr[3],nr[2],far[3],mark_active_tris,
154	–	mark_active_interior,NULL,NULL);
155	–	smLocator_apply_func(smMesh,nr[2],far[2],far[3],mark_active_tris,
156	–	mark_active_interior,NULL,NULL);
157	–	/* Far face triangles */
158	–	smLocator_apply_func(smMesh,far[0],far[2],far[1],mark_active_tris,
159	–	mark_active_interior,NULL,NULL);
160	–
161	–	smLocator_apply_func(smMesh,far[2],far[0],far[3],mark_active_tris,
162	–	mark_active_interior,NULL,NULL);
163	–	#ifdef TEST_DRIVER
164	–	VCOPY(FrustumFar[0],far[0]);
165	–	VCOPY(FrustumFar[1],far[1]);
166	–	VCOPY(FrustumFar[2],far[2]);
167	–	VCOPY(FrustumFar[3],far[3]);
168	–	VCOPY(FrustumNear[0],nr[0]);
169	–	VCOPY(FrustumNear[1],nr[1]);
170	–	VCOPY(FrustumNear[2],nr[2]);
171	–	VCOPY(FrustumNear[3],nr[3]);
172	–	#endif
173	–	}
174	–
175	–	/*
176	–	* smClean() : display has been wiped clean
177	–	*
178	–	* Called after display has been effectively cleared, meaning that all
179	–	* geometry must be resent down the pipeline in the next call to smUpdate().
180	–	*/
181	–	smClean()
182	–	{
65		smClean_notify = TRUE;
66	+	if(tmflag)
67	+	SM_TONE_MAP(smMesh) = 0;
68		}
69
70		int
#	Line 264 \| Line 148 \| register QUADTREE qt;
148		stCount_level_leaves(lcnt+1, QT_NTH_CHILD(qt,3));
149		}
150		else
151	<	lcnt[0]++;
151	>	if(QT_LEAF_IS_FLAG(qt))
152	>	lcnt[0]++;
153		}
154
155
#	Line 284 \| Line 169 \| int lvl;
169		return(NULL);
170		if (QT_IS_TREE(qt) && !QT_IS_FLAG(qt)) /* not in our frustum */
171		return(NULL);
172	+	if(QT_IS_LEAF(qt) && !QT_LEAF_IS_FLAG(qt)) /* not in our frustum */
173	+	return(NULL);
174		/* else look up node */
175		if ((le = qtCache_find(qt)) == NULL)
176		error(SYSTEM, "out of memory in qtRender_level");
177		if (QT_IS_TREE(qt) && (QT_IS_EMPTY(le->qt) \|\| lvl > 0))
178		{ /* compute children */
179		qtSubdivide_tri(v0,v1,v2,a,b,c);
180	<	rc[0] = qtRender_level(QT_NTH_CHILD(qt,0),v0,a,c,sm,lvl-1);
181	<	rc[1] = qtRender_level(QT_NTH_CHILD(qt,1),a,v1,b,sm,lvl-1);
182	<	rc[2] = qtRender_level(QT_NTH_CHILD(qt,2),c,b,v2,sm,lvl-1);
183	<	rc[3] = qtRender_level(QT_NTH_CHILD(qt,3),b,c,a,sm,lvl-1);
180	>	rc[0] = qtRender_level(QT_NTH_CHILD(qt,0),v0,c,b,sm,lvl-1);
181	>	rc[1] = qtRender_level(QT_NTH_CHILD(qt,1),c,v1,a,sm,lvl-1);
182	>	rc[2] = qtRender_level(QT_NTH_CHILD(qt,2),b,a,v2,sm,lvl-1);
183	>	rc[3] = qtRender_level(QT_NTH_CHILD(qt,3),a,b,c,sm,lvl-1);
184		}
185		if (QT_IS_EMPTY(le->qt))
186		{ /* let's make some data! */
#	Line 316 \| Line 203 \| int lvl;
203		{ /* from triangle set */
204		OBJECT *os;
205		int s0, s1, s2;
206	<
206	>
207		os = qtqueryset(qt);
208	<	for (n = os[0]; n; n--)
208	>	for (i = os[0]; i; i--)
209		{
210	<	tri = SM_NTH_TRI(sm,os[n]);
210	>	if(SM_IS_NTH_T_BASE(sm,os[i]))
211	>	continue;
212	>	tri = SM_NTH_TRI(sm,os[i]);
213	>	if(!T_IS_VALID(tri))
214	>	continue;
215	>	n++;
216		s0 = T_NTH_V(tri,0);
217		s1 = T_NTH_V(tri,1);
218		s2 = T_NTH_V(tri,2);
#	Line 340 \| Line 232 \| int lvl;
232		rgbs[2] += SM_NTH_RGB(sm,s0)[2] + SM_NTH_RGB(sm,s1)[2]
233		+ SM_NTH_RGB(sm,s2)[2];
234		}
235	<	n = 3*os[0];
235	>	n *= 3;
236		}
237		if (!n)
238		return(NULL);
#	Line 358 \| Line 250 \| int lvl;
250		VSUM(c,SM_VIEW_CENTER(sm),c,le->av.dist);
251		/* draw triangle */
252		glColor3ub(le->av.rgb[0],le->av.rgb[1],le->av.rgb[2]);
361	–	/* NOTE: Triangle vertex order may change */
362	–	glVertex3d(c[0],c[1],c[2]);
363	–	glVertex3d(b[0],b[1],b[2]);
253		glVertex3d(a[0],a[1],a[2]);
254	+	glVertex3d(b[0],b[1],b[2]);
255	+	glVertex3d(c[0],c[1],c[2]);
256	+
257		}
258		return(&le->av);
259		}
#	Line 371 \| Line 263 \| smRender_stree_level(sm,lvl)
263		SM *sm;
264		int lvl;
265		{
266	<	QUADTREE root;
266	>	QUADTREE qt;
267		int i;
268		FVECT t0,t1,t2;
269	+	STREE *st;
270
271	<	if (lvl < 1)
271	>
272	>	if (lvl < 0)
273		return;
274	+	st = SM_LOCATOR(sm);
275		glPushAttrib(GL_LIGHTING_BIT);
276		glShadeModel(GL_FLAT);
277		glBegin(GL_TRIANGLES);
278	<	for(i=0; i < 4; i++)
278	>	for(i=0; i < ST_NUM_ROOT_NODES; i++)
279		{
280	<	root = ST_NTH_ROOT(SM_LOCATOR(sm),i);
281	<	stNth_base_verts(SM_LOCATOR(sm),i,t0,t1,t2);
282	<	qtRender_level(root,t0,t1,t2,sm,lvl-1);
280	>	qt = ST_ROOT_QT(st,i);
281	>	qtRender_level(qt,ST_NTH_V(st,i,0),ST_NTH_V(st,i,1),ST_NTH_V(st,i,2),
282	>	sm,lvl);
283		}
284		glEnd();
285		glPopAttrib();
#	Line 395 \| Line 290 \| *smRender_stree(sm, qual) / render some quadtree trian**
290		SM *sm;
291		int qual;
292		{
293	<	int i, ntarget;
293	>	int i, n,ntarget;
294		int lvlcnt[QT_MAX_LEVELS];
295	<
295	>	STREE *st;
296	>	int4 *active_flag;
297		if (qual <= 0)
298		return;
299		/* compute rendering target */
300		ntarget = 0;
301	<	SM_FOR_ALL_ACTIVE_TRIS(sm,i)
302	<	ntarget++;
303	<	ntarget = ntarget*qual/100;
301	>
302	>	active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG);
303	>	for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
304	>	if(active_flag[n])
305	>	for(i=0; i < 32; i++)
306	>	if(active_flag[n] & (1L << i))
307	>	ntarget++;
308	>
309	>	ntarget = ntarget*qual/MAXQUALITY;
310		if (!ntarget)
311		return;
312		for (i = QT_MAX_LEVELS; i--; )
313		lvlcnt[i] = 0;
314	<	stCount_level_leaves(lvlcnt, SM_LOCATOR(sm)->root);
314	>
315	>	st = SM_LOCATOR(sm);
316	>	for(i=0; i < ST_NUM_ROOT_NODES;i++)
317	>	stCount_level_leaves(lvlcnt, ST_ROOT_QT(st,i));
318	>
319		for (ntarget -= lvlcnt[i=0]; i < QT_MAX_LEVELS-1; ntarget -= lvlcnt[++i])
320		if (ntarget < lvlcnt[i+1])
321		break;
#	Line 418 \| Line 324 \| int qual;
324		}
325
326
421	–	smRender_tri(sm,i,vp,clr)
422	–	SM *sm;
423	–	int i;
424	–	FVECT vp;
425	–	int clr;
426	–	{
427	–	TRI *tri;
428	–	double ptr[3];
429	–	int j;
327
328	<	tri = SM_NTH_TRI(sm,i);
329	<	if (clr) SM_CLEAR_NTH_T_NEW(sm,i);
328	>	#define render_tri(v0,v1,v2,rgb0,rgb1,rgb2) \
329	>	{glColor3ub(rgb0[0],rgb0[1],rgb0[2]); glVertex3fv(v0); \
330	>	glColor3ub(rgb1[0],rgb1[1],rgb1[2]); glVertex3fv(v1); \
331	>	glColor3ub(rgb2[0],rgb2[1],rgb2[2]); glVertex3fv(v2);} \
332
333	<	/* NOTE:Triangles are defined clockwise:historical relative to spherical
334	<	tris: could change
335	<	*/
336	<	for(j=2; j>= 0; j--)
337	<	{
439	<	#ifdef DEBUG
440	<	if(SM_BG_SAMPLE(sm,T_NTH_V(tri,j)))
441	<	eputs("SmRenderTri(): shouldnt have bg samples\n");
442	<	#endif
443	<	glColor3ub(SM_NTH_RGB(sm,T_NTH_V(tri,j))[0],
444	<	SM_NTH_RGB(sm,T_NTH_V(tri,j))[1],
445	<	SM_NTH_RGB(sm,T_NTH_V(tri,j))[2]);
446	<	VCOPY(ptr,SM_T_NTH_WV(sm,tri,j));
447	<	glVertex3d(ptr[0],ptr[1],ptr[2]);
448	<	}
449	<	}
450	<
451	<	smRender_mixed_tri(sm,i,vp,clr)
452	<	SM *sm;
453	<	int i;
454	<	FVECT vp;
455	<	int clr;
333	>	render_mixed_tri(v0,v1,v2,rgb0,rgb1,rgb2,bg0,bg1,bg2,vp,vc)
334	>	float v0[3],v1[3],v2[3];
335	>	BYTE rgb0[3],rgb1[3],rgb2[3];
336	>	int bg0,bg1,bg2;
337	>	FVECT vp,vc;
338		{
457	–	TRI *tri;
339		double p[3],d;
340		int j,ids[3],cnt;
341		int rgb[3];
342
462	–	tri = SM_NTH_TRI(sm,i);
463	–	if (clr) SM_CLEAR_NTH_T_NEW(sm,i);
464	–
343		/* NOTE:Triangles are defined clockwise:historical relative to spherical
344		tris: could change
345		*/
346	+	if(bg0 && bg1 && bg2)
347	+	return;
348	+
349		cnt = 0;
350		d = 0.0;
351		rgb[0] = rgb[1] = rgb[2] = 0;
352	<	for(j=0;j < 3;j++)
352	>
353	>	if(!bg0)
354		{
355	<	ids[j] = T_NTH_V(tri,j);
356	<	if(!SM_BG_SAMPLE(sm,ids[j]))
357	<	{
358	<	rgb[0] += SM_NTH_RGB(sm,ids[j])[0];
359	<	rgb[1] += SM_NTH_RGB(sm,ids[j])[1];
478	<	rgb[2] += SM_NTH_RGB(sm,ids[j])[2];
479	<	cnt++;
480	<	d += DIST(vp,SM_NTH_WV(sm,ids[j]));
481	<	}
355	>	rgb[0] += rgb0[0];
356	>	rgb[1] += rgb0[1];
357	>	rgb[2] += rgb0[2];
358	>	cnt++;
359	>	d += DIST(vp,v0);
360		}
361	+	if(!bg1)
362	+	{
363	+	rgb[0] += rgb1[0];
364	+	rgb[1] += rgb1[1];
365	+	rgb[2] += rgb1[2];
366	+	cnt++;
367	+	d += DIST(vp,v1);
368	+	}
369	+	if(!bg2)
370	+	{
371	+	rgb[0] += rgb2[0];
372	+	rgb[1] += rgb2[1];
373	+	rgb[2] += rgb2[2];
374	+	cnt++;
375	+	d += DIST(vp,v2);
376	+	}
377		if(cnt > 1)
378		{
379		rgb[0]/=cnt; rgb[1]/=cnt; rgb[2]/=cnt;
380		d /= (double)cnt;
381		}
382	<	for(j=2; j>= 0; j--)
382	>	if(bg0)
383		{
384	<	if(SM_BG_SAMPLE(sm,ids[j]))
385	<	{
386	<	glColor3ub(rgb[0],rgb[1],rgb[2]);
387	<	VSUB(p,SM_NTH_WV(sm,ids[j]),SM_VIEW_CENTER(sm));
388	<	p[0] *= d;
389	<	p[1] *= d;
390	<	p[2] *= d;
391	<	VADD(p,p,SM_VIEW_CENTER(sm));
392	<	}
393	<	else
394	<	{
395	<	glColor3ub(SM_NTH_RGB(sm,ids[j])[0],SM_NTH_RGB(sm,ids[j])[1],
502	<	SM_NTH_RGB(sm,ids[j])[2]);
503	<	VCOPY(p,SM_NTH_WV(sm,ids[j]));
504	<	}
505	<	glVertex3d(p[0],p[1],p[2]);
384	>	glColor3ub(rgb[0],rgb[1],rgb[2]);
385	>	VSUB(p,v0,vc);
386	>	p[0] *= d;
387	>	p[1] *= d;
388	>	p[2] *= d;
389	>	VADD(p,p,vc);
390	>	glVertex3dv(p);
391	>	}
392	>	else
393	>	{
394	>	glColor3ub(rgb0[0],rgb0[1],rgb0[2]);
395	>	glVertex3fv(v0);
396		}
397	+	if(bg1)
398	+	{
399	+	glColor3ub(rgb[0],rgb[1],rgb[2]);
400	+	VSUB(p,v1,vc);
401	+	p[0] *= d;
402	+	p[1] *= d;
403	+	p[2] *= d;
404	+	VADD(p,p,vc);
405	+	glVertex3dv(p);
406	+	}
407	+	else
408	+	{
409	+	glColor3ub(rgb1[0],rgb1[1],rgb1[2]);
410	+	glVertex3fv(v1);
411	+	}
412	+	if(bg2)
413	+	{
414	+	glColor3ub(rgb[0],rgb[1],rgb[2]);
415	+	VSUB(p,v2,vc);
416	+	p[0] *= d;
417	+	p[1] *= d;
418	+	p[2] *= d;
419	+	VADD(p,p,vc);
420	+	glVertex3dv(p);
421	+	}
422	+	else
423	+	{
424	+	glColor3ub(rgb2[0],rgb2[1],rgb2[2]);
425	+	glVertex3fv(v2);
426	+	}
427	+
428		}
429
430	<	smRender_bg_tri(sm,i,vp,d,clr)
431	<	SM *sm;
432	<	int i;
433	<	FVECT vp;
430	>	render_bg_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,vc,d)
431	>	float v0[3],v1[3],v2[3];
432	>	BYTE rgb0[3],rgb1[3],rgb2[3];
433	>	FVECT vp,vc;
434		double d;
514	–	int clr;
435		{
436		double p[3];
517	–	int j,id;
518	–	TRI *tri;
437
438	<	tri = SM_NTH_TRI(sm,i);
439	<	if (clr) SM_CLEAR_NTH_T_NEW(sm,i);
438	>	glColor3ub(rgb0[0],rgb0[1],rgb0[2]);
439	>	VSUB(p,v0,vc);
440	>	if(dev_zmin >= 0.99)
441	>	{
442	>	p[0] *= d;
443	>	p[1] *= d;
444	>	p[2] *= d;
445	>	}
446	>	VADD(p,p,vp);
447	>	glVertex3dv(p);
448
449	<	/* NOTE:Triangles are defined clockwise:historical relative to spherical
450	<	tris: could change
451	<	*/
526	<	for(j=2; j>= 0; j--)
449	>	glColor3ub(rgb1[0],rgb1[1],rgb1[2]);
450	>	VSUB(p,v1,vc);
451	>	if(dev_zmin >= 0.99)
452		{
453	<	id = T_NTH_V(tri,j);
454	<	glColor3ub(SM_NTH_RGB(sm,id)[0],SM_NTH_RGB(sm,id)[1],
455	<	SM_NTH_RGB(sm,id)[2]);
531	<	VSUB(p,SM_NTH_WV(sm,id),SM_VIEW_CENTER(sm));
532	<	if(dev_zmin >= 0.99)
533	<	{
534	<	p[0] *= d;
535	<	p[1] *= d;
536	<	p[2] *= d;
537	<	}
538	<	VADD(p,p,vp);
539	<	glVertex3d(p[0],p[1],p[2]);
453	>	p[0] *= d;
454	>	p[1] *= d;
455	>	p[2] *= d;
456		}
457	+	VADD(p,p,vp);
458	+	glVertex3dv(p);
459	+
460	+
461	+	glColor3ub(rgb2[0],rgb2[1],rgb2[2]);
462	+	VSUB(p,v2,vc);
463	+	if(dev_zmin >= 0.99)
464	+	{
465	+	p[0] *= d;
466	+	p[1] *= d;
467	+	p[2] *= d;
468	+	}
469	+	VADD(p,p,vp);
470	+	glVertex3dv(p);
471	+
472		}
473
474	<	smRender_mesh(sm,vp,clr)
474	>	smRender_mesh(sm,vp)
475		SM *sm;
476		FVECT vp;
546	–	int clr;
477		{
478	<	int i;
478	>	int i,n,bg0,bg1,bg2;
479	>	double d;
480	>	int v0_id,v1_id,v2_id;
481		TRI *tri;
482	<	double ptr[3],d;
483	<	int j;
482	>	float (*wp)[3];
483	>	BYTE (*rgb)[3];
484	>	int4 active_flag,bg_flag;
485
486	+	wp = SM_WP(sm);
487	+	rgb =SM_RGB(sm);
488		d = (dev_zmin+dev_zmax)/2.0;
489		glPushAttrib(GL_DEPTH_BUFFER_BIT);
490
491		/* First draw background polygons */
557	–
492		glDisable(GL_DEPTH_TEST);
493		glBegin(GL_TRIANGLES);
494	<	SM_FOR_ALL_ACTIVE_BG_TRIS(sm,i)
495	<	smRender_bg_tri(sm,i,vp,d,clr);
494	>
495	>	active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG);
496	>	bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG);
497	>	for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
498	>	if(active_flag[n] & bg_flag[n])
499	>	for(i=0; i < 32; i++)
500	>	if(active_flag[n] & bg_flag[n] & (1L << i))
501	>	{
502	>	tri = SM_NTH_TRI(sm,(n<<5)+i);
503	>	v0_id = T_NTH_V(tri,0);
504	>	v1_id = T_NTH_V(tri,1);
505	>	v2_id = T_NTH_V(tri,2);
506	>	render_bg_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
507	>	rgb[v2_id],vp,SM_VIEW_CENTER(sm),d);
508	>	}
509		glEnd();
510	<
510	>
511		glEnable(GL_DEPTH_TEST);
512		glBegin(GL_TRIANGLES);
513	<	SM_FOR_ALL_ACTIVE_FG_TRIS(sm,i)
514	<	{
515	<	if(!SM_MIXED_TRI(sm,i))
516	<	smRender_tri(sm,i,vp,clr);
517	<	else
518	<	smRender_mixed_tri(sm,i,vp,clr);
519	<	}
513	>	for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
514	>	if(active_flag[n])
515	>	for(i=0; i < 32; i++)
516	>	if((active_flag[n] & (1L << i)) && !(bg_flag[n] & (1L << i)))
517	>	{
518	>	tri = SM_NTH_TRI(sm,(n<<5)+i);
519	>	v0_id = T_NTH_V(tri,0);
520	>	v1_id = T_NTH_V(tri,1);
521	>	v2_id = T_NTH_V(tri,2);
522	>	bg0 = SM_DIR_ID(sm,v0_id) \|\| SM_BASE_ID(sm,v0_id);
523	>	bg1 = SM_DIR_ID(sm,v1_id) \|\| SM_BASE_ID(sm,v1_id);
524	>	bg2 = SM_DIR_ID(sm,v2_id) \|\| SM_BASE_ID(sm,v2_id);
525	>	if(!(bg0 \|\| bg1 \|\| bg2))
526	>	render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
527	>	rgb[v2_id])
528	>	else
529	>	render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],
530	>	rgb[v1_id],rgb[v2_id],bg0,bg1,bg2,vp,SM_VIEW_CENTER(sm));
531	>	}
532		glEnd();
533
534		glPopAttrib();
535		}
536
578	–	smRender_tri_edges(sm,i)
579	–	SM *sm;
580	–	int i;
581	–	{
582	–	TRI *tri;
583	–	int j;
584	–	double ptr[3];
585	–
586	–
587	–	tri = SM_NTH_TRI(sm,i);
588	–
589	–	/* Triangles are defined clockwise:historical relative to spherical
590	–	tris: could change
591	–	*/
592	–	for(j=2; j >=0; j--)
593	–	{
594	–	VCOPY(ptr,SM_NTH_WV(sm,T_NTH_V(tri,j)));
595	–	glVertex3d(ptr[0],ptr[1],ptr[2]);
596	–	VCOPY(ptr,SM_NTH_WV(sm,T_NTH_V(tri,(j+1)%3)));
597	–	glVertex3d(ptr[0],ptr[1],ptr[2]);
598	–	}
599	–	}
600	–
537		int
538		compare_tri_depths(T_DEPTH td1,T_DEPTH td2)
539		{
#	Line 611 \| Line 547 \| *compare_tri_depths(T_DEPTH td1,T_DEPTH td2)*
547		return(-1);
548
549		return(0);
550	+
551		}
552
553	<	LIST
554	<	*smDepth_sort_tris(sm,vp,td)
553	>	#ifdef DEBUG
554	>	#define freebuf(b) tempbuf(-1)
555	>	#endif
556	>
557	>
558	>	char *
559	>	tempbuf(len) /* get a temporary buffer */
560	>	unsigned len;
561	>	{
562	>	extern char malloc(), realloc();
563	>	static char *tempbuf = NULL;
564	>	static unsigned tempbuflen = 0;
565	>
566	>	#ifdef DEBUG
567	>	static int in_use=FALSE;
568	>
569	>	if(len == -1)
570	>	{
571	>	in_use = FALSE;
572	>	return(NULL);
573	>	}
574	>	if(in_use)
575	>	{
576	>	eputs("Buffer in use:cannot allocate:tempbuf()\n");
577	>	return(NULL);
578	>	}
579	>	#endif
580	>	if (len > tempbuflen) {
581	>	if (tempbuflen > 0)
582	>	tempbuf = realloc(tempbuf, len);
583	>	else
584	>	tempbuf = malloc(len);
585	>	tempbuflen = tempbuf==NULL ? 0 : len;
586	>	}
587	>	#ifdef DEBUG
588	>	in_use = TRUE;
589	>	#endif
590	>	return(tempbuf);
591	>	}
592	>
593	>	smOrder_new_tris(sm,vp,td)
594		SM *sm;
595		FVECT vp;
596		T_DEPTH *td;
597		{
598	<	int i,j,t_id,v;
598	>	int n,i,j,tcnt,v;
599		TRI *tri;
600		double d,min_d;
601	<	LIST *tlist=NULL;
601	>	FVECT diff;
602	>	int4 new_flag,bg_flag;
603
604	<	i = 0;
605	<	SM_FOR_ALL_NEW_TRIS(sm,t_id)
606	<	{
607	<	if(SM_BG_TRI(sm,t_id))
608	<	{
609	<	tlist = push_data(tlist,t_id);
610	<	continue;
611	<	}
612	<	tri = SM_NTH_TRI(sm,t_id);
613	<	#ifdef DEBUG
614	<	if(i >= smNew_tri_cnt)
615	<	{
616	<	eputs("smDepth_sort_tris():More tris than reported by smNew_tri_cnt\n");
617	<	break;
618	<	}
619	<	#endif
620	<	td[i].tri = t_id;
621	<	min_d = -1;
622	<	for(j=0;j < 3;j++)
623	<	{
624	<	v = T_NTH_V(tri,j);
625	<	if(!SM_BG_SAMPLE(sm,v))
626	<	{
650	<	d = DIST(vp,SM_NTH_WV(sm,v));
651	<	if(min_d == -1 \|\| d < min_d)
652	<	min_d = d;
653	<	}
654	<	}
655	<	td[i].depth = min_d;
656	<	i++;
604	>	tcnt=0;
605	>	new_flag = SM_NTH_FLAGS(sm,T_NEW_FLAG);
606	>	bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG);
607	>	for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
608	>	if(new_flag[n] & ~bg_flag[n])
609	>	for(i=0; i < 32; i++)
610	>	if(new_flag[n] & (1L << i) & ~bg_flag[n])
611	>	{
612	>	tri = SM_NTH_TRI(sm,(n<<5)+i);
613	>	td[tcnt].tri = (n << 5)+i;
614	>	min_d = -1;
615	>	for(j=0;j < 3;j++)
616	>	{
617	>	v = T_NTH_V(tri,j);
618	>	if(!SM_BG_SAMPLE(sm,v))
619	>	{
620	>	VSUB(diff,SM_NTH_WV(sm,v),vp);
621	>	d = DOT(diff,diff);
622	>	if(min_d == -1 \|\| d < min_d)
623	>	min_d = d;
624	>	}
625	>	}
626	>	td[tcnt++].depth = min_d;
627		}
628	<	td[i].tri = -1;
629	<	if(i)
630	<	qsort((void *)td,i,sizeof(T_DEPTH),compare_tri_depths);
661	<	return(tlist);
628	>	td[tcnt].tri = -1;
629	>	if(tcnt)
630	>	qsort((void *)td,tcnt,sizeof(T_DEPTH),compare_tri_depths);
631		}
632
633
#	Line 667 \| Line 636 \| *SM sm;**
636		FVECT vp;
637		int clr;
638		{
639	<	static T_DEPTH *td= NULL;
671	<	static int tsize = 0;
672	<	int i;
639	>	int i,n,v0_id,v1_id,v2_id,bg0,bg1,bg2;
640		GLint depth_test;
641		double d;
642	<	LIST *bglist;
642	>	TRI *tri;
643	>	float (*wp)[3];
644	>	BYTE (*rgb)[3];
645	>	int4 new_flag,bg_flag;
646	>	T_DEPTH *td = NULL;
647		/* For all of the NEW triangles (since last update): assume
648		ACTIVE. Go through and sort on depth value (from vp). Turn
649		Depth Buffer test off and render back-front
650		*/
651	<	/* NOTE: could malloc each time or hard code */
681	<	if(smNew_tri_cnt > tsize)
651	>	if(!EQUAL_VEC3(SM_VIEW_CENTER(sm),vp))
652		{
653	<	if(td)
654	<	free((char *)td);
655	<	td = (T_DEPTH )malloc(smNew_tri_cntsizeof(T_DEPTH));
656	<	tsize = smNew_tri_cnt;
653	>	/* Must depth sort if view points do not coincide */
654	>	td = (T_DEPTH )tempbuf(smNew_tri_cntsizeof(T_DEPTH));
655	>	#ifdef DEBUG
656	>	if(!td)
657	>	eputs("Cant create list:wont depth sort:smUpdate_rendered_mesh\n");
658	>	#endif
659	>	smOrder_new_tris(sm,vp,td);
660		}
661	<	if(!td)
662	<	{
690	<	error(SYSTEM,"smUpdate_Rendered_mesh:Cannot allocate memory\n");
691	<	}
692	<	bglist = smDepth_sort_tris(sm,vp,td);
693	<
661	>	wp = SM_WP(sm);
662	>	rgb =SM_RGB(sm);
663		/* Turn Depth Test off -- using Painter's algorithm */
664		glPushAttrib(GL_DEPTH_BUFFER_BIT);
665	<	glDisable(GL_DEPTH_TEST);
665	>	glDepthFunc(GL_ALWAYS);
666		d = (dev_zmin+dev_zmax)/2.0;
667	+
668		/* Now render back-to front */
669		/* First render bg triangles */
670	+	new_flag = SM_NTH_FLAGS(sm,T_NEW_FLAG);
671	+	bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG);
672		glBegin(GL_TRIANGLES);
673	<	while(bglist)
674	<	smRender_bg_tri(sm,pop_list(&bglist),vp,d,clr);
673	>	for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
674	>	if(new_flag[n] & bg_flag[n])
675	>	for(i=0; i < 32; i++)
676	>	if(new_flag[n] & (1L << i) & bg_flag[n] )
677	>	{
678	>	tri = SM_NTH_TRI(sm,(n<<5)+i);
679	>	v0_id = T_NTH_V(tri,0);
680	>	v1_id = T_NTH_V(tri,1);
681	>	v2_id = T_NTH_V(tri,2);
682	>	render_bg_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
683	>	rgb[v2_id],vp,SM_VIEW_CENTER(sm),d);
684	>	}
685		glEnd();
686
687
688		glBegin(GL_TRIANGLES);
689	<	i=0;
690	<	while(td[i].tri != -1)
691	<	if(!SM_MIXED_TRI(sm,td[i].tri))
692	<	smRender_tri(sm,td[i++].tri,vp,clr);
693	<	else
694	<	smRender_mixed_tri(sm,td[i++].tri,vp,clr);
689	>	if(!td)
690	>	{
691	>	for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;)
692	>	if(new_flag[n] & ~bg_flag[n])
693	>	for(i=0; i < 32; i++)
694	>	if(new_flag[n] & (1L << i) & ~bg_flag[n])
695	>	{
696	>	tri = SM_NTH_TRI(sm,(n<<5)+i);
697	>	/* Dont need to check for valid tri because flags are
698	>	cleared on delete
699	>	*/
700	>	v0_id = T_NTH_V(tri,0);
701	>	v1_id = T_NTH_V(tri,1);
702	>	v2_id = T_NTH_V(tri,2);
703	>	bg0 = SM_DIR_ID(sm,v0_id) \|\| SM_BASE_ID(sm,v0_id);
704	>	bg1 = SM_DIR_ID(sm,v1_id) \|\| SM_BASE_ID(sm,v1_id);
705	>	bg2 = SM_DIR_ID(sm,v2_id) \|\| SM_BASE_ID(sm,v2_id);
706	>	if(!(bg0 \|\| bg1 \|\| bg2))
707	>	render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
708	>	rgb[v2_id])
709	>	else
710	>	render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],
711	>	rgb[v1_id],rgb[v2_id],bg0,bg1,bg2,vp,
712	>	SM_VIEW_CENTER(sm));
713	>	}
714	>	}
715	>	else
716	>	{
717	>	for(i=0; td[i].tri != -1;i++)
718	>	{
719	>	tri = SM_NTH_TRI(sm,td[i].tri);
720	>	/* Dont need to check for valid tri because flags are
721	>	cleared on delete
722	>	*/
723	>	v0_id = T_NTH_V(tri,0);
724	>	v1_id = T_NTH_V(tri,1);
725	>	v2_id = T_NTH_V(tri,2);
726	>	bg0 = SM_DIR_ID(sm,v0_id) \|\| SM_BASE_ID(sm,v0_id);
727	>	bg1 = SM_DIR_ID(sm,v1_id) \|\| SM_BASE_ID(sm,v1_id);
728	>	bg2 = SM_DIR_ID(sm,v2_id) \|\| SM_BASE_ID(sm,v2_id);
729	>	if(!(bg0 \|\| bg1 \|\| bg2))
730	>	render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
731	>	rgb[v2_id])
732	>	else
733	>	render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],
734	>	rgb[v1_id],rgb[v2_id],bg0,bg1,bg2,vp,
735	>	SM_VIEW_CENTER(sm));
736	>	}
737	>	#ifdef DEBUG
738	>	freebuf(td);
739	>	#endif
740	>	}
741		glEnd();
742
743		/* Restore Depth Test */
#	Line 733 \| Line 761 \| smUpdate(view,qual)
761		int qual;
762		{
763		double d;
764	<	int last_update;
737	<	int t;
764	>	int last_update,t;
765
766	+	if(!smMesh)
767	+	return;
768	+
769		/* If view has moved beyond epsilon from canonical: must rebuild -
770		epsilon is calculated as running avg of distance of sample points
771		from canonical view: m = 1/(AVG(1/r)): some fraction of this
772		*/
773		d = DIST(view->vp,SM_VIEW_CENTER(smMesh));
774	<	if(qual >= 100 && d > SM_ALLOWED_VIEW_CHANGE(smMesh))
774	>	if(qual >= MAXQUALITY && d > SM_ALLOWED_VIEW_CHANGE(smMesh))
775		{
776		/* Re-build the mesh */
777		#ifdef TEST_DRIVER
778		odev.v = *view;
779	<	#endif
780	<	smRebuild_mesh(smMesh,view->vp);
779	>	#endif
780	>	mark_tris_in_frustum(view);
781	>	smRebuild_mesh(smMesh,view);
782	>	smClean_notify = TRUE;
783		}
784	<	/* This is our final update iff qual==100 and view==&odev.v */
785	<	last_update = qual>=100 && view==&(odev.v);
784	>	/* This is our final update iff qual==MAXQUALITY and view==&odev.v */
785	>	last_update = qual>=MAXQUALITY && view==&(odev.v);
786		/* Check if we should draw ALL triangles in current frustum */
787	<	if(smClean_notify \|\| smNew_tri_cnt > SM_NUM_TRIS(smMesh)*SM_INC_PERCENT)
787	>	if(smClean_notify \|\| smNew_tri_cnt>SM_SAMPLE_TRIS(smMesh)*SM_INC_PERCENT)
788		{
789		#ifdef TEST_DRIVER
790		glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
#	Line 761 \| Line 793 \| smUpdate(view,qual)
793		{
794		tmClearHisto();
795		tmAddHisto(SM_BRT(smMesh),SM_NUM_SAMP(smMesh),1);
796	<	if(tmComputeMapping(0.,0.,0.) != TM_E_OK \|\|
797	<	tmMapPixels(SM_RGB(smMesh),SM_BRT(smMesh),SM_CHR(smMesh),
798	<	SM_NUM_SAMP(smMesh)) != TM_E_OK)
799	<	return;
796	>	if(tmComputeMapping(0.,0.,0.) != TM_E_OK)
797	>	return;
798	>	tmMapPixels(SM_RGB(smMesh),SM_BRT(smMesh),SM_CHR(smMesh),
799	>	SM_NUM_SAMP(smMesh));
800		}
801		#endif
802		mark_tris_in_frustum(view);
803	<	if (qual <= 75)
803	>	if (qual <= (MAXQUALITY*3/4))
804		smRender_stree(smMesh,qual);
805		else
806	<	smRender_mesh(smMesh,view->vp,last_update);
806	>	smRender_mesh(smMesh,view->vp);
807		#ifdef TEST_DRIVER
808		glFlush();
809		glutSwapBuffers();
#	Line 779 \| Line 811 \| smUpdate(view,qual)
811		}
812		/* Do an incremental update instead */
813		else
814	<	{
815	<	if(!smNew_tri_cnt)
814	>	{
815	>	if(!smNew_tri_cnt)
816		return;
817		#ifdef TEST_DRIVER
818		glDrawBuffer(GL_FRONT);
#	Line 793 \| Line 825 \| smUpdate(view,qual)
825		if(tmComputeMapping(0.,0.,0.) != TM_E_OK)
826		return;
827		}
828	<	if(tmMapPixels(SM_NTH_RGB(smMesh,t),&SM_NTH_BRT(smMesh,t),
829	<	SM_NTH_CHR(smMesh,t), SM_NUM_SAMP(smMesh)-t) != TM_E_OK)
830	<	return;
828	>	tmMapPixels(SM_NTH_RGB(smMesh,t),&SM_NTH_BRT(smMesh,t),
829	>	SM_NTH_CHR(smMesh,t), SM_NUM_SAMP(smMesh)-t);
830	>
831		#endif
832		smUpdate_Rendered_mesh(smMesh,view->vp,last_update);
833
#	Line 803 \| Line 835 \| smUpdate(view,qual)
835		glDrawBuffer(GL_BACK);
836		#endif
837		}
838	+
839		SM_TONE_MAP(smMesh) = SM_NUM_SAMP(smMesh);
840	+
841		if (last_update)
842		{
843		smClean_notify = FALSE;
#	Line 813 \| Line 847 \| smUpdate(view,qual)
847		}
848
849		}
850	+
851	+
852	+
853	+
854	+
855	+
856	+
857	+

Diff Legend

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

Comparing ray/src/hd/sm_ogl.c (file contents): Revision 3.7 by gwlarson, Wed Sep 16 18:16:29 1998 UTC vs. Revision 3.13 by gwlarson, Sun Jan 10 10:27:48 1999 UTC

Diff Legend

Comparing ray/src/hd/sm_ogl.c (file contents):
Revision 3.7 by gwlarson, Wed Sep 16 18:16:29 1998 UTC vs.
Revision 3.13 by gwlarson, Sun Jan 10 10:27:48 1999 UTC