FreeWRL / FreeX3D 4.3.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
42GLUnurbs::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
106void
107GLUnurbs::bgnrender(void)
108{
109 if (autoloadmode) {
110#ifdef HAVE_GL_H
111 loadGLMatrices();
112#endif
113 }
114}
115
116void
117GLUnurbs::endrender(void)
118{
119}
120
121void
122GLUnurbs::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
132void
133GLUnurbs::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
145void
146GLUnurbs::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
163void
164GLUnurbs::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
176void
177GLUnurbs::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
199void
200GLUnurbs::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
242void
243GLUnurbs::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 */
285void
286GLUnurbs::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 */
299void
300GLUnurbs::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}