#include <GL/gl.h>

Include dependency graph for glu.h:

Macros
#define	GLAPIENTRY

#define	GLAPIENTRYP GLAPIENTRY *

#define	GLAPI extern

#define	GLU_EXT_object_space_tess 1

#define	GLU_EXT_nurbs_tessellator 1

#define	GLU_FALSE 0

#define	GLU_TRUE 1

#define	GLU_VERSION_1_1 1

#define	GLU_VERSION_1_2 1

#define	GLU_VERSION_1_3 1

#define	GLU_VERSION 100800

#define	GLU_EXTENSIONS 100801

#define	GLU_INVALID_ENUM 100900

#define	GLU_INVALID_VALUE 100901

#define	GLU_OUT_OF_MEMORY 100902

#define	GLU_INCOMPATIBLE_GL_VERSION 100903

#define	GLU_INVALID_OPERATION 100904

#define	GLU_OUTLINE_POLYGON 100240

#define	GLU_OUTLINE_PATCH 100241

#define	GLU_NURBS_ERROR 100103

#define	GLU_ERROR 100103

#define	GLU_NURBS_BEGIN 100164

#define	GLU_NURBS_BEGIN_EXT 100164

#define	GLU_NURBS_VERTEX 100165

#define	GLU_NURBS_VERTEX_EXT 100165

#define	GLU_NURBS_NORMAL 100166

#define	GLU_NURBS_NORMAL_EXT 100166

#define	GLU_NURBS_COLOR 100167

#define	GLU_NURBS_COLOR_EXT 100167

#define	GLU_NURBS_TEXTURE_COORD 100168

#define	GLU_NURBS_TEX_COORD_EXT 100168

#define	GLU_NURBS_END 100169

#define	GLU_NURBS_END_EXT 100169

#define	GLU_NURBS_BEGIN_DATA 100170

#define	GLU_NURBS_BEGIN_DATA_EXT 100170

#define	GLU_NURBS_VERTEX_DATA 100171

#define	GLU_NURBS_VERTEX_DATA_EXT 100171

#define	GLU_NURBS_NORMAL_DATA 100172

#define	GLU_NURBS_NORMAL_DATA_EXT 100172

#define	GLU_NURBS_COLOR_DATA 100173

#define	GLU_NURBS_COLOR_DATA_EXT 100173

#define	GLU_NURBS_TEXTURE_COORD_DATA 100174

#define	GLU_NURBS_TEX_COORD_DATA_EXT 100174

#define	GLU_NURBS_END_DATA 100175

#define	GLU_NURBS_END_DATA_EXT 100175

#define	GLU_NURBS_ERROR1 100251

#define	GLU_NURBS_ERROR2 100252

#define	GLU_NURBS_ERROR3 100253

#define	GLU_NURBS_ERROR4 100254

#define	GLU_NURBS_ERROR5 100255

#define	GLU_NURBS_ERROR6 100256

#define	GLU_NURBS_ERROR7 100257

#define	GLU_NURBS_ERROR8 100258

#define	GLU_NURBS_ERROR9 100259

#define	GLU_NURBS_ERROR10 100260

#define	GLU_NURBS_ERROR11 100261

#define	GLU_NURBS_ERROR12 100262

#define	GLU_NURBS_ERROR13 100263

#define	GLU_NURBS_ERROR14 100264

#define	GLU_NURBS_ERROR15 100265

#define	GLU_NURBS_ERROR16 100266

#define	GLU_NURBS_ERROR17 100267

#define	GLU_NURBS_ERROR18 100268

#define	GLU_NURBS_ERROR19 100269

#define	GLU_NURBS_ERROR20 100270

#define	GLU_NURBS_ERROR21 100271

#define	GLU_NURBS_ERROR22 100272

#define	GLU_NURBS_ERROR23 100273

#define	GLU_NURBS_ERROR24 100274

#define	GLU_NURBS_ERROR25 100275

#define	GLU_NURBS_ERROR26 100276

#define	GLU_NURBS_ERROR27 100277

#define	GLU_NURBS_ERROR28 100278

#define	GLU_NURBS_ERROR29 100279

#define	GLU_NURBS_ERROR30 100280

#define	GLU_NURBS_ERROR31 100281

#define	GLU_NURBS_ERROR32 100282

#define	GLU_NURBS_ERROR33 100283

#define	GLU_NURBS_ERROR34 100284

#define	GLU_NURBS_ERROR35 100285

#define	GLU_NURBS_ERROR36 100286

#define	GLU_NURBS_ERROR37 100287

#define	GLU_AUTO_LOAD_MATRIX 100200

#define	GLU_CULLING 100201

#define	GLU_SAMPLING_TOLERANCE 100203

#define	GLU_DISPLAY_MODE 100204

#define	GLU_PARAMETRIC_TOLERANCE 100202

#define	GLU_SAMPLING_METHOD 100205

#define	GLU_U_STEP 100206

#define	GLU_V_STEP 100207

#define	GLU_NURBS_MODE 100160

#define	GLU_NURBS_MODE_EXT 100160

#define	GLU_NURBS_TESSELLATOR 100161

#define	GLU_NURBS_TESSELLATOR_EXT 100161

#define	GLU_NURBS_RENDERER 100162

#define	GLU_NURBS_RENDERER_EXT 100162

#define	GLU_OBJECT_PARAMETRIC_ERROR 100208

#define	GLU_OBJECT_PARAMETRIC_ERROR_EXT 100208

#define	GLU_OBJECT_PATH_LENGTH 100209

#define	GLU_OBJECT_PATH_LENGTH_EXT 100209

#define	GLU_PATH_LENGTH 100215

#define	GLU_PARAMETRIC_ERROR 100216

#define	GLU_DOMAIN_DISTANCE 100217

#define	GLU_MAP1_TRIM_2 100210

#define	GLU_MAP1_TRIM_3 100211

#define	GLU_POINT 100010

#define	GLU_LINE 100011

#define	GLU_FILL 100012

#define	GLU_SILHOUETTE 100013

#define	GLU_SMOOTH 100000

#define	GLU_FLAT 100001

#define	GLU_NONE 100002

#define	GLU_OUTSIDE 100020

#define	GLU_INSIDE 100021

#define	GLU_TESS_BEGIN 100100

#define	GLU_BEGIN 100100

#define	GLU_TESS_VERTEX 100101

#define	GLU_VERTEX 100101

#define	GLU_TESS_END 100102

#define	GLU_END 100102

#define	GLU_TESS_ERROR 100103

#define	GLU_TESS_EDGE_FLAG 100104

#define	GLU_EDGE_FLAG 100104

#define	GLU_TESS_COMBINE 100105

#define	GLU_TESS_BEGIN_DATA 100106

#define	GLU_TESS_VERTEX_DATA 100107

#define	GLU_TESS_END_DATA 100108

#define	GLU_TESS_ERROR_DATA 100109

#define	GLU_TESS_EDGE_FLAG_DATA 100110

#define	GLU_TESS_COMBINE_DATA 100111

#define	GLU_CW 100120

#define	GLU_CCW 100121

#define	GLU_INTERIOR 100122

#define	GLU_EXTERIOR 100123

#define	GLU_UNKNOWN 100124

#define	GLU_TESS_WINDING_RULE 100140

#define	GLU_TESS_BOUNDARY_ONLY 100141

#define	GLU_TESS_TOLERANCE 100142

#define	GLU_TESS_ERROR1 100151

#define	GLU_TESS_ERROR2 100152

#define	GLU_TESS_ERROR3 100153

#define	GLU_TESS_ERROR4 100154

#define	GLU_TESS_ERROR5 100155

#define	GLU_TESS_ERROR6 100156

#define	GLU_TESS_ERROR7 100157

#define	GLU_TESS_ERROR8 100158

#define	GLU_TESS_MISSING_BEGIN_POLYGON 100151

#define	GLU_TESS_MISSING_BEGIN_CONTOUR 100152

#define	GLU_TESS_MISSING_END_POLYGON 100153

#define	GLU_TESS_MISSING_END_CONTOUR 100154

#define	GLU_TESS_COORD_TOO_LARGE 100155

#define	GLU_TESS_NEED_COMBINE_CALLBACK 100156

#define	GLU_TESS_WINDING_ODD 100130

#define	GLU_TESS_WINDING_NONZERO 100131

#define	GLU_TESS_WINDING_POSITIVE 100132

#define	GLU_TESS_WINDING_NEGATIVE 100133

#define	GLU_TESS_WINDING_ABS_GEQ_TWO 100134

#define	GLU_TESS_MAX_COORD 1.0e150

Typedefs
typedef struct GLUnurbs	GLUnurbs

typedef struct GLUquadric	GLUquadric

typedef struct GLUtesselator	GLUtesselator

typedef GLUnurbs	GLUnurbsObj

typedef GLUquadric	GLUquadricObj

typedef GLUtesselator	GLUtesselatorObj

typedef GLUtesselator	GLUtriangulatorObj

Functions
typedef	void (GLAPIENTRYP _GLUfuncptr)(void)

GLAPI void GLAPIENTRY	gluBeginCurve (GLUnurbs *nurb)

GLAPI void GLAPIENTRY	gluBeginPolygon (GLUtesselator *tess)

GLAPI void GLAPIENTRY	gluBeginSurface (GLUnurbs *nurb)

GLAPI void GLAPIENTRY	gluBeginTrim (GLUnurbs *nurb)

GLAPI GLint GLAPIENTRY	gluBuild1DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data)

GLAPI GLint GLAPIENTRY	gluBuild1DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void *data)

GLAPI GLint GLAPIENTRY	gluBuild2DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data)

GLAPI GLint GLAPIENTRY	gluBuild2DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *data)

GLAPI GLint GLAPIENTRY	gluBuild3DMipmapLevels (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void *data)

GLAPI GLint GLAPIENTRY	gluBuild3DMipmaps (GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)

GLAPI GLboolean GLAPIENTRY	gluCheckExtension (const GLubyte extName, const GLubyte extString)

GLAPI void GLAPIENTRY	gluCylinder (GLUquadric *quad, GLdouble base, GLdouble top, GLdouble height, GLint slices, GLint stacks)

GLAPI void GLAPIENTRY	gluDeleteNurbsRenderer (GLUnurbs *nurb)

GLAPI void GLAPIENTRY	gluDeleteQuadric (GLUquadric *quad)

GLAPI void GLAPIENTRY	gluDeleteTess (GLUtesselator *tess)

GLAPI void GLAPIENTRY	gluDisk (GLUquadric *quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops)

GLAPI void GLAPIENTRY	gluEndCurve (GLUnurbs *nurb)

GLAPI void GLAPIENTRY	gluEndPolygon (GLUtesselator *tess)

GLAPI void GLAPIENTRY	gluEndSurface (GLUnurbs *nurb)

GLAPI void GLAPIENTRY	gluEndTrim (GLUnurbs *nurb)

GLAPI const GLubyte *GLAPIENTRY	gluErrorString (GLenum error)

GLAPI void GLAPIENTRY	gluGetNurbsProperty (GLUnurbs nurb, GLenum property, GLfloat data)

GLAPI const GLubyte *GLAPIENTRY	gluGetString (GLenum name)

GLAPI void GLAPIENTRY	gluGetTessProperty (GLUtesselator tess, GLenum which, GLdouble data)

GLAPI void GLAPIENTRY	gluLoadSamplingMatrices (GLUnurbs nurb, const GLfloat model, const GLfloat perspective, const GLint view)

GLAPI void GLAPIENTRY	gluLookAt (GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ)

GLAPI GLUnurbs *GLAPIENTRY	gluNewNurbsRenderer (void)

GLAPI GLUquadric *GLAPIENTRY	gluNewQuadric (void)

GLAPI GLUtesselator *GLAPIENTRY	gluNewTess (void)

GLAPI void GLAPIENTRY	gluNextContour (GLUtesselator *tess, GLenum type)

GLAPI void GLAPIENTRY	gluNurbsCallback (GLUnurbs *nurb, GLenum which, _GLUfuncptr CallBackFunc)

GLAPI void GLAPIENTRY	gluNurbsCallbackData (GLUnurbs nurb, GLvoid userData)

GLAPI void GLAPIENTRY	gluNurbsCallbackDataEXT (GLUnurbs nurb, GLvoid userData)

GLAPI void GLAPIENTRY	gluNurbsCurve (GLUnurbs nurb, GLint knotCount, GLfloat knots, GLint stride, GLfloat *control, GLint order, GLenum type)

GLAPI void GLAPIENTRY	gluNurbsProperty (GLUnurbs *nurb, GLenum property, GLfloat value)

GLAPI void GLAPIENTRY	gluNurbsSurface (GLUnurbs nurb, GLint sKnotCount, GLfloat sKnots, GLint tKnotCount, GLfloat tKnots, GLint sStride, GLint tStride, GLfloat control, GLint sOrder, GLint tOrder, GLenum type)

GLAPI void GLAPIENTRY	gluOrtho2D (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)

GLAPI void GLAPIENTRY	gluPartialDisk (GLUquadric *quad, GLdouble inner, GLdouble outer, GLint slices, GLint loops, GLdouble start, GLdouble sweep)

GLAPI void GLAPIENTRY	gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)

GLAPI void GLAPIENTRY	gluPickMatrix (GLdouble x, GLdouble y, GLdouble delX, GLdouble delY, GLint *viewport)

GLAPI GLint GLAPIENTRY	gluProject (GLdouble objX, GLdouble objY, GLdouble objZ, const GLdouble model, const GLdouble proj, const GLint view, GLdouble winX, GLdouble winY, GLdouble winZ)

GLAPI void GLAPIENTRY	gluPwlCurve (GLUnurbs nurb, GLint count, GLfloat data, GLint stride, GLenum type)

GLAPI void GLAPIENTRY	gluQuadricCallback (GLUquadric *quad, GLenum which, _GLUfuncptr CallBackFunc)

GLAPI void GLAPIENTRY	gluQuadricDrawStyle (GLUquadric *quad, GLenum draw)

GLAPI void GLAPIENTRY	gluQuadricNormals (GLUquadric *quad, GLenum normal)

