ReactOS Development > Doxygen

00001 /*
00002 ** License Applicability. Except to the extent portions of this file are
00003 ** made subject to an alternative license as permitted in the SGI Free
00004 ** Software License B, Version 1.1 (the "License"), the contents of this
00005 ** file are subject only to the provisions of the License. You may not use
00006 ** this file except in compliance with the License. You may obtain a copy
00007 ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
00008 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
00009 ** 
00010 ** http://oss.sgi.com/projects/FreeB
00011 ** 
00012 ** Note that, as provided in the License, the Software is distributed on an
00013 ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
00014 ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
00015 ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
00016 ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
00017 ** 
00018 ** Original Code. The Original Code is: OpenGL Sample Implementation,
00019 ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
00020 ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
00021 ** Copyright in any portions created by third parties is as indicated
00022 ** elsewhere herein. All Rights Reserved.
00023 ** 
00024 ** Additional Notice Provisions: The application programming interfaces
00025 ** established by SGI in conjunction with the Original Code are The
00026 ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
00027 ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
00028 ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
00029 ** Window System(R) (Version 1.3), released October 19, 1998. This software
00030 ** was created using the OpenGL(R) version 1.2.1 Sample Implementation
00031 ** published by SGI, but has not been independently verified as being
00032 ** compliant with the OpenGL(R) version 1.2.1 Specification.
00033 **
00034 ** $Date: 2006-03-12 00:07:02 +0000 (Sun, 12 Mar 2006) $ $Revision: 1.1 $
00035 */
00036 /*
00037 ** $Header: /cygdrive/c/RCVS/CVS/ReactOS/reactos/lib/glu32/libnurbs/interface/glinterface.cc,v 1.1 2004/02/02 16:39:08 navaraf Exp $
00038 */
00039 
00040 #include "gluos.h"
00041 #include <GL/gl.h>
00042 #include <GL/glu.h>
00043 #include <stdio.h>
00044 #include "glimports.h"
00045 #include "glrenderer.h"
00046 #include "nurbsconsts.h"
00047 
00048 //#define DOWN_LOAD_NURBS
00049 #ifdef DOWN_LOAD_NURBS
00050 
00051 #include "oglTrimNurbs.h"
00052 static int surfcount = 0;
00053 static oglTrimNurbs* otn = NULL;
00054 nurbSurf* tempNurb = NULL;
00055 oglTrimLoops* tempTrim = NULL;
00056 #endif
00057 
00058 
00059 //for LOD
00060 extern "C" {void glu_LOD_eval_list(GLUnurbs *nurb, int level);}
00061 
00062 void glu_LOD_eval_list(GLUnurbs *nurb, int level)
00063 {
00064     nurb->LOD_eval_list(level);
00065 }
00066 
00067 GLUnurbs * GLAPIENTRY
00068 gluNewNurbsRenderer(void)
00069 {
00070   GLUnurbs *t;
00071   
00072   t = new GLUnurbs();
00073   return t;
00074 }
00075 
00076 void GLAPIENTRY
00077 gluDeleteNurbsRenderer(GLUnurbs *r)
00078 {
00079     delete r;
00080 }
00081 
00082 extern "C"
00083 void GLAPIENTRY
00084 
00085 gluDeleteNurbsTessellatorEXT(GLUnurbsObj *r)
00086 {
00087   delete r;
00088 }
00089 
00090 void GLAPIENTRY
00091 gluBeginSurface(GLUnurbs *r)
00092 {
00093 #ifdef DOWN_LOAD_NURBS
00094 surfcount++;
00095 tempTrim = OTL_make(10,10);
00096 #endif
00097     r->bgnsurface(0); 
00098 }
00099 
00100 void GLAPIENTRY
00101 gluBeginCurve(GLUnurbs *r)
00102 {
00103     r->bgncurve(0); 
00104 }
00105 
00106 void GLAPIENTRY
00107 gluEndCurve(GLUnurbs *r)
00108 {
00109     r->endcurve(); 
00110 }
00111 
00112 void GLAPIENTRY
00113 gluEndSurface(GLUnurbs *r)
00114 {
00115 #ifdef DOWN_LOAD_NURBS
00116 if(surfcount == 1)
00117   otn = OTN_make(1);
00118 OTN_insert(otn, tempNurb, tempTrim);
00119 if(surfcount  >= 1)
00120 {
00121 #ifdef DEBUG
00122 printf("write file\n");
00123 #endif
00124 OTN_write(otn, "out.otn");
00125 
00126 }
00127 #endif
00128 
00129     r->endsurface(); 
00130 }
00131 
00132 void GLAPIENTRY
00133 gluBeginTrim(GLUnurbs *r)
00134 {
00135 #ifdef DOWN_LOAD_NURBS
00136 OTL_bgnTrim(tempTrim);
00137 #endif
00138 
00139     r->bgntrim(); 
00140 }
00141 
00142 void GLAPIENTRY
00143 gluEndTrim(GLUnurbs *r)
00144 {
00145 #ifdef DOWN_LOAD_NURBS
00146 OTL_endTrim(tempTrim);
00147 #endif
00148     r->endtrim(); 
00149 }
00150 
00151 void GLAPIENTRY
00152 gluPwlCurve(GLUnurbs *r, GLint count, INREAL array[], 
00153         GLint stride, GLenum type)
00154 {
00155 #ifdef DOWN_LOAD_NURBS
00156 OTL_pwlCurve(tempTrim, count, array, stride, type);
00157 #endif
00158 
00159     int realType;
00160     switch(type) {
00161       case GLU_MAP1_TRIM_2:
00162     realType = N_P2D;
00163     break;
00164       case GLU_MAP1_TRIM_3:
00165     realType = N_P2DR;
00166     break;
00167       default:
00168     realType = type;
00169     break;
00170     }
00171     r->pwlcurve(count, array, sizeof(INREAL) * stride, realType);
00172 }
00173 
00174 void GLAPIENTRY
00175 gluNurbsCurve(GLUnurbs *r, GLint nknots, INREAL knot[], GLint stride, 
00176           INREAL ctlarray[], GLint order, GLenum type)
00177 {
00178 #ifdef DOWN_LOAD_NURBS
00179 OTL_nurbsCurve(tempTrim, nknots, knot, stride, ctlarray, order, type);
00180 #endif
00181 
00182     int realType;
00183 
00184     switch(type) {
00185       case GLU_MAP1_TRIM_2:
00186     realType = N_P2D;
00187     break;
00188       case GLU_MAP1_TRIM_3:
00189     realType = N_P2DR;
00190     break;
00191       default:
00192     realType = type;
00193     break;
00194     }
00195 
00196     r->nurbscurve(nknots, knot, sizeof(INREAL) * stride, ctlarray, order, 
00197         realType);
00198 }
00199 
00200 void GLAPIENTRY
00201 gluNurbsSurface(GLUnurbs *r, GLint sknot_count, GLfloat *sknot, 
00202                 GLint tknot_count, GLfloat *tknot, 
00203                 GLint s_stride, GLint t_stride, 
00204                 GLfloat *ctlarray, GLint sorder, GLint torder, 
00205                 GLenum type)
00206 {
00207 #ifdef DOWN_LOAD_NURBS
00208   {
00209     int dimension;
00210     switch(type){
00211     case GL_MAP2_VERTEX_3:
00212       dimension = 3;
00213       break;
00214     case GL_MAP2_VERTEX_4:
00215       dimension = 4;
00216       break;
00217     default:
00218       fprintf(stderr, "error in glinterface.c++, type no implemented\n");
00219       exit(1);
00220     }
00221 tempNurb = nurbSurfMake(sknot_count, sknot,
00222             tknot_count, tknot,
00223             sorder, torder,
00224             dimension,
00225             ctlarray,
00226             s_stride, t_stride);
00227             
00228   }
00229 #endif
00230 
00231     r->nurbssurface(sknot_count, sknot, tknot_count, tknot, 
00232         sizeof(INREAL) * s_stride, sizeof(INREAL) * t_stride, 
00233         ctlarray, sorder, torder, type);
00234 }
00235 
00236 void GLAPIENTRY
00237 gluLoadSamplingMatrices(GLUnurbs *r, const GLfloat modelMatrix[16],
00238                 const GLfloat projMatrix[16], 
00239                 const GLint viewport[4])
00240 {
00241     r->useGLMatrices(modelMatrix, projMatrix, viewport);
00242 }
00243 
00244 void GLAPIENTRY
00245 gluNurbsProperty(GLUnurbs *r, GLenum property, GLfloat value)
00246 {
00247     GLfloat nurbsValue;
00248     
00249     switch (property) {
00250       case GLU_AUTO_LOAD_MATRIX:      
00251         r->setautoloadmode(value);
00252     return;
00253 
00254       case GLU_CULLING:
00255     if (value != 0.0) {
00256         nurbsValue = N_CULLINGON;
00257     } else {
00258         nurbsValue = N_NOCULLING;
00259     }
00260     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, nurbsValue);
00261     r->setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLING, nurbsValue);
00262     r->setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLING, nurbsValue);
00263     r->setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLING, nurbsValue);
00264         return;
00265 
00266       case GLU_SAMPLING_METHOD:
00267     if (value == GLU_PATH_LENGTH) {
00268         nurbsValue = N_PATHLENGTH;
00269     } else if (value == GLU_PARAMETRIC_ERROR) {
00270         nurbsValue = N_PARAMETRICDISTANCE;
00271     } else if (value == GLU_DOMAIN_DISTANCE) {
00272         nurbsValue = N_DOMAINDISTANCE;
00273             r->set_is_domain_distance_sampling(1); //optimzing untrimmed case
00274 
00275     } else if (value == GLU_OBJECT_PARAMETRIC_ERROR) {
00276         nurbsValue = N_OBJECTSPACE_PARA;
00277         r->setautoloadmode( 0.0 ); 
00278         r->setSamplingMatrixIdentity();
00279     } else if (value == GLU_OBJECT_PATH_LENGTH) {
00280         nurbsValue = N_OBJECTSPACE_PATH;
00281         r->setautoloadmode( 0.0 ); 
00282         r->setSamplingMatrixIdentity();
00283     } else {
00284             r->postError(GLU_INVALID_VALUE);
00285             return;
00286         }
00287 
00288     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
00289     r->setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
00290     r->setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
00291     r->setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
00292     return;
00293 
00294       case GLU_SAMPLING_TOLERANCE:
00295     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
00296     r->setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, value);
00297     r->setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, value);
00298     r->setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, value);
00299     return;
00300 
00301       case GLU_PARAMETRIC_TOLERANCE:
00302     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
00303         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_ERROR_TOLERANCE, value);
00304         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_ERROR_TOLERANCE, value);
00305         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_ERROR_TOLERANCE, value);
00306         return;
00307     
00308 
00309       case GLU_DISPLAY_MODE:
00310     
00311     if (value == GLU_FILL) {
00312       nurbsValue = N_FILL;
00313     } else if (value == GLU_OUTLINE_POLYGON) {
00314       nurbsValue = N_OUTLINE_POLY;
00315     } else if (value == GLU_OUTLINE_PATCH) {
00316       nurbsValue = N_OUTLINE_PATCH;
00317     } else {
00318       r->postError(GLU_INVALID_VALUE);
00319       return;
00320     }
00321     r->setnurbsproperty(N_DISPLAY, nurbsValue);
00322     
00323     break;
00324 
00325       case GLU_U_STEP:
00326         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, value);
00327         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, value);
00328         r->setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
00329         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, value);
00330     
00331     //added for optimizing untrimmed case
00332         r->set_domain_distance_u_rate(value);
00333     break;
00334 
00335       case GLU_V_STEP:
00336         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_T_STEPS, value);
00337         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_T_STEPS, value);
00338         r->setnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value);
00339         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_T_STEPS, value);
00340 
00341     //added for optimizing untrimmed case
00342         r->set_domain_distance_v_rate(value);
00343     break;
00344     
00345       case GLU_NURBS_MODE:
00346     if(value == GLU_NURBS_RENDERER)
00347       r->put_callbackFlag(0);
00348     else if(value == GLU_NURBS_TESSELLATOR)
00349       r->put_callbackFlag(1);
00350     else
00351       r->postError(GLU_INVALID_ENUM);
00352     break;
00353 
00354       default:
00355     r->postError(GLU_INVALID_ENUM);
00356     return; 
00357     }
00358 }
00359 
00360 void GLAPIENTRY
00361 gluGetNurbsProperty(GLUnurbs *r, GLenum property, GLfloat *value)
00362 {
00363     GLfloat nurbsValue;
00364 
00365     switch(property) {
00366       case GLU_AUTO_LOAD_MATRIX:
00367     if (r->getautoloadmode()) {
00368         *value = GL_TRUE;
00369     } else {
00370         *value = GL_FALSE;
00371     }
00372     break;
00373       case GLU_CULLING:
00374     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, &nurbsValue);
00375     if (nurbsValue == N_CULLINGON) {
00376         *value = GL_TRUE;
00377     } else {
00378         *value = GL_FALSE;
00379     }
00380     break;
00381       case GLU_SAMPLING_METHOD:
00382     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, value);
00383     if(*value == N_PATHLENGTH)
00384       *value = GLU_PATH_LENGTH;
00385     else if(*value == N_PARAMETRICDISTANCE)
00386       *value = GLU_PARAMETRIC_ERROR;
00387     else if(*value == N_DOMAINDISTANCE)
00388       *value = GLU_DOMAIN_DISTANCE;
00389     else if(*value == N_OBJECTSPACE_PATH)
00390       *value = GLU_OBJECT_PATH_LENGTH;
00391     else if(*value == N_OBJECTSPACE_PARA)
00392       *value = GLU_OBJECT_PARAMETRIC_ERROR; 
00393     break;
00394       case GLU_SAMPLING_TOLERANCE:
00395     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
00396     break;
00397       case GLU_PARAMETRIC_TOLERANCE:
00398     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
00399         break;
00400 
00401       case GLU_U_STEP:
00402         r->getnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
00403     break;
00404       case GLU_V_STEP:
00405         r->getnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value);
00406     break;
00407       case GLU_DISPLAY_MODE:
00408     r->getnurbsproperty(N_DISPLAY, &nurbsValue);
00409     if (nurbsValue == N_FILL) {
00410         *value = GLU_FILL;
00411     } else if (nurbsValue == N_OUTLINE_POLY) {
00412         *value = GLU_OUTLINE_POLYGON;
00413     } else {
00414         *value = GLU_OUTLINE_PATCH;
00415     }
00416     break;
00417 
00418       case GLU_NURBS_MODE:
00419     if(r->is_callback())
00420       *value = GLU_NURBS_TESSELLATOR;
00421     else
00422       *value = GLU_NURBS_RENDERER;
00423     break;
00424     
00425       default:
00426     r->postError(GLU_INVALID_ENUM);
00427     return;
00428     }
00429 }
00430 
00431 extern "C" void GLAPIENTRY
00432 gluNurbsCallback(GLUnurbs *r, GLenum which, _GLUfuncptr fn )
00433 {
00434     switch (which) {
00435     case GLU_NURBS_BEGIN:
00436     case GLU_NURBS_END:
00437     case GLU_NURBS_VERTEX:
00438     case GLU_NURBS_NORMAL:
00439     case GLU_NURBS_TEXTURE_COORD:
00440     case GLU_NURBS_COLOR:
00441     case GLU_NURBS_BEGIN_DATA:
00442     case GLU_NURBS_END_DATA:
00443     case GLU_NURBS_VERTEX_DATA:
00444     case GLU_NURBS_NORMAL_DATA:
00445     case GLU_NURBS_TEXTURE_COORD_DATA:
00446     case GLU_NURBS_COLOR_DATA: 
00447     r->putSurfCallBack(which, fn);
00448     break;
00449 
00450     case GLU_NURBS_ERROR:
00451     r->errorCallback = (void (APIENTRY *)( GLenum e )) fn;
00452     break;
00453     default:
00454     r->postError(GLU_INVALID_ENUM);
00455     return;
00456     }
00457 }
00458 
00459 extern "C"
00460 void GLAPIENTRY
00461 gluNurbsCallbackDataEXT(GLUnurbs* r, void* userData)
00462 {
00463   r->setNurbsCallbackData(userData);
00464 }
00465 
00466 extern "C"
00467 void GLAPIENTRY
00468 gluNurbsCallbackData(GLUnurbs* r, void* userData)
00469 {
00470   gluNurbsCallbackDataEXT(r,userData);
00471 }
Generated on Fri May 25 2012 04:21:45 for ReactOS by
1.7.6.1