ReactOS 0.4.15-dev-8231-g29a56f3
insurfeval.cc
Go to the documentation of this file.
1/*
2** License Applicability. Except to the extent portions of this file are
3** made subject to an alternative license as permitted in the SGI Free
4** Software License B, Version 1.1 (the "License"), the contents of this
5** file are subject only to the provisions of the License. You may not use
6** this file except in compliance with the License. You may obtain a copy
7** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
8** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
9**
10** http://oss.sgi.com/projects/FreeB
11**
12** Note that, as provided in the License, the Software is distributed on an
13** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
14** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
15** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
16** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
17**
18** Original Code. The Original Code is: OpenGL Sample Implementation,
19** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
20** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
21** Copyright in any portions created by third parties is as indicated
22** elsewhere herein. All Rights Reserved.
23**
24** Additional Notice Provisions: The application programming interfaces
25** established by SGI in conjunction with the Original Code are The
26** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
27** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
28** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
29** Window System(R) (Version 1.3), released October 19, 1998. This software
30** was created using the OpenGL(R) version 1.2.1 Sample Implementation
31** published by SGI, but has not been independently verified as being
32** compliant with the OpenGL(R) version 1.2.1 Specification.
33**
34*/
35/*
36*/
37
38#include "gluos.h"
39//#include <stdlib.h>
40//#include <stdio.h>
41//#include <GL/gl.h>
42#include <math.h>
43#include <assert.h>
44
45#include "glsurfeval.h"
46
47//extern int surfcount;
48
49//#define CRACK_TEST
50
51#define AVOID_ZERO_NORMAL
52
53#ifdef AVOID_ZERO_NORMAL
54#define myabs(x) ((x>0)? x: (-x))
55#define MYZERO 0.000001
56#define MYDELTA 0.001
57#endif
58
59//#define USE_LOD
60#ifdef USE_LOD
61//#define LOD_EVAL_COORD(u,v) inDoEvalCoord2EM(u,v)
62#define LOD_EVAL_COORD(u,v) glEvalCoord2f(u,v)
63
64static void LOD_interpolate(REAL A[2], REAL B[2], REAL C[2], int j, int k, int pow2_level,
65 REAL& u, REAL& v)
66{
67 REAL a,a1,b,b1;
68
69 a = ((REAL) j) / ((REAL) pow2_level);
70 a1 = 1-a;
71
72 if(j != 0)
73 {
74 b = ((REAL) k) / ((REAL)j);
75 b1 = 1-b;
76 }
77 REAL x,y,z;
78 x = a1;
79 if(j==0)
80 {
81 y=0; z=0;
82 }
83 else{
84 y = b1*a;
85 z = b *a;
86 }
87
88 u = x*A[0] + y*B[0] + z*C[0];
89 v = x*A[1] + y*B[1] + z*C[1];
90}
91
93 int level)
94{
95 int k,j;
96 int pow2_level;
97 /*compute 2^level*/
98 pow2_level = 1;
99
100 for(j=0; j<level; j++)
101 pow2_level *= 2;
102 for(j=0; j<=pow2_level-1; j++)
103 {
104 REAL u,v;
105
106/* beginCallBack(GL_TRIANGLE_STRIP);*/
108 LOD_interpolate(A,B,C, j+1, j+1, pow2_level, u,v);
109#ifdef USE_LOD
110 LOD_EVAL_COORD(u,v);
111// glEvalCoord2f(u,v);
112#else
114#endif
115
116 for(k=0; k<=j; k++)
117 {
118 LOD_interpolate(A,B,C,j,j-k,pow2_level, u,v);
119#ifdef USE_LOD
120 LOD_EVAL_COORD(u,v);
121// glEvalCoord2f(u,v);
122#else
124#endif
125
126 LOD_interpolate(A,B,C,j+1,j-k,pow2_level, u,v);
127
128#ifdef USE_LOD
129 LOD_EVAL_COORD(u,v);
130// glEvalCoord2f(u,v);
131#else
133#endif
134 }
135// endCallBack();
136glEnd();
137 }
138}
139
140void OpenGLSurfaceEvaluator::LOD_eval(int num_vert, REAL* verts, int type,
141 int level
142 )
143{
144 int i,k;
145 switch(type){
147 case GL_QUAD_STRIP:
148 for(i=2, k=4; i<=num_vert-2; i+=2, k+=4)
149 {
150 LOD_triangle(verts+k-4, verts+k-2, verts+k,
151 level
152 );
153 LOD_triangle(verts+k-2, verts+k+2, verts+k,
154 level
155 );
156 }
157 if(num_vert % 2 ==1)
158 {
159 LOD_triangle(verts+2*(num_vert-3), verts+2*(num_vert-2), verts+2*(num_vert-1),
160 level
161 );
162 }
163 break;
164 case GL_TRIANGLE_FAN:
165 for(i=1, k=2; i<=num_vert-2; i++, k+=2)
166 {
167 LOD_triangle(verts,verts+k, verts+k+2,
168 level
169 );
170 }
171 break;
172
173 default:
174 fprintf(stderr, "typy not supported in LOD_\n");
175 }
176}
177
178
179#endif //USE_LOD
180
181//#define GENERIC_TEST
182#ifdef GENERIC_TEST
183extern float xmin, xmax, ymin, ymax, zmin, zmax; /*bounding box*/
184extern int temp_signal;
185
186static void gTessVertexSphere(float u, float v, float temp_normal[3], float temp_vertex[3])
187{
188 float r=2.0;
189 float Ox = 0.5*(xmin+xmax);
190 float Oy = 0.5*(ymin+ymax);
191 float Oz = 0.5*(zmin+zmax);
192 float nx = cos(v) * sin(u);
193 float ny = sin(v) * sin(u);
194 float nz = cos(u);
195 float x= Ox+r * nx;
196 float y= Oy+r * ny;
197 float z= Oz+r * nz;
198
199 temp_normal[0] = nx;
200 temp_normal[1] = ny;
201 temp_normal[2] = nz;
202 temp_vertex[0] = x;
203 temp_vertex[1] = y;
204 temp_vertex[2] = z;
205
206// glNormal3f(nx,ny,nz);
207// glVertex3f(x,y,z);
208}
209
210static void gTessVertexCyl(float u, float v, float temp_normal[3], float temp_vertex[3])
211{
212 float r=2.0;
213 float Ox = 0.5*(xmin+xmax);
214 float Oy = 0.5*(ymin+ymax);
215 float Oz = 0.5*(zmin+zmax);
216 float nx = cos(v);
217 float ny = sin(v);
218 float nz = 0;
219 float x= Ox+r * nx;
220 float y= Oy+r * ny;
221 float z= Oz - 2*u;
222
223 temp_normal[0] = nx;
224 temp_normal[1] = ny;
225 temp_normal[2] = nz;
226 temp_vertex[0] = x;
227 temp_vertex[1] = y;
228 temp_vertex[2] = z;
229
230/*
231 glNormal3f(nx,ny,nz);
232 glVertex3f(x,y,z);
233*/
234}
235
236#endif //GENERIC_TEST
237
239{
241 for(temp = list; temp != NULL; temp = temp->next)
242 {
244 }
245}
246
248{
249 int i,j,k,l;
250 float u,v;
251
252 int ustride = bpm->bpatch->dimension * bpm->bpatch->vorder;
253 int vstride = bpm->bpatch->dimension;
254 inMap2f(
256 bpm->bpatch->umin,
257 bpm->bpatch->umax,
258 ustride,
259 bpm->bpatch->uorder,
260 bpm->bpatch->vmin,
261 bpm->bpatch->vmax,
262 vstride,
263 bpm->bpatch->vorder,
264 bpm->bpatch->ctlpoints);
265
266 bpm->vertex_array = (float*) malloc(sizeof(float)* (bpm->index_UVarray/2) * 3+1); /*in case the origional dimenion is 4, then we need 4 space to pass to evaluator.*/
267 assert(bpm->vertex_array);
268 bpm->normal_array = (float*) malloc(sizeof(float)* (bpm->index_UVarray/2) * 3);
269 assert(bpm->normal_array);
270#ifdef CRACK_TEST
271if( global_ev_u1 ==2 && global_ev_u2 == 3
272 && global_ev_v1 ==2 && global_ev_v2 == 3)
273{
274REAL vertex[4];
275REAL normal[4];
276#ifdef DEBUG
277printf("***number 1\n");
278#endif
279
281inEvalCoord2f(3.0, 3.0);
282inEvalCoord2f(2.0, 3.0);
283inEvalCoord2f(3.0, 2.7);
284inEvalCoord2f(2.0, 2.7);
285inEvalCoord2f(3.0, 2.0);
286inEvalCoord2f(2.0, 2.0);
288
289
291inEvalCoord2f(2.0, 3.0);
292inEvalCoord2f(2.0, 2.0);
293inEvalCoord2f(2.0, 2.7);
295
296}
297
298/*
299if( global_ev_u1 ==2 && global_ev_u2 == 3
300 && global_ev_v1 ==1 && global_ev_v2 == 2)
301{
302#ifdef DEBUG
303printf("***number 2\n");
304#endif
305beginCallBack(GL_QUAD_STRIP);
306inEvalCoord2f(2.0, 2.0);
307inEvalCoord2f(2.0, 1.0);
308inEvalCoord2f(3.0, 2.0);
309inEvalCoord2f(3.0, 1.0);
310endCallBack();
311}
312*/
313if( global_ev_u1 ==1 && global_ev_u2 == 2
314 && global_ev_v1 ==2 && global_ev_v2 == 3)
315{
316#ifdef DEBUG
317printf("***number 3\n");
318#endif
320inEvalCoord2f(2.0, 3.0);
321inEvalCoord2f(1.0, 3.0);
322inEvalCoord2f(2.0, 2.3);
323inEvalCoord2f(1.0, 2.3);
324inEvalCoord2f(2.0, 2.0);
325inEvalCoord2f(1.0, 2.0);
327
329inEvalCoord2f(2.0, 2.3);
330inEvalCoord2f(2.0, 2.0);
331inEvalCoord2f(2.0, 3.0);
333
334}
335return;
336#endif
337
338 k=0;
339 l=0;
340
341 for(i=0; i<bpm->index_length_array; i++)
342 {
344 for(j=0; j<bpm->length_array[i]; j++)
345 {
346 u = bpm->UVarray[k];
347 v = bpm->UVarray[k+1];
349 bpm->vertex_array+l,
350 bpm->normal_array+l);
351
354
355 k += 2;
356 l += 3;
357 }
359 }
360}
361
363{
364 REAL du, dv;
365 REAL point[4];
366 REAL normal[3];
367 REAL u,v;
373}
374
376{
377
378 REAL point[4];
379 REAL normal[3];
381}
382
383
384
385/*define a grid. store the values into the global variabls:
386 * global_grid_*
387 *These values will be used later by evaluating functions
388 */
390 int nv, REAL v0, REAL v1)
391{
392 global_grid_u0 = u0;
394 global_grid_nu = nu;
397 global_grid_nv = nv;
398}
399
400void OpenGLSurfaceEvaluator::inEvalMesh2(int lowU, int lowV, int highU, int highV)
401{
402 REAL du, dv;
403 int i,j;
404 REAL point[4];
405 REAL normal[3];
406 if(global_grid_nu == 0 || global_grid_nv == 0)
407 return; /*no points need to be output*/
410
412 for(i=lowU; i<highU; i++){
414 REAL u2 = ((i+1) == global_grid_nu)? global_grid_u1: (global_grid_u0+(i+1)*du);
415
416 bgnqstrip();
417 for(j=highV; j>=lowV; j--){
419
422 }
423 endqstrip();
424 }
425 }
426
427 else{
428 for(i=lowV; i<highV; i++){
430 REAL v2 = ((i+1) == global_grid_nv)? global_grid_v1: (global_grid_v0+(i+1)*dv);
431
432 bgnqstrip();
433 for(j=highU; j>=lowU; j--){
437 }
438 endqstrip();
439 }
440 }
441
442}
443
445 REAL ulower,
446 REAL uupper,
447 int ustride,
448 int uorder,
449 REAL vlower,
450 REAL vupper,
451 int vstride,
452 int vorder,
453 REAL *ctlPoints)
454{
455 int i,j,x;
457
458
459
460 if(k == GL_MAP2_VERTEX_3) k=3;
461 else if (k==GL_MAP2_VERTEX_4) k =4;
462 else {
463 printf("error in inMap2f, maptype=%i is wrong, k,map is not updated\n", k);
464 return;
465 }
466
467 global_ev_k = k;
468 global_ev_u1 = ulower;
469 global_ev_u2 = uupper;
472 global_ev_v1 = vlower;
473 global_ev_v2 = vupper;
476
477 /*copy the contrl points from ctlPoints to global_ev_ctlPoints*/
478 for (i=0; i<uorder; i++) {
479 for (j=0; j<vorder; j++) {
480 for (x=0; x<k; x++) {
481 data[x] = ctlPoints[x];
482 }
483 ctlPoints += vstride;
484 data += k;
485 }
486 ctlPoints += ustride - vstride * vorder;
487 }
488
489}
490
491
492/*
493 *given a point p with homegeneous coordiante (x,y,z,w),
494 *let pu(x,y,z,w) be its partial derivative vector with
495 *respect to u
496 *and pv(x,y,z,w) be its partial derivative vector with repect to v.
497 *This function returns the partial derivative vectors of the
498 *inhomegensous coordinates, i.e.,
499 * (x/w, y/w, z/w) with respect to u and v.
500 */
502{
503 pu[0] = pu[0]*p[3] - pu[3]*p[0];
504 pu[1] = pu[1]*p[3] - pu[3]*p[1];
505 pu[2] = pu[2]*p[3] - pu[3]*p[2];
506
507 pv[0] = pv[0]*p[3] - pv[3]*p[0];
508 pv[1] = pv[1]*p[3] - pv[3]*p[1];
509 pv[2] = pv[2]*p[3] - pv[3]*p[2];
510}
511
512/*compute the cross product of pu and pv and normalize.
513 *the normal is returned in retNormal
514 * pu: dimension 3
515 * pv: dimension 3
516 * n: return normal, of dimension 3
517 */
519{
520 REAL mag;
521
522 n[0] = pu[1]*pv[2] - pu[2]*pv[1];
523 n[1] = pu[2]*pv[0] - pu[0]*pv[2];
524 n[2] = pu[0]*pv[1] - pu[1]*pv[0];
525
526 mag = sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]);
527
528 if (mag > 0.0) {
529 n[0] /= mag;
530 n[1] /= mag;
531 n[2] /= mag;
532 }
533}
534
535
536
537/*Compute point and normal
538 *see the head of inDoDomain2WithDerivs
539 *for the meaning of the arguments
540 */
542 REAL *retPoint, REAL *retNormal)
543{
544
545 REAL du[4];
546 REAL dv[4];
547
548
549 assert(global_ev_k>=3 && global_ev_k <= 4);
550 /*compute homegeneous point and partial derivatives*/
552
553#ifdef AVOID_ZERO_NORMAL
554
555 if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
556 {
557
558 REAL tempdu[4];
559 REAL tempdata[4];
562 if(u-MYDELTA*(u2-u1) < u1)
563 u = u+ MYDELTA*(u2-u1);
564 else
565 u = u-MYDELTA*(u2-u1);
567 }
568 if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
569 {
570 REAL tempdv[4];
571 REAL tempdata[4];
574 if(v-MYDELTA*(v2-v1) < v1)
575 v = v+ MYDELTA*(v2-v1);
576 else
577 v = v-MYDELTA*(v2-v1);
579 }
580#endif
581
582
583 /*compute normal*/
584 switch(global_ev_k){
585 case 3:
586 inComputeNormal2(du, dv, retNormal);
587
588 break;
589 case 4:
590 inComputeFirstPartials(retPoint, du, dv);
591 inComputeNormal2(du, dv, retNormal);
592 /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
593 retPoint[0] /= retPoint[3];
594 retPoint[1] /= retPoint[3];
595 retPoint[2] /= retPoint[3];
596 break;
597 }
598 /*output this vertex*/
599/* inMeshStreamInsert(global_ms, retPoint, retNormal);*/
600
601
602
603 glNormal3fv(retNormal);
604 glVertex3fv(retPoint);
605
606
607
608
609 #ifdef DEBUG
610 printf("vertex(%f,%f,%f)\n", retPoint[0],retPoint[1],retPoint[2]);
611 #endif
612
613
614
615}
616
617/*Compute point and normal
618 *see the head of inDoDomain2WithDerivs
619 *for the meaning of the arguments
620 */
622 REAL *retPoint, REAL *retNormal)
623{
624
625 REAL du[4];
626 REAL dv[4];
627
628
629 assert(global_ev_k>=3 && global_ev_k <= 4);
630 /*compute homegeneous point and partial derivatives*/
631// inPreEvaluateBU(global_ev_k, global_ev_uorder, global_ev_vorder, (u-global_ev_u1)/(global_ev_u2-global_ev_u1), global_ev_ctlPoints);
633
634
635#ifdef AVOID_ZERO_NORMAL
636
637 if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
638 {
639
640 REAL tempdu[4];
641 REAL tempdata[4];
644 if(u-MYDELTA*(u2-u1) < u1)
645 u = u+ MYDELTA*(u2-u1);
646 else
647 u = u-MYDELTA*(u2-u1);
649 }
650 if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
651 {
652 REAL tempdv[4];
653 REAL tempdata[4];
656 if(v-MYDELTA*(v2-v1) < v1)
657 v = v+ MYDELTA*(v2-v1);
658 else
659 v = v-MYDELTA*(v2-v1);
661 }
662#endif
663
664 /*compute normal*/
665 switch(global_ev_k){
666 case 3:
667 inComputeNormal2(du, dv, retNormal);
668 break;
669 case 4:
670 inComputeFirstPartials(retPoint, du, dv);
671 inComputeNormal2(du, dv, retNormal);
672 /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
673 retPoint[0] /= retPoint[3];
674 retPoint[1] /= retPoint[3];
675 retPoint[2] /= retPoint[3];
676 break;
677 }
678}
679
680/*Compute point and normal
681 *see the head of inDoDomain2WithDerivs
682 *for the meaning of the arguments
683 */
685 REAL *retPoint, REAL *retNormal)
686{
687
688 REAL du[4];
689 REAL dv[4];
690
691
692 assert(global_ev_k>=3 && global_ev_k <= 4);
693 /*compute homegeneous point and partial derivatives*/
694// inPreEvaluateBV(global_ev_k, global_ev_uorder, global_ev_vorder, (v-global_ev_v1)/(global_ev_v2-global_ev_v1), global_ev_ctlPoints);
695
697
698
699#ifdef AVOID_ZERO_NORMAL
700
701 if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
702 {
703
704 REAL tempdu[4];
705 REAL tempdata[4];
708 if(u-MYDELTA*(u2-u1) < u1)
709 u = u+ MYDELTA*(u2-u1);
710 else
711 u = u-MYDELTA*(u2-u1);
713 }
714 if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
715 {
716 REAL tempdv[4];
717 REAL tempdata[4];
720 if(v-MYDELTA*(v2-v1) < v1)
721 v = v+ MYDELTA*(v2-v1);
722 else
723 v = v-MYDELTA*(v2-v1);
725 }
726#endif
727
728 /*compute normal*/
729 switch(global_ev_k){
730 case 3:
731 inComputeNormal2(du, dv, retNormal);
732 break;
733 case 4:
734 inComputeFirstPartials(retPoint, du, dv);
735 inComputeNormal2(du, dv, retNormal);
736 /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
737 retPoint[0] /= retPoint[3];
738 retPoint[1] /= retPoint[3];
739 retPoint[2] /= retPoint[3];
740 break;
741 }
742}
743
744
745/*Compute point and normal
746 *see the head of inDoDomain2WithDerivs
747 *for the meaning of the arguments
748 */
750 REAL *retPoint, REAL *retNormal)
751{
752
753 REAL du[4];
754 REAL dv[4];
755
756
757 assert(global_ev_k>=3 && global_ev_k <= 4);
758 /*compute homegeneous point and partial derivatives*/
760
761
762#ifdef AVOID_ZERO_NORMAL
763
764 if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
765 {
766
767 REAL tempdu[4];
768 REAL tempdata[4];
771 if(u-MYDELTA*(u2-u1) < u1)
772 u = u+ MYDELTA*(u2-u1);
773 else
774 u = u-MYDELTA*(u2-u1);
776 }
777 if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
778 {
779 REAL tempdv[4];
780 REAL tempdata[4];
783 if(v-MYDELTA*(v2-v1) < v1)
784 v = v+ MYDELTA*(v2-v1);
785 else
786 v = v-MYDELTA*(v2-v1);
788 }
789#endif
790
791 /*compute normal*/
792 switch(global_ev_k){
793 case 3:
794 inComputeNormal2(du, dv, retNormal);
795 break;
796 case 4:
797 inComputeFirstPartials(retPoint, du, dv);
798 inComputeNormal2(du, dv, retNormal);
799 /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
800 retPoint[0] /= retPoint[3];
801 retPoint[1] /= retPoint[3];
802 retPoint[2] /= retPoint[3];
803 break;
804 }
805// glNormal3fv(retNormal);
806// glVertex3fv(retPoint);
807}
808
809void OpenGLSurfaceEvaluator::inPreEvaluateBV(int k, int uorder, int vorder, REAL vprime, REAL *baseData)
810{
811 int j,row,col;
812 REAL p, pdv;
813 REAL *data;
814
815 if(global_vprime != vprime || global_vorder != vorder) {
817 global_vprime = vprime;
819 }
820
821 for(j=0; j<k; j++){
822 data = baseData+j;
823 for(row=0; row<uorder; row++){
824 p = global_vcoeff[0] * (*data);
825 pdv = global_vcoeffDeriv[0] * (*data);
826 data += k;
827 for(col = 1; col < vorder; col++){
828 p += global_vcoeff[col] * (*data);
829 pdv += global_vcoeffDeriv[col] * (*data);
830 data += k;
831 }
832 global_BV[row][j] = p;
833 global_PBV[row][j] = pdv;
834 }
835 }
836}
837
838void OpenGLSurfaceEvaluator::inPreEvaluateBU(int k, int uorder, int vorder, REAL uprime, REAL *baseData)
839{
840 int j,row,col;
841 REAL p, pdu;
842 REAL *data;
843
844 if(global_uprime != uprime || global_uorder != uorder) {
846 global_uprime = uprime;
848 }
849
850 for(j=0; j<k; j++){
851 data = baseData+j;
852 for(col=0; col<vorder; col++){
853 data = baseData+j + k*col;
854 p = global_ucoeff[0] * (*data);
855 pdu = global_ucoeffDeriv[0] * (*data);
856 data += k*uorder;
857 for(row = 1; row < uorder; row++){
858 p += global_ucoeff[row] * (*data);
859 pdu += global_ucoeffDeriv[row] * (*data);
860 data += k * uorder;
861 }
862 global_BU[col][j] = p;
863 global_PBU[col][j] = pdu;
864 }
865 }
866}
867
869 REAL u1, REAL u2, int uorder,
870 REAL v1, REAL v2, int vorder,
871 REAL *baseData,
872 REAL *retPoint, REAL* retdu, REAL *retdv)
873{
874 int j, col;
875
876 REAL vprime;
877
878
879 if((u2 == u1) || (v2 == v1))
880 return;
881
882 vprime = (v - v1) / (v2 - v1);
883
884
885 if(global_vprime != vprime || global_vorder != vorder) {
887 global_vprime = vprime;
889 }
890
891
892 for(j=0; j<k; j++)
893 {
894 retPoint[j] = retdu[j] = retdv[j] = 0.0;
895 for (col = 0; col < vorder; col++) {
896 retPoint[j] += global_BU[col][j] * global_vcoeff[col];
897 retdu[j] += global_PBU[col][j] * global_vcoeff[col];
898 retdv[j] += global_BU[col][j] * global_vcoeffDeriv[col];
899 }
900 }
901}
902
904 REAL u1, REAL u2, int uorder,
905 REAL v1, REAL v2, int vorder,
906 REAL *baseData,
907 REAL *retPoint, REAL* retdu, REAL *retdv)
908{
909 int j, row;
910 REAL uprime;
911
912
913 if((u2 == u1) || (v2 == v1))
914 return;
915 uprime = (u - u1) / (u2 - u1);
916
917
918 if(global_uprime != uprime || global_uorder != uorder) {
920 global_uprime = uprime;
922 }
923
924
925 for(j=0; j<k; j++)
926 {
927 retPoint[j] = retdu[j] = retdv[j] = 0.0;
928 for (row = 0; row < uorder; row++) {
929 retPoint[j] += global_BV[row][j] * global_ucoeff[row];
930 retdu[j] += global_BV[row][j] * global_ucoeffDeriv[row];
931 retdv[j] += global_PBV[row][j] * global_ucoeff[row];
932 }
933 }
934}
935
936
937/*
938 *given a Bezier surface, and parameter (u,v), compute the point in the object space,
939 *and the normal
940 *k: the dimension of the object space: usually 2,3,or 4.
941 *u,v: the paramter pair.
942 *u1,u2,uorder: the Bezier polynomial of u coord is defined on [u1,u2] with order uorder.
943 *v1,v2,vorder: the Bezier polynomial of v coord is defined on [v1,v2] with order vorder.
944 *baseData: contrl points. arranged as: (u,v,k).
945 *retPoint: the computed point (one point) with dimension k.
946 *retdu: the computed partial derivative with respect to u.
947 *retdv: the computed partial derivative with respect to v.
948 */
950 REAL u1, REAL u2, int uorder,
951 REAL v1, REAL v2, int vorder,
952 REAL *baseData,
953 REAL *retPoint, REAL *retdu, REAL *retdv)
954{
955 int j, row, col;
956 REAL uprime;
957 REAL vprime;
958 REAL p;
959 REAL pdv;
960 REAL *data;
961
962 if((u2 == u1) || (v2 == v1))
963 return;
964 uprime = (u - u1) / (u2 - u1);
965 vprime = (v - v1) / (v2 - v1);
966
967 /* Compute coefficients for values and derivs */
968
969 /* Use already cached values if possible */
970 if(global_uprime != uprime || global_uorder != uorder) {
973 global_uprime = uprime;
974 }
975 if (global_vprime != vprime ||
979 global_vprime = vprime;
980 }
981
982 for (j = 0; j < k; j++) {
983 data=baseData+j;
984 retPoint[j] = retdu[j] = retdv[j] = 0.0;
985 for (row = 0; row < uorder; row++) {
986 /*
987 ** Minor optimization.
988 ** The col == 0 part of the loop is extracted so we don't
989 ** have to initialize p and pdv to 0.
990 */
991 p = global_vcoeff[0] * (*data);
992 pdv = global_vcoeffDeriv[0] * (*data);
993 data += k;
994 for (col = 1; col < vorder; col++) {
995 /* Incrementally build up p, pdv value */
996 p += global_vcoeff[col] * (*data);
997 pdv += global_vcoeffDeriv[col] * (*data);
998 data += k;
999 }
1000 /* Use p, pdv value to incrementally add up r, du, dv */
1001 retPoint[j] += global_ucoeff[row] * p;
1002 retdu[j] += global_ucoeffDeriv[row] * p;
1003 retdv[j] += global_ucoeff[row] * pdv;
1004 }
1005 }
1006}
1007
1008
1009/*
1010 *compute the Bezier polynomials C[n,j](v) for all j at v with
1011 *return values stored in coeff[], where
1012 * C[n,j](v) = (n,j) * v^j * (1-v)^(n-j),
1013 * j=0,1,2,...,n.
1014 *order : n+1
1015 *vprime: v
1016 *coeff : coeff[j]=C[n,j](v), this array store the returned values.
1017 *The algorithm is a recursive scheme:
1018 * C[0,0]=1;
1019 * C[n,j](v) = (1-v)*C[n-1,j](v) + v*C[n-1,j-1](v), n>=1
1020 *This code is copied from opengl/soft/so_eval.c:PreEvaluate
1021 */
1023{
1024 int i, j;
1025 REAL oldval, temp;
1026 REAL oneMinusvprime;
1027
1028 /*
1029 * Minor optimization
1030 * Compute orders 1 and 2 outright, and set coeff[0], coeff[1] to
1031 * their i==1 loop values to avoid the initialization and the i==1 loop.
1032 */
1033 if (order == 1) {
1034 coeff[0] = 1.0;
1035 return;
1036 }
1037
1038 oneMinusvprime = 1-vprime;
1039 coeff[0] = oneMinusvprime;
1040 coeff[1] = vprime;
1041 if (order == 2) return;
1042
1043 for (i = 2; i < order; i++) {
1044 oldval = coeff[0] * vprime;
1045 coeff[0] = oneMinusvprime * coeff[0];
1046 for (j = 1; j < i; j++) {
1047 temp = oldval;
1048 oldval = coeff[j] * vprime;
1049 coeff[j] = temp + oneMinusvprime * coeff[j];
1050 }
1051 coeff[j] = oldval;
1052 }
1053}
1054
1055/*
1056 *compute the Bezier polynomials C[n,j](v) and derivatives for all j at v with
1057 *return values stored in coeff[] and coeffDeriv[].
1058 *see the head of function inPreEvaluate for the definition of C[n,j](v)
1059 *and how to compute the values.
1060 *The algorithm to compute the derivative is:
1061 * dC[0,0](v) = 0.
1062 * dC[n,j](v) = n*(dC[n-1,j-1](v) - dC[n-1,j](v)).
1063 *
1064 *This code is copied from opengl/soft/so_eval.c:PreEvaluateWidthDeriv
1065 */
1067 REAL *coeff, REAL *coeffDeriv)
1068{
1069 int i, j;
1070 REAL oldval, temp;
1071 REAL oneMinusvprime;
1072
1073 oneMinusvprime = 1-vprime;
1074 /*
1075 * Minor optimization
1076 * Compute orders 1 and 2 outright, and set coeff[0], coeff[1] to
1077 * their i==1 loop values to avoid the initialization and the i==1 loop.
1078 */
1079 if (order == 1) {
1080 coeff[0] = 1.0;
1081 coeffDeriv[0] = 0.0;
1082 return;
1083 } else if (order == 2) {
1084 coeffDeriv[0] = -1.0;
1085 coeffDeriv[1] = 1.0;
1086 coeff[0] = oneMinusvprime;
1087 coeff[1] = vprime;
1088 return;
1089 }
1090 coeff[0] = oneMinusvprime;
1091 coeff[1] = vprime;
1092 for (i = 2; i < order - 1; i++) {
1093 oldval = coeff[0] * vprime;
1094 coeff[0] = oneMinusvprime * coeff[0];
1095 for (j = 1; j < i; j++) {
1096 temp = oldval;
1097 oldval = coeff[j] * vprime;
1098 coeff[j] = temp + oneMinusvprime * coeff[j];
1099 }
1100 coeff[j] = oldval;
1101 }
1102 coeffDeriv[0] = -coeff[0];
1103 /*
1104 ** Minor optimization:
1105 ** Would make this a "for (j=1; j<order-1; j++)" loop, but it is always
1106 ** executed at least once, so this is more efficient.
1107 */
1108 j=1;
1109 do {
1110 coeffDeriv[j] = coeff[j-1] - coeff[j];
1111 j++;
1112 } while (j < order - 1);
1113 coeffDeriv[j] = coeff[j-1];
1114
1115 oldval = coeff[0] * vprime;
1116 coeff[0] = oneMinusvprime * coeff[0];
1117 for (j = 1; j < i; j++) {
1118 temp = oldval;
1119 oldval = coeff[j] * vprime;
1120 coeff[j] = temp + oneMinusvprime * coeff[j];
1121 }
1122 coeff[j] = oldval;
1123}
1124
1125void OpenGLSurfaceEvaluator::inEvalULine(int n_points, REAL v, REAL* u_vals,
1126 int stride, REAL ret_points[][3], REAL ret_normals[][3])
1127{
1128 int i,k;
1129 REAL temp[4];
1131
1132 for(i=0,k=0; i<n_points; i++, k += stride)
1133 {
1134 inDoEvalCoord2NOGE_BV(u_vals[k],v,temp, ret_normals[i]);
1135
1136 ret_points[i][0] = temp[0];
1137 ret_points[i][1] = temp[1];
1138 ret_points[i][2] = temp[2];
1139
1140 }
1141
1142}
1143
1144void OpenGLSurfaceEvaluator::inEvalVLine(int n_points, REAL u, REAL* v_vals,
1145 int stride, REAL ret_points[][3], REAL ret_normals[][3])
1146{
1147 int i,k;
1148 REAL temp[4];
1150 for(i=0,k=0; i<n_points; i++, k += stride)
1151 {
1152 inDoEvalCoord2NOGE_BU(u, v_vals[k], temp, ret_normals[i]);
1153 ret_points[i][0] = temp[0];
1154 ret_points[i][1] = temp[1];
1155 ret_points[i][2] = temp[2];
1156 }
1157}
1158
1159
1160/*triangulate a strip bounded by two lines which are parallel to U-axis
1161 *upperVerts: the verteces on the upper line
1162 *lowerVertx: the verteces on the lower line
1163 *n_upper >=1
1164 *n_lower >=1
1165 */
1166void OpenGLSurfaceEvaluator::inEvalUStrip(int n_upper, REAL v_upper, REAL* upper_val, int n_lower, REAL v_lower, REAL* lower_val)
1167{
1168 int i,j,k,l;
1169 REAL leftMostV[2];
1170 typedef REAL REAL3[3];
1171
1172 REAL3* upperXYZ = (REAL3*) malloc(sizeof(REAL3)*n_upper);
1173 assert(upperXYZ);
1174 REAL3* upperNormal = (REAL3*) malloc(sizeof(REAL3) * n_upper);
1175 assert(upperNormal);
1176 REAL3* lowerXYZ = (REAL3*) malloc(sizeof(REAL3)*n_lower);
1177 assert(lowerXYZ);
1178 REAL3* lowerNormal = (REAL3*) malloc(sizeof(REAL3) * n_lower);
1179 assert(lowerNormal);
1180
1181 inEvalULine(n_upper, v_upper, upper_val, 1, upperXYZ, upperNormal);
1182 inEvalULine(n_lower, v_lower, lower_val, 1, lowerXYZ, lowerNormal);
1183
1184
1185
1186 REAL* leftMostXYZ;
1187 REAL* leftMostNormal;
1188
1189 /*
1190 *the algorithm works by scanning from left to right.
1191 *leftMostV: the left most of the remaining verteces (on both upper and lower).
1192 * it could an element of upperVerts or lowerVerts.
1193 *i: upperVerts[i] is the first vertex to the right of leftMostV on upper line *j: lowerVerts[j] is the first vertex to the right of leftMostV on lower line */
1194
1195 /*initialize i,j,and leftMostV
1196 */
1197 if(upper_val[0] <= lower_val[0])
1198 {
1199 i=1;
1200 j=0;
1201
1202 leftMostV[0] = upper_val[0];
1203 leftMostV[1] = v_upper;
1204 leftMostXYZ = upperXYZ[0];
1205 leftMostNormal = upperNormal[0];
1206 }
1207 else
1208 {
1209 i=0;
1210 j=1;
1211
1212 leftMostV[0] = lower_val[0];
1213 leftMostV[1] = v_lower;
1214
1215 leftMostXYZ = lowerXYZ[0];
1216 leftMostNormal = lowerNormal[0];
1217 }
1218
1219 /*the main loop.
1220 *the invariance is that:
1221 *at the beginning of each loop, the meaning of i,j,and leftMostV are
1222 *maintained
1223 */
1224 while(1)
1225 {
1226 if(i >= n_upper) /*case1: no more in upper*/
1227 {
1228 if(j<n_lower-1) /*at least two vertices in lower*/
1229 {
1230 bgntfan();
1231 glNormal3fv(leftMostNormal);
1232 glVertex3fv(leftMostXYZ);
1233
1234 while(j<n_lower){
1235 glNormal3fv(lowerNormal[j]);
1236 glVertex3fv(lowerXYZ[j]);
1237 j++;
1238
1239 }
1240 endtfan();
1241 }
1242 break; /*exit the main loop*/
1243 }
1244 else if(j>= n_lower) /*case2: no more in lower*/
1245 {
1246 if(i<n_upper-1) /*at least two vertices in upper*/
1247 {
1248 bgntfan();
1249 glNormal3fv(leftMostNormal);
1250 glVertex3fv(leftMostXYZ);
1251
1252 for(k=n_upper-1; k>=i; k--) /*reverse order for two-side lighting*/
1253 {
1254 glNormal3fv(upperNormal[k]);
1255 glVertex3fv(upperXYZ[k]);
1256 }
1257
1258 endtfan();
1259 }
1260 break; /*exit the main loop*/
1261 }
1262 else /* case3: neither is empty, plus the leftMostV, there is at least one triangle to output*/
1263 {
1264 if(upper_val[i] <= lower_val[j])
1265 {
1266 bgntfan();
1267
1268 glNormal3fv(lowerNormal[j]);
1269 glVertex3fv(lowerXYZ[j]);
1270
1271 /*find the last k>=i such that
1272 *upperverts[k][0] <= lowerverts[j][0]
1273 */
1274 k=i;
1275
1276 while(k<n_upper)
1277 {
1278 if(upper_val[k] > lower_val[j])
1279 break;
1280 k++;
1281
1282 }
1283 k--;
1284
1285
1286 for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
1287 {
1288 glNormal3fv(upperNormal[l]);
1289 glVertex3fv(upperXYZ[l]);
1290
1291 }
1292 glNormal3fv(leftMostNormal);
1293 glVertex3fv(leftMostXYZ);
1294
1295 endtfan();
1296
1297 /*update i and leftMostV for next loop
1298 */
1299 i = k+1;
1300
1301 leftMostV[0] = upper_val[k];
1302 leftMostV[1] = v_upper;
1303 leftMostNormal = upperNormal[k];
1304 leftMostXYZ = upperXYZ[k];
1305 }
1306 else /*upperVerts[i][0] > lowerVerts[j][0]*/
1307 {
1308 bgntfan();
1309 glNormal3fv(upperNormal[i]);
1310 glVertex3fv(upperXYZ[i]);
1311
1312 glNormal3fv(leftMostNormal);
1313 glVertex3fv(leftMostXYZ);
1314
1315
1316 /*find the last k>=j such that
1317 *lowerverts[k][0] < upperverts[i][0]
1318 */
1319 k=j;
1320 while(k< n_lower)
1321 {
1322 if(lower_val[k] >= upper_val[i])
1323 break;
1324 glNormal3fv(lowerNormal[k]);
1325 glVertex3fv(lowerXYZ[k]);
1326
1327 k++;
1328 }
1329 endtfan();
1330
1331 /*update j and leftMostV for next loop
1332 */
1333 j=k;
1334 leftMostV[0] = lower_val[j-1];
1335 leftMostV[1] = v_lower;
1336
1337 leftMostNormal = lowerNormal[j-1];
1338 leftMostXYZ = lowerXYZ[j-1];
1339 }
1340 }
1341 }
1342 //clean up
1343 free(upperXYZ);
1344 free(lowerXYZ);
1345 free(upperNormal);
1346 free(lowerNormal);
1347}
1348
1349/*triangulate a strip bounded by two lines which are parallel to V-axis
1350 *leftVerts: the verteces on the left line
1351 *rightVertx: the verteces on the right line
1352 *n_left >=1
1353 *n_right >=1
1354 */
1355void OpenGLSurfaceEvaluator::inEvalVStrip(int n_left, REAL u_left, REAL* left_val, int n_right, REAL u_right, REAL* right_val)
1356{
1357 int i,j,k,l;
1358 REAL botMostV[2];
1359 typedef REAL REAL3[3];
1360
1361 REAL3* leftXYZ = (REAL3*) malloc(sizeof(REAL3)*n_left);
1362 assert(leftXYZ);
1363 REAL3* leftNormal = (REAL3*) malloc(sizeof(REAL3) * n_left);
1364 assert(leftNormal);
1365 REAL3* rightXYZ = (REAL3*) malloc(sizeof(REAL3)*n_right);
1366 assert(rightXYZ);
1367 REAL3* rightNormal = (REAL3*) malloc(sizeof(REAL3) * n_right);
1368 assert(rightNormal);
1369
1370 inEvalVLine(n_left, u_left, left_val, 1, leftXYZ, leftNormal);
1371 inEvalVLine(n_right, u_right, right_val, 1, rightXYZ, rightNormal);
1372
1373
1374
1375 REAL* botMostXYZ;
1376 REAL* botMostNormal;
1377
1378 /*
1379 *the algorithm works by scanning from bot to top.
1380 *botMostV: the bot most of the remaining verteces (on both left and right).
1381 * it could an element of leftVerts or rightVerts.
1382 *i: leftVerts[i] is the first vertex to the top of botMostV on left line
1383 *j: rightVerts[j] is the first vertex to the top of botMostV on rightline */
1384
1385 /*initialize i,j,and botMostV
1386 */
1387 if(left_val[0] <= right_val[0])
1388 {
1389 i=1;
1390 j=0;
1391
1392 botMostV[0] = u_left;
1393 botMostV[1] = left_val[0];
1394 botMostXYZ = leftXYZ[0];
1395 botMostNormal = leftNormal[0];
1396 }
1397 else
1398 {
1399 i=0;
1400 j=1;
1401
1402 botMostV[0] = u_right;
1403 botMostV[1] = right_val[0];
1404
1405 botMostXYZ = rightXYZ[0];
1406 botMostNormal = rightNormal[0];
1407 }
1408
1409 /*the main loop.
1410 *the invariance is that:
1411 *at the beginning of each loop, the meaning of i,j,and botMostV are
1412 *maintained
1413 */
1414 while(1)
1415 {
1416 if(i >= n_left) /*case1: no more in left*/
1417 {
1418 if(j<n_right-1) /*at least two vertices in right*/
1419 {
1420 bgntfan();
1421 glNormal3fv(botMostNormal);
1422 glVertex3fv(botMostXYZ);
1423
1424 while(j<n_right){
1425 glNormal3fv(rightNormal[j]);
1426 glVertex3fv(rightXYZ[j]);
1427 j++;
1428
1429 }
1430 endtfan();
1431 }
1432 break; /*exit the main loop*/
1433 }
1434 else if(j>= n_right) /*case2: no more in right*/
1435 {
1436 if(i<n_left-1) /*at least two vertices in left*/
1437 {
1438 bgntfan();
1439 glNormal3fv(botMostNormal);
1440 glVertex3fv(botMostXYZ);
1441
1442 for(k=n_left-1; k>=i; k--) /*reverse order for two-side lighting*/
1443 {
1444 glNormal3fv(leftNormal[k]);
1445 glVertex3fv(leftXYZ[k]);
1446 }
1447
1448 endtfan();
1449 }
1450 break; /*exit the main loop*/
1451 }
1452 else /* case3: neither is empty, plus the botMostV, there is at least one triangle to output*/
1453 {
1454 if(left_val[i] <= right_val[j])
1455 {
1456 bgntfan();
1457
1458 glNormal3fv(rightNormal[j]);
1459 glVertex3fv(rightXYZ[j]);
1460
1461 /*find the last k>=i such that
1462 *leftverts[k][0] <= rightverts[j][0]
1463 */
1464 k=i;
1465
1466 while(k<n_left)
1467 {
1468 if(left_val[k] > right_val[j])
1469 break;
1470 k++;
1471
1472 }
1473 k--;
1474
1475
1476 for(l=k; l>=i; l--)/*the reverse is for two-side lighting*/
1477 {
1478 glNormal3fv(leftNormal[l]);
1479 glVertex3fv(leftXYZ[l]);
1480
1481 }
1482 glNormal3fv(botMostNormal);
1483 glVertex3fv(botMostXYZ);
1484
1485 endtfan();
1486
1487 /*update i and botMostV for next loop
1488 */
1489 i = k+1;
1490
1491 botMostV[0] = u_left;
1492 botMostV[1] = left_val[k];
1493 botMostNormal = leftNormal[k];
1494 botMostXYZ = leftXYZ[k];
1495 }
1496 else /*left_val[i] > right_val[j])*/
1497 {
1498 bgntfan();
1499 glNormal3fv(leftNormal[i]);
1500 glVertex3fv(leftXYZ[i]);
1501
1502 glNormal3fv(botMostNormal);
1503 glVertex3fv(botMostXYZ);
1504
1505
1506 /*find the last k>=j such that
1507 *rightverts[k][0] < leftverts[i][0]
1508 */
1509 k=j;
1510 while(k< n_right)
1511 {
1512 if(right_val[k] >= left_val[i])
1513 break;
1514 glNormal3fv(rightNormal[k]);
1515 glVertex3fv(rightXYZ[k]);
1516
1517 k++;
1518 }
1519 endtfan();
1520
1521 /*update j and botMostV for next loop
1522 */
1523 j=k;
1524 botMostV[0] = u_right;
1525 botMostV[1] = right_val[j-1];
1526
1527 botMostNormal = rightNormal[j-1];
1528 botMostXYZ = rightXYZ[j-1];
1529 }
1530 }
1531 }
1532 //clean up
1533 free(leftXYZ);
1534 free(rightXYZ);
1535 free(leftNormal);
1536 free(rightNormal);
1537}
1538
1539/*-----------------------begin evalMachine-------------------*/
1541 REAL ulower,
1542 REAL uupper,
1543 int ustride,
1544 int uorder,
1545 REAL vlower,
1546 REAL vupper,
1547 int vstride,
1548 int vorder,
1549 REAL *ctlPoints)
1550{
1551 int i,j,x;
1552 surfEvalMachine *temp_em;
1553 switch(which){
1554 case 0: //vertex
1555 vertex_flag = 1;
1556 temp_em = &em_vertex;
1557 break;
1558 case 1: //normal
1559 normal_flag = 1;
1560 temp_em = &em_normal;
1561 break;
1562 case 2: //color
1563 color_flag = 1;
1564 temp_em = &em_color;
1565 break;
1566 default:
1567 texcoord_flag = 1;
1568 temp_em = &em_texcoord;
1569 break;
1570 }
1571
1572 REAL *data = temp_em->ctlPoints;
1573
1574 temp_em->uprime = -1;//initilized
1575 temp_em->vprime = -1;
1576
1577 temp_em->k = k;
1578 temp_em->u1 = ulower;
1579 temp_em->u2 = uupper;
1580 temp_em->ustride = ustride;
1581 temp_em->uorder = uorder;
1582 temp_em->v1 = vlower;
1583 temp_em->v2 = vupper;
1584 temp_em->vstride = vstride;
1585 temp_em->vorder = vorder;
1586
1587 /*copy the contrl points from ctlPoints to global_ev_ctlPoints*/
1588 for (i=0; i<uorder; i++) {
1589 for (j=0; j<vorder; j++) {
1590 for (x=0; x<k; x++) {
1591 data[x] = ctlPoints[x];
1592 }
1593 ctlPoints += vstride;
1594 data += k;
1595 }
1596 ctlPoints += ustride - vstride * vorder;
1597 }
1598}
1599
1601 REAL *retPoint, REAL *retdu, REAL *retdv)
1602{
1603 int j, row, col;
1604 REAL the_uprime;
1605 REAL the_vprime;
1606 REAL p;
1607 REAL pdv;
1608 REAL *data;
1609
1610 if((em->u2 == em->u1) || (em->v2 == em->v1))
1611 return;
1612 the_uprime = (u - em->u1) / (em->u2 - em->u1);
1613 the_vprime = (v - em->v1) / (em->v2 - em->v1);
1614
1615 /* Compute coefficients for values and derivs */
1616
1617 /* Use already cached values if possible */
1618 if(em->uprime != the_uprime) {
1619 inPreEvaluateWithDeriv(em->uorder, the_uprime, em->ucoeff, em->ucoeffDeriv);
1620 em->uprime = the_uprime;
1621 }
1622 if (em->vprime != the_vprime) {
1623 inPreEvaluateWithDeriv(em->vorder, the_vprime, em->vcoeff, em->vcoeffDeriv);
1624 em->vprime = the_vprime;
1625 }
1626
1627 for (j = 0; j < em->k; j++) {
1628 data=em->ctlPoints+j;
1629 retPoint[j] = retdu[j] = retdv[j] = 0.0;
1630 for (row = 0; row < em->uorder; row++) {
1631 /*
1632 ** Minor optimization.
1633 ** The col == 0 part of the loop is extracted so we don't
1634 ** have to initialize p and pdv to 0.
1635 */
1636 p = em->vcoeff[0] * (*data);
1637 pdv = em->vcoeffDeriv[0] * (*data);
1638 data += em->k;
1639 for (col = 1; col < em->vorder; col++) {
1640 /* Incrementally build up p, pdv value */
1641 p += em->vcoeff[col] * (*data);
1642 pdv += em->vcoeffDeriv[col] * (*data);
1643 data += em->k;
1644 }
1645 /* Use p, pdv value to incrementally add up r, du, dv */
1646 retPoint[j] += em->ucoeff[row] * p;
1647 retdu[j] += em->ucoeffDeriv[row] * p;
1648 retdv[j] += em->ucoeff[row] * pdv;
1649 }
1650 }
1651}
1652
1654 REAL *retPoint)
1655{
1656 int j, row, col;
1657 REAL the_uprime;
1658 REAL the_vprime;
1659 REAL p;
1660 REAL *data;
1661
1662 if((em->u2 == em->u1) || (em->v2 == em->v1))
1663 return;
1664 the_uprime = (u - em->u1) / (em->u2 - em->u1);
1665 the_vprime = (v - em->v1) / (em->v2 - em->v1);
1666
1667 /* Compute coefficients for values and derivs */
1668
1669 /* Use already cached values if possible */
1670 if(em->uprime != the_uprime) {
1671 inPreEvaluate(em->uorder, the_uprime, em->ucoeff);
1672 em->uprime = the_uprime;
1673 }
1674 if (em->vprime != the_vprime) {
1675 inPreEvaluate(em->vorder, the_vprime, em->vcoeff);
1676 em->vprime = the_vprime;
1677 }
1678
1679 for (j = 0; j < em->k; j++) {
1680 data=em->ctlPoints+j;
1681 retPoint[j] = 0.0;
1682 for (row = 0; row < em->uorder; row++) {
1683 /*
1684 ** Minor optimization.
1685 ** The col == 0 part of the loop is extracted so we don't
1686 ** have to initialize p and pdv to 0.
1687 */
1688 p = em->vcoeff[0] * (*data);
1689 data += em->k;
1690 for (col = 1; col < em->vorder; col++) {
1691 /* Incrementally build up p, pdv value */
1692 p += em->vcoeff[col] * (*data);
1693 data += em->k;
1694 }
1695 /* Use p, pdv value to incrementally add up r, du, dv */
1696 retPoint[j] += em->ucoeff[row] * p;
1697 }
1698 }
1699}
1700
1701
1703{
1704 REAL temp_vertex[5];
1705 REAL temp_normal[3];
1706 REAL temp_color[4];
1707 REAL temp_texcoord[4];
1708
1709 if(texcoord_flag)
1710 {
1711 inDoDomain2EM(&em_texcoord, u,v, temp_texcoord);
1712 texcoordCallBack(temp_texcoord, userData);
1713 }
1714 if(color_flag)
1715 {
1716 inDoDomain2EM(&em_color, u,v, temp_color);
1717 colorCallBack(temp_color, userData);
1718 }
1719
1720 if(normal_flag) //there is a normla map
1721 {
1722 inDoDomain2EM(&em_normal, u,v, temp_normal);
1723 normalCallBack(temp_normal, userData);
1724
1725 if(vertex_flag)
1726 {
1727 inDoDomain2EM(&em_vertex, u,v,temp_vertex);
1728 if(em_vertex.k == 4)
1729 {
1730 temp_vertex[0] /= temp_vertex[3];
1731 temp_vertex[1] /= temp_vertex[3];
1732 temp_vertex[2] /= temp_vertex[3];
1733 }
1734 temp_vertex[3]=u;
1735 temp_vertex[4]=v;
1736 vertexCallBack(temp_vertex, userData);
1737 }
1738 }
1739 else if(auto_normal_flag) //no normal map but there is a normal callbackfunctin
1740 {
1741 REAL du[4];
1742 REAL dv[4];
1743
1744 /*compute homegeneous point and partial derivatives*/
1745 inDoDomain2WithDerivsEM(&em_vertex, u,v,temp_vertex,du,dv);
1746
1747 if(em_vertex.k ==4)
1748 inComputeFirstPartials(temp_vertex, du, dv);
1749
1750#ifdef AVOID_ZERO_NORMAL
1751 if(myabs(dv[0]) <= MYZERO && myabs(dv[1]) <= MYZERO && myabs(dv[2]) <= MYZERO)
1752 {
1753
1754 REAL tempdu[4];
1755 REAL tempdata[4];
1756 REAL u1 = em_vertex.u1;
1757 REAL u2 = em_vertex.u2;
1758 if(u-MYDELTA*(u2-u1) < u1)
1759 u = u+ MYDELTA*(u2-u1);
1760 else
1761 u = u-MYDELTA*(u2-u1);
1762 inDoDomain2WithDerivsEM(&em_vertex,u,v, tempdata, tempdu, dv);
1763
1764 if(em_vertex.k ==4)
1765 inComputeFirstPartials(temp_vertex, du, dv);
1766 }
1767 else if(myabs(du[0]) <= MYZERO && myabs(du[1]) <= MYZERO && myabs(du[2]) <= MYZERO)
1768 {
1769 REAL tempdv[4];
1770 REAL tempdata[4];
1771 REAL v1 = em_vertex.v1;
1772 REAL v2 = em_vertex.v2;
1773 if(v-MYDELTA*(v2-v1) < v1)
1774 v = v+ MYDELTA*(v2-v1);
1775 else
1776 v = v-MYDELTA*(v2-v1);
1777 inDoDomain2WithDerivsEM(&em_vertex,u,v, tempdata, du, tempdv);
1778
1779 if(em_vertex.k ==4)
1780 inComputeFirstPartials(temp_vertex, du, dv);
1781 }
1782#endif
1783
1784 /*compute normal*/
1785 switch(em_vertex.k){
1786 case 3:
1787
1788 inComputeNormal2(du, dv, temp_normal);
1789 break;
1790 case 4:
1791
1792// inComputeFirstPartials(temp_vertex, du, dv);
1793 inComputeNormal2(du, dv, temp_normal);
1794
1795 /*transform the homegeneous coordinate of retPoint into inhomogenous one*/
1796 temp_vertex[0] /= temp_vertex[3];
1797 temp_vertex[1] /= temp_vertex[3];
1798 temp_vertex[2] /= temp_vertex[3];
1799 break;
1800 }
1801 normalCallBack(temp_normal, userData);
1802 temp_vertex[3] = u;
1803 temp_vertex[4] = v;
1804 vertexCallBack(temp_vertex, userData);
1805
1806 }/*end if auto_normal*/
1807 else //no normal map, and no normal callback function
1808 {
1809 if(vertex_flag)
1810 {
1811 inDoDomain2EM(&em_vertex, u,v,temp_vertex);
1812 if(em_vertex.k == 4)
1813 {
1814 temp_vertex[0] /= temp_vertex[3];
1815 temp_vertex[1] /= temp_vertex[3];
1816 temp_vertex[2] /= temp_vertex[3];
1817 }
1818 temp_vertex[3] = u;
1819 temp_vertex[4] = v;
1820 vertexCallBack(temp_vertex, userData);
1821 }
1822 }
1823}
1824
1825
1827{
1828 int i,j,k;
1829 float u,v;
1830
1831 int ustride;
1832 int vstride;
1833
1834#ifdef USE_LOD
1835 if(bpm->bpatch != NULL)
1836 {
1837 bezierPatch* p=bpm->bpatch;
1838 ustride = p->dimension * p->vorder;
1839 vstride = p->dimension;
1840
1841 glMap2f( (p->dimension == 3)? GL_MAP2_VERTEX_3 : GL_MAP2_VERTEX_4,
1842 p->umin,
1843 p->umax,
1844 ustride,
1845 p->uorder,
1846 p->vmin,
1847 p->vmax,
1848 vstride,
1849 p->vorder,
1850 p->ctlpoints);
1851
1852
1853/*
1854 inMap2fEM(0, p->dimension,
1855 p->umin,
1856 p->umax,
1857 ustride,
1858 p->uorder,
1859 p->vmin,
1860 p->vmax,
1861 vstride,
1862 p->vorder,
1863 p->ctlpoints);
1864*/
1865 }
1866#else
1867
1868 if(bpm->bpatch != NULL){
1869 bezierPatch* p = bpm->bpatch;
1870 ustride = p->dimension * p->vorder;
1871 vstride = p->dimension;
1872 inMap2fEM(0, p->dimension,
1873 p->umin,
1874 p->umax,
1875 ustride,
1876 p->uorder,
1877 p->vmin,
1878 p->vmax,
1879 vstride,
1880 p->vorder,
1881 p->ctlpoints);
1882 }
1883 if(bpm->bpatch_normal != NULL){
1884 bezierPatch* p = bpm->bpatch_normal;
1885 ustride = p->dimension * p->vorder;
1886 vstride = p->dimension;
1887 inMap2fEM(1, p->dimension,
1888 p->umin,
1889 p->umax,
1890 ustride,
1891 p->uorder,
1892 p->vmin,
1893 p->vmax,
1894 vstride,
1895 p->vorder,
1896 p->ctlpoints);
1897 }
1898 if(bpm->bpatch_color != NULL){
1899 bezierPatch* p = bpm->bpatch_color;
1900 ustride = p->dimension * p->vorder;
1901 vstride = p->dimension;
1902 inMap2fEM(2, p->dimension,
1903 p->umin,
1904 p->umax,
1905 ustride,
1906 p->uorder,
1907 p->vmin,
1908 p->vmax,
1909 vstride,
1910 p->vorder,
1911 p->ctlpoints);
1912 }
1913 if(bpm->bpatch_texcoord != NULL){
1915 ustride = p->dimension * p->vorder;
1916 vstride = p->dimension;
1917 inMap2fEM(3, p->dimension,
1918 p->umin,
1919 p->umax,
1920 ustride,
1921 p->uorder,
1922 p->vmin,
1923 p->vmax,
1924 vstride,
1925 p->vorder,
1926 p->ctlpoints);
1927 }
1928#endif
1929
1930
1931 k=0;
1932 for(i=0; i<bpm->index_length_array; i++)
1933 {
1934#ifdef USE_LOD
1935 if(bpm->type_array[i] == GL_POLYGON) //a mesh
1936 {
1937 GLfloat *temp = bpm->UVarray+k;
1938 GLfloat u0 = temp[0];
1939 GLfloat v0 = temp[1];
1940 GLfloat u1 = temp[2];
1941 GLfloat v1 = temp[3];
1942 GLint nu = (GLint) ( temp[4]);
1943 GLint nv = (GLint) ( temp[5]);
1944 GLint umin = (GLint) ( temp[6]);
1945 GLint vmin = (GLint) ( temp[7]);
1946 GLint umax = (GLint) ( temp[8]);
1947 GLint vmax = (GLint) ( temp[9]);
1948
1951 }
1952 else
1953 {
1954 LOD_eval(bpm->length_array[i], bpm->UVarray+k, bpm->type_array[i],
1955 0
1956 );
1957 }
1958 k+= 2*bpm->length_array[i];
1959
1960#else //undef USE_LOD
1961
1962#ifdef CRACK_TEST
1963if( bpm->bpatch->umin == 2 && bpm->bpatch->umax == 3
1964 && bpm->bpatch->vmin ==2 && bpm->bpatch->vmax == 3)
1965{
1966REAL vertex[4];
1967REAL normal[4];
1968#ifdef DEBUG
1969printf("***number ****1\n");
1970#endif
1971
1973inDoEvalCoord2EM(3.0, 3.0);
1974inDoEvalCoord2EM(2.0, 3.0);
1975inDoEvalCoord2EM(3.0, 2.7);
1976inDoEvalCoord2EM(2.0, 2.7);
1977inDoEvalCoord2EM(3.0, 2.0);
1978inDoEvalCoord2EM(2.0, 2.0);
1980
1982inDoEvalCoord2EM(2.0, 3.0);
1983inDoEvalCoord2EM(2.0, 2.0);
1984inDoEvalCoord2EM(2.0, 2.7);
1986
1987}
1988if( bpm->bpatch->umin == 1 && bpm->bpatch->umax == 2
1989 && bpm->bpatch->vmin ==2 && bpm->bpatch->vmax == 3)
1990{
1991#ifdef DEBUG
1992printf("***number 3\n");
1993#endif
1995inDoEvalCoord2EM(2.0, 3.0);
1996inDoEvalCoord2EM(1.0, 3.0);
1997inDoEvalCoord2EM(2.0, 2.3);
1998inDoEvalCoord2EM(1.0, 2.3);
1999inDoEvalCoord2EM(2.0, 2.0);
2000inDoEvalCoord2EM(1.0, 2.0);
2002
2004inDoEvalCoord2EM(2.0, 2.3);
2005inDoEvalCoord2EM(2.0, 2.0);
2006inDoEvalCoord2EM(2.0, 3.0);
2008
2009}
2010return;
2011#endif //CRACK_TEST
2012
2014
2015 for(j=0; j<bpm->length_array[i]; j++)
2016 {
2017 u = bpm->UVarray[k];
2018 v = bpm->UVarray[k+1];
2019#ifdef USE_LOD
2020 LOD_EVAL_COORD(u,v);
2021// glEvalCoord2f(u,v);
2022#else
2023
2024#ifdef GENERIC_TEST
2025 float temp_normal[3];
2026 float temp_vertex[3];
2027 if(temp_signal == 0)
2028 {
2029 gTessVertexSphere(u,v, temp_normal, temp_vertex);
2030//printf("normal=(%f,%f,%f)\n", temp_normal[0], temp_normal[1], temp_normal[2])//printf("veretx=(%f,%f,%f)\n", temp_vertex[0], temp_vertex[1], temp_vertex[2]);
2031 normalCallBack(temp_normal, userData);
2032 vertexCallBack(temp_vertex, userData);
2033 }
2034 else if(temp_signal == 1)
2035 {
2036 gTessVertexCyl(u,v, temp_normal, temp_vertex);
2037//printf("normal=(%f,%f,%f)\n", temp_normal[0], temp_normal[1], temp_normal[2])//printf("veretx=(%f,%f,%f)\n", temp_vertex[0], temp_vertex[1], temp_vertex[2]);
2038 normalCallBack(temp_normal, userData);
2039 vertexCallBack(temp_vertex, userData);
2040 }
2041 else
2042#endif //GENERIC_TEST
2043
2045
2046#endif //USE_LOD
2047
2048 k += 2;
2049 }
2051
2052#endif //USE_LOD
2053 }
2054}
2055
2057{
2059 for(temp = list; temp != NULL; temp = temp->next)
2060 {
2062 }
2063}
2064
_STLP_DECLSPEC complex< float > _STLP_CALL cos(const complex< float > &)
_STLP_DECLSPEC complex< float > _STLP_CALL sin(const complex< float > &)
_STLP_DECLSPEC complex< float > _STLP_CALL sqrt(const complex< float > &)
Definition: complex.cpp:188
#define nz(x)
r l[0]
Definition: byte_order.h:168
Definition: ehthrow.cxx:93
Definition: ehthrow.cxx:54
Definition: terminate.cpp:24
surfEvalMachine em_normal
Definition: glsurfeval.h:350
void inBPMListEvalEM(bezierPatchMesh *list)
Definition: insurfeval.cc:2056
REAL global_vcoeffDeriv[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:245
REAL global_ucoeffDeriv[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:244
void inDoDomain2WithDerivs(int k, REAL u, REAL v, REAL u1, REAL u2, int uorder, REAL v1, REAL v2, int vorder, REAL *baseData, REAL *retPoint, REAL *retdu, REAL *retdv)
Definition: insurfeval.cc:949
REAL global_ev_ctlPoints[IN_MAX_BEZIER_ORDER *IN_MAX_BEZIER_ORDER *IN_MAX_DIMENSION]
Definition: glsurfeval.h:262
void inBPMEval(bezierPatchMesh *bpm)
Definition: insurfeval.cc:247
surfEvalMachine em_color
Definition: glsurfeval.h:351
void LOD_eval(int num_vert, REAL *verts, int type, int level)
void vertexCallBack(const GLfloat *vert, void *data)
Definition: glsurfeval.cc:1255
void texcoordCallBack(const GLfloat *texcoord, void *data)
Definition: glsurfeval.cc:1283
void inDoEvalCoord2NOGE(REAL u, REAL v, REAL *retPoint, REAL *retNormal)
Definition: insurfeval.cc:749
void inEvalCoord2f(REAL u, REAL v)
Definition: insurfeval.cc:375
void inDoEvalCoord2EM(REAL u, REAL v)
Definition: insurfeval.cc:1702
void endCallBack(void *data)
Definition: glsurfeval.cc:1246
void inPreEvaluateBV_intfac(REAL v)
Definition: glsurfeval.h:316
void inComputeNormal2(REAL *pu, REAL *pv, REAL *n)
Definition: insurfeval.cc:518
void inDoDomain2WithDerivsBV(int k, REAL u, REAL v, REAL u1, REAL u2, int uorder, REAL v1, REAL v2, int vorder, REAL *baseData, REAL *retPoint, REAL *retdu, REAL *retdv)
Definition: insurfeval.cc:903
void inDoEvalCoord2NOGE_BU(REAL u, REAL v, REAL *retPoint, REAL *retNormal)
Definition: insurfeval.cc:621
void inDoDomain2EM(surfEvalMachine *em, REAL u, REAL v, REAL *retPoint)
Definition: insurfeval.cc:1653
void inComputeFirstPartials(REAL *p, REAL *pu, REAL *pv)
Definition: insurfeval.cc:501
void inEvalULine(int n_points, REAL v, REAL *u_vals, int stride, REAL ret_points[][3], REAL ret_normals[][3])
Definition: insurfeval.cc:1125
void inBPMListEval(bezierPatchMesh *list)
Definition: insurfeval.cc:238
void inPreEvaluateBU(int k, int uorder, int vorder, REAL uprime, REAL *baseData)
Definition: insurfeval.cc:838
REAL global_PBU[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
Definition: glsurfeval.h:250
REAL global_ucoeff[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:242
void beginCallBack(GLenum type, void *data)
Definition: glsurfeval.cc:1237
void inEvalUStrip(int n_upper, REAL v_upper, REAL *upper_val, int n_lower, REAL v_lower, REAL *lower_val)
Definition: insurfeval.cc:1166
void inDoDomain2WithDerivsEM(surfEvalMachine *em, REAL u, REAL v, REAL *retPoint, REAL *retdu, REAL *retdv)
Definition: insurfeval.cc:1600
surfEvalMachine em_vertex
Definition: glsurfeval.h:349
REAL global_PBV[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
Definition: glsurfeval.h:248
void colorCallBack(const GLfloat *color, void *data)
Definition: glsurfeval.cc:1274
void inPreEvaluateBV(int k, int uorder, int vorder, REAL vprime, REAL *baseData)
Definition: insurfeval.cc:809
void inPreEvaluateBU_intfac(REAL u)
Definition: glsurfeval.h:321
void inEvalVStrip(int n_left, REAL u_left, REAL *left_val, int n_right, REAL u_right, REAL *right_val)
Definition: insurfeval.cc:1355
void normalCallBack(const GLfloat *normal, void *data)
Definition: glsurfeval.cc:1265
void inPreEvaluate(int order, REAL vprime, REAL *coeff)
Definition: insurfeval.cc:1022
void inMap2f(int k, REAL ulower, REAL uupper, int ustride, int uorder, REAL vlower, REAL vupper, int vstride, int vorder, REAL *ctlPoints)
Definition: insurfeval.cc:444
void inMapGrid2f(int nu, REAL u0, REAL u1, int nv, REAL v0, REAL v1)
Definition: insurfeval.cc:389
REAL global_BV[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
Definition: glsurfeval.h:247
void inDoEvalCoord2NOGE_BV(REAL u, REAL v, REAL *retPoint, REAL *retNormal)
Definition: insurfeval.cc:684
void inEvalPoint2(int i, int j)
Definition: insurfeval.cc:362
void inMap2fEM(int which, int dimension, REAL ulower, REAL uupper, int ustride, int uorder, REAL vlower, REAL vupper, int vstride, int vorder, REAL *ctlPoints)
Definition: insurfeval.cc:1540
void inEvalVLine(int n_points, REAL u, REAL *v_vals, int stride, REAL ret_points[][3], REAL ret_normals[][3])
Definition: insurfeval.cc:1144
void inDoDomain2WithDerivsBU(int k, REAL u, REAL v, REAL u1, REAL u2, int uorder, REAL v1, REAL v2, int vorder, REAL *baseData, REAL *retPoint, REAL *retdu, REAL *retdv)
Definition: insurfeval.cc:868
void LOD_triangle(REAL A[2], REAL B[2], REAL C[2], int level)
void inPreEvaluateWithDeriv(int order, REAL vprime, REAL *coeff, REAL *coeffDeriv)
Definition: insurfeval.cc:1066
surfEvalMachine em_texcoord
Definition: glsurfeval.h:352
void inDoEvalCoord2(REAL u, REAL v, REAL *retPoint, REAL *retNormal)
Definition: insurfeval.cc:541
void inBPMEvalEM(bezierPatchMesh *bpm)
Definition: insurfeval.cc:1826
REAL global_vcoeff[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:243
void inEvalMesh2(int lowU, int lowV, int highU, int highV)
Definition: insurfeval.cc:400
REAL global_BU[IN_MAX_BEZIER_ORDER][IN_MAX_DIMENSION]
Definition: glsurfeval.h:249
Definition: list.h:37
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define NULL
Definition: types.h:112
float REAL
Definition: types.h:41
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
#define assert(x)
Definition: debug.h:53
POINTL point
Definition: edittest.c:50
#define printf
Definition: freeldr.h:97
GLAPI void GLAPIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
GLint level
Definition: gl.h:1546
float GLfloat
Definition: gl.h:161
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
#define GL_TRIANGLE_FAN
Definition: gl.h:196
const GLdouble * v
Definition: gl.h:2040
GLAPI void GLAPIENTRY glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLAPI void GLAPIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define GL_FILL
Definition: gl.h:267
GLAPI void GLAPIENTRY glBegin(GLenum mode)
GLAPI void GLAPIENTRY glVertex3fv(const GLfloat *v)
#define GL_MAP2_VERTEX_4
Definition: gl.h:568
#define GL_MAP2_VERTEX_3
Definition: gl.h:567
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLAPI void GLAPIENTRY glEnd(void)
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
#define GL_POLYGON
Definition: gl.h:199
int GLint
Definition: gl.h:156
#define GL_TRIANGLE_STRIP
Definition: gl.h:195
GLAPI void GLAPIENTRY glNormal3fv(const GLfloat *v)
#define GL_QUAD_STRIP
Definition: gl.h:198
GLdouble n
Definition: glext.h:7729
GLdouble GLdouble GLint ustride
Definition: glext.h:8308
GLsizei stride
Definition: glext.h:5848
GLfloat GLfloat nz
Definition: glext.h:8896
GLclampd zmax
Definition: glext.h:10123
GLfloat ny
Definition: glext.h:8896
GLdouble GLdouble GLint GLint uorder
Definition: glext.h:8308
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLfloat GLfloat GLfloat GLfloat nx
Definition: glext.h:8898
GLdouble GLdouble u2
Definition: glext.h:8308
GLfloat v0
Definition: glext.h:6061
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint vorder
Definition: glext.h:8308
GLfloat GLfloat p
Definition: glext.h:8902
GLuint GLdouble GLdouble GLint GLint order
Definition: glext.h:11194
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
GLfloat GLfloat v1
Definition: glext.h:6062
GLfloat GLfloat GLfloat v2
Definition: glext.h:6063
GLdouble u1
Definition: glext.h:8308
GLdouble GLdouble z
Definition: glext.h:5874
GLdouble GLdouble GLint GLint GLdouble GLdouble GLint vstride
Definition: glext.h:8308
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
#define stderr
Definition: stdio.h:100
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define myabs(x)
Definition: insurfeval.cc:54
#define MYZERO
Definition: insurfeval.cc:55
#define MYDELTA
Definition: insurfeval.cc:56
#define a
Definition: ke_i.h:78
#define b
Definition: ke_i.h:79
static const struct update_accum a1
Definition: msg.c:578
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
int k
Definition: mpi.c:3369
@ normal
Definition: optimize.h:166
static calc_node_t temp
Definition: rpn_ieee.c:38
bezierPatch * bpatch
bezierPatch * bpatch_color
bezierPatch * bpatch_texcoord
bezierPatch * bpatch_normal
float vmax
Definition: bezierPatch.h:37
float umin
Definition: bezierPatch.h:37
float vmin
Definition: bezierPatch.h:37
float * ctlpoints
Definition: bezierPatch.h:58
float umax
Definition: bezierPatch.h:37
REAL ucoeffDeriv[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:78
REAL ucoeff[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:76
REAL vcoeff[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:77
REAL vcoeffDeriv[IN_MAX_BEZIER_ORDER]
Definition: glsurfeval.h:79
REAL ctlPoints[IN_MAX_BEZIER_ORDER *IN_MAX_BEZIER_ORDER *IN_MAX_DIMENSION]
Definition: glsurfeval.h:75
Definition: mesh.c:4558
static GLenum which
Definition: wgl_font.c:159
_In_ ULONG_PTR _In_opt_ DESIGNVECTOR * pdv
Definition: winddi.h:3723