GLAPI void GLAPIENTRY	gluQuadricOrientation (GLUquadric *quad, GLenum orientation)

GLAPI void GLAPIENTRY	gluQuadricTexture (GLUquadric *quad, GLboolean texture)

GLAPI GLint GLAPIENTRY	gluScaleImage (GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid dataOut)

GLAPI void GLAPIENTRY	gluSphere (GLUquadric *quad, GLdouble radius, GLint slices, GLint stacks)

GLAPI void GLAPIENTRY	gluTessBeginContour (GLUtesselator *tess)

GLAPI void GLAPIENTRY	gluTessBeginPolygon (GLUtesselator tess, GLvoid data)

GLAPI void GLAPIENTRY	gluTessCallback (GLUtesselator *tess, GLenum which, _GLUfuncptr CallBackFunc)

GLAPI void GLAPIENTRY	gluTessEndContour (GLUtesselator *tess)

GLAPI void GLAPIENTRY	gluTessEndPolygon (GLUtesselator *tess)

GLAPI void GLAPIENTRY	gluTessNormal (GLUtesselator *tess, GLdouble valueX, GLdouble valueY, GLdouble valueZ)

GLAPI void GLAPIENTRY	gluTessProperty (GLUtesselator *tess, GLenum which, GLdouble data)

GLAPI void GLAPIENTRY	gluTessVertex (GLUtesselator tess, GLdouble location, GLvoid *data)

GLAPI GLint GLAPIENTRY	gluUnProject (GLdouble winX, GLdouble winY, GLdouble winZ, const GLdouble model, const GLdouble proj, const GLint view, GLdouble objX, GLdouble objY, GLdouble objZ)

GLAPI GLint GLAPIENTRY	gluUnProject4 (GLdouble winX, GLdouble winY, GLdouble winZ, GLdouble clipW, const GLdouble model, const GLdouble proj, const GLint view, GLdouble nearVal, GLdouble farVal, GLdouble objX, GLdouble objY, GLdouble objZ, GLdouble *objW)

Macro Definition Documentation

◆ GLAPI

#define GLAPI extern

Definition at line 61 of file glu.h.

◆ GLAPIENTRY

#define GLAPIENTRY

Definition at line 44 of file glu.h.

◆ GLAPIENTRYP

#define GLAPIENTRYP GLAPIENTRY *

Definition at line 49 of file glu.h.

◆ GLU_AUTO_LOAD_MATRIX

#define GLU_AUTO_LOAD_MATRIX 100200

Definition at line 167 of file glu.h.

◆ GLU_BEGIN

#define GLU_BEGIN 100100

Definition at line 215 of file glu.h.

◆ GLU_CCW

#define GLU_CCW 100121

Definition at line 233 of file glu.h.

◆ GLU_CULLING

#define GLU_CULLING 100201

Definition at line 168 of file glu.h.

◆ GLU_CW

#define GLU_CW 100120

Definition at line 232 of file glu.h.

◆ GLU_DISPLAY_MODE

#define GLU_DISPLAY_MODE 100204

Definition at line 170 of file glu.h.

◆ GLU_DOMAIN_DISTANCE

#define GLU_DOMAIN_DISTANCE 100217

Definition at line 189 of file glu.h.

◆ GLU_EDGE_FLAG

#define GLU_EDGE_FLAG 100104

Definition at line 222 of file glu.h.

◆ GLU_END

#define GLU_END 100102

Definition at line 219 of file glu.h.

◆ GLU_ERROR

#define GLU_ERROR 100103

Definition at line 101 of file glu.h.

◆ GLU_EXT_nurbs_tessellator

#define GLU_EXT_nurbs_tessellator 1

Definition at line 72 of file glu.h.

◆ GLU_EXT_object_space_tess

#define GLU_EXT_object_space_tess 1

Definition at line 71 of file glu.h.

◆ GLU_EXTENSIONS

#define GLU_EXTENSIONS 100801

Definition at line 85 of file glu.h.

◆ GLU_EXTERIOR

#define GLU_EXTERIOR 100123

Definition at line 235 of file glu.h.

◆ GLU_FALSE

#define GLU_FALSE 0

Definition at line 75 of file glu.h.

◆ GLU_FILL

#define GLU_FILL 100012

Definition at line 198 of file glu.h.

◆ GLU_FLAT

#define GLU_FLAT 100001

Definition at line 206 of file glu.h.

◆ GLU_INCOMPATIBLE_GL_VERSION

#define GLU_INCOMPATIBLE_GL_VERSION 100903

Definition at line 91 of file glu.h.

◆ GLU_INSIDE

#define GLU_INSIDE 100021

Definition at line 211 of file glu.h.

◆ GLU_INTERIOR

#define GLU_INTERIOR 100122

Definition at line 234 of file glu.h.

◆ GLU_INVALID_ENUM

#define GLU_INVALID_ENUM 100900

Definition at line 88 of file glu.h.

◆ GLU_INVALID_OPERATION

#define GLU_INVALID_OPERATION 100904

Definition at line 92 of file glu.h.

◆ GLU_INVALID_VALUE

#define GLU_INVALID_VALUE 100901

Definition at line 89 of file glu.h.

◆ GLU_LINE

#define GLU_LINE 100011

Definition at line 197 of file glu.h.

◆ GLU_MAP1_TRIM_2

#define GLU_MAP1_TRIM_2 100210

Definition at line 192 of file glu.h.

◆ GLU_MAP1_TRIM_3

#define GLU_MAP1_TRIM_3 100211

Definition at line 193 of file glu.h.

◆ GLU_NONE

#define GLU_NONE 100002

Definition at line 207 of file glu.h.

◆ GLU_NURBS_BEGIN

#define GLU_NURBS_BEGIN 100164

Definition at line 102 of file glu.h.

◆ GLU_NURBS_BEGIN_DATA

#define GLU_NURBS_BEGIN_DATA 100170

Definition at line 114 of file glu.h.

◆ GLU_NURBS_BEGIN_DATA_EXT

#define GLU_NURBS_BEGIN_DATA_EXT 100170

Definition at line 115 of file glu.h.

◆ GLU_NURBS_BEGIN_EXT

#define GLU_NURBS_BEGIN_EXT 100164

Definition at line 103 of file glu.h.

◆ GLU_NURBS_COLOR

#define GLU_NURBS_COLOR 100167

Definition at line 108 of file glu.h.

◆ GLU_NURBS_COLOR_DATA

#define GLU_NURBS_COLOR_DATA 100173

Definition at line 120 of file glu.h.

◆ GLU_NURBS_COLOR_DATA_EXT

#define GLU_NURBS_COLOR_DATA_EXT 100173

Definition at line 121 of file glu.h.

◆ GLU_NURBS_COLOR_EXT

#define GLU_NURBS_COLOR_EXT 100167

Definition at line 109 of file glu.h.

◆ GLU_NURBS_END

#define GLU_NURBS_END 100169

Definition at line 112 of file glu.h.

◆ GLU_NURBS_END_DATA

#define GLU_NURBS_END_DATA 100175

Definition at line 124 of file glu.h.

◆ GLU_NURBS_END_DATA_EXT

#define GLU_NURBS_END_DATA_EXT 100175

Definition at line 125 of file glu.h.

◆ GLU_NURBS_END_EXT

#define GLU_NURBS_END_EXT 100169

Definition at line 113 of file glu.h.

◆ GLU_NURBS_ERROR

#define GLU_NURBS_ERROR 100103

Definition at line 100 of file glu.h.

◆ GLU_NURBS_ERROR1

#define GLU_NURBS_ERROR1 100251

Definition at line 128 of file glu.h.

◆ GLU_NURBS_ERROR10

#define GLU_NURBS_ERROR10 100260

Definition at line 137 of file glu.h.

◆ GLU_NURBS_ERROR11

#define GLU_NURBS_ERROR11 100261

Definition at line 138 of file glu.h.

◆ GLU_NURBS_ERROR12

#define GLU_NURBS_ERROR12 100262

Definition at line 139 of file glu.h.

◆ GLU_NURBS_ERROR13

#define GLU_NURBS_ERROR13 100263

Definition at line 140 of file glu.h.

◆ GLU_NURBS_ERROR14

#define GLU_NURBS_ERROR14 100264

Definition at line 141 of file glu.h.

◆ GLU_NURBS_ERROR15

#define GLU_NURBS_ERROR15 100265

Definition at line 142 of file glu.h.

◆ GLU_NURBS_ERROR16

#define GLU_NURBS_ERROR16 100266

Definition at line 143 of file glu.h.

◆ GLU_NURBS_ERROR17

#define GLU_NURBS_ERROR17 100267

Definition at line 144 of file glu.h.

◆ GLU_NURBS_ERROR18

#define GLU_NURBS_ERROR18 100268

Definition at line 145 of file glu.h.

◆ GLU_NURBS_ERROR19

#define GLU_NURBS_ERROR19 100269

Definition at line 146 of file glu.h.

◆ GLU_NURBS_ERROR2

#define GLU_NURBS_ERROR2 100252

Definition at line 129 of file glu.h.

◆ GLU_NURBS_ERROR20

#define GLU_NURBS_ERROR20 100270

Definition at line 147 of file glu.h.

◆ GLU_NURBS_ERROR21

#define GLU_NURBS_ERROR21 100271

Definition at line 148 of file glu.h.

◆ GLU_NURBS_ERROR22

#define GLU_NURBS_ERROR22 100272

Definition at line 149 of file glu.h.

◆ GLU_NURBS_ERROR23

#define GLU_NURBS_ERROR23 100273

Definition at line 150 of file glu.h.

◆ GLU_NURBS_ERROR24

#define GLU_NURBS_ERROR24 100274

Definition at line 151 of file glu.h.

◆ GLU_NURBS_ERROR25

#define GLU_NURBS_ERROR25 100275

Definition at line 152 of file glu.h.

◆ GLU_NURBS_ERROR26

#define GLU_NURBS_ERROR26 100276

Definition at line 153 of file glu.h.

◆ GLU_NURBS_ERROR27

#define GLU_NURBS_ERROR27 100277

Definition at line 154 of file glu.h.

◆ GLU_NURBS_ERROR28

#define GLU_NURBS_ERROR28 100278

Definition at line 155 of file glu.h.

◆ GLU_NURBS_ERROR29

#define GLU_NURBS_ERROR29 100279

Definition at line 156 of file glu.h.

◆ GLU_NURBS_ERROR3

#define GLU_NURBS_ERROR3 100253

Definition at line 130 of file glu.h.

◆ GLU_NURBS_ERROR30

#define GLU_NURBS_ERROR30 100280

Definition at line 157 of file glu.h.

◆ GLU_NURBS_ERROR31

#define GLU_NURBS_ERROR31 100281

Definition at line 158 of file glu.h.

◆ GLU_NURBS_ERROR32

#define GLU_NURBS_ERROR32 100282

Definition at line 159 of file glu.h.

◆ GLU_NURBS_ERROR33

#define GLU_NURBS_ERROR33 100283

Definition at line 160 of file glu.h.

◆ GLU_NURBS_ERROR34

#define GLU_NURBS_ERROR34 100284

Definition at line 161 of file glu.h.

◆ GLU_NURBS_ERROR35

#define GLU_NURBS_ERROR35 100285

Definition at line 162 of file glu.h.

◆ GLU_NURBS_ERROR36

#define GLU_NURBS_ERROR36 100286

Definition at line 163 of file glu.h.

◆ GLU_NURBS_ERROR37

#define GLU_NURBS_ERROR37 100287

Definition at line 164 of file glu.h.

◆ GLU_NURBS_ERROR4

#define GLU_NURBS_ERROR4 100254

Definition at line 131 of file glu.h.

◆ GLU_NURBS_ERROR5

#define GLU_NURBS_ERROR5 100255

Definition at line 132 of file glu.h.

◆ GLU_NURBS_ERROR6

#define GLU_NURBS_ERROR6 100256

Definition at line 133 of file glu.h.

◆ GLU_NURBS_ERROR7

#define GLU_NURBS_ERROR7 100257

Definition at line 134 of file glu.h.

◆ GLU_NURBS_ERROR8

#define GLU_NURBS_ERROR8 100258

Definition at line 135 of file glu.h.

◆ GLU_NURBS_ERROR9

#define GLU_NURBS_ERROR9 100259

Definition at line 136 of file glu.h.

◆ GLU_NURBS_MODE

#define GLU_NURBS_MODE 100160

Definition at line 175 of file glu.h.

◆ GLU_NURBS_MODE_EXT

#define GLU_NURBS_MODE_EXT 100160

Definition at line 176 of file glu.h.

◆ GLU_NURBS_NORMAL

#define GLU_NURBS_NORMAL 100166

Definition at line 106 of file glu.h.

◆ GLU_NURBS_NORMAL_DATA

#define GLU_NURBS_NORMAL_DATA 100172

Definition at line 118 of file glu.h.

◆ GLU_NURBS_NORMAL_DATA_EXT

#define GLU_NURBS_NORMAL_DATA_EXT 100172

Definition at line 119 of file glu.h.

◆ GLU_NURBS_NORMAL_EXT

#define GLU_NURBS_NORMAL_EXT 100166

Definition at line 107 of file glu.h.

◆ GLU_NURBS_RENDERER

#define GLU_NURBS_RENDERER 100162

Definition at line 179 of file glu.h.

◆ GLU_NURBS_RENDERER_EXT

#define GLU_NURBS_RENDERER_EXT 100162

Definition at line 180 of file glu.h.

◆ GLU_NURBS_TESSELLATOR

#define GLU_NURBS_TESSELLATOR 100161

Definition at line 177 of file glu.h.

◆ GLU_NURBS_TESSELLATOR_EXT

#define GLU_NURBS_TESSELLATOR_EXT 100161

Definition at line 178 of file glu.h.

◆ GLU_NURBS_TEX_COORD_DATA_EXT

#define GLU_NURBS_TEX_COORD_DATA_EXT 100174

Definition at line 123 of file glu.h.

◆ GLU_NURBS_TEX_COORD_EXT

#define GLU_NURBS_TEX_COORD_EXT 100168

