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 |
|
* sm_ogl.c |
6 |
|
* |
7 |
|
* Rendering routines for triangle mesh representation utilizing OpenGL |
8 |
< |
*/ |
8 |
> |
* |
9 |
> |
* smClean(tmflag) : display has been wiped clean |
10 |
> |
* int tmflag; |
11 |
> |
* Called after display has been effectively cleared, meaning that all |
12 |
> |
* geometry must be resent down the pipeline in the next call to smUpdate(). |
13 |
> |
* If tmflag is set, tone-mapping should be performed |
14 |
> |
* |
15 |
> |
* smUpdate(vp, qua) : update OpenGL output geometry for view vp |
16 |
> |
* VIEW *vp; : desired view |
17 |
> |
* int qua; : quality level (percentage on linear time scale) |
18 |
> |
* |
19 |
> |
* Draw new geometric representation using OpenGL calls. Assume that the |
20 |
> |
* view has already been set up and the correct frame buffer has been |
21 |
> |
* selected for drawing. The quality level is on a linear scale, where 100% |
22 |
> |
* is full (final) quality. It is not necessary to redraw geometry that has |
23 |
> |
* been output since the last call to smClean(). (The last view drawn will |
24 |
> |
* be vp==&odev.v each time.) |
25 |
> |
*/ |
26 |
|
#include "standard.h" |
27 |
|
|
28 |
|
#include <GL/gl.h> |
30 |
|
#include "sm_flag.h" |
31 |
|
#include "sm_list.h" |
32 |
|
#include "sm_geom.h" |
19 |
– |
#include "sm_qtree.h" |
20 |
– |
#include "sm_stree.h" |
33 |
|
#include "sm.h" |
34 |
|
|
35 |
< |
static int smClean_notify = TRUE; /*If true:Do full redraw on next update*/ |
36 |
< |
static int smCompute_mapping = TRUE;/*If true:re-tonemap on next update */ |
37 |
< |
static int smIncremental = FALSE; /*If true: there has been incremental |
38 |
< |
rendering since last full draw */ |
35 |
> |
int smClean_notify = TRUE; /*If TRUE:Do full redraw on next update*/ |
36 |
> |
static int smCompute_mapping = TRUE; /*If TRUE:re-tonemap on next update */ |
37 |
> |
static int smIncremental = FALSE; /*If TRUE: there has been incremental |
38 |
> |
rendering since last full draw */ |
39 |
> |
#define NEW_TRI_CNT 1000 /* Default number of tris to allocate |
40 |
> |
space to sort for incremental update*/ |
41 |
|
#define SM_RENDER_FG 0 /* Render foreground tris only*/ |
42 |
|
#define SM_RENDER_BG 1 /* Render background tris only */ |
43 |
< |
#define SM_RENDER_MIXED 4 /* Render mixed tris only */ |
44 |
< |
#define SM_RENDER_CULL 8 /* Perform view frustum culling */ |
45 |
< |
#define BASE 1 |
32 |
< |
#define DIR 2 |
43 |
> |
#define SM_RENDER_CULL 8 /* Perform view frustum culling */ |
44 |
> |
#define BASE 1 /* Indicates base triangle */ |
45 |
> |
#define DIR 2 /* Indicates triangle w/directional pts*/ |
46 |
|
/* FOR DISPLAY LIST RENDERING: **********************************************/ |
47 |
< |
#define SM_DL_LEVELS 2 /* # of levels down to create display lists */ |
48 |
< |
#define SM_DL_LISTS 42 /* # of qtree nodes in tree at above level: |
49 |
< |
should be 2*(4^(SM_DL_LEVELS+1)-1)/(4-1) */ |
47 |
> |
#define SM_DL_LEVELS 2 /* # of levels down to create display lists */ |
48 |
> |
#define SM_DL_LISTS 42 /* # of qtree nodes in tree at above level: |
49 |
> |
should be 2*(4^(SM_DL_LEVELS+1)-1)/(4-1) */ |
50 |
|
static GLuint Display_lists[SM_DL_LISTS][2] = {0}; |
51 |
|
/****************************************************************************/ |
52 |
|
|
72 |
|
}T_DEPTH; |
73 |
|
/**********************************************************************/ |
74 |
|
|
62 |
– |
|
75 |
|
/* |
76 |
|
* smClean(tmflag) : display has been wiped clean |
77 |
|
* int tmflag; |
83 |
|
int tmflag; |
84 |
|
{ |
85 |
|
smClean_notify = TRUE; |
86 |
< |
if(tmflag) |
75 |
< |
smCompute_mapping = TRUE; |
86 |
> |
smCompute_mapping = tmflag; |
87 |
|
} |
88 |
|
|
89 |
|
int |
90 |
|
qtCache_init(nel) /* initialize for at least nel elements */ |
91 |
|
int nel; |
92 |
|
{ |
93 |
< |
static int hsiztab[] = { |
94 |
< |
8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 0 |
95 |
< |
}; |
96 |
< |
register int i; |
93 |
> |
static int hsiztab[] = { |
94 |
> |
8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 0 |
95 |
> |
}; |
96 |
> |
register int i; |
97 |
|
|
98 |
< |
if (nel <= 0) { /* call to free table */ |
99 |
< |
if (qt_hsiz) { |
100 |
< |
free((char *)qt_htbl); |
101 |
< |
qt_htbl = NULL; |
102 |
< |
qt_hsiz = 0; |
92 |
< |
} |
93 |
< |
return(0); |
98 |
> |
if (nel <= 0) { /* call to free table */ |
99 |
> |
if (qt_hsiz) { |
100 |
> |
free((void *)qt_htbl); |
101 |
> |
qt_htbl = NULL; |
102 |
> |
qt_hsiz = 0; |
103 |
|
} |
104 |
< |
nel += nel>>1; /* 66% occupancy */ |
105 |
< |
for (i = 0; hsiztab[i]; i++) |
106 |
< |
if (hsiztab[i] > nel) |
107 |
< |
break; |
108 |
< |
if (!(qt_hsiz = hsiztab[i])) |
109 |
< |
qt_hsiz = nel*2 + 1; /* not always prime */ |
110 |
< |
qt_htbl = (QT_LUENT *)calloc(qt_hsiz, sizeof(QT_LUENT)); |
111 |
< |
if (qt_htbl == NULL) |
112 |
< |
qt_hsiz = 0; |
113 |
< |
for (i = qt_hsiz; i--; ) |
114 |
< |
qt_htbl[i].qt = EMPTY; |
115 |
< |
return(qt_hsiz); |
104 |
> |
return(0); |
105 |
> |
} |
106 |
> |
nel += nel>>1; /* 66% occupancy */ |
107 |
> |
for (i = 0; hsiztab[i]; i++) |
108 |
> |
if (hsiztab[i] > nel) |
109 |
> |
break; |
110 |
> |
if (!(qt_hsiz = hsiztab[i])) |
111 |
> |
qt_hsiz = nel*2 + 1; /* not always prime */ |
112 |
> |
qt_htbl = (QT_LUENT *)calloc(qt_hsiz, sizeof(QT_LUENT)); |
113 |
> |
if (qt_htbl == NULL) |
114 |
> |
qt_hsiz = 0; |
115 |
> |
for (i = qt_hsiz; i--; ) |
116 |
> |
qt_htbl[i].qt = EMPTY; |
117 |
> |
return(qt_hsiz); |
118 |
|
} |
119 |
|
|
120 |
|
QT_LUENT * |
121 |
|
qtCache_find(qt) /* find a quadtree table entry */ |
122 |
|
QUADTREE qt; |
123 |
|
{ |
124 |
< |
int i, n; |
125 |
< |
register int ndx; |
126 |
< |
register QT_LUENT *le; |
124 |
> |
int i, n; |
125 |
> |
register int ndx; |
126 |
> |
register QT_LUENT *le; |
127 |
|
|
128 |
< |
if (qt_hsiz == 0 && !qtCache_init(1)) |
129 |
< |
return(NULL); |
128 |
> |
if (qt_hsiz == 0 && !qtCache_init(1)) |
129 |
> |
return(NULL); |
130 |
|
tryagain: /* hash table lookup */ |
131 |
< |
ndx = (unsigned long)qt % qt_hsiz; |
132 |
< |
for (i = 0, n = 1; i < qt_hsiz; i++, n += 2) { |
133 |
< |
le = &qt_htbl[ndx]; |
134 |
< |
if (QT_IS_EMPTY(le->qt) || le->qt == qt) |
135 |
< |
return(le); |
136 |
< |
if ((ndx += n) >= qt_hsiz) /* this happens rarely */ |
137 |
< |
ndx = ndx % qt_hsiz; |
138 |
< |
} |
139 |
< |
/* table is full, reallocate */ |
140 |
< |
le = qt_htbl; |
141 |
< |
ndx = qt_hsiz; |
142 |
< |
if (!qtCache_init(ndx+1)) { /* no more memory! */ |
143 |
< |
qt_htbl = le; |
144 |
< |
qt_hsiz = ndx; |
145 |
< |
return(NULL); |
146 |
< |
} |
131 |
> |
ndx = (unsigned long)qt % qt_hsiz; |
132 |
> |
for (i = 0, n = 1; i < qt_hsiz; i++, n += 2) { |
133 |
> |
le = &qt_htbl[ndx]; |
134 |
> |
if (QT_IS_EMPTY(le->qt) || le->qt == qt) |
135 |
> |
return(le); |
136 |
> |
if ((ndx += n) >= qt_hsiz) /* this happens rarely */ |
137 |
> |
ndx = ndx % qt_hsiz; |
138 |
> |
} |
139 |
> |
/* table is full, reallocate */ |
140 |
> |
le = qt_htbl; |
141 |
> |
ndx = qt_hsiz; |
142 |
> |
if (!qtCache_init(ndx+1)) { /* no more memory! */ |
143 |
> |
qt_htbl = le; |
144 |
> |
qt_hsiz = ndx; |
145 |
> |
return(NULL); |
146 |
> |
} |
147 |
|
/* copy old table to new and free */ |
148 |
< |
while (ndx--) |
149 |
< |
if (!QT_IS_EMPTY(le[ndx].qt)) |
150 |
< |
copystruct(qtCache_find(le[ndx].qt), &le[ndx]); |
151 |
< |
free((char *)le); |
152 |
< |
goto tryagain; /* should happen only once! */ |
148 |
> |
while (ndx--) |
149 |
> |
if (!QT_IS_EMPTY(le[ndx].qt)) |
150 |
> |
copystruct(qtCache_find(le[ndx].qt), &le[ndx]); |
151 |
> |
free((void *)le); |
152 |
> |
goto tryagain; /* should happen only once! */ |
153 |
|
} |
154 |
|
|
155 |
|
stCount_level_leaves(lcnt, qt) /* count quadtree leaf nodes at each level */ |
171 |
|
lcnt[0]++; |
172 |
|
} |
173 |
|
|
163 |
– |
|
174 |
|
QTRAVG * |
175 |
|
qtRender_level(qt,v0,v1,v2,sm,lvl) |
176 |
|
QUADTREE qt; |
219 |
|
} |
220 |
|
else |
221 |
|
{ /* from triangle set */ |
222 |
< |
OBJECT *os; |
223 |
< |
int s0, s1, s2; |
224 |
< |
|
222 |
> |
S_ID *os; |
223 |
> |
S_ID s0, s1, s2,s_id; |
224 |
> |
int t_id; |
225 |
> |
TRI *tri,*t; |
226 |
> |
|
227 |
|
os = qtqueryset(qt); |
228 |
|
for (i = os[0]; i; i--) |
229 |
|
{ |
230 |
< |
if(SM_IS_NTH_T_BASE(sm,os[i])) |
231 |
< |
continue; |
232 |
< |
tri = SM_NTH_TRI(sm,os[i]); |
233 |
< |
if(!T_IS_VALID(tri)) |
234 |
< |
continue; |
235 |
< |
n++; |
236 |
< |
s0 = T_NTH_V(tri,0); |
237 |
< |
s1 = T_NTH_V(tri,1); |
238 |
< |
s2 = T_NTH_V(tri,2); |
239 |
< |
VCOPY(a,SM_NTH_WV(sm,s0)); |
240 |
< |
VCOPY(b,SM_NTH_WV(sm,s1)); |
241 |
< |
VCOPY(c,SM_NTH_WV(sm,s2)); |
242 |
< |
distsum += SM_BG_SAMPLE(sm,s0) ? dev_zmax |
230 |
> |
s_id = os[i]; |
231 |
> |
t_id = SM_NTH_VERT(smMesh,s_id); |
232 |
> |
tri = t = SM_NTH_TRI(smMesh,t_id); |
233 |
> |
do |
234 |
> |
{ |
235 |
> |
if(!SM_IS_NTH_T_BASE(sm,t_id)) |
236 |
> |
{ |
237 |
> |
n++; |
238 |
> |
s0 = T_NTH_V(t,0); |
239 |
> |
s1 = T_NTH_V(t,1); |
240 |
> |
s2 = T_NTH_V(t,2); |
241 |
> |
VCOPY(a,SM_NTH_WV(sm,s0)); |
242 |
> |
VCOPY(b,SM_NTH_WV(sm,s1)); |
243 |
> |
VCOPY(c,SM_NTH_WV(sm,s2)); |
244 |
> |
distsum += SM_BG_SAMPLE(sm,s0) ? dev_zmax |
245 |
|
: sqrt(dist2(a,SM_VIEW_CENTER(sm))); |
246 |
< |
distsum += SM_BG_SAMPLE(sm,s1) ? dev_zmax |
247 |
< |
: sqrt(dist2(b,SM_VIEW_CENTER(sm))); |
248 |
< |
distsum += SM_BG_SAMPLE(sm,s2) ? dev_zmax |
246 |
> |
distsum += SM_BG_SAMPLE(sm,s1) ? dev_zmax |
247 |
> |
: sqrt(dist2(b,SM_VIEW_CENTER(sm))); |
248 |
> |
distsum += SM_BG_SAMPLE(sm,s2) ? dev_zmax |
249 |
|
: sqrt(dist2(c,SM_VIEW_CENTER(sm))); |
250 |
< |
rgbs[0] += SM_NTH_RGB(sm,s0)[0] + SM_NTH_RGB(sm,s1)[0] |
251 |
< |
+ SM_NTH_RGB(sm,s2)[0]; |
252 |
< |
rgbs[1] += SM_NTH_RGB(sm,s0)[1] + SM_NTH_RGB(sm,s1)[1] |
253 |
< |
+ SM_NTH_RGB(sm,s2)[1]; |
254 |
< |
rgbs[2] += SM_NTH_RGB(sm,s0)[2] + SM_NTH_RGB(sm,s1)[2] |
255 |
< |
+ SM_NTH_RGB(sm,s2)[2]; |
250 |
> |
rgbs[0] += SM_NTH_RGB(sm,s0)[0] + SM_NTH_RGB(sm,s1)[0] |
251 |
> |
+ SM_NTH_RGB(sm,s2)[0]; |
252 |
> |
rgbs[1] += SM_NTH_RGB(sm,s0)[1] + SM_NTH_RGB(sm,s1)[1] |
253 |
> |
+ SM_NTH_RGB(sm,s2)[1]; |
254 |
> |
rgbs[2] += SM_NTH_RGB(sm,s0)[2] + SM_NTH_RGB(sm,s1)[2] |
255 |
> |
+ SM_NTH_RGB(sm,s2)[2]; |
256 |
> |
} |
257 |
> |
|
258 |
> |
t_id = smTri_next_ccw_nbr(smMesh,t,s_id); |
259 |
> |
t = SM_NTH_TRI(smMesh,t_id); |
260 |
> |
|
261 |
> |
}while(t != tri); |
262 |
|
} |
263 |
|
n *= 3; |
264 |
|
} |
295 |
|
int i; |
296 |
|
FVECT t0,t1,t2; |
297 |
|
STREE *st; |
278 |
– |
|
298 |
|
|
299 |
|
if (lvl < 0) |
300 |
|
return; |
333 |
|
int i, n,ntarget; |
334 |
|
int lvlcnt[QT_MAX_LEVELS]; |
335 |
|
STREE *st; |
336 |
< |
int4 *active_flag; |
336 |
> |
int32 *active_flag; |
337 |
|
|
338 |
|
if (qual <= 0) |
339 |
|
return; |
365 |
|
smRender_approx_stree_level(sm,i); |
366 |
|
} |
367 |
|
|
349 |
– |
#define render_tri(v0,v1,v2,rgb0,rgb1,rgb2) \ |
350 |
– |
{glColor3ub(rgb0[0],rgb0[1],rgb0[2]); glVertex3fv(v0); \ |
351 |
– |
glColor3ub(rgb1[0],rgb1[1],rgb1[2]); glVertex3fv(v1); \ |
352 |
– |
glColor3ub(rgb2[0],rgb2[1],rgb2[2]); glVertex3fv(v2);} |
368 |
|
|
369 |
+ |
#define GLVERTEX3V(v) glVertex3fv(v) |
370 |
|
|
355 |
– |
render_bg_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,vc,d) |
356 |
– |
float v0[3],v1[3],v2[3]; |
357 |
– |
BYTE rgb0[3],rgb1[3],rgb2[3]; |
358 |
– |
FVECT vp,vc; |
359 |
– |
double d; |
360 |
– |
{ |
361 |
– |
double p[3]; |
362 |
– |
|
363 |
– |
glColor3ub(rgb0[0],rgb0[1],rgb0[2]); |
364 |
– |
VSUB(p,v0,vc); |
365 |
– |
if(dev_zmin >= 0.99) |
366 |
– |
{ |
367 |
– |
p[0] *= d; |
368 |
– |
p[1] *= d; |
369 |
– |
p[2] *= d; |
370 |
– |
} |
371 |
– |
VADD(p,p,vp); |
372 |
– |
glVertex3dv(p); |
373 |
– |
|
374 |
– |
glColor3ub(rgb1[0],rgb1[1],rgb1[2]); |
375 |
– |
VSUB(p,v1,vc); |
376 |
– |
if(dev_zmin >= 0.99) |
377 |
– |
{ |
378 |
– |
p[0] *= d; |
379 |
– |
p[1] *= d; |
380 |
– |
p[2] *= d; |
381 |
– |
} |
382 |
– |
VADD(p,p,vp); |
383 |
– |
glVertex3dv(p); |
384 |
– |
|
385 |
– |
|
386 |
– |
glColor3ub(rgb2[0],rgb2[1],rgb2[2]); |
387 |
– |
VSUB(p,v2,vc); |
388 |
– |
if(dev_zmin >= 0.99) |
389 |
– |
{ |
390 |
– |
p[0] *= d; |
391 |
– |
p[1] *= d; |
392 |
– |
p[2] *= d; |
393 |
– |
VADD(p,p,vp); |
394 |
– |
glVertex3dv(p); |
395 |
– |
} |
396 |
– |
} |
371 |
|
|
372 |
+ |
#define render_tri(v0,v1,v2,rgb0,rgb1,rgb2) \ |
373 |
+ |
{glColor3ub(rgb0[0],rgb0[1],rgb0[2]); GLVERTEX3V(v0); \ |
374 |
+ |
glColor3ub(rgb1[0],rgb1[1],rgb1[2]); GLVERTEX3V(v1); \ |
375 |
+ |
glColor3ub(rgb2[0],rgb2[1],rgb2[2]); GLVERTEX3V(v2);} |
376 |
|
|
377 |
|
/* |
378 |
|
* render_mixed_tri(v0,v1,v2,rgb0,rgb1,rgb2,b0,b1,b2) |
379 |
< |
* float v0[3],v1[3],v2[3]; : triangle vertex coordinates |
379 |
> |
* SFLOAT v0[3],v1[3],v2[3]; : triangle vertex coordinates |
380 |
|
* BYTE rgb0[3],rgb1[3],rgb2[3]; : vertex RGBs |
381 |
|
* int b0,b1,b2; : background or base vertex flag |
382 |
|
* |
383 |
< |
* render foreground or base vertex color as average of the background |
384 |
< |
* vertex RGBs. |
383 |
> |
* For triangles with one or more base or directional vertices. |
384 |
> |
* render base vertex color as average of the background and foreground |
385 |
> |
* vertex RGBs. The coordinates for a fg vertex are calculated by |
386 |
> |
* subtracting off the current view,normalizing, then scaling to fit |
387 |
> |
* into the current frustum. |
388 |
|
*/ |
389 |
|
render_mixed_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,vc,bg0,bg1,bg2) |
390 |
< |
float v0[3],v1[3],v2[3]; |
390 |
> |
SFLOAT v0[3],v1[3],v2[3]; |
391 |
|
BYTE rgb0[3],rgb1[3],rgb2[3]; |
392 |
|
FVECT vp,vc; |
393 |
|
int bg0,bg1,bg2; |
394 |
|
{ |
395 |
|
double d,p[3]; |
396 |
< |
int j,cnt,rgb[3],base; |
396 |
> |
int j,cnt,rgb[3]; |
397 |
|
|
398 |
< |
base = bg0==BASE || bg1==BASE || bg2==BASE; |
399 |
< |
|
400 |
< |
if(base) |
398 |
> |
/* Average color from bg vertices */ |
399 |
> |
cnt = 0; |
400 |
> |
if(bg0 == BASE || bg1==BASE || bg2 == BASE) |
401 |
|
{ |
421 |
– |
cnt = 0; |
402 |
|
rgb[0] = rgb[1] = rgb[2] = 0; |
403 |
|
if(bg0 != BASE) |
404 |
< |
{ |
405 |
< |
IADDV3(rgb,rgb0); |
406 |
< |
cnt++; |
407 |
< |
} |
408 |
< |
if(bg1 !=BASE) |
409 |
< |
{ |
410 |
< |
IADDV3(rgb,rgb1); |
411 |
< |
cnt++; |
412 |
< |
} |
404 |
> |
{ |
405 |
> |
IADDV3(rgb,rgb0); |
406 |
> |
cnt++; |
407 |
> |
} |
408 |
> |
if(bg1 != BASE) |
409 |
> |
{ |
410 |
> |
IADDV3(rgb,rgb1); |
411 |
> |
cnt++; |
412 |
> |
} |
413 |
|
if(bg2 != BASE) |
414 |
< |
{ |
415 |
< |
IADDV3(rgb,rgb2); |
416 |
< |
cnt++; |
417 |
< |
} |
414 |
> |
{ |
415 |
> |
IADDV3(rgb,rgb2); |
416 |
> |
cnt++; |
417 |
> |
} |
418 |
|
IDIVV3(rgb,cnt); |
419 |
|
} |
420 |
< |
|
421 |
< |
if(bg0== BASE) |
442 |
< |
glColor3ub(rgb[0],rgb[1],rgb[2]); |
420 |
> |
if(bg0 == BASE) |
421 |
> |
glColor3i(rgb[0],rgb[1],rgb[2]); |
422 |
|
else |
423 |
|
glColor3ub(rgb0[0],rgb0[1],rgb0[2]); |
424 |
|
|
430 |
|
glVertex3dv(p); |
431 |
|
} |
432 |
|
else |
433 |
< |
glVertex3fv(v0); |
433 |
> |
GLVERTEX3V(v0); |
434 |
|
|
435 |
< |
if(bg1== BASE) |
436 |
< |
glColor3ub(rgb[0],rgb[1],rgb[2]); |
435 |
> |
if(bg1 == BASE) |
436 |
> |
glColor3i(rgb[0],rgb[1],rgb[2]); |
437 |
|
else |
438 |
|
glColor3ub(rgb1[0],rgb1[1],rgb1[2]); |
439 |
|
|
445 |
|
glVertex3dv(p); |
446 |
|
} |
447 |
|
else |
448 |
< |
glVertex3fv(v1); |
448 |
> |
GLVERTEX3V(v1); |
449 |
|
|
450 |
< |
if(bg2== BASE) |
451 |
< |
glColor3ub(rgb[0],rgb[1],rgb[2]); |
450 |
> |
if(bg2 == BASE) |
451 |
> |
glColor3i(rgb[0],rgb[1],rgb[2]); |
452 |
|
else |
453 |
|
glColor3ub(rgb2[0],rgb2[1],rgb2[2]); |
454 |
|
|
460 |
|
glVertex3dv(p); |
461 |
|
} |
462 |
|
else |
463 |
< |
glVertex3fv(v2); |
463 |
> |
GLVERTEX3V(v2); |
464 |
|
} |
465 |
|
|
466 |
|
/* |
467 |
|
* smRender_bg_tris(sm,vp,t_flag,bg_flag,wp,rgb) |
468 |
|
* SM *sm; : mesh |
469 |
|
* FVECT vp; : current viewpoint |
470 |
< |
* int4 *t_flag,*bg_flag; : triangle flags: t_flag is generic, |
470 |
> |
* int32 *t_flag,*bg_flag; : triangle flags: t_flag is generic, |
471 |
|
* and bg_flag indicates if background tri; |
472 |
< |
* float (*wp)[3];BYTE (*rgb)[3]; : arrays of sample points and RGB colors |
472 |
> |
* SFLOAT (*wp)[3];BYTE (*rgb)[3]; : arrays of sample points and RGB colors |
473 |
|
* |
474 |
< |
* Sequentially gos through triangle list and renders all valid tris who |
474 |
> |
* Sequentially traverses triangle list and renders all valid tris who |
475 |
|
* have t_flag set, and bg_flag set. |
476 |
|
*/ |
477 |
|
|
478 |
|
smRender_bg_tris(sm,vp,t_flag,bg_flag,wp,rgb) |
479 |
|
SM *sm; |
480 |
|
FVECT vp; |
481 |
< |
int4 *t_flag,*bg_flag; |
482 |
< |
float (*wp)[3]; |
481 |
> |
int32 *t_flag,*bg_flag; |
482 |
> |
SFLOAT (*wp)[3]; |
483 |
|
BYTE (*rgb)[3]; |
484 |
|
{ |
485 |
|
double d; |
521 |
|
rgb[v2_id]) |
522 |
|
else |
523 |
|
render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
524 |
< |
rgb[v1_id],rgb[v2_id],vp,SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
524 |
> |
rgb[v1_id],rgb[v2_id],vp,SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
525 |
|
} |
526 |
|
glEnd(); |
527 |
|
|
529 |
|
|
530 |
|
} |
531 |
|
/* |
532 |
+ |
* smRender_new_bg_tris(sm,vp,new_flag,active_flag,bg_flag,wp,rgb) |
533 |
+ |
* SM *sm; : mesh |
534 |
+ |
* FVECT vp; : current viewpoint |
535 |
+ |
* int32 *new_flag,*active,*bg_flag; : triangle flags: idicates if tri is, |
536 |
+ |
* new,active,bg_flag |
537 |
+ |
* SFLOAT (*wp)[3];BYTE (*rgb)[3]; : arrays of sample points and RGB colors |
538 |
+ |
* |
539 |
+ |
* Sequentially traverses triangle list and renders all valid tris who |
540 |
+ |
* have new_flag set and active_flag and bg_flag set. |
541 |
+ |
*/ |
542 |
+ |
smRender_new_bg_tris(sm,vp,new_flag,active_flag,bg_flag,wp,rgb) |
543 |
+ |
SM *sm; |
544 |
+ |
FVECT vp; |
545 |
+ |
int32 *new_flag,*active_flag,*bg_flag; |
546 |
+ |
SFLOAT (*wp)[3]; |
547 |
+ |
BYTE (*rgb)[3]; |
548 |
+ |
{ |
549 |
+ |
double d; |
550 |
+ |
int v0_id,v1_id,v2_id; |
551 |
+ |
int i,n,bg0,bg1,bg2; |
552 |
+ |
TRI *tri; |
553 |
+ |
|
554 |
+ |
glMatrixMode(GL_MODELVIEW); |
555 |
+ |
|
556 |
+ |
glPushMatrix(); |
557 |
+ |
glTranslated(vp[0],vp[1],vp[2]); |
558 |
+ |
/* The points are a distance of 1 away from the origin: if necessary scale |
559 |
+ |
so that they fit in frustum and are therefore not clipped away |
560 |
+ |
*/ |
561 |
+ |
if(dev_zmin >= 0.99) |
562 |
+ |
{ |
563 |
+ |
d = (dev_zmin+dev_zmax)/2.0; |
564 |
+ |
glScaled(d,d,d); |
565 |
+ |
} |
566 |
+ |
/* move relative to the new view */ |
567 |
+ |
/* move points to unit sphere at origin */ |
568 |
+ |
glTranslated(-SM_VIEW_CENTER(sm)[0],-SM_VIEW_CENTER(sm)[1], |
569 |
+ |
-SM_VIEW_CENTER(sm)[2]); |
570 |
+ |
glBegin(GL_TRIANGLES); |
571 |
+ |
for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;) |
572 |
+ |
if(new_flag[n] & active_flag[n] & bg_flag[n]) |
573 |
+ |
for(i=0; i < 32; i++) |
574 |
+ |
if(new_flag[n] & active_flag[n] & bg_flag[n] & (1L << i)) |
575 |
+ |
{ |
576 |
+ |
tri = SM_NTH_TRI(sm,(n<<5)+i); |
577 |
+ |
v0_id = T_NTH_V(tri,0); |
578 |
+ |
v1_id = T_NTH_V(tri,1); |
579 |
+ |
v2_id = T_NTH_V(tri,2); |
580 |
+ |
bg0 = SM_DIR_ID(sm,v0_id)?DIR:SM_BASE_ID(sm,v0_id)?BASE:0; |
581 |
+ |
bg1 = SM_DIR_ID(sm,v1_id)?DIR:SM_BASE_ID(sm,v1_id)?BASE:0; |
582 |
+ |
bg2 = SM_DIR_ID(sm,v2_id)?DIR:SM_BASE_ID(sm,v2_id)?BASE:0; |
583 |
+ |
if(bg0==DIR && bg1==DIR && bg2==DIR) |
584 |
+ |
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
585 |
+ |
rgb[v2_id]) |
586 |
+ |
else |
587 |
+ |
render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
588 |
+ |
rgb[v1_id],rgb[v2_id],vp,SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
589 |
+ |
} |
590 |
+ |
glEnd(); |
591 |
+ |
|
592 |
+ |
glPopMatrix(); |
593 |
+ |
|
594 |
+ |
} |
595 |
+ |
|
596 |
+ |
/* |
597 |
|
* render_base_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,b0,b1,b2) |
598 |
< |
* float v0[3],v1[3],v2[3]; : triangle vertex coordinates |
598 |
> |
* SFLOAT v0[3],v1[3],v2[3]; : triangle vertex coordinates |
599 |
|
* BYTE rgb0[3],rgb1[3],rgb2[3]; : vertex RGBs |
600 |
|
* FVECT vp; : current viewpoint |
601 |
|
* int b0,b1,b2; : vertex base flag |
605 |
|
* the average distance to the non-base vertices |
606 |
|
*/ |
607 |
|
render_base_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,b0,b1,b2) |
608 |
< |
float v0[3],v1[3],v2[3]; |
608 |
> |
SFLOAT v0[3],v1[3],v2[3]; |
609 |
|
BYTE rgb0[3],rgb1[3],rgb2[3]; |
610 |
|
FVECT vp; |
611 |
|
int b0,b1,b2; |
618 |
|
cnt = 0; |
619 |
|
rgb[0] = rgb[1] = rgb[2] = 0; |
620 |
|
d = 0.0; |
621 |
< |
|
621 |
> |
/* If all vertices are base: don't render */ |
622 |
|
if(b0&&b1&&b2) |
623 |
|
return; |
624 |
|
/* First calculate color and coordinates |
656 |
|
else |
657 |
|
{ |
658 |
|
glColor3ub(rgb0[0],rgb0[1],rgb0[2]); |
659 |
< |
glVertex3fv(v0); |
659 |
> |
GLVERTEX3V(v0); |
660 |
|
} |
661 |
|
if(b1) |
662 |
|
{ |
669 |
|
else |
670 |
|
{ |
671 |
|
glColor3ub(rgb1[0],rgb1[1],rgb1[2]); |
672 |
< |
glVertex3fv(v1); |
672 |
> |
GLVERTEX3V(v1); |
673 |
|
} |
674 |
|
if(b2) |
675 |
|
{ |
682 |
|
else |
683 |
|
{ |
684 |
|
glColor3ub(rgb2[0],rgb2[1],rgb2[2]); |
685 |
< |
glVertex3fv(v2); |
685 |
> |
GLVERTEX3V(v2); |
686 |
|
} |
687 |
|
} |
688 |
|
/* |
689 |
|
* smRender_fg_tris(sm,vp,t_flag,bg_flag,wp,rgb) |
690 |
|
* SM *sm; : mesh |
691 |
|
* FVECT vp; : current viewpoint |
692 |
< |
* int4 *t_flag,*bg_flag; : triangle flags: t_flag is generic,bg_flag |
692 |
> |
* int32 *t_flag,*bg_flag; : triangle flags: t_flag is generic,bg_flag |
693 |
|
* indicates if background tri; |
694 |
< |
* float (*wp)[3];BYTE (*rgb)[3]; : arrays of sample points and RGB colors |
694 |
> |
* SFLOAT (*wp)[3];BYTE (*rgb)[3]; : arrays of sample points and RGB colors |
695 |
|
* |
696 |
|
* Sequentially gos through triangle list and renders all valid tris who |
697 |
|
* have t_flag set, and NOT bg_flag set. |
699 |
|
smRender_fg_tris(sm,vp,t_flag,bg_flag,wp,rgb) |
700 |
|
SM *sm; |
701 |
|
FVECT vp; |
702 |
< |
int4 *t_flag,*bg_flag; |
703 |
< |
float (*wp)[3]; |
702 |
> |
int32 *t_flag,*bg_flag; |
703 |
> |
SFLOAT (*wp)[3]; |
704 |
|
BYTE (*rgb)[3]; |
705 |
|
{ |
706 |
|
TRI *tri; |
707 |
|
int i,n,b0,b1,b2; |
708 |
< |
int v0_id,v1_id,v2_id; |
708 |
> |
S_ID v0_id,v1_id,v2_id; |
709 |
|
|
710 |
|
glBegin(GL_TRIANGLES); |
711 |
|
for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;) |
726 |
|
else |
727 |
|
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
728 |
|
rgb[v2_id]) |
729 |
+ |
|
730 |
|
} |
731 |
|
glEnd(); |
732 |
|
|
733 |
|
} |
734 |
|
|
735 |
+ |
/* |
736 |
+ |
* smRender_new_fg_tris(sm,vp,new_flag,active_flag,bg_flag,wp,rgb) |
737 |
+ |
* SM *sm; : mesh |
738 |
+ |
* FVECT vp; : current viewpoint |
739 |
+ |
* int32 *new_flag,*active_flag,*bg_flag; : triangle flags: indicate if |
740 |
+ |
* tri is new,active,background |
741 |
+ |
* SFLOAT (*wp)[3];BYTE (*rgb)[3]; : arrays of sample points and RGB colors |
742 |
+ |
* |
743 |
+ |
* Sequentially gos through triangle list and renders all valid tris who |
744 |
+ |
* have new_flag and active_flag set, and NOT bg_flag set. |
745 |
+ |
*/ |
746 |
+ |
smRender_new_fg_tris(sm,vp,new_flag,active_flag,bg_flag,wp,rgb) |
747 |
+ |
SM *sm; |
748 |
+ |
FVECT vp; |
749 |
+ |
int32 *new_flag,*active_flag,*bg_flag; |
750 |
+ |
SFLOAT (*wp)[3]; |
751 |
+ |
BYTE (*rgb)[3]; |
752 |
+ |
{ |
753 |
+ |
TRI *tri; |
754 |
+ |
int i,n,b0,b1,b2; |
755 |
+ |
S_ID v0_id,v1_id,v2_id; |
756 |
+ |
|
757 |
+ |
glBegin(GL_TRIANGLES); |
758 |
+ |
for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;) |
759 |
+ |
if(new_flag[n] & active_flag[n]) |
760 |
+ |
for(i=0; i < 32; i++) |
761 |
+ |
if(new_flag[n] & active_flag[n] & (1L << i) & ~bg_flag[n]) |
762 |
+ |
{ |
763 |
+ |
tri = SM_NTH_TRI(sm,(n<<5)+i); |
764 |
+ |
v0_id = T_NTH_V(tri,0); |
765 |
+ |
v1_id = T_NTH_V(tri,1); |
766 |
+ |
v2_id = T_NTH_V(tri,2); |
767 |
+ |
b0 = SM_BASE_ID(sm,v0_id); |
768 |
+ |
b1 = SM_BASE_ID(sm,v1_id); |
769 |
+ |
b2 = SM_BASE_ID(sm,v2_id); |
770 |
+ |
if(b0 || b1 || b2) |
771 |
+ |
render_base_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
772 |
+ |
rgb[v1_id],rgb[v2_id],SM_VIEW_CENTER(sm),b0,b1,b2); |
773 |
+ |
else |
774 |
+ |
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
775 |
+ |
rgb[v2_id]) |
776 |
+ |
} |
777 |
+ |
glEnd(); |
778 |
|
|
779 |
+ |
} |
780 |
+ |
|
781 |
+ |
/* Test for qsort to depth sort triangles */ |
782 |
|
int |
783 |
|
compare_tri_depths(T_DEPTH *td1,T_DEPTH *td2) |
784 |
|
{ |
790 |
|
if(d < 0.0) |
791 |
|
return(-1); |
792 |
|
return(0); |
702 |
– |
|
793 |
|
} |
794 |
|
|
705 |
– |
#ifdef DEBUG |
706 |
– |
#define freebuf(b) tempbuf(-1) |
707 |
– |
#endif |
795 |
|
|
709 |
– |
char * |
710 |
– |
tempbuf(len) /* get a temporary buffer */ |
711 |
– |
unsigned len; |
712 |
– |
{ |
713 |
– |
extern char *malloc(), *realloc(); |
714 |
– |
static char *tempbuf = NULL; |
715 |
– |
static unsigned tempbuflen = 0; |
716 |
– |
|
717 |
– |
#ifdef DEBUG |
718 |
– |
static int in_use=FALSE; |
719 |
– |
|
720 |
– |
if(len == -1) |
721 |
– |
{ |
722 |
– |
in_use = FALSE; |
723 |
– |
return(NULL); |
724 |
– |
} |
725 |
– |
if(in_use) |
726 |
– |
{ |
727 |
– |
eputs("Buffer in use:cannot allocate:tempbuf()\n"); |
728 |
– |
return(NULL); |
729 |
– |
} |
730 |
– |
#endif |
731 |
– |
if (len > tempbuflen) { |
732 |
– |
if (tempbuflen > 0) |
733 |
– |
tempbuf = realloc(tempbuf, len); |
734 |
– |
else |
735 |
– |
tempbuf = malloc(len); |
736 |
– |
tempbuflen = tempbuf==NULL ? 0 : len; |
737 |
– |
} |
738 |
– |
#ifdef DEBUG |
739 |
– |
in_use = TRUE; |
740 |
– |
#endif |
741 |
– |
return(tempbuf); |
742 |
– |
} |
743 |
– |
|
796 |
|
/* |
797 |
|
* smOrder_new_tris(sm,vp,td) |
798 |
|
* SM *sm; : mesh |
802 |
|
* Creates list of all new tris, with their distance from the current |
803 |
|
* viewpoint, and sorts the list based on this distance |
804 |
|
*/ |
805 |
< |
smOrder_new_tris(sm,vp,td) |
805 |
> |
T_DEPTH |
806 |
> |
*smOrder_new_tris(sm,vp) |
807 |
|
SM *sm; |
808 |
|
FVECT vp; |
756 |
– |
T_DEPTH *td; |
809 |
|
{ |
810 |
< |
int n,i,j,tcnt,v; |
810 |
> |
T_DEPTH *td; |
811 |
> |
int n,i,j,tcnt,v,size; |
812 |
|
TRI *tri; |
813 |
|
double d,min_d; |
814 |
|
FVECT diff; |
815 |
< |
int4 *new_flag,*bg_flag; |
815 |
> |
int32 *new_flag,*bg_flag,*active_flag; |
816 |
> |
|
817 |
> |
td = (T_DEPTH *)tempbuf(NEW_TRI_CNT*sizeof(T_DEPTH),FALSE); |
818 |
> |
size = NEW_TRI_CNT; |
819 |
|
|
820 |
|
tcnt=0; |
821 |
|
new_flag = SM_NTH_FLAGS(sm,T_NEW_FLAG); |
822 |
|
bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG); |
823 |
+ |
active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG); |
824 |
|
for(n=((SM_NUM_TRI(sm)+31)>>5) +1; --n;) |
825 |
< |
if(new_flag[n] & ~bg_flag[n]) |
825 |
> |
if(active_flag[n] & new_flag[n] & ~bg_flag[n]) |
826 |
|
for(i=0; i < 32; i++) |
827 |
< |
if(new_flag[n] & (1L << i) & ~bg_flag[n]) |
827 |
> |
if(active_flag[n] & new_flag[n] & (1L << i) & ~bg_flag[n]) |
828 |
|
{ |
829 |
|
tri = SM_NTH_TRI(sm,(n<<5)+i); |
830 |
+ |
if(tcnt+1 >= size) |
831 |
+ |
{ |
832 |
+ |
size += 100; |
833 |
+ |
td = (T_DEPTH *)tempbuf(size*sizeof(T_DEPTH),TRUE); |
834 |
+ |
} |
835 |
|
td[tcnt].tri = (n << 5)+i; |
836 |
|
min_d = -1; |
837 |
|
for(j=0;j < 3;j++) |
847 |
|
td[tcnt].tri = -1; |
848 |
|
if(tcnt) |
849 |
|
qsort((void *)td,tcnt,sizeof(T_DEPTH),compare_tri_depths); |
850 |
+ |
return(td); |
851 |
|
} |
852 |
|
|
853 |
|
/* |
889 |
|
SM *sm; |
890 |
|
FVECT vp; |
891 |
|
{ |
892 |
< |
int i,n,v0_id,v1_id,v2_id,b0,b1,b2; |
892 |
> |
S_ID v0_id,v1_id,v2_id; |
893 |
> |
int i,n,b0,b1,b2; |
894 |
|
TRI *tri; |
895 |
< |
float (*wp)[3]; |
895 |
> |
SFLOAT (*wp)[3]; |
896 |
|
BYTE (*rgb)[3]; |
897 |
< |
int4 *new_flag,*bg_flag; |
897 |
> |
int32 *new_flag,*bg_flag,*active_flag; |
898 |
|
T_DEPTH *td = NULL; |
899 |
|
|
836 |
– |
smUpdate_tm(sm); |
900 |
|
|
901 |
< |
/* For all of the NEW triangles (since last update): assume |
902 |
< |
ACTIVE. Go through and sort on depth value (from vp). Turn |
901 |
> |
/* For all of the NEW and ACTIVE triangles (since last update): |
902 |
> |
Go through and sort on depth value (from vp). Turn |
903 |
|
Depth Buffer test off and render back-front |
904 |
< |
*/ |
904 |
> |
*/ |
905 |
> |
|
906 |
> |
/* Must depth sort if current view point is not same as canonical */ |
907 |
|
if(!EQUAL_VEC3(SM_VIEW_CENTER(sm),vp)) |
908 |
< |
{ |
844 |
< |
/* Must depth sort if view points do not coincide */ |
845 |
< |
td = (T_DEPTH *)tempbuf(smNew_tri_cnt*sizeof(T_DEPTH)); |
846 |
< |
if(td) |
847 |
< |
smOrder_new_tris(sm,vp,td); |
848 |
< |
#ifdef DEBUG |
849 |
< |
else |
850 |
< |
eputs("Cant create list:wont depth sort:smUpdate_incremental\n"); |
851 |
< |
#endif |
852 |
< |
} |
908 |
> |
td = smOrder_new_tris(sm,vp); |
909 |
|
wp = SM_WP(sm); |
910 |
|
rgb =SM_RGB(sm); |
911 |
|
new_flag = SM_NTH_FLAGS(sm,T_NEW_FLAG); |
912 |
+ |
active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG); |
913 |
|
bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG); |
914 |
|
/* Turn Depth Test off -- using Painter's algorithm */ |
915 |
|
glPushAttrib(GL_DEPTH_BUFFER_BIT); |
916 |
|
glDepthFunc(GL_ALWAYS); |
917 |
|
|
918 |
< |
smRender_bg_tris(sm,vp,new_flag,bg_flag,wp,rgb); |
918 |
> |
smRender_new_bg_tris(sm,vp,new_flag,active_flag,bg_flag,wp,rgb); |
919 |
|
if(!td) |
920 |
< |
smRender_fg_tris(sm,vp,new_flag,bg_flag,wp,rgb); |
920 |
> |
smRender_new_fg_tris(sm,vp,new_flag,active_flag,bg_flag,wp,rgb); |
921 |
|
else |
922 |
|
{ |
923 |
|
glBegin(GL_TRIANGLES); |
952 |
|
* SM *sm; : mesh |
953 |
|
* QUADTREE qt; : quadtree base node |
954 |
|
* FVECT vp; : current viewpoint |
955 |
< |
* float (*wp)[3]; : array of sample points |
955 |
> |
* SFLOAT (*wp)[3]; : array of sample points |
956 |
|
* BYTE (*rgb)[3]; : array of RGB values for samples |
957 |
|
* int i,level_i,level,max_level,leaf_cnt; |
958 |
< |
* : variables to keep track of where |
958 |
> |
* : variables to keep track of where |
959 |
|
* we are in the quadtree traversal in order to map nodes to |
960 |
|
* corresponding array locations, where nodes are stored in breadth- |
961 |
|
* first order. i is the index of the current node,level_i is the |
974 |
|
SM *sm; |
975 |
|
QUADTREE qt; |
976 |
|
FVECT vp; |
977 |
< |
float (*wp)[3]; |
977 |
> |
SFLOAT (*wp)[3]; |
978 |
|
BYTE (*rgb)[3]; |
979 |
|
int i,level_i,level,max_level,leaf_cnt; |
980 |
|
int which; |
1028 |
|
* SM *sm; : mesh |
1029 |
|
* QUADTREE qt; : quadtree base node |
1030 |
|
* FVECT vp; : current viewpoint |
1031 |
< |
* float (*wp)[3] : array of sample points |
1031 |
> |
* SFLOAT (*wp)[3] : array of sample points |
1032 |
|
* BYTE (*rgb)[3] : array of RGB values for samples |
1033 |
|
* int which; : flag indicates whether to render fg or bg tris |
1034 |
|
* int cull; : if true, only traverse active (flagged) nodes |
1038 |
|
SM *sm; |
1039 |
|
QUADTREE qt; |
1040 |
|
FVECT vp; |
1041 |
< |
float (*wp)[3]; |
1041 |
> |
SFLOAT (*wp)[3]; |
1042 |
|
BYTE (*rgb)[3]; |
1043 |
|
int which,cull; |
1044 |
|
{ |
1049 |
|
|
1050 |
|
if(QT_IS_LEAF(qt)) |
1051 |
|
{ |
1052 |
< |
TRI *t; |
1053 |
< |
OBJECT *optr; |
1054 |
< |
int t_id,v0_id,v1_id,v2_id,bg0,bg1,bg2; |
1052 |
> |
TRI *t,*tri; |
1053 |
> |
S_ID *optr,s_id,v0_id,v1_id,v2_id; |
1054 |
> |
int bg0,bg1,bg2,t_id; |
1055 |
|
|
1056 |
|
if(cull && !QT_LEAF_IS_FLAG(qt)) |
1057 |
|
return; |
1058 |
|
|
1059 |
|
optr = qtqueryset(qt); |
1060 |
< |
for (i = QT_SET_CNT(optr),optr = QT_SET_PTR(optr);i > 0; i--) |
1060 |
> |
for (i = QT_SET_CNT(optr);i > 0; i--) |
1061 |
|
{ |
1062 |
< |
t_id = QT_SET_NEXT_ELEM(optr); |
1063 |
< |
t = SM_NTH_TRI(sm,t_id); |
1064 |
< |
if(!T_IS_VALID(t) || (cull &&!SM_IS_NTH_T_ACTIVE(sm,t_id)) || |
1065 |
< |
SM_IS_NTH_T_NEW(sm,t_id)) |
1009 |
< |
continue; |
1010 |
< |
|
1011 |
< |
bg0 = SM_IS_NTH_T_BG(sm,t_id); |
1012 |
< |
if((which== SM_RENDER_FG && bg0) || (which== SM_RENDER_BG && !bg0)) |
1013 |
< |
continue; |
1014 |
< |
|
1015 |
< |
v0_id = T_NTH_V(t,0); |
1016 |
< |
v1_id = T_NTH_V(t,1); |
1017 |
< |
v2_id = T_NTH_V(t,2); |
1018 |
< |
if(bg0) |
1062 |
> |
s_id = QT_SET_NEXT_ELEM(optr); |
1063 |
> |
t_id = SM_NTH_VERT(smMesh,s_id); |
1064 |
> |
tri = t = SM_NTH_TRI(smMesh,t_id); |
1065 |
> |
do |
1066 |
|
{ |
1067 |
< |
bg0 = SM_DIR_ID(sm,v0_id)?DIR:SM_BASE_ID(sm,v0_id)?BASE:0; |
1068 |
< |
bg1 = SM_DIR_ID(sm,v1_id)?DIR:SM_BASE_ID(sm,v1_id)?BASE:0; |
1069 |
< |
bg2 = SM_DIR_ID(sm,v2_id)?DIR:SM_BASE_ID(sm,v2_id)?BASE:0; |
1070 |
< |
SM_SET_NTH_T_NEW(sm,t_id); |
1071 |
< |
if(bg0==DIR && bg1==DIR && bg2==DIR) |
1072 |
< |
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
1073 |
< |
rgb[v2_id]) |
1074 |
< |
else |
1075 |
< |
render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
1076 |
< |
rgb[v1_id],rgb[v2_id],vp,SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
1077 |
< |
} |
1078 |
< |
else |
1079 |
< |
{ |
1080 |
< |
SM_SET_NTH_T_NEW(sm,t_id); |
1081 |
< |
bg0 = SM_BASE_ID(sm,v0_id); |
1082 |
< |
bg1 = SM_BASE_ID(sm,v1_id); |
1083 |
< |
bg2 = SM_BASE_ID(sm,v2_id); |
1084 |
< |
if(bg0 || bg1 || bg2) |
1085 |
< |
render_base_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
1086 |
< |
rgb[v1_id],rgb[v2_id],SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
1087 |
< |
else |
1088 |
< |
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
1089 |
< |
rgb[v2_id]) |
1090 |
< |
} |
1067 |
> |
if((!cull || SM_IS_NTH_T_ACTIVE(sm,t_id)) && !SM_IS_NTH_T_NEW(sm,t_id)) |
1068 |
> |
{ |
1069 |
> |
bg0 = SM_IS_NTH_T_BG(sm,t_id); |
1070 |
> |
if((which == SM_RENDER_FG && !bg0) || (which== SM_RENDER_BG && bg0)) |
1071 |
> |
{ |
1072 |
> |
v0_id = T_NTH_V(t,0); |
1073 |
> |
v1_id = T_NTH_V(t,1); |
1074 |
> |
v2_id = T_NTH_V(t,2); |
1075 |
> |
if(bg0) |
1076 |
> |
{ |
1077 |
> |
bg0 = SM_DIR_ID(sm,v0_id)?DIR:SM_BASE_ID(sm,v0_id)?BASE:0; |
1078 |
> |
bg1 = SM_DIR_ID(sm,v1_id)?DIR:SM_BASE_ID(sm,v1_id)?BASE:0; |
1079 |
> |
bg2 = SM_DIR_ID(sm,v2_id)?DIR:SM_BASE_ID(sm,v2_id)?BASE:0; |
1080 |
> |
SM_SET_NTH_T_NEW(sm,t_id); |
1081 |
> |
if(bg0==DIR && bg1==DIR && bg2==DIR) |
1082 |
> |
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
1083 |
> |
rgb[v2_id]) |
1084 |
> |
else |
1085 |
> |
render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
1086 |
> |
rgb[v1_id],rgb[v2_id],vp,SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
1087 |
> |
} |
1088 |
> |
else |
1089 |
> |
{ |
1090 |
> |
SM_SET_NTH_T_NEW(sm,t_id); |
1091 |
> |
bg0 = SM_BASE_ID(sm,v0_id); |
1092 |
> |
bg1 = SM_BASE_ID(sm,v1_id); |
1093 |
> |
bg2 = SM_BASE_ID(sm,v2_id); |
1094 |
> |
if(bg0 || bg1 || bg2) |
1095 |
> |
render_base_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id], |
1096 |
> |
rgb[v1_id],rgb[v2_id],SM_VIEW_CENTER(sm),bg0,bg1,bg2); |
1097 |
> |
else |
1098 |
> |
render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id], |
1099 |
> |
rgb[v2_id]) |
1100 |
> |
} |
1101 |
> |
} |
1102 |
> |
} |
1103 |
> |
t_id = smTri_next_ccw_nbr(smMesh,t,s_id); |
1104 |
> |
t = SM_NTH_TRI(smMesh,t_id); |
1105 |
> |
}while(t!=tri); |
1106 |
|
} |
1107 |
|
} |
1108 |
|
else |
1111 |
|
smRender_qtree(sm,QT_NTH_CHILD(qt,i),vp,wp,rgb,which,cull); |
1112 |
|
} |
1113 |
|
|
1114 |
+ |
|
1115 |
|
/* |
1116 |
|
* smRender_mesh(sm,view,cull) : Render mesh Triangles |
1117 |
|
* SM *sm; : mesh |
1128 |
|
VIEW *view; |
1129 |
|
int cull; |
1130 |
|
{ |
1131 |
< |
float (*wp)[3]; |
1131 |
> |
SFLOAT (*wp)[3]; |
1132 |
|
BYTE (*rgb)[3]; |
1133 |
|
int i; |
1134 |
|
STREE *st= SM_LOCATOR(sm); |
1135 |
|
|
1073 |
– |
smUpdate_tm(sm); |
1074 |
– |
|
1136 |
|
wp = SM_WP(sm); |
1137 |
|
rgb =SM_RGB(sm); |
1138 |
|
|
1141 |
|
if(cull) |
1142 |
|
smCull(sm,view,SM_ALL_LEVELS); |
1143 |
|
|
1083 |
– |
|
1144 |
|
glPushAttrib(GL_DEPTH_BUFFER_BIT); |
1145 |
|
glDisable(GL_DEPTH_TEST); |
1146 |
|
|
1149 |
|
/* move relative to the new view */ |
1150 |
|
glTranslated(view->vp[0],view->vp[1],view->vp[2]); |
1151 |
|
|
1092 |
– |
|
1152 |
|
/* The points are a distance of 1 away from the origin: if necessary |
1153 |
|
scale so that they fit in frustum and are therefore not clipped away |
1154 |
|
*/ |
1189 |
|
SM *sm; |
1190 |
|
VIEW *view; |
1191 |
|
{ |
1192 |
< |
float (*wp)[3]; |
1192 |
> |
SFLOAT (*wp)[3]; |
1193 |
|
BYTE (*rgb)[3]; |
1194 |
|
STREE *st; |
1195 |
|
int i; |
1208 |
|
|
1209 |
|
return; |
1210 |
|
} |
1211 |
+ |
smClear_flags(sm,T_NEW_FLAG); |
1212 |
+ |
|
1213 |
|
smCull(sm,view,SM_DL_LEVELS); |
1214 |
|
|
1215 |
|
st = SM_LOCATOR(sm); |
1268 |
|
VIEW *view; |
1269 |
|
int render_flag; |
1270 |
|
{ |
1271 |
< |
int4 *active_flag,*bg_flag; |
1272 |
< |
float (*wp)[3]; |
1271 |
> |
int32 *active_flag,*bg_flag; |
1272 |
> |
SFLOAT (*wp)[3]; |
1273 |
|
BYTE (*rgb)[3]; |
1274 |
|
|
1275 |
|
wp = SM_WP(sm); |
1276 |
< |
rgb =SM_RGB(sm); |
1276 |
> |
rgb = SM_RGB(sm); |
1277 |
|
active_flag = SM_NTH_FLAGS(sm,T_ACTIVE_FLAG); |
1278 |
|
bg_flag = SM_NTH_FLAGS(sm,T_BG_FLAG); |
1279 |
|
|
1427 |
|
VIEW *view; |
1428 |
|
int qual; |
1429 |
|
{ |
1369 |
– |
|
1370 |
– |
/* Recompute tone mapping if specified */ |
1371 |
– |
if( qual >= MAXQUALITY && smCompute_mapping) |
1372 |
– |
smUpdate_tm(sm); |
1373 |
– |
|
1430 |
|
/* Unless quality > MAXQUALITY, render using display lists */ |
1431 |
|
if(qual <= MAXQUALITY) |
1432 |
|
{ |
1433 |
|
/* If quality above threshold: render mesh*/ |
1434 |
< |
if(qual > (MAXQUALITY*2/4)) |
1434 |
> |
if(qual > (MAXQUALITY*2/4) ) |
1435 |
|
/* render stree using display lists */ |
1436 |
|
smRender_mesh_dl(sm,view); |
1437 |
|
else |
1438 |
+ |
{ |
1439 |
|
/* If quality below threshold, use approximate rendering */ |
1440 |
|
smRender_approx(sm,qual,view); |
1441 |
+ |
} |
1442 |
|
} |
1443 |
|
else |
1444 |
< |
/* render stree without display lists */ |
1444 |
> |
{ |
1445 |
> |
/* render stree without display lists */ |
1446 |
|
smRender_mesh(sm,view,TRUE); |
1447 |
+ |
} |
1448 |
|
} |
1449 |
|
|
1450 |
|
|
1464 |
|
VIEW *view; |
1465 |
|
int qual; |
1466 |
|
{ |
1467 |
+ |
|
1468 |
|
/* Is there anything to render? */ |
1469 |
|
if(!smMesh || SM_NUM_TRI(smMesh)<=0) |
1470 |
|
return; |
1471 |
< |
|
1471 |
> |
|
1472 |
|
/* Is viewer MOVING?*/ |
1473 |
|
if(qual < MAXQUALITY) |
1474 |
|
{ |
1475 |
+ |
if(smIncremental) |
1476 |
+ |
smUpdate_tm(smMesh); |
1477 |
+ |
|
1478 |
|
/* Render mesh using display lists */ |
1479 |
|
smRender(smMesh,view,qual); |
1480 |
|
return; |
1481 |
|
} |
1418 |
– |
|
1482 |
|
/* Viewer is STATIONARY */ |
1420 |
– |
|
1483 |
|
/* Has view moved epsilon from canonical view? (epsilon= percentage |
1484 |
|
(SM_VIEW_FRAC) of running average of the distance of the sample points |
1485 |
|
from the canonical view */ |
1486 |
|
if(DIST(view->vp,SM_VIEW_CENTER(smMesh)) > SM_ALLOWED_VIEW_CHANGE(smMesh)) |
1487 |
|
{ |
1488 |
|
/* Must rebuild mesh with current view as new canonical view */ |
1489 |
< |
smRebuild_mesh(smMesh,view); |
1489 |
> |
smRebuild(smMesh,view); |
1490 |
|
/* Existing display lists and tonemapping are no longer valid */ |
1491 |
|
clear_display_lists(); |
1492 |
< |
smCompute_mapping = TRUE; |
1492 |
> |
smCompute_mapping = FALSE; |
1493 |
> |
smUpdate_tm(smMesh); |
1494 |
|
/* Render all the triangles in the new mesh */ |
1495 |
|
smRender(smMesh,view,qual+1); |
1496 |
|
} |
1498 |
|
/* Has a complete redraw been requested ?*/ |
1499 |
|
if(smClean_notify) |
1500 |
|
{ |
1501 |
+ |
if(smIncremental) |
1502 |
+ |
smUpdate_tm(smMesh); |
1503 |
|
smIncremental = FALSE; |
1504 |
|
smRender(smMesh,view,qual); |
1505 |
|
} |
1506 |
|
else |
1507 |
|
{ |
1508 |
< |
/* Viewer fixed and receiving new samples for the same view */ |
1444 |
< |
if(!smNew_tri_cnt) |
1445 |
< |
return; |
1446 |
< |
|
1508 |
> |
smUpdate_tm(smMesh); |
1509 |
|
/* If number of new triangles relatively small: do incremental update */ |
1510 |
< |
if(smNew_tri_cnt < SM_SAMPLE_TRIS(smMesh)*SM_INC_PERCENT) |
1511 |
< |
{ |
1512 |
< |
/* Mark Existing display lists in frustum invalid */ |
1513 |
< |
if(!smIncremental) |
1514 |
< |
{ |
1515 |
< |
smInvalidate_view(smMesh,view); |
1516 |
< |
smIncremental = TRUE; |
1455 |
< |
} |
1456 |
< |
smRender_inc(smMesh,view->vp); |
1457 |
< |
} |
1458 |
< |
else |
1459 |
< |
/* Otherwise render all of the active triangles */ |
1460 |
< |
smRender(smMesh,view,qual+1); |
1510 |
> |
/* Mark Existing display lists in frustum invalid */ |
1511 |
> |
if(!smIncremental) |
1512 |
> |
{ |
1513 |
> |
smInvalidate_view(smMesh,view); |
1514 |
> |
smIncremental = TRUE; |
1515 |
> |
} |
1516 |
> |
smRender_inc(smMesh,view->vp); |
1517 |
|
} |
1518 |
|
/* This is our final update iff qual==MAXQUALITY and view==&odev.v */ |
1519 |
|
if( (qual >= MAXQUALITY) && (view == &(odev.v))) |
1520 |
|
{ |
1521 |
|
/* reset rendering flags */ |
1522 |
|
smClean_notify = FALSE; |
1523 |
< |
smNew_tri_cnt = 0; |
1524 |
< |
smClear_flags(smMesh,T_NEW_FLAG); |
1523 |
> |
if(smIncremental) |
1524 |
> |
smClear_flags(smMesh,T_NEW_FLAG); |
1525 |
|
qtCache_init(0); |
1526 |
|
} |
1527 |
|
|
1528 |
|
} |
1529 |
+ |
|
1530 |
+ |
|
1531 |
+ |
|
1532 |
+ |
|
1533 |
+ |
|
1534 |
+ |
|
1535 |
+ |
|