FreeWRL/FreeX3D  3.0.0
glrenderer.cc
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 "glimports.h"
40 #include "glrenderer.h"
41 
42 GLUnurbs::GLUnurbs()
43  : NurbsTessellator(curveEvaluator, surfaceEvaluator)
44 {
45  redefineMaps();
46  defineMap(GL_MAP2_NORMAL, 0, 3);
47  defineMap(GL_MAP1_NORMAL, 0, 3);
48  defineMap(GL_MAP2_TEXTURE_COORD_1, 0, 1);
49  defineMap(GL_MAP1_TEXTURE_COORD_1, 0, 1);
50  defineMap(GL_MAP2_TEXTURE_COORD_2, 0, 2);
51  defineMap(GL_MAP1_TEXTURE_COORD_2, 0, 2);
52  defineMap(GL_MAP2_TEXTURE_COORD_3, 0, 3);
53  defineMap(GL_MAP1_TEXTURE_COORD_3, 0, 3);
54  defineMap(GL_MAP2_TEXTURE_COORD_4, 1, 4);
55  defineMap(GL_MAP1_TEXTURE_COORD_4, 1, 4);
56  defineMap(GL_MAP2_VERTEX_4, 1, 4);
57  defineMap(GL_MAP1_VERTEX_4, 1, 4);
58  defineMap(GL_MAP2_VERTEX_3, 0, 3);
59  defineMap(GL_MAP1_VERTEX_3, 0, 3);
60  defineMap(GL_MAP2_COLOR_4, 0, 4);
61  defineMap(GL_MAP1_COLOR_4, 0, 4);
62  defineMap(GL_MAP2_INDEX, 0, 1);
63  defineMap(GL_MAP1_INDEX, 0, 1);
64 
65  setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
66  setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
67  setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
68  setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, (float) N_PATHLENGTH);
69 
70  setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, (float) 50.0);
71  setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, (float) 50.0);
72  setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, (float) 50.0);
73  setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, (float) 50.0);
74 
75  setnurbsproperty(GL_MAP1_VERTEX_3, N_ERROR_TOLERANCE, (float) 0.50);
76  setnurbsproperty(GL_MAP1_VERTEX_4, N_ERROR_TOLERANCE, (float) 0.50);
77  setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, (float) 0.50);
78  setnurbsproperty(GL_MAP2_VERTEX_4, N_ERROR_TOLERANCE, (float) 0.50);
79 
80  setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, (float) 100.0);
81  setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, (float) 100.0);
82  setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, (float) 100.0);
83  setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, (float) 100.0);
84 
85  //added for optimizing untrimmed case
86  set_domain_distance_u_rate(100.0);
87 
88  setnurbsproperty(GL_MAP1_VERTEX_3, N_T_STEPS, (float) 100.0);
89  setnurbsproperty(GL_MAP1_VERTEX_4, N_T_STEPS, (float) 100.0);
90  setnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, (float) 100.0);
91  setnurbsproperty(GL_MAP2_VERTEX_4, N_T_STEPS, (float) 100.0);
92 
93  //added for optimizing untrimmed case
94  set_domain_distance_v_rate(100.0);
95  set_is_domain_distance_sampling(0); //since the default is path_length
96 
97  //default autoloadmode is true
98  autoloadmode = 1;
99 
100  //default callbackFlag is 0
101  callbackFlag = 0;
102 
103  errorCallback = NULL;
104 }
105 
106 void
107 GLUnurbs::bgnrender(void)
108 {
109  if (autoloadmode) {
110 #ifdef HAVE_GL_H
111  loadGLMatrices();
112 #endif
113  }
114 }
115 
116 void
117 GLUnurbs::endrender(void)
118 {
119 }
120 
121 void
122 GLUnurbs::errorHandler(int i)
123 {
124  int gluError;
125 
126  gluError = i + (GLU_NURBS_ERROR1 - 1);
127  postError( gluError );
128 }
129 
130 #ifdef HAVE_GL_H
131 
132 void
133 GLUnurbs::loadGLMatrices(void)
134 {
135  GLfloat vmat[4][4];
136  GLint viewport[4];
137 
138  grabGLMatrix((GLfloat (*)[4]) vmat);
139  loadCullingMatrix((GLfloat (*)[4]) vmat);
140  ::glGetIntegerv((GLenum) GL_VIEWPORT, (GLint *) viewport);
141  loadSamplingMatrix((const GLfloat (*)[4]) vmat, (const GLint *) viewport);
142 }
143 #endif
144 
145 void
146 GLUnurbs::useGLMatrices(const GLfloat modelMatrix[16],
147  const GLfloat projMatrix[16],
148  const GLint viewport[4])
149 {
150  GLfloat vmat[4][4];
151 
152  multmatrix4d(vmat, (const GLfloat (*)[4]) modelMatrix,
153  (const GLfloat (*)[4]) projMatrix);
154  loadCullingMatrix((GLfloat (*)[4]) vmat);
155  loadSamplingMatrix((const GLfloat (*)[4]) vmat, (const GLint *) viewport);
156 }
157 
158 /*--------------------------------------------------------------------------
159  * grabGLMatrix
160  *--------------------------------------------------------------------------
161  */
162  #ifdef HAVE_GL_H
163 void
164 GLUnurbs::grabGLMatrix(GLfloat vmat[4][4])
165 {
166  GLfloat m1[4][4], m2[4][4];
167 
168  ::glGetFloatv((GLenum) GL_MODELVIEW_MATRIX, (GLfloat *) &(m1[0][0]));
169  ::glGetFloatv((GLenum) GL_PROJECTION_MATRIX, (GLfloat *) &(m2[0][0]));
170  multmatrix4d((GLfloat (*)[4]) vmat,
171  (const GLfloat (*)[4]) m1, (const GLfloat (*)[4]) m2);
172 }
173 #endif
174 
175 //for object space tesselation: view independent
176 void
177 GLUnurbs::setSamplingMatrixIdentity( void )
178 {
179  INREAL smat[4][4] = {
180  {1,0,0,0},
181  {0,1,0,0},
182  {0,0,1,0},
183  {0,0,0,1}
184  };
185  const long rstride = sizeof(smat[0]) / sizeof(smat[0][0]);
186  const long cstride = 1;
187 
188  setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
189  cstride);
190  setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
191  cstride);
192  setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
193  cstride);
194  setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
195  cstride);
196 }
197 
198 
199 void
200 GLUnurbs::loadSamplingMatrix(const GLfloat vmat[4][4],
201  const GLint viewport[4])
202 {
203 
204  /* rescale the mapping to correspond to pixels in x/y */
205  REAL xsize = 0.5 * (REAL) (viewport[2]);
206  REAL ysize = 0.5 * (REAL) (viewport[3]);
207 
208  INREAL smat[4][4];
209  smat[0][0] = vmat[0][0] * xsize;
210  smat[1][0] = vmat[1][0] * xsize;
211  smat[2][0] = vmat[2][0] * xsize;
212  smat[3][0] = vmat[3][0] * xsize;
213 
214  smat[0][1] = vmat[0][1] * ysize;
215  smat[1][1] = vmat[1][1] * ysize;
216  smat[2][1] = vmat[2][1] * ysize;
217  smat[3][1] = vmat[3][1] * ysize;
218 
219  smat[0][2] = 0.0;
220  smat[1][2] = 0.0;
221  smat[2][2] = 0.0;
222  smat[3][2] = 0.0;
223 
224  smat[0][3] = vmat[0][3];
225  smat[1][3] = vmat[1][3];
226  smat[2][3] = vmat[2][3];
227  smat[3][3] = vmat[3][3];
228 
229  const long rstride = sizeof(smat[0]) / sizeof(smat[0][0]);
230  const long cstride = 1;
231 
232  setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
233  cstride);
234  setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
235  cstride);
236  setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMATRIX, &smat[0][0], rstride,
237  cstride);
238  setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMATRIX, &smat[0][0], rstride,
239  cstride);
240 }
241 
242 void
243 GLUnurbs::loadCullingMatrix(GLfloat vmat[4][4])
244 {
245  INREAL cmat[4][4];
246 
247  cmat[0][0] = vmat[0][0];
248  cmat[0][1] = vmat[0][1];
249  cmat[0][2] = vmat[0][2];
250  cmat[0][3] = vmat[0][3];
251 
252  cmat[1][0] = vmat[1][0];
253  cmat[1][1] = vmat[1][1];
254  cmat[1][2] = vmat[1][2];
255  cmat[1][3] = vmat[1][3];
256 
257  cmat[2][0] = vmat[2][0];
258  cmat[2][1] = vmat[2][1];
259  cmat[2][2] = vmat[2][2];
260  cmat[2][3] = vmat[2][3];
261 
262  cmat[3][0] = vmat[3][0];
263  cmat[3][1] = vmat[3][1];
264  cmat[3][2] = vmat[3][2];
265  cmat[3][3] = vmat[3][3];
266 
267  const long rstride = sizeof(cmat[0]) / sizeof(cmat[0][0]);
268  const long cstride = 1;
269 
270  setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLINGMATRIX, &cmat[0][0], rstride,
271  cstride);
272  setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLINGMATRIX, &cmat[0][0], rstride,
273  cstride);
274  //added for curves by zl
275  setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLINGMATRIX, &cmat[0][0], rstride,
276  cstride);
277  setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLINGMATRIX, &cmat[0][0], rstride,
278  cstride);
279 }
280 
281 /*---------------------------------------------------------------------
282  * A = B * MAT ; transform a 4d vector through a 4x4 matrix
283  *---------------------------------------------------------------------
284  */
285 void
286 GLUnurbs::transform4d(GLfloat A[4], GLfloat B[4], GLfloat mat[4][4])
287 {
288 
289  A[0] = B[0]*mat[0][0] + B[1]*mat[1][0] + B[2]*mat[2][0] + B[3]*mat[3][0];
290  A[1] = B[0]*mat[0][1] + B[1]*mat[1][1] + B[2]*mat[2][1] + B[3]*mat[3][1];
291  A[2] = B[0]*mat[0][2] + B[1]*mat[1][2] + B[2]*mat[2][2] + B[3]*mat[3][2];
292  A[3] = B[0]*mat[0][3] + B[1]*mat[1][3] + B[2]*mat[2][3] + B[3]*mat[3][3];
293 }
294 
295 /*---------------------------------------------------------------------
296  * new = [left][right] ; multiply two matrices together
297  *---------------------------------------------------------------------
298  */
299 void
300 GLUnurbs::multmatrix4d (GLfloat n[4][4], const GLfloat left[4][4],
301  const GLfloat right[4][4])
302 {
303  transform4d ((GLfloat *) n[0],(GLfloat *) left[0],(GLfloat (*)[4]) right);
304  transform4d ((GLfloat *) n[1],(GLfloat *) left[1],(GLfloat (*)[4]) right);
305  transform4d ((GLfloat *) n[2],(GLfloat *) left[2],(GLfloat (*)[4]) right);
306  transform4d ((GLfloat *) n[3],(GLfloat *) left[3],(GLfloat (*)[4]) right);
307 }