Definition at line 111 of file glu.h.

◆ GLU_NURBS_TEXTURE_COORD

#define GLU_NURBS_TEXTURE_COORD 100168

Definition at line 110 of file glu.h.

◆ GLU_NURBS_TEXTURE_COORD_DATA

#define GLU_NURBS_TEXTURE_COORD_DATA 100174

Definition at line 122 of file glu.h.

◆ GLU_NURBS_VERTEX

#define GLU_NURBS_VERTEX 100165

Definition at line 104 of file glu.h.

◆ GLU_NURBS_VERTEX_DATA

#define GLU_NURBS_VERTEX_DATA 100171

Definition at line 116 of file glu.h.

◆ GLU_NURBS_VERTEX_DATA_EXT

#define GLU_NURBS_VERTEX_DATA_EXT 100171

Definition at line 117 of file glu.h.

◆ GLU_NURBS_VERTEX_EXT

#define GLU_NURBS_VERTEX_EXT 100165

Definition at line 105 of file glu.h.

◆ GLU_OBJECT_PARAMETRIC_ERROR

#define GLU_OBJECT_PARAMETRIC_ERROR 100208

Definition at line 183 of file glu.h.

◆ GLU_OBJECT_PARAMETRIC_ERROR_EXT

#define GLU_OBJECT_PARAMETRIC_ERROR_EXT 100208

Definition at line 184 of file glu.h.

◆ GLU_OBJECT_PATH_LENGTH

#define GLU_OBJECT_PATH_LENGTH 100209

Definition at line 185 of file glu.h.

◆ GLU_OBJECT_PATH_LENGTH_EXT

#define GLU_OBJECT_PATH_LENGTH_EXT 100209

Definition at line 186 of file glu.h.

◆ GLU_OUT_OF_MEMORY

#define GLU_OUT_OF_MEMORY 100902

Definition at line 90 of file glu.h.

◆ GLU_OUTLINE_PATCH

#define GLU_OUTLINE_PATCH 100241

Definition at line 97 of file glu.h.

◆ GLU_OUTLINE_POLYGON

#define GLU_OUTLINE_POLYGON 100240

Definition at line 96 of file glu.h.

◆ GLU_OUTSIDE

#define GLU_OUTSIDE 100020

Definition at line 210 of file glu.h.

◆ GLU_PARAMETRIC_ERROR

#define GLU_PARAMETRIC_ERROR 100216

Definition at line 188 of file glu.h.

◆ GLU_PARAMETRIC_TOLERANCE

#define GLU_PARAMETRIC_TOLERANCE 100202

Definition at line 171 of file glu.h.

◆ GLU_PATH_LENGTH

#define GLU_PATH_LENGTH 100215

Definition at line 187 of file glu.h.

◆ GLU_POINT

#define GLU_POINT 100010

Definition at line 196 of file glu.h.

◆ GLU_SAMPLING_METHOD

#define GLU_SAMPLING_METHOD 100205

Definition at line 172 of file glu.h.

◆ GLU_SAMPLING_TOLERANCE

#define GLU_SAMPLING_TOLERANCE 100203

Definition at line 169 of file glu.h.

◆ GLU_SILHOUETTE

#define GLU_SILHOUETTE 100013

Definition at line 199 of file glu.h.

◆ GLU_SMOOTH

#define GLU_SMOOTH 100000

Definition at line 205 of file glu.h.

◆ GLU_TESS_BEGIN

#define GLU_TESS_BEGIN 100100

Definition at line 214 of file glu.h.

◆ GLU_TESS_BEGIN_DATA

#define GLU_TESS_BEGIN_DATA 100106

Definition at line 224 of file glu.h.

◆ GLU_TESS_BOUNDARY_ONLY

#define GLU_TESS_BOUNDARY_ONLY 100141

Definition at line 240 of file glu.h.

◆ GLU_TESS_COMBINE

#define GLU_TESS_COMBINE 100105

Definition at line 223 of file glu.h.

◆ GLU_TESS_COMBINE_DATA

#define GLU_TESS_COMBINE_DATA 100111

Definition at line 229 of file glu.h.

◆ GLU_TESS_COORD_TOO_LARGE

#define GLU_TESS_COORD_TOO_LARGE 100155

Definition at line 256 of file glu.h.

◆ GLU_TESS_EDGE_FLAG

#define GLU_TESS_EDGE_FLAG 100104

Definition at line 221 of file glu.h.

◆ GLU_TESS_EDGE_FLAG_DATA

#define GLU_TESS_EDGE_FLAG_DATA 100110

Definition at line 228 of file glu.h.

◆ GLU_TESS_END

#define GLU_TESS_END 100102

Definition at line 218 of file glu.h.

◆ GLU_TESS_END_DATA

#define GLU_TESS_END_DATA 100108

Definition at line 226 of file glu.h.

◆ GLU_TESS_ERROR

#define GLU_TESS_ERROR 100103

Definition at line 220 of file glu.h.

◆ GLU_TESS_ERROR1

#define GLU_TESS_ERROR1 100151

Definition at line 244 of file glu.h.

◆ GLU_TESS_ERROR2

#define GLU_TESS_ERROR2 100152

Definition at line 245 of file glu.h.

◆ GLU_TESS_ERROR3

#define GLU_TESS_ERROR3 100153

Definition at line 246 of file glu.h.

◆ GLU_TESS_ERROR4

#define GLU_TESS_ERROR4 100154

Definition at line 247 of file glu.h.

◆ GLU_TESS_ERROR5

#define GLU_TESS_ERROR5 100155

Definition at line 248 of file glu.h.

◆ GLU_TESS_ERROR6

#define GLU_TESS_ERROR6 100156

Definition at line 249 of file glu.h.

◆ GLU_TESS_ERROR7

#define GLU_TESS_ERROR7 100157

Definition at line 250 of file glu.h.

◆ GLU_TESS_ERROR8

#define GLU_TESS_ERROR8 100158

Definition at line 251 of file glu.h.

◆ GLU_TESS_ERROR_DATA

#define GLU_TESS_ERROR_DATA 100109

Definition at line 227 of file glu.h.

◆ GLU_TESS_MAX_COORD

#define GLU_TESS_MAX_COORD 1.0e150

Definition at line 284 of file glu.h.

◆ GLU_TESS_MISSING_BEGIN_CONTOUR

#define GLU_TESS_MISSING_BEGIN_CONTOUR 100152

Definition at line 253 of file glu.h.

◆ GLU_TESS_MISSING_BEGIN_POLYGON

#define GLU_TESS_MISSING_BEGIN_POLYGON 100151

Definition at line 252 of file glu.h.

◆ GLU_TESS_MISSING_END_CONTOUR

#define GLU_TESS_MISSING_END_CONTOUR 100154

Definition at line 255 of file glu.h.

◆ GLU_TESS_MISSING_END_POLYGON

#define GLU_TESS_MISSING_END_POLYGON 100153

Definition at line 254 of file glu.h.

◆ GLU_TESS_NEED_COMBINE_CALLBACK

#define GLU_TESS_NEED_COMBINE_CALLBACK 100156

Definition at line 257 of file glu.h.

◆ GLU_TESS_TOLERANCE

#define GLU_TESS_TOLERANCE 100142

Definition at line 241 of file glu.h.

◆ GLU_TESS_VERTEX

#define GLU_TESS_VERTEX 100101

Definition at line 216 of file glu.h.

◆ GLU_TESS_VERTEX_DATA

#define GLU_TESS_VERTEX_DATA 100107

Definition at line 225 of file glu.h.

◆ GLU_TESS_WINDING_ABS_GEQ_TWO

#define GLU_TESS_WINDING_ABS_GEQ_TWO 100134

Definition at line 264 of file glu.h.

◆ GLU_TESS_WINDING_NEGATIVE

#define GLU_TESS_WINDING_NEGATIVE 100133

Definition at line 263 of file glu.h.

◆ GLU_TESS_WINDING_NONZERO

#define GLU_TESS_WINDING_NONZERO 100131

Definition at line 261 of file glu.h.

◆ GLU_TESS_WINDING_ODD

#define GLU_TESS_WINDING_ODD 100130

Definition at line 260 of file glu.h.

◆ GLU_TESS_WINDING_POSITIVE

#define GLU_TESS_WINDING_POSITIVE 100132

Definition at line 262 of file glu.h.

◆ GLU_TESS_WINDING_RULE

#define GLU_TESS_WINDING_RULE 100140

Definition at line 239 of file glu.h.

◆ GLU_TRUE

#define GLU_TRUE 1

Definition at line 76 of file glu.h.

◆ GLU_U_STEP

#define GLU_U_STEP 100206

Definition at line 173 of file glu.h.

◆ GLU_UNKNOWN

#define GLU_UNKNOWN 100124

Definition at line 236 of file glu.h.

◆ GLU_V_STEP

#define GLU_V_STEP 100207

Definition at line 174 of file glu.h.

◆ GLU_VERSION

#define GLU_VERSION 100800

Definition at line 84 of file glu.h.

◆ GLU_VERSION_1_1

#define GLU_VERSION_1_1 1

Definition at line 79 of file glu.h.

◆ GLU_VERSION_1_2

#define GLU_VERSION_1_2 1

Definition at line 80 of file glu.h.

◆ GLU_VERSION_1_3

#define GLU_VERSION_1_3 1

Definition at line 81 of file glu.h.

◆ GLU_VERTEX

#define GLU_VERTEX 100101

Definition at line 217 of file glu.h.

Typedef Documentation

◆ GLUnurbs

typedef struct GLUnurbs GLUnurbs

Definition at line 274 of file glu.h.

◆ GLUnurbsObj

typedef GLUnurbs GLUnurbsObj

Definition at line 279 of file glu.h.

◆ GLUquadric

typedef struct GLUquadric GLUquadric

Definition at line 275 of file glu.h.

◆ GLUquadricObj

typedef GLUquadric GLUquadricObj

Definition at line 280 of file glu.h.

◆ GLUtesselator

typedef struct GLUtesselator GLUtesselator

Definition at line 276 of file glu.h.

◆ GLUtesselatorObj

typedef GLUtesselator GLUtesselatorObj

Definition at line 281 of file glu.h.

◆ GLUtriangulatorObj

typedef GLUtesselator GLUtriangulatorObj

Definition at line 282 of file glu.h.

Function Documentation

◆ gluBeginCurve()

GLAPI void GLAPIENTRY gluBeginCurve ( GLUnurbs * nurb )

Definition at line 99 of file glinterface.cc.

 {
     r->bgncurve(0); 
 }

◆ gluBeginPolygon()

GLAPI void GLAPIENTRY gluBeginPolygon ( GLUtesselator * tess )

Definition at line 611 of file tess.c.

 {
   gluTessBeginPolygon( tess, NULL );
   gluTessBeginContour( tess );
 }

◆ gluBeginSurface()

GLAPI void GLAPIENTRY gluBeginSurface ( GLUnurbs * nurb )

Definition at line 89 of file glinterface.cc.

 {
 #ifdef DOWN_LOAD_NURBS
 surfcount++;
 tempTrim = OTL_make(10,10);
 #endif
     r->bgnsurface(0); 
 }

◆ gluBeginTrim()

GLAPI void GLAPIENTRY gluBeginTrim ( GLUnurbs * nurb )

Definition at line 131 of file glinterface.cc.

 {
 #ifdef DOWN_LOAD_NURBS
 OTL_bgnTrim(tempTrim);
 #endif
 
     r->bgntrim(); 
 }

◆ gluBuild1DMipmapLevels()

GLAPI GLint GLAPIENTRY gluBuild1DMipmapLevels	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLenum	format,
		GLenum	type,
		GLint	level,
		GLint	base,
		GLint	max,
		const void *	data
	)

Definition at line 3643 of file mipmap.c.

 {
    int levels;
 
    int rc= checkMipmapArgs(internalFormat,format,type);
    if (rc != 0) return rc;
 
    if (width < 1) {
        return GLU_INVALID_VALUE;
    }
 
    levels = computeLog(width);
 
    levels+= userLevel;
    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
       return GLU_INVALID_VALUE;
 
    return gluBuild1DMipmapLevelsCore(target, internalFormat,
                      width,
                      width,format, type,
                      userLevel, baseLevel, maxLevel,
                      data);
 } /* gluBuild1DMipmapLevels() */

◆ gluBuild1DMipmaps()

GLAPI GLint GLAPIENTRY gluBuild1DMipmaps	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLenum	format,
		GLenum	type,
		const void *	data
	)

Definition at line 3672 of file mipmap.c.

 {
    GLint widthPowerOf2;
    int levels;
    GLint dummy;
 
    int rc= checkMipmapArgs(internalFormat,format,type);
    if (rc != 0) return rc;
 
    if (width < 1) {
        return GLU_INVALID_VALUE;
    }
 
    closestFit(target,width,1,internalFormat,format,type,&widthPowerOf2,&dummy);
    levels = computeLog(widthPowerOf2);
 
    return gluBuild1DMipmapLevelsCore(target,internalFormat,
                      width,
                      widthPowerOf2,
                      format,type,0,0,levels,data);
 }

◆ gluBuild2DMipmapLevels()

GLAPI GLint GLAPIENTRY gluBuild2DMipmapLevels	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		GLint	level,
		GLint	base,
		GLint	max,
		const void *	data
	)

Definition at line 4554 of file mipmap.c.

 {
    int level, levels;
 
    int rc= checkMipmapArgs(internalFormat,format,type);
    if (rc != 0) return rc;
 
    if (width < 1 || height < 1) {
        return GLU_INVALID_VALUE;
    }
 
    levels = computeLog(width);
    level = computeLog(height);
    if (level > levels) levels=level;
 
    levels+= userLevel;
    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
       return GLU_INVALID_VALUE;
 
    return gluBuild2DMipmapLevelsCore(target, internalFormat,
                      width, height,
                      width, height,
                      format, type,
                      userLevel, baseLevel, maxLevel,
                      data);
 } /* gluBuild2DMipmapLevels() */

◆ gluBuild2DMipmaps()

