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:
10 ** http://oss.sgi.com/projects/FreeB
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.
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.
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.
42 #include "glimports.h"
43 #include "glrenderer.h"
44 #include "nurbsconsts.h"
46 //#define DOWN_LOAD_NURBS
47 #ifdef DOWN_LOAD_NURBS
49 #include "oglTrimNurbs.h"
50 static int surfcount
= 0;
51 static oglTrimNurbs
* otn
= NULL
;
52 nurbSurf
* tempNurb
= NULL
;
53 oglTrimLoops
* tempTrim
= NULL
;
58 extern "C" {void glu_LOD_eval_list(GLUnurbs
*nurb
, int level
);}
60 void glu_LOD_eval_list(GLUnurbs
*nurb
, int level
)
62 nurb
->LOD_eval_list(level
);
66 gluNewNurbsRenderer(void)
75 gluDeleteNurbsRenderer(GLUnurbs
*r
)
83 gluDeleteNurbsTessellatorEXT(GLUnurbsObj
*r
)
89 gluBeginSurface(GLUnurbs
*r
)
91 #ifdef DOWN_LOAD_NURBS
93 tempTrim
= OTL_make(10,10);
99 gluBeginCurve(GLUnurbs
*r
)
105 gluEndCurve(GLUnurbs
*r
)
111 gluEndSurface(GLUnurbs
*r
)
113 #ifdef DOWN_LOAD_NURBS
116 OTN_insert(otn
, tempNurb
, tempTrim
);
120 printf("write file\n");
122 OTN_write(otn
, "out.otn");
131 gluBeginTrim(GLUnurbs
*r
)
133 #ifdef DOWN_LOAD_NURBS
134 OTL_bgnTrim(tempTrim
);
141 gluEndTrim(GLUnurbs
*r
)
143 #ifdef DOWN_LOAD_NURBS
144 OTL_endTrim(tempTrim
);
150 gluPwlCurve(GLUnurbs
*r
, GLint count
, INREAL array
[],
151 GLint stride
, GLenum type
)
153 #ifdef DOWN_LOAD_NURBS
154 OTL_pwlCurve(tempTrim
, count
, array
, stride
, type
);
159 case GLU_MAP1_TRIM_2
:
162 case GLU_MAP1_TRIM_3
:
169 r
->pwlcurve(count
, array
, sizeof(INREAL
) * stride
, realType
);
173 gluNurbsCurve(GLUnurbs
*r
, GLint nknots
, INREAL knot
[], GLint stride
,
174 INREAL ctlarray
[], GLint order
, GLenum type
)
176 #ifdef DOWN_LOAD_NURBS
177 OTL_nurbsCurve(tempTrim
, nknots
, knot
, stride
, ctlarray
, order
, type
);
183 case GLU_MAP1_TRIM_2
:
186 case GLU_MAP1_TRIM_3
:
194 r
->nurbscurve(nknots
, knot
, sizeof(INREAL
) * stride
, ctlarray
, order
,
199 gluNurbsSurface(GLUnurbs
*r
, GLint sknot_count
, GLfloat
*sknot
,
200 GLint tknot_count
, GLfloat
*tknot
,
201 GLint s_stride
, GLint t_stride
,
202 GLfloat
*ctlarray
, GLint sorder
, GLint torder
,
205 #ifdef DOWN_LOAD_NURBS
209 case GL_MAP2_VERTEX_3
:
212 case GL_MAP2_VERTEX_4
:
216 fprintf(stderr
, "error in glinterface.c++, type no implemented\n");
219 tempNurb
= nurbSurfMake(sknot_count
, sknot
,
229 r
->nurbssurface(sknot_count
, sknot
, tknot_count
, tknot
,
230 sizeof(INREAL
) * s_stride
, sizeof(INREAL
) * t_stride
,
231 ctlarray
, sorder
, torder
, type
);
235 gluLoadSamplingMatrices(GLUnurbs
*r
, const GLfloat modelMatrix
[16],
236 const GLfloat projMatrix
[16],
237 const GLint viewport
[4])
239 r
->useGLMatrices(modelMatrix
, projMatrix
, viewport
);
243 gluNurbsProperty(GLUnurbs
*r
, GLenum property
, GLfloat value
)
248 case GLU_AUTO_LOAD_MATRIX
:
249 r
->setautoloadmode(value
);
254 nurbsValue
= N_CULLINGON
;
256 nurbsValue
= N_NOCULLING
;
258 r
->setnurbsproperty(GL_MAP2_VERTEX_3
, N_CULLING
, nurbsValue
);
259 r
->setnurbsproperty(GL_MAP2_VERTEX_4
, N_CULLING
, nurbsValue
);
260 r
->setnurbsproperty(GL_MAP1_VERTEX_3
, N_CULLING
, nurbsValue
);
261 r
->setnurbsproperty(GL_MAP1_VERTEX_4
, N_CULLING
, nurbsValue
);
264 case GLU_SAMPLING_METHOD
:
265 if (value
== GLU_PATH_LENGTH
) {
266 nurbsValue
= N_PATHLENGTH
;
267 } else if (value
== GLU_PARAMETRIC_ERROR
) {
268 nurbsValue
= N_PARAMETRICDISTANCE
;
269 } else if (value
== GLU_DOMAIN_DISTANCE
) {
270 nurbsValue
= N_DOMAINDISTANCE
;
271 r
->set_is_domain_distance_sampling(1); //optimzing untrimmed case
273 } else if (value
== GLU_OBJECT_PARAMETRIC_ERROR
) {
274 nurbsValue
= N_OBJECTSPACE_PARA
;
275 r
->setautoloadmode( 0.0 );
276 r
->setSamplingMatrixIdentity();
277 } else if (value
== GLU_OBJECT_PATH_LENGTH
) {
278 nurbsValue
= N_OBJECTSPACE_PATH
;
279 r
->setautoloadmode( 0.0 );
280 r
->setSamplingMatrixIdentity();
282 r
->postError(GLU_INVALID_VALUE
);
286 r
->setnurbsproperty(GL_MAP2_VERTEX_3
, N_SAMPLINGMETHOD
, nurbsValue
);
287 r
->setnurbsproperty(GL_MAP2_VERTEX_4
, N_SAMPLINGMETHOD
, nurbsValue
);
288 r
->setnurbsproperty(GL_MAP1_VERTEX_3
, N_SAMPLINGMETHOD
, nurbsValue
);
289 r
->setnurbsproperty(GL_MAP1_VERTEX_4
, N_SAMPLINGMETHOD
, nurbsValue
);
292 case GLU_SAMPLING_TOLERANCE
:
293 r
->setnurbsproperty(GL_MAP2_VERTEX_3
, N_PIXEL_TOLERANCE
, value
);
294 r
->setnurbsproperty(GL_MAP2_VERTEX_4
, N_PIXEL_TOLERANCE
, value
);
295 r
->setnurbsproperty(GL_MAP1_VERTEX_3
, N_PIXEL_TOLERANCE
, value
);
296 r
->setnurbsproperty(GL_MAP1_VERTEX_4
, N_PIXEL_TOLERANCE
, value
);
299 case GLU_PARAMETRIC_TOLERANCE
:
300 r
->setnurbsproperty(GL_MAP2_VERTEX_3
, N_ERROR_TOLERANCE
, value
);
301 r
->setnurbsproperty(GL_MAP2_VERTEX_4
, N_ERROR_TOLERANCE
, value
);
302 r
->setnurbsproperty(GL_MAP1_VERTEX_3
, N_ERROR_TOLERANCE
, value
);
303 r
->setnurbsproperty(GL_MAP1_VERTEX_4
, N_ERROR_TOLERANCE
, value
);
307 case GLU_DISPLAY_MODE
:
309 if (value
== GLU_FILL
) {
311 } else if (value
== GLU_OUTLINE_POLYGON
) {
312 nurbsValue
= N_OUTLINE_POLY
;
313 } else if (value
== GLU_OUTLINE_PATCH
) {
314 nurbsValue
= N_OUTLINE_PATCH
;
316 r
->postError(GLU_INVALID_VALUE
);
319 r
->setnurbsproperty(N_DISPLAY
, nurbsValue
);
324 r
->setnurbsproperty(GL_MAP1_VERTEX_3
, N_S_STEPS
, value
);
325 r
->setnurbsproperty(GL_MAP1_VERTEX_4
, N_S_STEPS
, value
);
326 r
->setnurbsproperty(GL_MAP2_VERTEX_3
, N_S_STEPS
, value
);
327 r
->setnurbsproperty(GL_MAP2_VERTEX_4
, N_S_STEPS
, value
);
329 //added for optimizing untrimmed case
330 r
->set_domain_distance_u_rate(value
);
334 r
->setnurbsproperty(GL_MAP1_VERTEX_3
, N_T_STEPS
, value
);
335 r
->setnurbsproperty(GL_MAP1_VERTEX_4
, N_T_STEPS
, value
);
336 r
->setnurbsproperty(GL_MAP2_VERTEX_3
, N_T_STEPS
, value
);
337 r
->setnurbsproperty(GL_MAP2_VERTEX_4
, N_T_STEPS
, value
);
339 //added for optimizing untrimmed case
340 r
->set_domain_distance_v_rate(value
);
344 if(value
== GLU_NURBS_RENDERER
)
345 r
->put_callbackFlag(0);
346 else if(value
== GLU_NURBS_TESSELLATOR
)
347 r
->put_callbackFlag(1);
349 r
->postError(GLU_INVALID_ENUM
);
353 r
->postError(GLU_INVALID_ENUM
);
359 gluGetNurbsProperty(GLUnurbs
*r
, GLenum property
, GLfloat
*value
)
364 case GLU_AUTO_LOAD_MATRIX
:
365 if (r
->getautoloadmode()) {
372 r
->getnurbsproperty(GL_MAP2_VERTEX_3
, N_CULLING
, &nurbsValue
);
373 if (nurbsValue
== N_CULLINGON
) {
379 case GLU_SAMPLING_METHOD
:
380 r
->getnurbsproperty(GL_MAP2_VERTEX_3
, N_SAMPLINGMETHOD
, value
);
381 if(*value
== N_PATHLENGTH
)
382 *value
= GLU_PATH_LENGTH
;
383 else if(*value
== N_PARAMETRICDISTANCE
)
384 *value
= GLU_PARAMETRIC_ERROR
;
385 else if(*value
== N_DOMAINDISTANCE
)
386 *value
= GLU_DOMAIN_DISTANCE
;
387 else if(*value
== N_OBJECTSPACE_PATH
)
388 *value
= GLU_OBJECT_PATH_LENGTH
;
389 else if(*value
== N_OBJECTSPACE_PARA
)
390 *value
= GLU_OBJECT_PARAMETRIC_ERROR
;
392 case GLU_SAMPLING_TOLERANCE
:
393 r
->getnurbsproperty(GL_MAP2_VERTEX_3
, N_PIXEL_TOLERANCE
, value
);
395 case GLU_PARAMETRIC_TOLERANCE
:
396 r
->getnurbsproperty(GL_MAP2_VERTEX_3
, N_ERROR_TOLERANCE
, value
);
400 r
->getnurbsproperty(GL_MAP2_VERTEX_3
, N_S_STEPS
, value
);
403 r
->getnurbsproperty(GL_MAP2_VERTEX_3
, N_T_STEPS
, value
);
405 case GLU_DISPLAY_MODE
:
406 r
->getnurbsproperty(N_DISPLAY
, &nurbsValue
);
407 if (nurbsValue
== N_FILL
) {
409 } else if (nurbsValue
== N_OUTLINE_POLY
) {
410 *value
= GLU_OUTLINE_POLYGON
;
412 *value
= GLU_OUTLINE_PATCH
;
418 *value
= GLU_NURBS_TESSELLATOR
;
420 *value
= GLU_NURBS_RENDERER
;
424 r
->postError(GLU_INVALID_ENUM
);
429 extern "C" void GLAPIENTRY
430 gluNurbsCallback(GLUnurbs
*r
, GLenum which
, _GLUfuncptr fn
)
433 case GLU_NURBS_BEGIN
:
435 case GLU_NURBS_VERTEX
:
436 case GLU_NURBS_NORMAL
:
437 case GLU_NURBS_TEXTURE_COORD
:
438 case GLU_NURBS_COLOR
:
439 case GLU_NURBS_BEGIN_DATA
:
440 case GLU_NURBS_END_DATA
:
441 case GLU_NURBS_VERTEX_DATA
:
442 case GLU_NURBS_NORMAL_DATA
:
443 case GLU_NURBS_TEXTURE_COORD_DATA
:
444 case GLU_NURBS_COLOR_DATA
:
445 r
->putSurfCallBack(which
, fn
);
448 case GLU_NURBS_ERROR
:
449 r
->errorCallback
= (void (APIENTRY
*)( GLenum e
)) fn
;
452 r
->postError(GLU_INVALID_ENUM
);
459 gluNurbsCallbackDataEXT(GLUnurbs
* r
, void* userData
)
461 r
->setNurbsCallbackData(userData
);
466 gluNurbsCallbackData(GLUnurbs
* r
, void* userData
)
468 gluNurbsCallbackDataEXT(r
,userData
);