ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/sm_ogl.c
(Generate patch)

Comparing ray/src/hd/sm_ogl.c (file contents):
Revision 3.9 by gwlarson, Wed Nov 11 12:05:39 1998 UTC vs.
Revision 3.12 by gwlarson, Tue Jan 5 16:52:38 1999 UTC

# Line 47 | Line 47 | static QT_LUENT        *qt_htbl = NULL;        /* quadtree cache */
47   static int      qt_hsiz = 0;            /* quadtree cache size */
48  
49  
50 <
51 < mark_active_tris(qtptr,fptr)
52 < QUADTREE *qtptr;
53 < int *fptr;
54 < {
55 <  QUADTREE qt = *qtptr;
56 <  OBJECT *os,*optr;
57 <  register int i,t_id;
58 <  TRI *tri;
59 <
60 <  if(!QT_FLAG_FILL_TRI(*fptr))
61 <     (*fptr)++;
62 <  if(QT_IS_EMPTY(qt) || QT_LEAF_IS_FLAG(qt))
63 <    return;
64 <
65 <  /* For each triangle in the set, set the which flag*/
66 <  os = qtqueryset(qt);
67 <
68 <  for (i = QT_SET_CNT(os), optr = QT_SET_PTR(os); i > 0; i--)
69 <  {
70 <    t_id = QT_SET_NEXT_ELEM(optr);
71 <    /* Set the render flag */
72 <    tri = SM_NTH_TRI(smMesh,t_id);
73 <    if(!T_IS_VALID(tri) || SM_IS_NTH_T_BASE(smMesh,t_id))
74 <        continue;
75 <    SM_SET_NTH_T_ACTIVE(smMesh,t_id);
76 <    /* Set the Active bits of the Vertices */
77 <    S_SET_FLAG(T_NTH_V(tri,0));
78 <    S_SET_FLAG(T_NTH_V(tri,1));
79 <    S_SET_FLAG(T_NTH_V(tri,2));
80 <
81 <  }
82 < }
83 <
84 < #define mark_active_interior mark_active_tris
85 <
86 < mark_tris_in_frustum(view)
87 < VIEW *view;
88 < {
89 <    FVECT nr[4],far[4];
90 <    FPEQ peq;
91 <    int debug=0;
92 <    /* Mark triangles in approx. view frustum as being active:set
93 <       LRU counter: for use in discarding samples when out
94 <       of space
95 <       Radiance often has no far clipping plane: but driver will set
96 <       dev_zmin,dev_zmax to satisfy OGL
97 <    */
98 <
99 <    /* First clear all the quadtree node and triangle active flags */
100 <    qtClearAllFlags();
101 <    smClear_flags(smMesh,T_ACTIVE_FLAG);
102 <    /* Clear all of the active sample flags*/
103 <    sClear_all_flags(SM_SAMP(smMesh));
104 <
105 <
106 <    /* calculate the world space coordinates of the view frustum */
107 <    calculate_view_frustum(view->vp,view->hvec,view->vvec,view->horiz,
108 <                           view->vert, dev_zmin,dev_zmax,nr,far);
109 <
110 < #ifdef TEST_DRIVER
111 <    VCOPY(FrustumFar[0],far[0]);
112 <    VCOPY(FrustumFar[1],far[1]);
113 <    VCOPY(FrustumFar[2],far[2]);
114 <    VCOPY(FrustumFar[3],far[3]);
115 <    VCOPY(FrustumNear[0],nr[0]);
116 <    VCOPY(FrustumNear[1],nr[1]);
117 <    VCOPY(FrustumNear[2],nr[2]);
118 <    VCOPY(FrustumNear[3],nr[3]);
119 < #endif
120 <    /* Project the view frustum onto the spherical quadtree */
121 <    /* For every cell intersected by the projection of the faces
122 <
123 <       of the frustum: mark all triangles in the cell as ACTIVE-
124 <       Also set the triangles LRU clock counter
125 <       */
126 <    
127 <    if(EQUAL_VEC3(view->vp,SM_VIEW_CENTER(smMesh)))
128 <    {/* Near face triangles */
129 <
130 <      smLocator_apply_func(smMesh,nr[0],nr[2],nr[3],mark_active_tris,
131 <                         mark_active_interior,NULL);
132 <      smLocator_apply_func(smMesh,nr[2],nr[0],nr[1],mark_active_tris,
133 <                         mark_active_interior,NULL);
134 <      return;
135 <    }
136 <
137 <    /* Test the view against the planes: and swap orientation if inside:*/
138 <    tri_plane_equation(nr[0],nr[2],nr[3], &peq,FALSE);
139 <    if(PT_ON_PLANE(SM_VIEW_CENTER(smMesh),peq) < 0.0)
140 <    {/* Near face triangles */
141 <      smLocator_apply_func(smMesh,nr[3],nr[2],nr[0],mark_active_tris,
142 <                           mark_active_interior,NULL);
143 <      smLocator_apply_func(smMesh,nr[1],nr[0],nr[2],mark_active_tris,
144 <                         mark_active_interior,NULL);
145 <    }
146 <    else
147 <    {/* Near face triangles */
148 <      smLocator_apply_func(smMesh,nr[0],nr[2],nr[3],mark_active_tris,
149 <                           mark_active_interior,NULL);
150 <      smLocator_apply_func(smMesh,nr[2],nr[0],nr[1],mark_active_tris,
151 <                         mark_active_interior,NULL);
152 <    }
153 <    tri_plane_equation(nr[0],far[3],far[0], &peq,FALSE);
154 <    if(PT_ON_PLANE(SM_VIEW_CENTER(smMesh),peq) < 0.0)
155 <    { /* Right face triangles */
156 <      smLocator_apply_func(smMesh,far[0],far[3],nr[0],mark_active_tris,
157 <                           mark_active_interior,NULL);
158 <      smLocator_apply_func(smMesh,nr[3],nr[0],far[3],mark_active_tris,
159 <                           mark_active_interior,NULL);
160 <    }
161 <    else
162 <    {/* Right face triangles */
163 <      smLocator_apply_func(smMesh,nr[0],far[3],far[0],mark_active_tris,
164 <                           mark_active_interior,NULL);
165 <      smLocator_apply_func(smMesh,far[3],nr[0],nr[3],mark_active_tris,
166 <                           mark_active_interior,NULL);
167 <    }
168 <
169 <    tri_plane_equation(nr[1],far[2],nr[2], &peq,FALSE);
170 <    if(PT_ON_PLANE(SM_VIEW_CENTER(smMesh),peq) < 0.0)
171 <    { /* Left face triangles */
172 <      smLocator_apply_func(smMesh,nr[2],far[2],nr[1],mark_active_tris,
173 <                           mark_active_interior,NULL);
174 <      smLocator_apply_func(smMesh,far[1],nr[1],far[2],mark_active_tris,
175 <                           mark_active_interior,NULL);  
176 <    }
177 <    else
178 <    { /* Left face triangles */
179 <      smLocator_apply_func(smMesh,nr[1],far[2],nr[2],mark_active_tris,
180 <                           mark_active_interior,NULL);
181 <      smLocator_apply_func(smMesh,far[2],nr[1],far[1],mark_active_tris,
182 <                   mark_active_interior,NULL);
183 <
184 <    }
185 <    tri_plane_equation(nr[0],far[0],nr[1], &peq,FALSE);
186 <    if(PT_ON_PLANE(SM_VIEW_CENTER(smMesh),peq) < 0.0)
187 <    {/* Top face triangles */
188 <      smLocator_apply_func(smMesh,nr[1],far[0],nr[0],mark_active_tris,
189 <                           mark_active_interior,NULL);
190 <      smLocator_apply_func(smMesh,far[1],far[0],nr[1],mark_active_tris,
191 <                           mark_active_interior,NULL);
192 <    }
193 <    else
194 <    {/* Top face triangles */
195 <      smLocator_apply_func(smMesh,nr[0],far[0],nr[1],mark_active_tris,
196 <                           mark_active_interior,NULL);
197 <      smLocator_apply_func(smMesh,nr[1],far[0],far[1],mark_active_tris,
198 <                           mark_active_interior,NULL);
199 <    }
200 <    tri_plane_equation(nr[3],nr[2],far[3], &peq,FALSE);
201 <    if(PT_ON_PLANE(SM_VIEW_CENTER(smMesh),peq) < 0.0)
202 <    {/* Bottom face triangles */
203 <      smLocator_apply_func(smMesh,far[3],nr[2],nr[3],mark_active_tris,
204 <                           mark_active_interior,NULL);
205 <      smLocator_apply_func(smMesh,far[3],far[2],nr[2],mark_active_tris,
206 <                           mark_active_interior,NULL);
207 <    }
208 <    else
209 <    { /* Bottom face triangles */
210 <      smLocator_apply_func(smMesh,nr[3],nr[2],far[3],mark_active_tris,
211 <                           mark_active_interior,NULL);
212 <      smLocator_apply_func(smMesh,nr[2],far[2],far[3],mark_active_tris,
213 <                           mark_active_interior,NULL);
214 <    }
215 <     tri_plane_equation(far[2],far[0],far[1], &peq,FALSE);
216 <    if(PT_ON_PLANE(SM_VIEW_CENTER(smMesh),peq) < 0.0)
217 <    {/* Far face triangles */
218 <      smLocator_apply_func(smMesh,far[0],far[2],far[1],mark_active_tris,
219 <                           mark_active_interior,NULL);
220 <      smLocator_apply_func(smMesh,far[2],far[0],far[3],mark_active_tris,
221 <                           mark_active_interior,NULL);
222 <    }
223 <    else
224 <    {/* Far face triangles */
225 <      smLocator_apply_func(smMesh,far[1],far[2],far[0],mark_active_tris,
226 <                           mark_active_interior,NULL);
227 <      smLocator_apply_func(smMesh,far[3],far[0],far[2],mark_active_tris,
228 <                           mark_active_interior,NULL);
229 <    }
230 <
231 < }
232 <
233 < /*
234 < * smClean()            : display has been wiped clean
235 < *
236 < * Called after display has been effectively cleared, meaning that all
237 < * geometry must be resent down the pipeline in the next call to smUpdate().
238 < */
50 > /*
51 >  * smClean()           : display has been wiped clean
52 >  *
53 >  * Called after display has been effectively cleared, meaning that all
54 >  * geometry must be resent down the pipeline in the next call to smUpdate().
55 >  */
56   smClean()
57   {
58      smClean_notify = TRUE;
# Line 322 | Line 139 | register QUADTREE qt;
139      stCount_level_leaves(lcnt+1, QT_NTH_CHILD(qt,3));
140    }
141    else
142 <    lcnt[0]++;
142 >    if(QT_LEAF_IS_FLAG(qt))
143 >      lcnt[0]++;
144   }
145  
146  
# Line 342 | Line 160 | int lvl;
160      return(NULL);
161    if (QT_IS_TREE(qt) && !QT_IS_FLAG(qt))        /* not in our frustum */
162      return(NULL);
163 +  if(QT_IS_LEAF(qt)  && !QT_LEAF_IS_FLAG(qt))   /* not in our frustum */
164 +    return(NULL);
165                                          /* else look up node */
166    if ((le = qtCache_find(qt)) == NULL)
167      error(SYSTEM, "out of memory in qtRender_level");
168    if (QT_IS_TREE(qt) && (QT_IS_EMPTY(le->qt) || lvl > 0))
169    {                                     /* compute children */
170      qtSubdivide_tri(v0,v1,v2,a,b,c);
171 <    rc[0] = qtRender_level(QT_NTH_CHILD(qt,0),v0,a,c,sm,lvl-1);
172 <    rc[1] = qtRender_level(QT_NTH_CHILD(qt,1),a,v1,b,sm,lvl-1);
173 <    rc[2] = qtRender_level(QT_NTH_CHILD(qt,2),c,b,v2,sm,lvl-1);
174 <    rc[3] = qtRender_level(QT_NTH_CHILD(qt,3),b,c,a,sm,lvl-1);
171 >    rc[0] = qtRender_level(QT_NTH_CHILD(qt,0),v0,c,b,sm,lvl-1);
172 >    rc[1] = qtRender_level(QT_NTH_CHILD(qt,1),c,v1,a,sm,lvl-1);
173 >    rc[2] = qtRender_level(QT_NTH_CHILD(qt,2),b,a,v2,sm,lvl-1);
174 >    rc[3] = qtRender_level(QT_NTH_CHILD(qt,3),a,b,c,sm,lvl-1);
175    }
176    if (QT_IS_EMPTY(le->qt))
177    {                                     /* let's make some data! */
# Line 374 | Line 194 | int lvl;
194      {                                   /* from triangle set */
195        OBJECT *os;
196        int s0, s1, s2;
197 <
197 >      
198        os = qtqueryset(qt);
199 <      for (n = os[0]; n; n--)
199 >      for (i = os[0]; i; i--)
200        {
201 <        if(SM_IS_NTH_T_BASE(sm,os[n]))
201 >        if(SM_IS_NTH_T_BASE(sm,os[i]))
202             continue;
203 <        tri = SM_NTH_TRI(sm,os[n]);
203 >        tri = SM_NTH_TRI(sm,os[i]);
204          if(!T_IS_VALID(tri))
205            continue;
206 <        
206 >        n++;
207          s0 = T_NTH_V(tri,0);
208          s1 = T_NTH_V(tri,1);
209          s2 = T_NTH_V(tri,2);
# Line 403 | Line 223 | int lvl;
223          rgbs[2] += SM_NTH_RGB(sm,s0)[2] + SM_NTH_RGB(sm,s1)[2]
224                    + SM_NTH_RGB(sm,s2)[2];
225        }
226 <      n = 3*os[0];
226 >      n *= 3;
227      }
228      if (!n)
229        return(NULL);
# Line 434 | Line 254 | smRender_stree_level(sm,lvl)
254   SM *sm;
255   int lvl;
256   {
257 <  QUADTREE root;
257 >  QUADTREE qt;
258    int i;
259    FVECT t0,t1,t2;
260    STREE *st;
261  
262    
263 <  if (lvl < 1)
263 >  if (lvl < 0)
264      return;
265    st = SM_LOCATOR(sm);
266    glPushAttrib(GL_LIGHTING_BIT);
# Line 448 | Line 268 | int lvl;
268    glBegin(GL_TRIANGLES);
269    for(i=0; i < ST_NUM_ROOT_NODES; i++)
270    {
271 <    root = ST_NTH_ROOT(st,i);
272 <    qtRender_level(root,ST_NTH_V(st,i,0),ST_NTH_V(st,i,1),ST_NTH_V(st,i,2),
273 <                   sm,lvl-1);
271 >    qt = ST_ROOT_QT(st,i);
272 >    qtRender_level(qt,ST_NTH_V(st,i,0),ST_NTH_V(st,i,1),ST_NTH_V(st,i,2),
273 >                   sm,lvl);
274    }
275    glEnd();
276    glPopAttrib();
# Line 463 | Line 283 | int qual;
283   {
284    int i, ntarget;
285    int lvlcnt[QT_MAX_LEVELS];
286 +  STREE *st;
287  
288    if (qual <= 0)
289      return;
# Line 475 | Line 296 | int qual;
296      return;
297    for (i = QT_MAX_LEVELS; i--; )
298      lvlcnt[i] = 0;
299 <  stCount_level_leaves(lvlcnt, ST_TOP_ROOT(SM_LOCATOR(sm)));
300 <  stCount_level_leaves(lvlcnt, ST_BOTTOM_ROOT(SM_LOCATOR(sm)));  
299 >  
300 >  st = SM_LOCATOR(sm);
301 >  for(i=0; i < ST_NUM_ROOT_NODES;i++)
302 >    stCount_level_leaves(lvlcnt, ST_ROOT_QT(st,i));
303 >  
304    for (ntarget -= lvlcnt[i=0]; i < QT_MAX_LEVELS-1; ntarget -= lvlcnt[++i])
305      if (ntarget < lvlcnt[i+1])
306        break;
# Line 485 | Line 309 | int qual;
309   }
310  
311  
488 – smRender_tri(sm,i,vp,clr)
489 – SM *sm;
490 – int i;
491 – FVECT vp;
492 – int clr;
493 – {
494 –  TRI *tri;
495 –  double ptr[3];
496 –  int j;
312  
313 <  tri = SM_NTH_TRI(sm,i);
314 <  if (clr) SM_CLR_NTH_T_NEW(sm,i);
315 <  for(j=0; j <= 2; j++)
316 <  {
502 < #ifdef DEBUG
503 <    if(SM_BG_SAMPLE(sm,T_NTH_V(tri,j)))
504 <      eputs("SmRenderTri(): shouldnt have bg samples\n");
505 < #endif
506 <    glColor3ub(SM_NTH_RGB(sm,T_NTH_V(tri,j))[0],
507 <               SM_NTH_RGB(sm,T_NTH_V(tri,j))[1],
508 <               SM_NTH_RGB(sm,T_NTH_V(tri,j))[2]);
509 <    VCOPY(ptr,SM_T_NTH_WV(sm,tri,j));
510 <    glVertex3d(ptr[0],ptr[1],ptr[2]);
511 <  }
512 < }
313 > #define render_tri(v0,v1,v2,rgb0,rgb1,rgb2) \
314 >  {glColor3ub(rgb0[0],rgb0[1],rgb0[2]);  glVertex3fv(v0); \
315 >  glColor3ub(rgb1[0],rgb1[1],rgb1[2]);  glVertex3fv(v1); \
316 >  glColor3ub(rgb2[0],rgb2[1],rgb2[2]);  glVertex3fv(v2);} \
317  
318 < smRender_mixed_tri(sm,i,vp,clr)
319 < SM *sm;
320 < int i;
321 < FVECT vp;
322 < int clr;
318 > render_mixed_tri(v0,v1,v2,rgb0,rgb1,rgb2,bg0,bg1,bg2,vp,vc)
319 > float v0[3],v1[3],v2[3];
320 > BYTE rgb0[3],rgb1[3],rgb2[3];
321 > int bg0,bg1,bg2;
322 > FVECT vp,vc;
323   {
520 –  TRI *tri;
324    double p[3],d;
325    int j,ids[3],cnt;
326    int rgb[3];
327  
525 –  tri = SM_NTH_TRI(sm,i);
526 –  if (clr) SM_CLR_NTH_T_NEW(sm,i);
527 –
328    /* NOTE:Triangles are defined clockwise:historical relative to spherical
329       tris: could change
330       */
331    cnt = 0;
332    d = 0.0;
333    rgb[0] = rgb[1] = rgb[2] = 0;
334 <  for(j=0;j < 3;j++)
334 >
335 >  if(bg0 && bg1 && bg2)
336 >    return;
337 >
338 >  if(!bg0)
339    {
340 <      ids[j] = T_NTH_V(tri,j);
341 <      if(!SM_BG_SAMPLE(sm,ids[j]))
342 <      {
343 <          rgb[0] += SM_NTH_RGB(sm,ids[j])[0];
344 <          rgb[1] += SM_NTH_RGB(sm,ids[j])[1];
541 <          rgb[2] += SM_NTH_RGB(sm,ids[j])[2];
542 <          cnt++;
543 <          d += DIST(vp,SM_NTH_WV(sm,ids[j]));
544 <      }
340 >    rgb[0] += rgb0[0];
341 >    rgb[1] += rgb0[1];
342 >    rgb[2] += rgb0[2];
343 >    cnt++;
344 >    d += DIST(vp,v0);
345    }
346 +  if(!bg1)
347 +  {
348 +    rgb[0] += rgb1[0];
349 +    rgb[1] += rgb1[1];
350 +    rgb[2] += rgb1[2];
351 +    cnt++;
352 +    d += DIST(vp,v1);
353 +  }
354 +  if(!bg2)
355 +  {
356 +    rgb[0] += rgb2[0];
357 +    rgb[1] += rgb2[1];
358 +    rgb[2] += rgb2[2];
359 +    cnt++;
360 +    d += DIST(vp,v2);
361 +  }
362    if(cnt > 1)
363    {
364      rgb[0]/=cnt; rgb[1]/=cnt; rgb[2]/=cnt;
365      d /= (double)cnt;
366    }
367 <  for(j=0; j <= 2; j++)
367 >  if(bg0)
368    {
369 <    if(SM_BG_SAMPLE(sm,ids[j]))
370 <    {
371 <        glColor3ub(rgb[0],rgb[1],rgb[2]);
372 <        VSUB(p,SM_NTH_WV(sm,ids[j]),SM_VIEW_CENTER(sm));
373 <        p[0] *= d;
374 <        p[1] *= d;
375 <        p[2] *= d;
376 <        VADD(p,p,SM_VIEW_CENTER(sm));
377 <    }
378 <    else
379 <    {
380 <        glColor3ub(SM_NTH_RGB(sm,ids[j])[0],SM_NTH_RGB(sm,ids[j])[1],
565 <                   SM_NTH_RGB(sm,ids[j])[2]);
566 <        VCOPY(p,SM_NTH_WV(sm,ids[j]));
567 <    }
568 <    glVertex3d(p[0],p[1],p[2]);
369 >    glColor3ub(rgb[0],rgb[1],rgb[2]);
370 >    VSUB(p,v0,vc);
371 >    p[0] *= d;
372 >    p[1] *= d;
373 >    p[2] *= d;
374 >    VADD(p,p,vc);
375 >    glVertex3dv(p);
376 >  }
377 >  else
378 >  {
379 >    glColor3ub(rgb0[0],rgb0[1],rgb0[2]);
380 >    glVertex3fv(v0);
381     }
382 +  if(bg1)
383 +  {
384 +    glColor3ub(rgb[0],rgb[1],rgb[2]);
385 +    VSUB(p,v1,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(rgb1[0],rgb1[1],rgb1[2]);
395 +    glVertex3fv(v1);
396 +   }
397 +  if(bg2)
398 +  {
399 +    glColor3ub(rgb[0],rgb[1],rgb[2]);
400 +    VSUB(p,v2,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(rgb2[0],rgb2[1],rgb2[2]);
410 +    glVertex3fv(v2);
411 +   }
412 +
413   }
414  
415 < smRender_bg_tri(sm,i,vp,d,clr)
416 < SM *sm;
417 < int i;
418 < FVECT vp;
415 > render_bg_tri(v0,v1,v2,rgb0,rgb1,rgb2,vp,vc,d)
416 > float v0[3],v1[3],v2[3];
417 > BYTE rgb0[3],rgb1[3],rgb2[3];
418 > FVECT vp,vc;
419   double d;
577 – int clr;
420   {
421    double p[3];
580 –  int j,id;
581 –  TRI *tri;
422    
423 <  tri = SM_NTH_TRI(sm,i);
424 <  if (clr) SM_CLR_NTH_T_NEW(sm,i);
423 >  glColor3ub(rgb0[0],rgb0[1],rgb0[2]);
424 >  VSUB(p,v0,vc);
425 >  if(dev_zmin >= 0.99)
426 >  {
427 >    p[0] *= d;
428 >    p[1] *= d;
429 >    p[2] *= d;
430 >  }
431 >  VADD(p,p,vp);
432 >  glVertex3dv(p);
433  
434 <  /* NOTE:Triangles are defined clockwise:historical relative to spherical
435 <     tris: could change
436 <     */
589 <  for(j=0; j <= 2; j++)
434 >  glColor3ub(rgb1[0],rgb1[1],rgb1[2]);
435 >  VSUB(p,v1,vc);
436 >  if(dev_zmin >= 0.99)
437    {
438 <      id = T_NTH_V(tri,j);
439 <      glColor3ub(SM_NTH_RGB(sm,id)[0],SM_NTH_RGB(sm,id)[1],
440 <                 SM_NTH_RGB(sm,id)[2]);
594 <      VSUB(p,SM_NTH_WV(sm,id),SM_VIEW_CENTER(sm));
595 <      if(dev_zmin >= 0.99)
596 <       {
597 <           p[0] *= d;
598 <           p[1] *= d;
599 <           p[2] *= d;
600 <       }
601 <      VADD(p,p,vp);
602 <      glVertex3d(p[0],p[1],p[2]);
438 >    p[0] *= d;
439 >    p[1] *= d;
440 >    p[2] *= d;
441    }
442 +  VADD(p,p,vp);
443 +  glVertex3dv(p);
444 +
445 +
446 +  glColor3ub(rgb2[0],rgb2[1],rgb2[2]);
447 +  VSUB(p,v2,vc);
448 +  if(dev_zmin >= 0.99)
449 +  {
450 +    p[0] *= d;
451 +    p[1] *= d;
452 +    p[2] *= d;
453 +  }
454 +  VADD(p,p,vp);
455 +  glVertex3dv(p);
456 +
457   }
458  
459   smRender_mesh(sm,vp,clr)
# Line 608 | Line 461 | SM *sm;
461   FVECT vp;
462   int clr;
463   {
464 <  int i;
464 >  int i,bg0,bg1,bg2;
465 >  double d;
466 >  int v0_id,v1_id,v2_id;
467    TRI *tri;
468 <  double ptr[3],d;
469 <  int j;
468 >  float (*wp)[3];
469 >  BYTE  (*rgb)[3];
470  
471 +  wp = SM_WP(sm);
472 +  rgb =SM_RGB(sm);
473    d = (dev_zmin+dev_zmax)/2.0;
474    glPushAttrib(GL_DEPTH_BUFFER_BIT);
475    
476    /* First draw background polygons */
477    glDisable(GL_DEPTH_TEST);
478    glBegin(GL_TRIANGLES);
479 +  /* Maintain a list? */
480    SM_FOR_ALL_ACTIVE_BG_TRIS(sm,i)
481 <     smRender_bg_tri(sm,i,vp,d,clr);
481 >  {
482 >    if (clr)
483 >      SM_CLR_NTH_T_NEW(sm,i);
484 >    tri = SM_NTH_TRI(sm,i);
485 >    v0_id = T_NTH_V(tri,0);
486 >    v1_id = T_NTH_V(tri,1);
487 >    v2_id = T_NTH_V(tri,2);
488 >    render_bg_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
489 >                   rgb[v2_id],vp,SM_VIEW_CENTER(sm),d);
490 >  }
491    glEnd();
492    glEnable(GL_DEPTH_TEST);
493    glBegin(GL_TRIANGLES);
494    SM_FOR_ALL_ACTIVE_FG_TRIS(sm,i)
495    {
496 <      if(!SM_MIXED_TRI(sm,i))
497 <        smRender_tri(sm,i,vp,clr);
496 >    if (clr)
497 >      SM_CLR_NTH_T_NEW(sm,i);
498 >    tri = SM_NTH_TRI(sm,i);
499 >    v0_id = T_NTH_V(tri,0);
500 >    v1_id = T_NTH_V(tri,1);
501 >    v2_id = T_NTH_V(tri,2);
502 >    bg0 = SM_DIR_ID(sm,v0_id) || SM_BASE_ID(sm,v0_id);
503 >    bg1 = SM_DIR_ID(sm,v1_id) || SM_BASE_ID(sm,v1_id);
504 >    bg2 = SM_DIR_ID(sm,v2_id) || SM_BASE_ID(sm,v2_id);
505 >    if(!(bg0 || bg1 || bg2))
506 >        render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
507 >                   rgb[v2_id])
508     else
509 <        smRender_mixed_tri(sm,i,vp,clr);
509 >        render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
510 >           rgb[v2_id],bg0,bg1,bg2,vp,SM_VIEW_CENTER(sm));
511    }
512    glEnd();
513  
514    glPopAttrib();
515   }
516  
517 < smRender_tri_edges(sm,i)
518 < SM *sm;
641 < int i;
517 > int
518 > compare_tri_depths(T_DEPTH *td1,T_DEPTH *td2)
519   {
520 <  TRI *tri;
644 <  int j;
645 <  double ptr[3];
520 >  double d;
521  
522 +  if(td1->tri==-1)
523 +    {
524 +      if(td2->tri==-1)
525 +        return(0);
526 +      else
527 +        return(-1);
528 +    }
529 +  if(td2->tri==-1)
530 +    return(1);
531  
532 <  tri = SM_NTH_TRI(sm,i);
533 <
534 <  for(j=0; j <= 2; j++)
535 <  {
536 <    VCOPY(ptr,SM_NTH_WV(sm,T_NTH_V(tri,j)));
537 <    glVertex3d(ptr[0],ptr[1],ptr[2]);
538 <    VCOPY(ptr,SM_NTH_WV(sm,T_NTH_V(tri,(j+1)%3)));
539 <    glVertex3d(ptr[0],ptr[1],ptr[2]);
656 <  }
532 >  d = td2->depth-td1->depth;
533 >  
534 >  if(d > 0.0)
535 >    return(1);
536 >  if(d < 0.0)
537 >    return(-1);
538 >  
539 >  return(0);
540   }
541  
542   int
543 < compare_tri_depths(T_DEPTH *td1,T_DEPTH *td2)
543 > compare_tri_depths_old(T_DEPTH *td1,T_DEPTH *td2)
544   {
545    double d;
546  
# Line 681 | Line 564 | T_DEPTH *td;
564    TRI *tri;
565    double d,min_d;
566    LIST *tlist=NULL;
567 +  FVECT diff;
568  
569    i = 0;
570    SM_FOR_ALL_NEW_TRIS(sm,t_id)
# Line 691 | Line 575 | T_DEPTH *td;
575          continue;
576      }
577      tri = SM_NTH_TRI(sm,t_id);
694 – #ifdef DEBUG
695 –    if(i >= smNew_tri_cnt)
696 –    {
697 –      eputs("smDepth_sort_tris():More tris than reported by smNew_tri_cnt\n");
698 –      break;
699 –    }
700 – #endif
578      td[i].tri = t_id;
579      min_d = -1;
580      for(j=0;j < 3;j++)
# Line 705 | Line 582 | T_DEPTH *td;
582          v = T_NTH_V(tri,j);
583          if(!SM_BG_SAMPLE(sm,v))
584          {
585 <            d = DIST(vp,SM_NTH_WV(sm,v));
585 >            VSUB(diff,SM_NTH_WV(sm,v),vp);
586 >            d = DOT(diff,diff);
587              if(min_d == -1 || d < min_d)
588                 min_d = d;
589          }
# Line 720 | Line 598 | T_DEPTH *td;
598   }
599  
600  
601 +
602 + LIST
603 + *smOrder_new_tris(sm,vp,td,sort)
604 + SM *sm;
605 + FVECT vp;
606 + T_DEPTH *td;
607 + int sort;
608 + {
609 +  int i,j,t_id,v;
610 +  TRI *tri;
611 +  double d,min_d;
612 +  LIST *tlist=NULL;
613 +  FVECT diff;
614 +
615 +  i = 0;
616 +  for(i=0; i < smNew_tri_cnt;i++)
617 +  {
618 +    t_id = smNew_tris[i].tri;
619 +
620 +    tri = SM_NTH_TRI(sm,t_id);
621 +    if(!T_IS_VALID(tri))
622 +    {
623 +      smNew_tris[i].tri = -1;
624 +      continue;
625 +    }
626 +    if(SM_BG_TRI(sm,t_id))
627 +    {
628 +        tlist = push_data(tlist,t_id);
629 +        smNew_tris[i].tri = -1;
630 +        continue;
631 +    }
632 +    if(!sort)
633 +      continue;
634 +    min_d = -1;
635 +    for(j=0;j < 3;j++)
636 +    {
637 +        v = T_NTH_V(tri,j);
638 +        if(!SM_BG_SAMPLE(sm,v))
639 +        {
640 +            VSUB(diff,SM_NTH_WV(sm,v),vp);
641 +            d = DOT(diff,diff);
642 +            if(min_d == -1 || d < min_d)
643 +               min_d = d;
644 +        }
645 +    }
646 +    td[i].depth = min_d;
647 +  }
648 +  if(!sort)
649 +    return(tlist);
650 +  qsort((void *)td,smNew_tri_cnt,sizeof(T_DEPTH),compare_tri_depths);
651 +  return(tlist);
652 + }
653 +
654 +
655   smUpdate_Rendered_mesh(sm,vp,clr)
656   SM *sm;
657   FVECT vp;
# Line 727 | Line 659 | int clr;
659   {
660    static T_DEPTH *td= NULL;
661    static int tsize = 0;
662 <  int i;
662 >  int i,v0_id,v1_id,v2_id,bg0,bg1,bg2;
663    GLint depth_test;
664    double d;
665    LIST *bglist;
666 +  TRI *tri;
667 +  float (*wp)[3];
668 +  BYTE  (*rgb)[3];
669 +
670    /* For all of the NEW triangles (since last update): assume
671       ACTIVE. Go through and sort on depth value (from vp). Turn
672       Depth Buffer test off and render back-front
673       */
674    /* NOTE: could malloc each time or hard code */
675 + #if 0
676    if(smNew_tri_cnt > tsize)
677    {
678      if(td)
# Line 748 | Line 685 | int clr;
685      error(SYSTEM,"smUpdate_Rendered_mesh:Cannot allocate memory\n");
686    }
687    bglist = smDepth_sort_tris(sm,vp,td);
688 <
688 > #else
689 >  td = smNew_tris;
690 >  if(!EQUAL_VEC3(SM_VIEW_CENTER(sm),vp))
691 >    bglist = smOrder_new_tris(sm,vp,td,1);
692 >  else
693 >    bglist = smOrder_new_tris(sm,vp,td,0);
694 > #endif
695 >  wp = SM_WP(sm);
696 >  rgb =SM_RGB(sm);
697    /* Turn Depth Test off -- using Painter's algorithm */
698    glPushAttrib(GL_DEPTH_BUFFER_BIT);
699    glDepthFunc(GL_ALWAYS);
# Line 757 | Line 702 | int clr;
702    /* First render bg triangles */
703    glBegin(GL_TRIANGLES);
704    while(bglist)
705 <     smRender_bg_tri(sm,pop_list(&bglist),vp,d,clr);
705 >  {
706 >    i = pop_list(&bglist);
707 >    if (clr)
708 >      SM_CLR_NTH_T_NEW(sm,i);
709 >    tri = SM_NTH_TRI(sm,i);
710 >    v0_id = T_NTH_V(tri,0);
711 >    v1_id = T_NTH_V(tri,1);
712 >    v2_id = T_NTH_V(tri,2);
713 >    render_bg_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
714 >                   rgb[v2_id],vp,SM_VIEW_CENTER(sm),d);
715 >  }
716    glEnd();
717  
718  
719    glBegin(GL_TRIANGLES);
720    i=0;
721 <  while(td[i].tri != -1)
722 <     if(!SM_MIXED_TRI(sm,td[i].tri))
723 <        smRender_tri(sm,td[i++].tri,vp,clr);
724 <     else
725 <        smRender_mixed_tri(sm,td[i++].tri,vp,clr);
721 >  while(i != smNew_tri_cnt)
722 >  {
723 >    if(td[i].tri == -1)
724 >      {
725 >        i++;
726 >        continue;
727 >      }
728 >    if (clr)
729 >      SM_CLR_NTH_T_NEW(sm,td[i].tri);
730 >    tri = SM_NTH_TRI(sm,td[i].tri);
731 >    v0_id = T_NTH_V(tri,0);
732 >    v1_id = T_NTH_V(tri,1);
733 >    v2_id = T_NTH_V(tri,2);
734 >    bg0 = SM_DIR_ID(sm,v0_id) || SM_BASE_ID(sm,v0_id);
735 >    bg1 = SM_DIR_ID(sm,v1_id) || SM_BASE_ID(sm,v1_id);
736 >    bg2 = SM_DIR_ID(sm,v2_id) || SM_BASE_ID(sm,v2_id);
737 >    if(!(bg0 || bg1 || bg2))
738 >      render_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
739 >                 rgb[v2_id])
740 >   else
741 >     render_mixed_tri(wp[v0_id],wp[v1_id],wp[v2_id],rgb[v0_id],rgb[v1_id],
742 >                      rgb[v2_id],bg0,bg1,bg2,vp,SM_VIEW_CENTER(sm));
743 >    i++;
744 >  }
745    glEnd();
746  
747    /* Restore Depth Test */
# Line 801 | Line 775 | smUpdate(view,qual)
775  
776    if(!smMesh)
777      return;
778 +
779    d = DIST(view->vp,SM_VIEW_CENTER(smMesh));
780    if(qual >= 100 && d > SM_ALLOWED_VIEW_CHANGE(smMesh))
781    {
# Line 810 | Line 785 | smUpdate(view,qual)
785   #endif  
786        mark_tris_in_frustum(view);
787        smRebuild_mesh(smMesh,view);
788 +      smClean_notify = TRUE;
789    }
790    /* This is our final update iff qual==100 and view==&odev.v */
791    last_update = qual>=100 && view==&(odev.v);
# Line 823 | Line 799 | smUpdate(view,qual)
799      {
800         tmClearHisto();
801         tmAddHisto(SM_BRT(smMesh),SM_NUM_SAMP(smMesh),1);
802 <       if(tmComputeMapping(0.,0.,0.) != TM_E_OK ||
803 <                   tmMapPixels(SM_RGB(smMesh),SM_BRT(smMesh),SM_CHR(smMesh),
804 <                                SM_NUM_SAMP(smMesh)) != TM_E_OK)
829 <            return;
802 >       tmComputeMapping(0.,0.,0.);
803 >       tmMapPixels(SM_RGB(smMesh),SM_BRT(smMesh),SM_CHR(smMesh),
804 >                   SM_NUM_SAMP(smMesh));
805      }
806   #endif
807      mark_tris_in_frustum(view);
# Line 855 | Line 830 | smUpdate(view,qual)
830          if(tmComputeMapping(0.,0.,0.) != TM_E_OK)
831             return;
832      }
833 <    if(tmMapPixels(SM_NTH_RGB(smMesh,t),&SM_NTH_BRT(smMesh,t),
834 <                   SM_NTH_CHR(smMesh,t), SM_NUM_SAMP(smMesh)-t) != TM_E_OK)
835 <          return;
833 >    tmMapPixels(SM_NTH_RGB(smMesh,t),&SM_NTH_BRT(smMesh,t),
834 >                   SM_NTH_CHR(smMesh,t), SM_NUM_SAMP(smMesh)-t);
835 >        
836   #endif    
837      smUpdate_Rendered_mesh(smMesh,view->vp,last_update);
838      
# Line 872 | Line 847 | smUpdate(view,qual)
847    {
848      smClean_notify = FALSE;
849      smNew_tri_cnt = 0;
850 + #if 0  
851      smClear_flags(smMesh,T_NEW_FLAG);
852 + #endif
853      qtCache_init(0);
854    }
855  

Diff Legend

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