GLAPI GLint GLAPIENTRY gluBuild2DMipmaps	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		const void *	data
	)

Definition at line 4586 of file mipmap.c.

 {
    GLint widthPowerOf2, heightPowerOf2;
    int level, levels;
 
    int rc= checkMipmapArgs(internalFormat,format,type);
    if (rc != 0) return rc;
 
    if (width < 1 || height < 1) {
        return GLU_INVALID_VALUE;
    }
 
    closestFit(target,width,height,internalFormat,format,type,
           &widthPowerOf2,&heightPowerOf2);
 
    levels = computeLog(widthPowerOf2);
    level = computeLog(heightPowerOf2);
    if (level > levels) levels=level;
 
    return gluBuild2DMipmapLevelsCore(target,internalFormat,
                      width, height,
                      widthPowerOf2,heightPowerOf2,
                      format,type,
                      0,0,levels,data);
 }  /* gluBuild2DMipmaps() */

◆ gluBuild3DMipmapLevels()

GLAPI GLint GLAPIENTRY gluBuild3DMipmapLevels	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLsizei	depth,
		GLenum	format,
		GLenum	type,
		GLint	level,
		GLint	base,
		GLint	max,
		const void *	data
	)

Definition at line 8446 of file mipmap.c.

 {
    int level, levels;
 
    int rc= checkMipmapArgs(internalFormat,format,type);
    if (rc != 0) return rc;
 
    if (width < 1 || height < 1 || depth < 1) {
        return GLU_INVALID_VALUE;
    }
 
    if(type == GL_BITMAP) {
       return GLU_INVALID_ENUM;
    }
 
    levels = computeLog(width);
    level = computeLog(height);
    if (level > levels) levels=level;
    level = computeLog(depth);
    if (level > levels) levels=level;
 
    levels+= userLevel;
    if (!isLegalLevels(userLevel,baseLevel,maxLevel,levels))
       return GLU_INVALID_VALUE;
 
    return gluBuild3DMipmapLevelsCore(target, internalFormat,
                      width, height, depth,
                      width, height, depth,
                      format, type,
                      userLevel, baseLevel, maxLevel,
                      data);
 } /* gluBuild3DMipmapLevels() */

◆ gluBuild3DMipmaps()

GLAPI GLint GLAPIENTRY gluBuild3DMipmaps	(	GLenum	target,
		GLint	internalFormat,
		GLsizei	width,
		GLsizei	height,
		GLsizei	depth,
		GLenum	format,
		GLenum	type,
		const void *	data
	)

Definition at line 8484 of file mipmap.c.

 {
    GLint widthPowerOf2, heightPowerOf2, depthPowerOf2;
    int level, levels;
 
    int rc= checkMipmapArgs(internalFormat,format,type);
    if (rc != 0) return rc;
 
    if (width < 1 || height < 1 || depth < 1) {
        return GLU_INVALID_VALUE;
    }
 
    if(type == GL_BITMAP) {
       return GLU_INVALID_ENUM;
    }
 
    closestFit3D(target,width,height,depth,internalFormat,format,type,
         &widthPowerOf2,&heightPowerOf2,&depthPowerOf2);
 
    levels = computeLog(widthPowerOf2);
    level = computeLog(heightPowerOf2);
    if (level > levels) levels=level;
    level = computeLog(depthPowerOf2);
    if (level > levels) levels=level;
 
    return gluBuild3DMipmapLevelsCore(target, internalFormat,
                      width, height, depth,
                      widthPowerOf2, heightPowerOf2,
                      depthPowerOf2,
                      format, type, 0, 0, levels,
                      data);
 } /* gluBuild3DMipmaps() */

◆ gluCheckExtension()

GLAPI GLboolean GLAPIENTRY gluCheckExtension	(	const GLubyte *	extName,
		const GLubyte *	extString
	)

Definition at line 63 of file registry.c.

 {
   GLboolean flag = GL_FALSE;
   char *word;
   char *lookHere;
   char *deleteThis;
 
   if (extString == NULL) return GL_FALSE;
 
   deleteThis = lookHere = (char *)malloc(strlen((const char *)extString)+1); 
   if (lookHere == NULL)
      return GL_FALSE;
   /* strtok() will modify string, so copy it somewhere */
   strcpy(lookHere,(const char *)extString);
 
   while ((word= strtok(lookHere," ")) != NULL) {
      if (strcmp(word,(const char *)extName) == 0) {
         flag = GL_TRUE;
     break;
      }  
      lookHere = NULL;       /* get next token */
   }
   free((void *)deleteThis);
   return flag;
 } /* gluCheckExtension() */

◆ gluCylinder()

GLAPI void GLAPIENTRY gluCylinder	(	GLUquadric *	quad,
		GLdouble	base,
		GLdouble	top,
		GLdouble	height,
		GLint	slices,
		GLint	stacks
	)

Definition at line 150 of file quad.c.

 {
     GLint i,j;
     GLfloat sinCache[CACHE_SIZE];
     GLfloat cosCache[CACHE_SIZE];
     GLfloat sinCache2[CACHE_SIZE];
     GLfloat cosCache2[CACHE_SIZE];
     GLfloat sinCache3[CACHE_SIZE];
     GLfloat cosCache3[CACHE_SIZE];
     GLfloat angle;
     GLfloat zLow, zHigh;
     GLfloat sintemp, costemp;
     GLfloat length;
     GLfloat deltaRadius;
     GLfloat zNormal;
     GLfloat xyNormalRatio;
     GLfloat radiusLow, radiusHigh;
     int needCache2, needCache3;
 
     if (slices >= CACHE_SIZE) slices = CACHE_SIZE-1;
 
     if (slices < 2 || stacks < 1 || baseRadius < 0.0 || topRadius < 0.0 ||
         height < 0.0) {
     gluQuadricError(qobj, GLU_INVALID_VALUE);
     return;
     }
 
     /* Compute length (needed for normal calculations) */
     deltaRadius = baseRadius - topRadius;
     length = SQRT(deltaRadius*deltaRadius + height*height);
     if (length == 0.0) {
     gluQuadricError(qobj, GLU_INVALID_VALUE);
     return;
     }
 
     /* Cache is the vertex locations cache */
     /* Cache2 is the various normals at the vertices themselves */
     /* Cache3 is the various normals for the faces */
     needCache2 = needCache3 = 0;
     if (qobj->normals == GLU_SMOOTH) {
     needCache2 = 1;
     }
 
     if (qobj->normals == GLU_FLAT) {
     if (qobj->drawStyle != GLU_POINT) {
         needCache3 = 1;
     }
     if (qobj->drawStyle == GLU_LINE) {
         needCache2 = 1;
     }
     }
 
     zNormal = deltaRadius / length;
     xyNormalRatio = height / length;
 
     for (i = 0; i < slices; i++) {
     angle = 2 * PI * i / slices;
     if (needCache2) {
         if (qobj->orientation == GLU_OUTSIDE) {
         sinCache2[i] = xyNormalRatio * SIN(angle);
         cosCache2[i] = xyNormalRatio * COS(angle);
         } else {
         sinCache2[i] = -xyNormalRatio * SIN(angle);
         cosCache2[i] = -xyNormalRatio * COS(angle);
         }
     }
     sinCache[i] = SIN(angle);
     cosCache[i] = COS(angle);
     }
 
     if (needCache3) {
     for (i = 0; i < slices; i++) {
         angle = 2 * PI * (i-0.5) / slices;
         if (qobj->orientation == GLU_OUTSIDE) {
         sinCache3[i] = xyNormalRatio * SIN(angle);
         cosCache3[i] = xyNormalRatio * COS(angle);
         } else {
         sinCache3[i] = -xyNormalRatio * SIN(angle);
         cosCache3[i] = -xyNormalRatio * COS(angle);
         }
     }
     }
 
     sinCache[slices] = sinCache[0];
     cosCache[slices] = cosCache[0];
     if (needCache2) {
     sinCache2[slices] = sinCache2[0];
     cosCache2[slices] = cosCache2[0];
     }
     if (needCache3) {
     sinCache3[slices] = sinCache3[0];
     cosCache3[slices] = cosCache3[0];
     }
 
     switch (qobj->drawStyle) {
       case GLU_FILL:
     /* Note:
     ** An argument could be made for using a TRIANGLE_FAN for the end
     ** of the cylinder of either radii is 0.0 (a cone).  However, a
     ** TRIANGLE_FAN would not work in smooth shading mode (the common
     ** case) because the normal for the apex is different for every
     ** triangle (and TRIANGLE_FAN doesn't let me respecify that normal).
     ** Now, my choice is GL_TRIANGLES, or leave the GL_QUAD_STRIP and
     ** just let the GL trivially reject one of the two triangles of the
     ** QUAD.  GL_QUAD_STRIP is probably faster, so I will leave this code
     ** alone.
     */
     for (j = 0; j < stacks; j++) {
         zLow = j * height / stacks;
         zHigh = (j + 1) * height / stacks;
         radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
         radiusHigh = baseRadius - deltaRadius * ((float) (j + 1) / stacks);
 
         glBegin(GL_QUAD_STRIP);
         for (i = 0; i <= slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
             glNormal3f(sinCache3[i], cosCache3[i], zNormal);
             break;
           case GLU_SMOOTH:
             glNormal3f(sinCache2[i], cosCache2[i], zNormal);
             break;
           case GLU_NONE:
           default:
             break;
         }
         if (qobj->orientation == GLU_OUTSIDE) {
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) j / stacks);
             }
             glVertex3f(radiusLow * sinCache[i],
                 radiusLow * cosCache[i], zLow);
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) (j+1) / stacks);
             }
             glVertex3f(radiusHigh * sinCache[i],
                 radiusHigh * cosCache[i], zHigh);
         } else {
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) (j+1) / stacks);
             }
             glVertex3f(radiusHigh * sinCache[i],
                 radiusHigh * cosCache[i], zHigh);
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) j / stacks);
             }
             glVertex3f(radiusLow * sinCache[i],
                 radiusLow * cosCache[i], zLow);
         }
         }
         glEnd();
     }
     break;
       case GLU_POINT:
     glBegin(GL_POINTS);
     for (i = 0; i < slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
           case GLU_SMOOTH:
         glNormal3f(sinCache2[i], cosCache2[i], zNormal);
         break;
           case GLU_NONE:
           default:
         break;
         }
         sintemp = sinCache[i];
         costemp = cosCache[i];
         for (j = 0; j <= stacks; j++) {
         zLow = j * height / stacks;
         radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
 
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) j / stacks);
         }
         glVertex3f(radiusLow * sintemp,
             radiusLow * costemp, zLow);
         }
     }
     glEnd();
     break;
       case GLU_LINE:
     for (j = 1; j < stacks; j++) {
         zLow = j * height / stacks;
         radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
 
         glBegin(GL_LINE_STRIP);
         for (i = 0; i <= slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
             glNormal3f(sinCache3[i], cosCache3[i], zNormal);
             break;
           case GLU_SMOOTH:
             glNormal3f(sinCache2[i], cosCache2[i], zNormal);
             break;
           case GLU_NONE:
           default:
             break;
         }
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) j / stacks);
         }
         glVertex3f(radiusLow * sinCache[i],
             radiusLow * cosCache[i], zLow);
         }
         glEnd();
     }
     /* Intentionally fall through here... */
       case GLU_SILHOUETTE:
     for (j = 0; j <= stacks; j += stacks) {
         zLow = j * height / stacks;
         radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
 
         glBegin(GL_LINE_STRIP);
         for (i = 0; i <= slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
             glNormal3f(sinCache3[i], cosCache3[i], zNormal);
             break;
           case GLU_SMOOTH:
             glNormal3f(sinCache2[i], cosCache2[i], zNormal);
             break;
           case GLU_NONE:
           default:
             break;
         }
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) j / stacks);
         }
         glVertex3f(radiusLow * sinCache[i], radiusLow * cosCache[i],
             zLow);
         }
         glEnd();
     }
     for (i = 0; i < slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
           case GLU_SMOOTH:
         glNormal3f(sinCache2[i], cosCache2[i], 0.0);
         break;
           case GLU_NONE:
           default:
         break;
         }
         sintemp = sinCache[i];
         costemp = cosCache[i];
         glBegin(GL_LINE_STRIP);
         for (j = 0; j <= stacks; j++) {
         zLow = j * height / stacks;
         radiusLow = baseRadius - deltaRadius * ((float) j / stacks);
 
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 (float) j / stacks);
         }
         glVertex3f(radiusLow * sintemp,
             radiusLow * costemp, zLow);
         }
         glEnd();
     }
     break;
       default:
     break;
     }
 }

◆ gluDeleteNurbsRenderer()

GLAPI void GLAPIENTRY gluDeleteNurbsRenderer ( GLUnurbs * nurb )

Definition at line 75 of file glinterface.cc.

 {
     delete r;
 }

◆ gluDeleteQuadric()

GLAPI void GLAPIENTRY gluDeleteQuadric ( GLUquadric * quad )

Definition at line 73 of file quad.c.

 {
     free(state);
 }

◆ gluDeleteTess()

GLAPI void GLAPIENTRY gluDeleteTess ( GLUtesselator * tess )

Definition at line 193 of file tess.c.

 {
   RequireState( tess, T_DORMANT );
   memFree( tess );
 }

◆ gluDisk()

GLAPI void GLAPIENTRY gluDisk	(	GLUquadric *	quad,
		GLdouble	inner,
		GLdouble	outer,
		GLint	slices,
		GLint	loops
	)

Definition at line 424 of file quad.c.

 {
     gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, 0.0, 360.0);
 }

◆ gluEndCurve()

GLAPI void GLAPIENTRY gluEndCurve ( GLUnurbs * nurb )

Definition at line 105 of file glinterface.cc.

 {
     r->endcurve(); 
 }

◆ gluEndPolygon()

GLAPI void GLAPIENTRY gluEndPolygon ( GLUtesselator * tess )

Definition at line 628 of file tess.c.

 {
   gluTessEndContour( tess );
   gluTessEndPolygon( tess );
 }

◆ gluEndSurface()

GLAPI void GLAPIENTRY gluEndSurface ( GLUnurbs * nurb )

Definition at line 111 of file glinterface.cc.

 {
 #ifdef DOWN_LOAD_NURBS
 if(surfcount == 1)
   otn = OTN_make(1);
 OTN_insert(otn, tempNurb, tempTrim);
 if(surfcount  >= 1)
 {
 #ifdef DEBUG
 printf("write file\n");
 #endif
 OTN_write(otn, "out.otn");
 
 }
 #endif
 
     r->endsurface(); 
 }

◆ gluEndTrim()

GLAPI void GLAPIENTRY gluEndTrim ( GLUnurbs * nurb )

Definition at line 141 of file glinterface.cc.

 {
 #ifdef DOWN_LOAD_NURBS
 OTL_endTrim(tempTrim);
 #endif
     r->endtrim(); 
 }

◆ gluErrorString()

GLAPI const GLubyte* GLAPIENTRY gluErrorString ( GLenum error )

Definition at line 67 of file error.c.

 {
     int i;
     for (i = 0; Errors[i].String; i++) {
         if (Errors[i].Token == errorCode)
             return (const GLubyte *) Errors[i].String;
     }
     if ((errorCode >= GLU_NURBS_ERROR1) && (errorCode <= GLU_NURBS_ERROR37)) {
     return (const GLubyte *) __gluNURBSErrorString(errorCode - (GLU_NURBS_ERROR1 - 1));
     }
     if ((errorCode >= GLU_TESS_ERROR1) && (errorCode <= GLU_TESS_ERROR6)) {
     return (const GLubyte *) __gluTessErrorString(errorCode - (GLU_TESS_ERROR1 - 1));
     }
     return (const GLubyte *) 0;
 }

◆ gluGetNurbsProperty()

GLAPI void GLAPIENTRY gluGetNurbsProperty	(	GLUnurbs *	nurb,
		GLenum	property,
		GLfloat *	data
	)

Definition at line 359 of file glinterface.cc.

 {
     GLfloat nurbsValue;
 
     switch(property) {
       case GLU_AUTO_LOAD_MATRIX:
     if (r->getautoloadmode()) {
         *value = GL_TRUE;
     } else {
         *value = GL_FALSE;
     }
     break;
       case GLU_CULLING:
     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, &nurbsValue);
     if (nurbsValue == N_CULLINGON) {
         *value = GL_TRUE;
     } else {
         *value = GL_FALSE;
     }
     break;
       case GLU_SAMPLING_METHOD:
     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, value);
     if(*value == N_PATHLENGTH)
       *value = GLU_PATH_LENGTH;
     else if(*value == N_PARAMETRICDISTANCE)
       *value = GLU_PARAMETRIC_ERROR;
     else if(*value == N_DOMAINDISTANCE)
       *value = GLU_DOMAIN_DISTANCE;
     else if(*value == N_OBJECTSPACE_PATH)
       *value = GLU_OBJECT_PATH_LENGTH;
     else if(*value == N_OBJECTSPACE_PARA)
       *value = GLU_OBJECT_PARAMETRIC_ERROR; 
     break;
       case GLU_SAMPLING_TOLERANCE:
     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
     break;
       case GLU_PARAMETRIC_TOLERANCE:
     r->getnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
         break;
 
       case GLU_U_STEP:
         r->getnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
     break;
       case GLU_V_STEP:
         r->getnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value);
     break;
       case GLU_DISPLAY_MODE:
     r->getnurbsproperty(N_DISPLAY, &nurbsValue);
     if (nurbsValue == N_FILL) {
         *value = GLU_FILL;
     } else if (nurbsValue == N_OUTLINE_POLY) {
         *value = GLU_OUTLINE_POLYGON;
     } else {
         *value = GLU_OUTLINE_PATCH;
     }
     break;
 
       case GLU_NURBS_MODE:
     if(r->is_callback())
       *value = GLU_NURBS_TESSELLATOR;
     else
       *value = GLU_NURBS_RENDERER;
     break;
     
       default:
     r->postError(GLU_INVALID_ENUM);
     return;
     }
 }

◆ gluGetString()

GLAPI const GLubyte* GLAPIENTRY gluGetString ( GLenum name )

Definition at line 44 of file registry.c.

 {
 
     if (name == GLU_VERSION) {
     return versionString;
     } else if (name == GLU_EXTENSIONS) {
     return extensionString;
     }
     return NULL;
 }

◆ gluGetTessProperty()

GLAPI void GLAPIENTRY gluGetTessProperty	(	GLUtesselator *	tess,
		GLenum	which,
		GLdouble *	data
	)

Definition at line 240 of file tess.c.

 {
    switch (which) {
    case GLU_TESS_TOLERANCE:
       /* tolerance should be in range [0..1] */
       assert(0.0 <= tess->relTolerance && tess->relTolerance <= 1.0);
       *value= tess->relTolerance;
       break;
    case GLU_TESS_WINDING_RULE:
       assert(tess->windingRule == GLU_TESS_WINDING_ODD ||
          tess->windingRule == GLU_TESS_WINDING_NONZERO ||
          tess->windingRule == GLU_TESS_WINDING_POSITIVE ||
          tess->windingRule == GLU_TESS_WINDING_NEGATIVE ||
          tess->windingRule == GLU_TESS_WINDING_ABS_GEQ_TWO);
       *value= tess->windingRule;
       break;
    case GLU_TESS_BOUNDARY_ONLY:
       assert(tess->boundaryOnly == TRUE || tess->boundaryOnly == FALSE);
       *value= tess->boundaryOnly;
       break;
    default:
       *value= 0.0;
       CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
       break;
    }
 } /* gluGetTessProperty() */

◆ gluLoadSamplingMatrices()

GLAPI void GLAPIENTRY gluLoadSamplingMatrices	(	GLUnurbs *	nurb,
		const GLfloat *	model,
		const GLfloat *	perspective,
		const GLint *	view
	)

◆ gluLookAt()

GLAPI void GLAPIENTRY gluLookAt	(	GLdouble	eyeX,
		GLdouble	eyeY,
		GLdouble	eyeZ,
		GLdouble	centerX,
		GLdouble	centerY,
		GLdouble	centerZ,
		GLdouble	upX,
		GLdouble	upY,
		GLdouble	upZ
	)

Definition at line 108 of file project.c.

 {
     float forward[3], side[3], up[3];
     GLfloat m[4][4];
 
     forward[0] = centerx - eyex;
     forward[1] = centery - eyey;
     forward[2] = centerz - eyez;
 
     up[0] = upx;
     up[1] = upy;
     up[2] = upz;
 
     normalize(forward);
 
     /* Side = forward x up */
     cross(forward, up, side);
     normalize(side);
 
     /* Recompute up as: up = side x forward */
     cross(side, forward, up);
 
     __gluMakeIdentityf(&m[0][0]);
     m[0][0] = side[0];
     m[1][0] = side[1];
     m[2][0] = side[2];
 
     m[0][1] = up[0];
     m[1][1] = up[1];
     m[2][1] = up[2];
 
     m[0][2] = -forward[0];
     m[1][2] = -forward[1];
     m[2][2] = -forward[2];
 
     glMultMatrixf(&m[0][0]);
     glTranslated(-eyex, -eyey, -eyez);
 }

◆ gluNewNurbsRenderer()

GLAPI GLUnurbs* GLAPIENTRY gluNewNurbsRenderer ( void )

Definition at line 66 of file glinterface.cc.

 {
   GLUnurbs *t;
   
   t = new GLUnurbs();
   return t;
 }

◆ gluNewQuadric()

GLAPI GLUquadric* GLAPIENTRY gluNewQuadric ( void )

Definition at line 54 of file quad.c.

 {
     GLUquadric *newstate;
 
     newstate = (GLUquadric *) malloc(sizeof(GLUquadric));
     if (newstate == NULL) {
     /* Can't report an error at this point... */
     return NULL;
     }
     newstate->normals = GLU_SMOOTH;
     newstate->textureCoords = GL_FALSE;
     newstate->orientation = GLU_OUTSIDE;
     newstate->drawStyle = GLU_FILL;
     newstate->errorCallback = NULL;
     return newstate;
 }

◆ gluNewTess()

GLAPI GLUtesselator* GLAPIENTRY gluNewTess ( void )

Definition at line 92 of file tess.c.

 {
   GLUtesselator *tess;
 
   /* Only initialize fields which can be changed by the api.  Other fields
    * are initialized where they are used.
    */
 
   if (memInit( MAX_FAST_ALLOC ) == 0) {
      return 0;          /* out of memory */
   }
   tess = (GLUtesselator *)memAlloc( sizeof( GLUtesselator ));
   if (tess == NULL) {
      return 0;          /* out of memory */
   }
 
   tess->state = T_DORMANT;
 
   tess->normal[0] = 0;
   tess->normal[1] = 0;
   tess->normal[2] = 0;
 
   tess->relTolerance = GLU_TESS_DEFAULT_TOLERANCE;
   tess->windingRule = GLU_TESS_WINDING_ODD;
   tess->flagBoundary = FALSE;
   tess->boundaryOnly = FALSE;
 
   tess->callBegin = &noBegin;
   tess->callEdgeFlag = &noEdgeFlag;
   tess->callVertex = &noVertex;
   tess->callEnd = &noEnd;
 
   tess->callError = &noError;
   tess->callCombine = &noCombine;
   tess->callMesh = &noMesh;
 
   tess->callBeginData= &__gl_noBeginData;
   tess->callEdgeFlagData= &__gl_noEdgeFlagData;
   tess->callVertexData= &__gl_noVertexData;
   tess->callEndData= &__gl_noEndData;
   tess->callErrorData= &__gl_noErrorData;
   tess->callCombineData= &__gl_noCombineData;
 
   tess->polygonData= NULL;
 
   return tess;
 }

◆ gluNextContour()

GLAPI void GLAPIENTRY gluNextContour	(	GLUtesselator *	tess,
		GLenum	type
	)

Definition at line 620 of file tess.c.

 {
   gluTessEndContour( tess );
   gluTessBeginContour( tess );
 }

◆ gluNurbsCallback()

GLAPI void GLAPIENTRY gluNurbsCallback	(	GLUnurbs *	nurb,
		GLenum	which,
		_GLUfuncptr	CallBackFunc
	)

Definition at line 430 of file glinterface.cc.

 {
     switch (which) {
     case GLU_NURBS_BEGIN:
     case GLU_NURBS_END:
     case GLU_NURBS_VERTEX:
     case GLU_NURBS_NORMAL:
     case GLU_NURBS_TEXTURE_COORD:
     case GLU_NURBS_COLOR:
     case GLU_NURBS_BEGIN_DATA:
     case GLU_NURBS_END_DATA:
     case GLU_NURBS_VERTEX_DATA:
     case GLU_NURBS_NORMAL_DATA:
     case GLU_NURBS_TEXTURE_COORD_DATA:
     case GLU_NURBS_COLOR_DATA: 
     r->putSurfCallBack(which, fn);
     break;
 
     case GLU_NURBS_ERROR:
     r->errorCallback = (void (APIENTRY *)( GLenum e )) fn;
     break;
     default:
     r->postError(GLU_INVALID_ENUM);
     return;
     }
 }

◆ gluNurbsCallbackData()

GLAPI void GLAPIENTRY gluNurbsCallbackData	(	GLUnurbs *	nurb,
		GLvoid *	userData
	)

Definition at line 466 of file glinterface.cc.

 {
   gluNurbsCallbackDataEXT(r,userData);
 }

◆ gluNurbsCallbackDataEXT()

GLAPI void GLAPIENTRY gluNurbsCallbackDataEXT	(	GLUnurbs *	nurb,
		GLvoid *	userData
	)

Definition at line 459 of file glinterface.cc.

 {
   r->setNurbsCallbackData(userData);
 }

Referenced by gluNurbsCallbackData().

◆ gluNurbsCurve()

GLAPI void GLAPIENTRY gluNurbsCurve	(	GLUnurbs *	nurb,
		GLint	knotCount,
		GLfloat *	knots,
		GLint	stride,
		GLfloat *	control,
		GLint	order,
		GLenum	type
	)

◆ gluNurbsProperty()

GLAPI void GLAPIENTRY gluNurbsProperty	(	GLUnurbs *	nurb,
		GLenum	property,
		GLfloat	value
	)

Definition at line 243 of file glinterface.cc.

 {
     GLfloat nurbsValue;
     
     switch (property) {
       case GLU_AUTO_LOAD_MATRIX:      
         r->setautoloadmode(value);
     return;
 
       case GLU_CULLING:
     if (value != 0.0) {
         nurbsValue = N_CULLINGON;
     } else {
         nurbsValue = N_NOCULLING;
     }
     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_CULLING, nurbsValue);
     r->setnurbsproperty(GL_MAP2_VERTEX_4, N_CULLING, nurbsValue);
     r->setnurbsproperty(GL_MAP1_VERTEX_3, N_CULLING, nurbsValue);
     r->setnurbsproperty(GL_MAP1_VERTEX_4, N_CULLING, nurbsValue);
         return;
 
       case GLU_SAMPLING_METHOD:
     if (value == GLU_PATH_LENGTH) {
         nurbsValue = N_PATHLENGTH;
     } else if (value == GLU_PARAMETRIC_ERROR) {
         nurbsValue = N_PARAMETRICDISTANCE;
     } else if (value == GLU_DOMAIN_DISTANCE) {
         nurbsValue = N_DOMAINDISTANCE;
             r->set_is_domain_distance_sampling(1); //optimzing untrimmed case
 
     } else if (value == GLU_OBJECT_PARAMETRIC_ERROR) {
         nurbsValue = N_OBJECTSPACE_PARA;
         r->setautoloadmode( 0.0 ); 
         r->setSamplingMatrixIdentity();
     } else if (value == GLU_OBJECT_PATH_LENGTH) {
         nurbsValue = N_OBJECTSPACE_PATH;
         r->setautoloadmode( 0.0 ); 
         r->setSamplingMatrixIdentity();
     } else {
             r->postError(GLU_INVALID_VALUE);
             return;
         }
 
     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
     r->setnurbsproperty(GL_MAP2_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
     r->setnurbsproperty(GL_MAP1_VERTEX_3, N_SAMPLINGMETHOD, nurbsValue);
     r->setnurbsproperty(GL_MAP1_VERTEX_4, N_SAMPLINGMETHOD, nurbsValue);
     return;
 
       case GLU_SAMPLING_TOLERANCE:
     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_PIXEL_TOLERANCE, value);
     r->setnurbsproperty(GL_MAP2_VERTEX_4, N_PIXEL_TOLERANCE, value);
     r->setnurbsproperty(GL_MAP1_VERTEX_3, N_PIXEL_TOLERANCE, value);
     r->setnurbsproperty(GL_MAP1_VERTEX_4, N_PIXEL_TOLERANCE, value);
     return;
 
       case GLU_PARAMETRIC_TOLERANCE:
     r->setnurbsproperty(GL_MAP2_VERTEX_3, N_ERROR_TOLERANCE, value);
         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_ERROR_TOLERANCE, value);
         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_ERROR_TOLERANCE, value);
         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_ERROR_TOLERANCE, value);
         return;
     
 
       case GLU_DISPLAY_MODE:
     
     if (value == GLU_FILL) {
       nurbsValue = N_FILL;
     } else if (value == GLU_OUTLINE_POLYGON) {
       nurbsValue = N_OUTLINE_POLY;
     } else if (value == GLU_OUTLINE_PATCH) {
       nurbsValue = N_OUTLINE_PATCH;
     } else {
       r->postError(GLU_INVALID_VALUE);
       return;
     }
     r->setnurbsproperty(N_DISPLAY, nurbsValue);
     
     break;
 
       case GLU_U_STEP:
         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_S_STEPS, value);
         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_S_STEPS, value);
         r->setnurbsproperty(GL_MAP2_VERTEX_3, N_S_STEPS, value);
         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_S_STEPS, value);
     
     //added for optimizing untrimmed case
         r->set_domain_distance_u_rate(value);
     break;
 
       case GLU_V_STEP:
         r->setnurbsproperty(GL_MAP1_VERTEX_3, N_T_STEPS, value);
         r->setnurbsproperty(GL_MAP1_VERTEX_4, N_T_STEPS, value);
         r->setnurbsproperty(GL_MAP2_VERTEX_3, N_T_STEPS, value);
         r->setnurbsproperty(GL_MAP2_VERTEX_4, N_T_STEPS, value);
 
     //added for optimizing untrimmed case
         r->set_domain_distance_v_rate(value);
     break;
     
       case GLU_NURBS_MODE:
     if(value == GLU_NURBS_RENDERER)
       r->put_callbackFlag(0);
     else if(value == GLU_NURBS_TESSELLATOR)
       r->put_callbackFlag(1);
     else
       r->postError(GLU_INVALID_ENUM);
     break;
 
       default:
     r->postError(GLU_INVALID_ENUM);
     return; 
     }
 }

◆ gluNurbsSurface()

GLAPI void GLAPIENTRY gluNurbsSurface	(	GLUnurbs *	nurb,
		GLint	sKnotCount,
		GLfloat *	sKnots,
		GLint	tKnotCount,
		GLfloat *	tKnots,
		GLint	sStride,
		GLint	tStride,
		GLfloat *	control,
		GLint	sOrder,
		GLint	tOrder,
		GLenum	type
	)

Definition at line 199 of file glinterface.cc.

 {
 #ifdef DOWN_LOAD_NURBS
   {
     int dimension;
     switch(type){
     case GL_MAP2_VERTEX_3:
       dimension = 3;
       break;
     case GL_MAP2_VERTEX_4:
       dimension = 4;
       break;
     default:
       fprintf(stderr, "error in glinterface.c++, type no implemented\n");
       exit(1);
     }
 tempNurb = nurbSurfMake(sknot_count, sknot,
             tknot_count, tknot,
             sorder, torder,
             dimension,
             ctlarray,
             s_stride, t_stride);
             
   }
 #endif
 
     r->nurbssurface(sknot_count, sknot, tknot_count, tknot, 
         sizeof(INREAL) * s_stride, sizeof(INREAL) * t_stride, 
         ctlarray, sorder, torder, type);
 }

◆ gluOrtho2D()

GLAPI void GLAPIENTRY gluOrtho2D	(	GLdouble	left,
		GLdouble	right,
		GLdouble	bottom,
		GLdouble	top
	)

Definition at line 57 of file project.c.

 {
     glOrtho(left, right, bottom, top, -1, 1);
 }

◆ gluPartialDisk()

GLAPI void GLAPIENTRY gluPartialDisk	(	GLUquadric *	quad,
		GLdouble	inner,
		GLdouble	outer,
		GLint	slices,
		GLint	loops,
		GLdouble	start,
		GLdouble	sweep
	)

Definition at line 431 of file quad.c.

 {
     GLint i,j;
     GLfloat sinCache[CACHE_SIZE];
     GLfloat cosCache[CACHE_SIZE];
     GLfloat angle;
     GLfloat sintemp, costemp;
     GLfloat deltaRadius;
     GLfloat radiusLow, radiusHigh;
     GLfloat texLow = 0.0, texHigh = 0.0;
     GLfloat angleOffset;
     GLint slices2;
     GLint finish;
 
     if (slices >= CACHE_SIZE) slices = CACHE_SIZE-1;
     if (slices < 2 || loops < 1 || outerRadius <= 0.0 || innerRadius < 0.0 ||
         innerRadius > outerRadius) {
     gluQuadricError(qobj, GLU_INVALID_VALUE);
     return;
     }
 
     if (sweepAngle < -360.0) sweepAngle = 360.0;
     if (sweepAngle > 360.0) sweepAngle = 360.0;
     if (sweepAngle < 0) {
     startAngle += sweepAngle;
     sweepAngle = -sweepAngle;
     }
 
     if (sweepAngle == 360.0) {
     slices2 = slices;
     } else {
     slices2 = slices + 1;
     }
 
     /* Compute length (needed for normal calculations) */
     deltaRadius = outerRadius - innerRadius;
 
     /* Cache is the vertex locations cache */
 
     angleOffset = startAngle / 180.0 * PI;
     for (i = 0; i <= slices; i++) {
     angle = angleOffset + ((PI * sweepAngle) / 180.0) * i / slices;
     sinCache[i] = SIN(angle);
     cosCache[i] = COS(angle);
     }
 
     if (sweepAngle == 360.0) {
     sinCache[slices] = sinCache[0];
     cosCache[slices] = cosCache[0];
     }
 
     switch(qobj->normals) {
       case GLU_FLAT:
       case GLU_SMOOTH:
     if (qobj->orientation == GLU_OUTSIDE) {
         glNormal3f(0.0, 0.0, 1.0);
     } else {
         glNormal3f(0.0, 0.0, -1.0);
     }
     break;
       default:
       case GLU_NONE:
     break;
     }
 
     switch (qobj->drawStyle) {
       case GLU_FILL:
     if (innerRadius == 0.0) {
         finish = loops - 1;
         /* Triangle strip for inner polygons */
         glBegin(GL_TRIANGLE_FAN);
         if (qobj->textureCoords) {
         glTexCoord2f(0.5, 0.5);
         }
         glVertex3f(0.0, 0.0, 0.0);
         radiusLow = outerRadius -
             deltaRadius * ((float) (loops-1) / loops);
         if (qobj->textureCoords) {
         texLow = radiusLow / outerRadius / 2;
         }
 
         if (qobj->orientation == GLU_OUTSIDE) {
         for (i = slices; i >= 0; i--) {
             if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
             }
             glVertex3f(radiusLow * sinCache[i],
                 radiusLow * cosCache[i], 0.0);
         }
         } else {
         for (i = 0; i <= slices; i++) {
             if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
             }
             glVertex3f(radiusLow * sinCache[i],
                 radiusLow * cosCache[i], 0.0);
         }
         }
         glEnd();
     } else {
         finish = loops;
     }
     for (j = 0; j < finish; j++) {
         radiusLow = outerRadius - deltaRadius * ((float) j / loops);
         radiusHigh = outerRadius - deltaRadius * ((float) (j + 1) / loops);
         if (qobj->textureCoords) {
         texLow = radiusLow / outerRadius / 2;
         texHigh = radiusHigh / outerRadius / 2;
         }
 
         glBegin(GL_QUAD_STRIP);
         for (i = 0; i <= slices; i++) {
         if (qobj->orientation == GLU_OUTSIDE) {
             if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
             }
             glVertex3f(radiusLow * sinCache[i],
                 radiusLow * cosCache[i], 0.0);
 
             if (qobj->textureCoords) {
             glTexCoord2f(texHigh * sinCache[i] + 0.5,
                 texHigh * cosCache[i] + 0.5);
             }
             glVertex3f(radiusHigh * sinCache[i],
                 radiusHigh * cosCache[i], 0.0);
         } else {
             if (qobj->textureCoords) {
             glTexCoord2f(texHigh * sinCache[i] + 0.5,
                 texHigh * cosCache[i] + 0.5);
             }
             glVertex3f(radiusHigh * sinCache[i],
                 radiusHigh * cosCache[i], 0.0);
 
             if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
             }
             glVertex3f(radiusLow * sinCache[i],
                 radiusLow * cosCache[i], 0.0);
         }
         }
         glEnd();
     }
     break;
       case GLU_POINT:
     glBegin(GL_POINTS);
     for (i = 0; i < slices2; i++) {
         sintemp = sinCache[i];
         costemp = cosCache[i];
         for (j = 0; j <= loops; j++) {
         radiusLow = outerRadius - deltaRadius * ((float) j / loops);
 
         if (qobj->textureCoords) {
             texLow = radiusLow / outerRadius / 2;
 
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
         }
         glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
         }
     }
     glEnd();
     break;
       case GLU_LINE:
     if (innerRadius == outerRadius) {
         glBegin(GL_LINE_STRIP);
 
         for (i = 0; i <= slices; i++) {
         if (qobj->textureCoords) {
             glTexCoord2f(sinCache[i] / 2 + 0.5,
                 cosCache[i] / 2 + 0.5);
         }
         glVertex3f(innerRadius * sinCache[i],
             innerRadius * cosCache[i], 0.0);
         }
         glEnd();
         break;
     }
     for (j = 0; j <= loops; j++) {
         radiusLow = outerRadius - deltaRadius * ((float) j / loops);
         if (qobj->textureCoords) {
         texLow = radiusLow / outerRadius / 2;
         }
 
         glBegin(GL_LINE_STRIP);
         for (i = 0; i <= slices; i++) {
         if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
         }
         glVertex3f(radiusLow * sinCache[i],
             radiusLow * cosCache[i], 0.0);
         }
         glEnd();
     }
     for (i=0; i < slices2; i++) {
         sintemp = sinCache[i];
         costemp = cosCache[i];
         glBegin(GL_LINE_STRIP);
         for (j = 0; j <= loops; j++) {
         radiusLow = outerRadius - deltaRadius * ((float) j / loops);
         if (qobj->textureCoords) {
             texLow = radiusLow / outerRadius / 2;
         }
 
         if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
         }
         glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
         }
         glEnd();
     }
     break;
       case GLU_SILHOUETTE:
     if (sweepAngle < 360.0) {
         for (i = 0; i <= slices; i+= slices) {
         sintemp = sinCache[i];
         costemp = cosCache[i];
         glBegin(GL_LINE_STRIP);
         for (j = 0; j <= loops; j++) {
             radiusLow = outerRadius - deltaRadius * ((float) j / loops);
 
             if (qobj->textureCoords) {
             texLow = radiusLow / outerRadius / 2;
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
             }
             glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
         }
         glEnd();
         }
     }
     for (j = 0; j <= loops; j += loops) {
         radiusLow = outerRadius - deltaRadius * ((float) j / loops);
         if (qobj->textureCoords) {
         texLow = radiusLow / outerRadius / 2;
         }
 
         glBegin(GL_LINE_STRIP);
         for (i = 0; i <= slices; i++) {
         if (qobj->textureCoords) {
             glTexCoord2f(texLow * sinCache[i] + 0.5,
                 texLow * cosCache[i] + 0.5);
         }
         glVertex3f(radiusLow * sinCache[i],
             radiusLow * cosCache[i], 0.0);
         }
         glEnd();
         if (innerRadius == outerRadius) break;
     }
     break;
       default:
     break;
     }
 }

◆ gluPerspective()

GLAPI void GLAPIENTRY gluPerspective	(	GLdouble	fovy,
		GLdouble	aspect,
		GLdouble	zNear,
		GLdouble	zFar
	)

Definition at line 65 of file project.c.

 {
     GLdouble m[4][4];
     double sine, cotangent, deltaZ;
     double radians = fovy / 2 * __glPi / 180;
 
     deltaZ = zFar - zNear;
     sine = sin(radians);
     if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
     return;
     }
     cotangent = COS(radians) / sine;
 
     __gluMakeIdentityd(&m[0][0]);
     m[0][0] = cotangent / aspect;
     m[1][1] = cotangent;
     m[2][2] = -(zFar + zNear) / deltaZ;
     m[2][3] = -1;
     m[3][2] = -2 * zNear * zFar / deltaZ;
     m[3][3] = 0;
     glMultMatrixd(&m[0][0]);
 }

◆ gluPickMatrix()

GLAPI void GLAPIENTRY gluPickMatrix	(	GLdouble	x,
		GLdouble	y,
		GLdouble	delX,
		GLdouble	delY,
		GLint *	viewport
	)

◆ gluProject()

GLAPI GLint GLAPIENTRY gluProject	(	GLdouble	objX,
		GLdouble	objY,
		GLdouble	objZ,
		const GLdouble *	model,
		const GLdouble *	proj,
		const GLint *	view,
		GLdouble *	winX,
		GLdouble *	winY,
		GLdouble *	winZ
	)

◆ gluPwlCurve()

GLAPI void GLAPIENTRY gluPwlCurve	(	GLUnurbs *	nurb,
		GLint	count,
		GLfloat *	data,
		GLint	stride,
		GLenum	type
	)

◆ gluQuadricCallback()

GLAPI void GLAPIENTRY gluQuadricCallback	(	GLUquadric *	quad,
		GLenum	which,
		_GLUfuncptr	CallBackFunc
	)

Definition at line 86 of file quad.c.

 {
     switch (which) {
       case GLU_ERROR:
     qobj->errorCallback = (void (GLAPIENTRY *)(GLint)) fn;
     break;
       default:
     gluQuadricError(qobj, GLU_INVALID_ENUM);
     return;
     }
 }

◆ gluQuadricDrawStyle()

GLAPI void GLAPIENTRY gluQuadricDrawStyle	(	GLUquadric *	quad,
		GLenum	draw
	)

Definition at line 134 of file quad.c.

 {
     switch(drawStyle) {
       case GLU_POINT:
       case GLU_LINE:
       case GLU_FILL:
       case GLU_SILHOUETTE:
     break;
       default:
     gluQuadricError(qobj, GLU_INVALID_ENUM);
     return;
     }
     qobj->drawStyle = drawStyle;
 }

◆ gluQuadricNormals()

GLAPI void GLAPIENTRY gluQuadricNormals	(	GLUquadric *	quad,
		GLenum	normal
	)

Definition at line 99 of file quad.c.

 {
     switch (normals) {
       case GLU_SMOOTH:
       case GLU_FLAT:
       case GLU_NONE:
     break;
       default:
     gluQuadricError(qobj, GLU_INVALID_ENUM);
     return;
     }
     qobj->normals = normals;
 }

◆ gluQuadricOrientation()

GLAPI void GLAPIENTRY gluQuadricOrientation	(	GLUquadric *	quad,
		GLenum	orientation
	)

Definition at line 120 of file quad.c.

 {
     switch(orientation) {
       case GLU_OUTSIDE:
       case GLU_INSIDE:
     break;
       default:
     gluQuadricError(qobj, GLU_INVALID_ENUM);
     return;
     }
     qobj->orientation = orientation;
 }

◆ gluQuadricTexture()

GLAPI void GLAPIENTRY gluQuadricTexture	(	GLUquadric *	quad,
		GLboolean	texture
	)

Definition at line 114 of file quad.c.

 {
     qobj->textureCoords = textureCoords;
 }

◆ gluScaleImage()

GLAPI GLint GLAPIENTRY gluScaleImage	(	GLenum	format,
		GLsizei	wIn,
		GLsizei	hIn,
		GLenum	typeIn,
		const void *	dataIn,
		GLsizei	wOut,
		GLsizei	hOut,
		GLenum	typeOut,
		GLvoid *	dataOut
	)

Definition at line 3498 of file mipmap.c.

 {
     int components;
     GLushort *beforeImage;
     GLushort *afterImage;
     PixelStorageModes psm;
 
     if (widthin == 0 || heightin == 0 || widthout == 0 || heightout == 0) {
     return 0;
     }
     if (widthin < 0 || heightin < 0 || widthout < 0 || heightout < 0) {
     return GLU_INVALID_VALUE;
     }
     if (!legalFormat(format) || !legalType(typein) || !legalType(typeout)) {
     return GLU_INVALID_ENUM;
     }
     if (!isLegalFormatForPackedPixelType(format, typein)) {
        return GLU_INVALID_OPERATION;
     }
     if (!isLegalFormatForPackedPixelType(format, typeout)) {
        return GLU_INVALID_OPERATION;
     }
     beforeImage =
     malloc(image_size(widthin, heightin, format, GL_UNSIGNED_SHORT));
     afterImage =
     malloc(image_size(widthout, heightout, format, GL_UNSIGNED_SHORT));
     if (beforeImage == NULL || afterImage == NULL) {
     free(beforeImage);
     free(afterImage);
     return GLU_OUT_OF_MEMORY;
     }
 
     retrieveStoreModes(&psm);
     fill_image(&psm,widthin, heightin, format, typein, is_index(format),
         datain, beforeImage);
     components = elements_per_group(format, 0);
     scale_internal(components, widthin, heightin, beforeImage,
         widthout, heightout, afterImage);
     empty_image(&psm,widthout, heightout, format, typeout,
         is_index(format), afterImage, dataout);
     free((GLbyte *) beforeImage);
     free((GLbyte *) afterImage);
 
     return 0;
 }

◆ gluSphere()

GLAPI void GLAPIENTRY gluSphere	(	GLUquadric *	quad,
		GLdouble	radius,
		GLint	slices,
		GLint	stacks
	)

Definition at line 694 of file quad.c.

 {
     GLint i,j;
     GLfloat sinCache1a[CACHE_SIZE];
     GLfloat cosCache1a[CACHE_SIZE];
     GLfloat sinCache2a[CACHE_SIZE];
     GLfloat cosCache2a[CACHE_SIZE];
     GLfloat sinCache3a[CACHE_SIZE];
     GLfloat cosCache3a[CACHE_SIZE];
     GLfloat sinCache1b[CACHE_SIZE];
     GLfloat cosCache1b[CACHE_SIZE];
     GLfloat sinCache2b[CACHE_SIZE];
     GLfloat cosCache2b[CACHE_SIZE];
     GLfloat sinCache3b[CACHE_SIZE];
     GLfloat cosCache3b[CACHE_SIZE];
     GLfloat angle;
     GLfloat zLow, zHigh;
     GLfloat sintemp1 = 0.0, sintemp2 = 0.0, sintemp3 = 0.0, sintemp4 = 0.0;
     GLfloat costemp1 = 0.0, costemp2 = 0.0, costemp3 = 0.0, costemp4 = 0.0;
     GLboolean needCache2, needCache3;
     GLint start, finish;
 
     if (slices >= CACHE_SIZE) slices = CACHE_SIZE-1;
     if (stacks >= CACHE_SIZE) stacks = CACHE_SIZE-1;
     if (slices < 2 || stacks < 1 || radius < 0.0) {
     gluQuadricError(qobj, GLU_INVALID_VALUE);
     return;
     }
 
     /* Cache is the vertex locations cache */
     /* Cache2 is the various normals at the vertices themselves */
     /* Cache3 is the various normals for the faces */
     needCache2 = needCache3 = GL_FALSE;
 
     if (qobj->normals == GLU_SMOOTH) {
     needCache2 = GL_TRUE;
     }
 
     if (qobj->normals == GLU_FLAT) {
     if (qobj->drawStyle != GLU_POINT) {
         needCache3 = GL_TRUE;
     }
     if (qobj->drawStyle == GLU_LINE) {
         needCache2 = GL_TRUE;
     }
     }
 
     for (i = 0; i < slices; i++) {
     angle = 2 * PI * i / slices;
     sinCache1a[i] = SIN(angle);
     cosCache1a[i] = COS(angle);
     if (needCache2) {
         sinCache2a[i] = sinCache1a[i];
         cosCache2a[i] = cosCache1a[i];
     }
     }
 
     for (j = 0; j <= stacks; j++) {
     angle = PI * j / stacks;
     if (needCache2) {
         if (qobj->orientation == GLU_OUTSIDE) {
         sinCache2b[j] = SIN(angle);
         cosCache2b[j] = COS(angle);
         } else {
         sinCache2b[j] = -SIN(angle);
         cosCache2b[j] = -COS(angle);
         }
     }
     sinCache1b[j] = radius * SIN(angle);
     cosCache1b[j] = radius * COS(angle);
     }
     /* Make sure it comes to a point */
     sinCache1b[0] = 0;
     sinCache1b[stacks] = 0;
 
     if (needCache3) {
     for (i = 0; i < slices; i++) {
         angle = 2 * PI * (i-0.5) / slices;
         sinCache3a[i] = SIN(angle);
         cosCache3a[i] = COS(angle);
     }
     for (j = 0; j <= stacks; j++) {
         angle = PI * (j - 0.5) / stacks;
         if (qobj->orientation == GLU_OUTSIDE) {
         sinCache3b[j] = SIN(angle);
         cosCache3b[j] = COS(angle);
         } else {
         sinCache3b[j] = -SIN(angle);
         cosCache3b[j] = -COS(angle);
         }
     }
     }
 
     sinCache1a[slices] = sinCache1a[0];
     cosCache1a[slices] = cosCache1a[0];
     if (needCache2) {
     sinCache2a[slices] = sinCache2a[0];
     cosCache2a[slices] = cosCache2a[0];
     }
     if (needCache3) {
     sinCache3a[slices] = sinCache3a[0];
     cosCache3a[slices] = cosCache3a[0];
     }
 
     switch (qobj->drawStyle) {
       case GLU_FILL:
     /* Do ends of sphere as TRIANGLE_FAN's (if not texturing)
     ** We don't do it when texturing because we need to respecify the
     ** texture coordinates of the apex for every adjacent vertex (because
     ** it isn't a constant for that point)
     */
     if (!(qobj->textureCoords)) {
         start = 1;
         finish = stacks - 1;
 
         /* Low end first (j == 0 iteration) */
         sintemp2 = sinCache1b[1];
         zHigh = cosCache1b[1];
         switch(qobj->normals) {
           case GLU_FLAT:
         sintemp3 = sinCache3b[1];
         costemp3 = cosCache3b[1];
         break;
           case GLU_SMOOTH:
         sintemp3 = sinCache2b[1];
         costemp3 = cosCache2b[1];
         glNormal3f(sinCache2a[0] * sinCache2b[0],
             cosCache2a[0] * sinCache2b[0],
             cosCache2b[0]);
         break;
           default:
         break;
         }
         glBegin(GL_TRIANGLE_FAN);
         glVertex3f(0.0, 0.0, radius);
         if (qobj->orientation == GLU_OUTSIDE) {
         for (i = slices; i >= 0; i--) {
             switch(qobj->normals) {
               case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp3,
                 cosCache2a[i] * sintemp3,
                 costemp3);
             break;
               case GLU_FLAT:
             if (i != slices) {
                 glNormal3f(sinCache3a[i+1] * sintemp3,
                     cosCache3a[i+1] * sintemp3,
                     costemp3);
             }
             break;
               case GLU_NONE:
               default:
             break;
             }
             glVertex3f(sintemp2 * sinCache1a[i],
                 sintemp2 * cosCache1a[i], zHigh);
         }
         } else {
         for (i = 0; i <= slices; i++) {
             switch(qobj->normals) {
               case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp3,
                 cosCache2a[i] * sintemp3,
                 costemp3);
             break;
               case GLU_FLAT:
             glNormal3f(sinCache3a[i] * sintemp3,
                 cosCache3a[i] * sintemp3,
                 costemp3);
             break;
               case GLU_NONE:
               default:
             break;
             }
             glVertex3f(sintemp2 * sinCache1a[i],
                 sintemp2 * cosCache1a[i], zHigh);
         }
         }
         glEnd();
 
         /* High end next (j == stacks-1 iteration) */
         sintemp2 = sinCache1b[stacks-1];
         zHigh = cosCache1b[stacks-1];
         switch(qobj->normals) {
           case GLU_FLAT:
         sintemp3 = sinCache3b[stacks];
         costemp3 = cosCache3b[stacks];
         break;
           case GLU_SMOOTH:
         sintemp3 = sinCache2b[stacks-1];
         costemp3 = cosCache2b[stacks-1];
         glNormal3f(sinCache2a[stacks] * sinCache2b[stacks],
             cosCache2a[stacks] * sinCache2b[stacks],
             cosCache2b[stacks]);
         break;
           default:
         break;
         }
         glBegin(GL_TRIANGLE_FAN);
         glVertex3f(0.0, 0.0, -radius);
         if (qobj->orientation == GLU_OUTSIDE) {
         for (i = 0; i <= slices; i++) {
             switch(qobj->normals) {
               case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp3,
                 cosCache2a[i] * sintemp3,
                 costemp3);
             break;
               case GLU_FLAT:
             glNormal3f(sinCache3a[i] * sintemp3,
                 cosCache3a[i] * sintemp3,
                 costemp3);
             break;
               case GLU_NONE:
               default:
             break;
             }
             glVertex3f(sintemp2 * sinCache1a[i],
                 sintemp2 * cosCache1a[i], zHigh);
         }
         } else {
         for (i = slices; i >= 0; i--) {
             switch(qobj->normals) {
               case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp3,
                 cosCache2a[i] * sintemp3,
                 costemp3);
             break;
               case GLU_FLAT:
             if (i != slices) {
                 glNormal3f(sinCache3a[i+1] * sintemp3,
                     cosCache3a[i+1] * sintemp3,
                     costemp3);
             }
             break;
               case GLU_NONE:
               default:
             break;
             }
             glVertex3f(sintemp2 * sinCache1a[i],
                 sintemp2 * cosCache1a[i], zHigh);
         }
         }
         glEnd();
     } else {
         start = 0;
         finish = stacks;
     }
     for (j = start; j < finish; j++) {
         zLow = cosCache1b[j];
         zHigh = cosCache1b[j+1];
         sintemp1 = sinCache1b[j];
         sintemp2 = sinCache1b[j+1];
         switch(qobj->normals) {
           case GLU_FLAT:
         sintemp4 = sinCache3b[j+1];
         costemp4 = cosCache3b[j+1];
         break;
           case GLU_SMOOTH:
         if (qobj->orientation == GLU_OUTSIDE) {
             sintemp3 = sinCache2b[j+1];
             costemp3 = cosCache2b[j+1];
             sintemp4 = sinCache2b[j];
             costemp4 = cosCache2b[j];
         } else {
             sintemp3 = sinCache2b[j];
             costemp3 = cosCache2b[j];
             sintemp4 = sinCache2b[j+1];
             costemp4 = cosCache2b[j+1];
         }
         break;
           default:
         break;
         }
 
         glBegin(GL_QUAD_STRIP);
         for (i = 0; i <= slices; i++) {
         switch(qobj->normals) {
           case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp3,
                 cosCache2a[i] * sintemp3,
                 costemp3);
             break;
           case GLU_FLAT:
           case GLU_NONE:
           default:
             break;
         }
         if (qobj->orientation == GLU_OUTSIDE) {
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) (j+1) / stacks);
             }
             glVertex3f(sintemp2 * sinCache1a[i],
                 sintemp2 * cosCache1a[i], zHigh);
         } else {
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) j / stacks);
             }
             glVertex3f(sintemp1 * sinCache1a[i],
                 sintemp1 * cosCache1a[i], zLow);
         }
         switch(qobj->normals) {
           case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp4,
                 cosCache2a[i] * sintemp4,
                 costemp4);
             break;
           case GLU_FLAT:
             glNormal3f(sinCache3a[i] * sintemp4,
                 cosCache3a[i] * sintemp4,
                 costemp4);
             break;
           case GLU_NONE:
           default:
             break;
         }
         if (qobj->orientation == GLU_OUTSIDE) {
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) j / stacks);
             }
             glVertex3f(sintemp1 * sinCache1a[i],
                 sintemp1 * cosCache1a[i], zLow);
         } else {
             if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) (j+1) / stacks);
             }
             glVertex3f(sintemp2 * sinCache1a[i],
                 sintemp2 * cosCache1a[i], zHigh);
         }
         }
         glEnd();
     }
     break;
       case GLU_POINT:
     glBegin(GL_POINTS);
     for (j = 0; j <= stacks; j++) {
         sintemp1 = sinCache1b[j];
         costemp1 = cosCache1b[j];
         switch(qobj->normals) {
           case GLU_FLAT:
           case GLU_SMOOTH:
         sintemp2 = sinCache2b[j];
         costemp2 = cosCache2b[j];
         break;
           default:
         break;
         }
         for (i = 0; i < slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
           case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp2,
                 cosCache2a[i] * sintemp2,
                 costemp2);
             break;
           case GLU_NONE:
           default:
             break;
         }
 
         zLow = j * radius / stacks;
 
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) j / stacks);
         }
         glVertex3f(sintemp1 * sinCache1a[i],
             sintemp1 * cosCache1a[i], costemp1);
         }
     }
     glEnd();
     break;
       case GLU_LINE:
       case GLU_SILHOUETTE:
     for (j = 1; j < stacks; j++) {
         sintemp1 = sinCache1b[j];
         costemp1 = cosCache1b[j];
         switch(qobj->normals) {
           case GLU_FLAT:
           case GLU_SMOOTH:
         sintemp2 = sinCache2b[j];
         costemp2 = cosCache2b[j];
         break;
           default:
         break;
         }
 
         glBegin(GL_LINE_STRIP);
         for (i = 0; i <= slices; i++) {
         switch(qobj->normals) {
           case GLU_FLAT:
             glNormal3f(sinCache3a[i] * sintemp2,
                 cosCache3a[i] * sintemp2,
                 costemp2);
             break;
           case GLU_SMOOTH:
             glNormal3f(sinCache2a[i] * sintemp2,
                 cosCache2a[i] * sintemp2,
                 costemp2);
             break;
           case GLU_NONE:
           default:
             break;
         }
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) j / stacks);
         }
         glVertex3f(sintemp1 * sinCache1a[i],
             sintemp1 * cosCache1a[i], costemp1);
         }
         glEnd();
     }
     for (i = 0; i < slices; i++) {
         sintemp1 = sinCache1a[i];
         costemp1 = cosCache1a[i];
         switch(qobj->normals) {
           case GLU_FLAT:
           case GLU_SMOOTH:
         sintemp2 = sinCache2a[i];
         costemp2 = cosCache2a[i];
         break;
           default:
         break;
         }
 
         glBegin(GL_LINE_STRIP);
         for (j = 0; j <= stacks; j++) {
         switch(qobj->normals) {
           case GLU_FLAT:
             glNormal3f(sintemp2 * sinCache3b[j],
                 costemp2 * sinCache3b[j],
                 cosCache3b[j]);
             break;
           case GLU_SMOOTH:
             glNormal3f(sintemp2 * sinCache2b[j],
                 costemp2 * sinCache2b[j],
                 cosCache2b[j]);
             break;
           case GLU_NONE:
           default:
             break;
         }
 
         if (qobj->textureCoords) {
             glTexCoord2f(1 - (float) i / slices,
                 1 - (float) j / stacks);
         }
         glVertex3f(sintemp1 * sinCache1b[j],
             costemp1 * sinCache1b[j], cosCache1b[j]);
         }
         glEnd();
     }
     break;
       default:
     break;
     }
 }

◆ gluTessBeginContour()

GLAPI void GLAPIENTRY gluTessBeginContour ( GLUtesselator * tess )

Definition at line 476 of file tess.c.

 {
   RequireState( tess, T_IN_POLYGON );
 
   tess->state = T_IN_CONTOUR;
   tess->lastEdge = NULL;
   if( tess->cacheCount > 0 ) {
     /* Just set a flag so we don't get confused by empty contours
      * -- these can be generated accidentally with the obsolete
      * NextContour() interface.
      */
     tess->emptyCache = TRUE;
   }
 }

◆ gluTessBeginPolygon()

GLAPI void GLAPIENTRY gluTessBeginPolygon	(	GLUtesselator *	tess,
		GLvoid *	data
	)

Definition at line 462 of file tess.c.

 {
   RequireState( tess, T_DORMANT );
 
   tess->state = T_IN_POLYGON;
   tess->cacheCount = 0;
   tess->emptyCache = FALSE;
   tess->mesh = NULL;
 
   tess->polygonData= data;
 }

◆ gluTessCallback()

GLAPI void GLAPIENTRY gluTessCallback	(	GLUtesselator *	tess,
		GLenum	which,
		_GLUfuncptr	CallBackFunc
	)

Definition at line 276 of file tess.c.

 {
   switch( which ) {
   case GLU_TESS_BEGIN:
     tess->callBegin = (fn == NULL) ? &noBegin : (void (GLAPIENTRY *)(GLenum)) fn;
     return;
   case GLU_TESS_BEGIN_DATA:
     tess->callBeginData = (fn == NULL) ?
     &__gl_noBeginData : (void (GLAPIENTRY *)(GLenum, void *)) fn;
     return;
   case GLU_TESS_EDGE_FLAG:
     tess->callEdgeFlag = (fn == NULL) ? &noEdgeFlag :
                     (void (GLAPIENTRY *)(GLboolean)) fn;
     /* If the client wants boundary edges to be flagged,
      * we render everything as separate triangles (no strips or fans).
      */
     tess->flagBoundary = (fn != NULL);
     return;
   case GLU_TESS_EDGE_FLAG_DATA:
     tess->callEdgeFlagData= (fn == NULL) ?
     &__gl_noEdgeFlagData : (void (GLAPIENTRY *)(GLboolean, void *)) fn;
     /* If the client wants boundary edges to be flagged,
      * we render everything as separate triangles (no strips or fans).
      */
     tess->flagBoundary = (fn != NULL);
     return;
   case GLU_TESS_VERTEX:
     tess->callVertex = (fn == NULL) ? &noVertex :
                       (void (GLAPIENTRY *)(void *)) fn;
     return;
   case GLU_TESS_VERTEX_DATA:
     tess->callVertexData = (fn == NULL) ?
     &__gl_noVertexData : (void (GLAPIENTRY *)(void *, void *)) fn;
     return;
   case GLU_TESS_END:
     tess->callEnd = (fn == NULL) ? &noEnd : (void (GLAPIENTRY *)(void)) fn;
     return;
   case GLU_TESS_END_DATA:
     tess->callEndData = (fn == NULL) ? &__gl_noEndData :
                        (void (GLAPIENTRY *)(void *)) fn;
     return;
   case GLU_TESS_ERROR:
     tess->callError = (fn == NULL) ? &noError : (void (GLAPIENTRY *)(GLenum)) fn;
     return;
   case GLU_TESS_ERROR_DATA:
     tess->callErrorData = (fn == NULL) ?
     &__gl_noErrorData : (void (GLAPIENTRY *)(GLenum, void *)) fn;
     return;
   case GLU_TESS_COMBINE:
     tess->callCombine = (fn == NULL) ? &noCombine :
     (void (GLAPIENTRY *)(GLdouble [3],void *[4], GLfloat [4], void ** )) fn;
     return;
   case GLU_TESS_COMBINE_DATA:
     tess->callCombineData = (fn == NULL) ? &__gl_noCombineData :
                        (void (GLAPIENTRY *)(GLdouble [3],
                              void *[4],
                              GLfloat [4],
                              void **,
                              void *)) fn;
     return;
   case GLU_TESS_MESH:
     tess->callMesh = (fn == NULL) ? &noMesh : (void (GLAPIENTRY *)(GLUmesh *)) fn;
     return;
   default:
     CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
     return;
   }
 }

◆ gluTessEndContour()

GLAPI void GLAPIENTRY gluTessEndContour ( GLUtesselator * tess )

Definition at line 493 of file tess.c.

 {
   RequireState( tess, T_IN_CONTOUR );
   tess->state = T_IN_POLYGON;
 }

◆ gluTessEndPolygon()

GLAPI void GLAPIENTRY gluTessEndPolygon ( GLUtesselator * tess )

Definition at line 500 of file tess.c.

 {
   GLUmesh *mesh;
 
   if (setjmp(tess->env) != 0) { 
      /* come back here if out of memory */
      CALL_ERROR_OR_ERROR_DATA( GLU_OUT_OF_MEMORY );
      return;
   }
 
   RequireState( tess, T_IN_POLYGON );
   tess->state = T_DORMANT;
 
   if( tess->mesh == NULL ) {
     if( ! tess->flagBoundary && tess->callMesh == &noMesh ) {
 
       /* Try some special code to make the easy cases go quickly
        * (eg. convex polygons).  This code does NOT handle multiple contours,
        * intersections, edge flags, and of course it does not generate
        * an explicit mesh either.
        */
       if( __gl_renderCache( tess )) {
     tess->polygonData= NULL;
     return;
       }
     }
     if ( !EmptyCache( tess ) ) longjmp(tess->env,1); /* could've used a label*/
   }
 
   /* Determine the polygon normal and project vertices onto the plane
    * of the polygon.
    */
   __gl_projectPolygon( tess );
 
   /* __gl_computeInterior( tess ) computes the planar arrangement specified
    * by the given contours, and further subdivides this arrangement
    * into regions.  Each region is marked "inside" if it belongs
    * to the polygon, according to the rule given by tess->windingRule.
    * Each interior region is guaranteed be monotone.
    */
   if ( !__gl_computeInterior( tess ) ) {
      longjmp(tess->env,1);  /* could've used a label */
   }
 
   mesh = tess->mesh;
   if( ! tess->fatalError ) {
     int rc = 1;
 
     /* If the user wants only the boundary contours, we throw away all edges
      * except those which separate the interior from the exterior.
      * Otherwise we tessellate all the regions marked "inside".
      */
     if( tess->boundaryOnly ) {
       rc = __gl_meshSetWindingNumber( mesh, 1, TRUE );
     } else {
       rc = __gl_meshTessellateInterior( mesh );
     }
     if (rc == 0) longjmp(tess->env,1);  /* could've used a label */
 
     __gl_meshCheckMesh( mesh );
 
     if( tess->callBegin != &noBegin || tess->callEnd != &noEnd
        || tess->callVertex != &noVertex || tess->callEdgeFlag != &noEdgeFlag
        || tess->callBeginData != &__gl_noBeginData
        || tess->callEndData != &__gl_noEndData
        || tess->callVertexData != &__gl_noVertexData
        || tess->callEdgeFlagData != &__gl_noEdgeFlagData )
     {
       if( tess->boundaryOnly ) {
     __gl_renderBoundary( tess, mesh );  /* output boundary contours */
       } else {
     __gl_renderMesh( tess, mesh );     /* output strips and fans */
       }
     }
     if( tess->callMesh != &noMesh ) {
 
       /* Throw away the exterior faces, so that all faces are interior.
        * This way the user doesn't have to check the "inside" flag,
        * and we don't need to even reveal its existence.  It also leaves
        * the freedom for an implementation to not generate the exterior
        * faces in the first place.
        */
       __gl_meshDiscardExterior( mesh );
       (*tess->callMesh)( mesh );        /* user wants the mesh itself */
       tess->mesh = NULL;
       tess->polygonData= NULL;
       return;
     }
   }
   __gl_meshDeleteMesh( mesh );
   tess->polygonData= NULL;
   tess->mesh = NULL;
 }

◆ gluTessNormal()

GLAPI void GLAPIENTRY gluTessNormal	(	GLUtesselator *	tess,
		GLdouble	valueX,
		GLdouble	valueY,
		GLdouble	valueZ
	)

Definition at line 268 of file tess.c.

 {
   tess->normal[0] = x;
   tess->normal[1] = y;
   tess->normal[2] = z;
 }

◆ gluTessProperty()

GLAPI void GLAPIENTRY gluTessProperty	(	GLUtesselator *	tess,
		GLenum	which,
		GLdouble	data
	)

Definition at line 201 of file tess.c.

 {
   GLenum windingRule;
 
   switch( which ) {
   case GLU_TESS_TOLERANCE:
     if( value < 0.0 || value > 1.0 ) break;
     tess->relTolerance = value;
     return;
 
   case GLU_TESS_WINDING_RULE:
     windingRule = (GLenum) value;
     if( windingRule != value ) break;   /* not an integer */
 
     switch( windingRule ) {
     case GLU_TESS_WINDING_ODD:
     case GLU_TESS_WINDING_NONZERO:
     case GLU_TESS_WINDING_POSITIVE:
     case GLU_TESS_WINDING_NEGATIVE:
     case GLU_TESS_WINDING_ABS_GEQ_TWO:
       tess->windingRule = windingRule;
       return;
     default:
       break;
     }
 
   case GLU_TESS_BOUNDARY_ONLY:
     tess->boundaryOnly = (value != 0);
     return;
 
   default:
     CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_ENUM );
     return;
   }
   CALL_ERROR_OR_ERROR_DATA( GLU_INVALID_VALUE );
 }

◆ gluTessVertex()

GLAPI void GLAPIENTRY gluTessVertex	(	GLUtesselator *	tess,
		GLdouble *	lo

Macros

Typedefs

Functions