#include <GL/gl.h>
Include dependency graph for glu.h:
Go to the source code of this file.
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 |
Macro Definition Documentation
◆ GLAPI
◆ GLAPIENTRY
◆ GLAPIENTRYP
| #define GLAPIENTRYP GLAPIENTRY * |
◆ GLU_AUTO_LOAD_MATRIX
◆ GLU_BEGIN
◆ GLU_CCW
◆ GLU_CULLING
◆ GLU_CW
◆ GLU_DISPLAY_MODE
◆ GLU_DOMAIN_DISTANCE
◆ GLU_EDGE_FLAG
◆ GLU_END
◆ GLU_ERROR
◆ GLU_EXT_nurbs_tessellator
◆ GLU_EXT_object_space_tess
◆ GLU_EXTENSIONS
◆ GLU_EXTERIOR
◆ GLU_FALSE
◆ GLU_FILL
◆ GLU_FLAT
◆ GLU_INCOMPATIBLE_GL_VERSION
◆ GLU_INSIDE
◆ GLU_INTERIOR
◆ GLU_INVALID_ENUM
◆ GLU_INVALID_OPERATION
◆ GLU_INVALID_VALUE
◆ GLU_LINE
◆ GLU_MAP1_TRIM_2
◆ GLU_MAP1_TRIM_3
◆ GLU_NONE
◆ GLU_NURBS_BEGIN
◆ GLU_NURBS_BEGIN_DATA
◆ GLU_NURBS_BEGIN_DATA_EXT
◆ GLU_NURBS_BEGIN_EXT
◆ GLU_NURBS_COLOR
◆ GLU_NURBS_COLOR_DATA
◆ GLU_NURBS_COLOR_DATA_EXT
◆ GLU_NURBS_COLOR_EXT
◆ GLU_NURBS_END
◆ GLU_NURBS_END_DATA
◆ GLU_NURBS_END_DATA_EXT
◆ GLU_NURBS_END_EXT
◆ GLU_NURBS_ERROR
◆ GLU_NURBS_ERROR1
◆ GLU_NURBS_ERROR10
◆ GLU_NURBS_ERROR11
◆ GLU_NURBS_ERROR12
◆ GLU_NURBS_ERROR13
◆ GLU_NURBS_ERROR14
◆ GLU_NURBS_ERROR15
◆ GLU_NURBS_ERROR16
◆ GLU_NURBS_ERROR17
◆ GLU_NURBS_ERROR18
◆ GLU_NURBS_ERROR19
◆ GLU_NURBS_ERROR2
◆ GLU_NURBS_ERROR20
◆ GLU_NURBS_ERROR21
◆ GLU_NURBS_ERROR22
◆ GLU_NURBS_ERROR23
◆ GLU_NURBS_ERROR24
◆ GLU_NURBS_ERROR25
◆ GLU_NURBS_ERROR26
◆ GLU_NURBS_ERROR27
◆ GLU_NURBS_ERROR28
◆ GLU_NURBS_ERROR29
◆ GLU_NURBS_ERROR3
◆ GLU_NURBS_ERROR30
◆ GLU_NURBS_ERROR31
◆ GLU_NURBS_ERROR32
◆ GLU_NURBS_ERROR33
◆ GLU_NURBS_ERROR34
◆ GLU_NURBS_ERROR35
◆ GLU_NURBS_ERROR36
◆ GLU_NURBS_ERROR37
◆ GLU_NURBS_ERROR4
◆ GLU_NURBS_ERROR5
◆ GLU_NURBS_ERROR6
◆ GLU_NURBS_ERROR7
◆ GLU_NURBS_ERROR8
◆ GLU_NURBS_ERROR9
◆ GLU_NURBS_MODE
◆ GLU_NURBS_MODE_EXT
◆ GLU_NURBS_NORMAL
◆ GLU_NURBS_NORMAL_DATA
◆ GLU_NURBS_NORMAL_DATA_EXT
◆ GLU_NURBS_NORMAL_EXT
◆ GLU_NURBS_RENDERER
◆ GLU_NURBS_RENDERER_EXT
◆ GLU_NURBS_TESSELLATOR
◆ GLU_NURBS_TESSELLATOR_EXT
◆ GLU_NURBS_TEX_COORD_DATA_EXT
◆ GLU_NURBS_TEX_COORD_EXT
◆ GLU_NURBS_TEXTURE_COORD
◆ GLU_NURBS_TEXTURE_COORD_DATA
◆ GLU_NURBS_VERTEX
◆ GLU_NURBS_VERTEX_DATA
◆ GLU_NURBS_VERTEX_DATA_EXT
◆ GLU_NURBS_VERTEX_EXT
◆ GLU_OBJECT_PARAMETRIC_ERROR
◆ GLU_OBJECT_PARAMETRIC_ERROR_EXT
◆ GLU_OBJECT_PATH_LENGTH
◆ GLU_OBJECT_PATH_LENGTH_EXT
◆ GLU_OUT_OF_MEMORY
◆ GLU_OUTLINE_PATCH
◆ GLU_OUTLINE_POLYGON
◆ GLU_OUTSIDE
◆ GLU_PARAMETRIC_ERROR
◆ GLU_PARAMETRIC_TOLERANCE
◆ GLU_PATH_LENGTH
◆ GLU_POINT
◆ GLU_SAMPLING_METHOD
◆ GLU_SAMPLING_TOLERANCE
◆ GLU_SILHOUETTE
◆ GLU_SMOOTH
◆ GLU_TESS_BEGIN
◆ GLU_TESS_BEGIN_DATA
◆ GLU_TESS_BOUNDARY_ONLY
◆ GLU_TESS_COMBINE
◆ GLU_TESS_COMBINE_DATA
◆ GLU_TESS_COORD_TOO_LARGE
◆ GLU_TESS_EDGE_FLAG
◆ GLU_TESS_EDGE_FLAG_DATA
◆ GLU_TESS_END
◆ GLU_TESS_END_DATA
◆ GLU_TESS_ERROR
◆ GLU_TESS_ERROR1
◆ GLU_TESS_ERROR2
◆ GLU_TESS_ERROR3
◆ GLU_TESS_ERROR4
◆ GLU_TESS_ERROR5
◆ GLU_TESS_ERROR6
◆ GLU_TESS_ERROR7
◆ GLU_TESS_ERROR8
◆ GLU_TESS_ERROR_DATA
◆ GLU_TESS_MAX_COORD
◆ GLU_TESS_MISSING_BEGIN_CONTOUR
◆ GLU_TESS_MISSING_BEGIN_POLYGON
◆ GLU_TESS_MISSING_END_CONTOUR
◆ GLU_TESS_MISSING_END_POLYGON
◆ GLU_TESS_NEED_COMBINE_CALLBACK
◆ GLU_TESS_TOLERANCE
◆ GLU_TESS_VERTEX
◆ GLU_TESS_VERTEX_DATA
◆ GLU_TESS_WINDING_ABS_GEQ_TWO
◆ GLU_TESS_WINDING_NEGATIVE
◆ GLU_TESS_WINDING_NONZERO
◆ GLU_TESS_WINDING_ODD
◆ GLU_TESS_WINDING_POSITIVE
◆ GLU_TESS_WINDING_RULE
◆ GLU_TRUE
◆ GLU_U_STEP
◆ GLU_UNKNOWN
◆ GLU_V_STEP
◆ GLU_VERSION
◆ GLU_VERSION_1_1
◆ GLU_VERSION_1_2
◆ GLU_VERSION_1_3
◆ GLU_VERTEX
Typedef Documentation
◆ GLUnurbs
◆ GLUnurbsObj
| typedef GLUnurbs GLUnurbsObj |
◆ GLUquadric
| typedef struct GLUquadric GLUquadric |
◆ GLUquadricObj
| typedef GLUquadric GLUquadricObj |
◆ GLUtesselator
| typedef struct GLUtesselator GLUtesselator |
◆ GLUtesselatorObj
| typedef GLUtesselator GLUtesselatorObj |
◆ GLUtriangulatorObj
| typedef GLUtesselator GLUtriangulatorObj |
Function Documentation
◆ gluBeginCurve()
| GLAPI void GLAPIENTRY gluBeginCurve | ( | GLUnurbs * | nurb | ) |
Definition at line 99 of file glinterface.cc.
◆ gluBeginPolygon()
| GLAPI void GLAPIENTRY gluBeginPolygon | ( | GLUtesselator * | tess | ) |
◆ gluBeginSurface()
| GLAPI void GLAPIENTRY gluBeginSurface | ( | GLUnurbs * | nurb | ) |
Definition at line 89 of file glinterface.cc.
90{
91#ifdef DOWN_LOAD_NURBS
92surfcount++;
93tempTrim = OTL_make(10,10);
94#endif
95 r->bgnsurface(0);
96}
◆ gluBeginTrim()
| GLAPI void GLAPIENTRY gluBeginTrim | ( | GLUnurbs * | nurb | ) |
Definition at line 131 of file glinterface.cc.
◆ 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.
3648{
3650
3652 if (rc != 0) return rc;
3653
3656 }
3657
3659
3660 levels+= userLevel;
3663
3665 width,
3667 userLevel, baseLevel, maxLevel,
3668 data);
3669} /* gluBuild1DMipmapLevels() */
static int gluBuild1DMipmapLevelsCore(GLenum, GLint, GLsizei, GLsizei, GLenum, GLenum, GLint, GLint, GLint, const void *)
Definition: mipmap.c:3547
◆ 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.
3675{
3676 GLint widthPowerOf2;
3679
3681 if (rc != 0) return rc;
3682
3685 }
3686
3689
3691 width,
3692 widthPowerOf2,
3694}
Definition: ndr_types.idl:28
static void closestFit(GLenum, GLint, GLint, GLint, GLenum, GLenum, GLint *, GLint *)
Definition: mipmap.c:3410
◆ 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.
4559{
4561
4563 if (rc != 0) return rc;
4564
4567 }
4568
4572
4573 levels+= userLevel;
4576
4581 userLevel, baseLevel, maxLevel,
4582 data);
4583} /* gluBuild2DMipmapLevels() */
static int gluBuild2DMipmapLevelsCore(GLenum, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLint, GLint, GLint, const void *)
Definition: mipmap.c:3802
◆ gluBuild2DMipmaps()
| GLAPI GLint GLAPIENTRY gluBuild2DMipmaps | ( | GLenum | target, |
| GLint | internalFormat, | ||
| GLsizei | width, | ||
| GLsizei | height, | ||
| GLenum | format, | ||
| GLenum | type, | ||
| const void * | data | ||
| ) |
◆ 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.
8451{
8453
8455 if (rc != 0) return rc;
8456
8459 }
8460
8463 }
8464
8470
8471 levels+= userLevel;
8474
8479 userLevel, baseLevel, maxLevel,
8480 data);
8481} /* gluBuild3DMipmapLevels() */
static int gluBuild3DMipmapLevelsCore(GLenum, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLint, GLint, GLint, const void *)
Definition: mipmap.c:7722
◆ 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.
8487{
8488 GLint widthPowerOf2, heightPowerOf2, depthPowerOf2;
8490
8492 if (rc != 0) return rc;
8493
8496 }
8497
8500 }
8501
8503 &widthPowerOf2,&heightPowerOf2,&depthPowerOf2);
8504
8510
8513 widthPowerOf2, heightPowerOf2,
8514 depthPowerOf2,
8516 data);
8517} /* gluBuild3DMipmaps() */
static void closestFit3D(GLenum target, GLint width, GLint height, GLint depth, GLint internalFormat, GLenum format, GLenum type, GLint *newWidth, GLint *newHeight, GLint *newDepth)
Definition: mipmap.c:7412
◆ gluCheckExtension()
Definition at line 63 of file registry.c.
64{
67 char *lookHere;
68 char *deleteThis;
69
71
75 /* strtok() will modify string, so copy it somewhere */
77
81 break;
82 }
84 }
87} /* gluCheckExtension() */
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean flag
Definition: glfuncs.h:52
◆ 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.
152{
161 GLfloat zLow, zHigh;
162 GLfloat sintemp, costemp;
164 GLfloat deltaRadius;
165 GLfloat zNormal;
166 GLfloat xyNormalRatio;
167 GLfloat radiusLow, radiusHigh;
168 int needCache2, needCache3;
169
171
172 if (slices < 2 || stacks < 1 || baseRadius < 0.0 || topRadius < 0.0 ||
173 height < 0.0) {
175 return;
176 }
177
178 /* Compute length (needed for normal calculations) */
179 deltaRadius = baseRadius - topRadius;
183 return;
184 }
185
186 /* Cache is the vertex locations cache */
187 /* Cache2 is the various normals at the vertices themselves */
188 /* Cache3 is the various normals for the faces */
189 needCache2 = needCache3 = 0;
191 needCache2 = 1;
192 }
193
196 needCache3 = 1;
197 }
199 needCache2 = 1;
200 }
201 }
202
203 zNormal = deltaRadius / length;
205
208 if (needCache2) {
212 } else {
215 }
216 }
219 }
220
221 if (needCache3) {
227 } else {
230 }
231 }
232 }
233
234 sinCache[slices] = sinCache[0];
235 cosCache[slices] = cosCache[0];
236 if (needCache2) {
237 sinCache2[slices] = sinCache2[0];
238 cosCache2[slices] = cosCache2[0];
239 }
240 if (needCache3) {
241 sinCache3[slices] = sinCache3[0];
242 cosCache3[slices] = cosCache3[0];
243 }
244
245 switch (qobj->drawStyle) {
247 /* Note:
248 ** An argument could be made for using a TRIANGLE_FAN for the end
249 ** of the cylinder of either radii is 0.0 (a cone). However, a
250 ** TRIANGLE_FAN would not work in smooth shading mode (the common
251 ** case) because the normal for the apex is different for every
252 ** triangle (and TRIANGLE_FAN doesn't let me respecify that normal).
253 ** Now, my choice is GL_TRIANGLES, or leave the GL_QUAD_STRIP and
254 ** just let the GL trivially reject one of the two triangles of the
255 ** QUAD. GL_QUAD_STRIP is probably faster, so I will leave this code
256 ** alone.
257 */
263
266 switch(qobj->normals) {
269 break;
272 break;
274 default:
275 break;
276 }
278 if (qobj->textureCoords) {
281 }
283 radiusLow * cosCache[i], zLow);
284 if (qobj->textureCoords) {
287 }
289 radiusHigh * cosCache[i], zHigh);
290 } else {
291 if (qobj->textureCoords) {
294 }
296 radiusHigh * cosCache[i], zHigh);
297 if (qobj->textureCoords) {
300 }
302 radiusLow * cosCache[i], zLow);
303 }
304 }
305 glEnd();
306 }
307 break;
311 switch(qobj->normals) {
315 break;
317 default:
318 break;
319 }
320 sintemp = sinCache[i];
321 costemp = cosCache[i];
325
326 if (qobj->textureCoords) {
329 }
330 glVertex3f(radiusLow * sintemp,
331 radiusLow * costemp, zLow);
332 }
333 }
334 glEnd();
335 break;
340
343 switch(qobj->normals) {
346 break;
349 break;
351 default:
352 break;
353 }
354 if (qobj->textureCoords) {
357 }
359 radiusLow * cosCache[i], zLow);
360 }
361 glEnd();
362 }
363 /* Intentionally fall through here... */
368
371 switch(qobj->normals) {
374 break;
377 break;
379 default:
380 break;
381 }
382 if (qobj->textureCoords) {
385 }
387 zLow);
388 }
389 glEnd();
390 }
392 switch(qobj->normals) {
396 break;
398 default:
399 break;
400 }
401 sintemp = sinCache[i];
402 costemp = cosCache[i];
407
408 if (qobj->textureCoords) {
411 }
412 glVertex3f(radiusLow * sintemp,
413 radiusLow * costemp, zLow);
414 }
415 glEnd();
416 }
417 break;
418 default:
419 break;
420 }
421}
GLAPI void GLAPIENTRY glTexCoord2f(GLfloat s, GLfloat t)
GLAPI void GLAPIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
GLAPI void GLAPIENTRY glBegin(GLenum mode)
GLAPI void GLAPIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z)
GLAPI void GLAPIENTRY glEnd(void)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
static float(__cdecl *square_half_float)(float x
◆ gluDeleteNurbsRenderer()
| GLAPI void GLAPIENTRY gluDeleteNurbsRenderer | ( | GLUnurbs * | nurb | ) |
Definition at line 75 of file glinterface.cc.
◆ gluDeleteQuadric()
| GLAPI void GLAPIENTRY gluDeleteQuadric | ( | GLUquadric * | quad | ) |
◆ gluDeleteTess()
| GLAPI void GLAPIENTRY gluDeleteTess | ( | GLUtesselator * | tess | ) |
◆ gluDisk()
| GLAPI void GLAPIENTRY gluDisk | ( | GLUquadric * | quad, |
| GLdouble | inner, | ||
| GLdouble | outer, | ||
| GLint | slices, | ||
| GLint | loops | ||
| ) |
◆ gluEndCurve()
| GLAPI void GLAPIENTRY gluEndCurve | ( | GLUnurbs * | nurb | ) |
Definition at line 105 of file glinterface.cc.
◆ gluEndPolygon()
| GLAPI void GLAPIENTRY gluEndPolygon | ( | GLUtesselator * | tess | ) |
◆ gluEndSurface()
| GLAPI void GLAPIENTRY gluEndSurface | ( | GLUnurbs * | nurb | ) |
Definition at line 111 of file glinterface.cc.
112{
113#ifdef DOWN_LOAD_NURBS
114if(surfcount == 1)
115 otn = OTN_make(1);
116OTN_insert(otn, tempNurb, tempTrim);
117if(surfcount >= 1)
118{
119#ifdef DEBUG
121#endif
122OTN_write(otn, "out.otn");
123
124}
125#endif
126
127 r->endsurface();
128}
◆ gluEndTrim()
| GLAPI void GLAPIENTRY gluEndTrim | ( | GLUnurbs * | nurb | ) |
Definition at line 141 of file glinterface.cc.
◆ gluErrorString()
| GLAPI const GLubyte *GLAPIENTRY gluErrorString | ( | GLenum | error | ) |
◆ gluGetNurbsProperty()
Definition at line 359 of file glinterface.cc.
360{
361 GLfloat nurbsValue;
362
367 } else {
369 }
370 break;
375 } else {
377 }
378 break;
391 break;
394 break;
397 break;
398
401 break;
404 break;
411 } else {
413 }
414 break;
415
419 else
421 break;
422
423 default:
425 return;
426 }
427}
Definition: locator.c:103
Definition: pdh_main.c:94
◆ gluGetString()
| GLAPI const GLubyte *GLAPIENTRY gluGetString | ( | GLenum | name | ) |
Definition at line 44 of file registry.c.
45{
46
51 }
53}
◆ gluGetTessProperty()
| GLAPI void GLAPIENTRY gluGetTessProperty | ( | GLUtesselator * | tess, |
| GLenum | which, | ||
| GLdouble * | data | ||
| ) |
◆ 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.
111{
114
115 forward[0] = centerx - eyex;
116 forward[1] = centery - eyey;
117 forward[2] = centerz - eyez;
118
119 up[0] = upx;
120 up[1] = upy;
121 up[2] = upz;
122
123 normalize(forward);
124
125 /* Side = forward x up */
127 normalize(side);
128
129 /* Recompute up as: up = side x forward */
131
133 m[0][0] = side[0];
134 m[1][0] = side[1];
135 m[2][0] = side[2];
136
140
141 m[0][2] = -forward[0];
142 m[1][2] = -forward[1];
143 m[2][2] = -forward[2];
144
146 glTranslated(-eyex, -eyey, -eyez);
147}
GLAPI void GLAPIENTRY glMultMatrixf(const GLfloat *m)
GLAPI void GLAPIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z)
◆ gluNewNurbsRenderer()
| GLAPI GLUnurbs *GLAPIENTRY gluNewNurbsRenderer | ( | void | ) |
◆ gluNewQuadric()
| GLAPI GLUquadric *GLAPIENTRY gluNewQuadric | ( | void | ) |
Definition at line 54 of file quad.c.
55{
56 GLUquadric *newstate;
57
60 /* Can't report an error at this point... */
62 }
67 newstate->errorCallback = NULL;
68 return newstate;
69}
Definition: quad.c:45
◆ gluNewTess()
| GLAPI GLUtesselator *GLAPIENTRY gluNewTess | ( | void | ) |
Definition at line 92 of file tess.c.
93{
94 GLUtesselator *tess;
95
96 /* Only initialize fields which can be changed by the api. Other fields
97 * are initialized where they are used.
98 */
99
101 return 0; /* out of memory */
102 }
105 return 0; /* out of memory */
106 }
107
109
110 tess->normal[0] = 0;
111 tess->normal[1] = 0;
112 tess->normal[2] = 0;
113
118
119 tess->callBegin = &noBegin;
120 tess->callEdgeFlag = &noEdgeFlag;
121 tess->callVertex = &noVertex;
122 tess->callEnd = &noEnd;
123
124 tess->callError = &noError;
125 tess->callCombine = &noCombine;
126 tess->callMesh = &noMesh;
127
128 tess->callBeginData= &__gl_noBeginData;
129 tess->callEdgeFlagData= &__gl_noEdgeFlagData;
130 tess->callVertexData= &__gl_noVertexData;
131 tess->callEndData= &__gl_noEndData;
132 tess->callErrorData= &__gl_noErrorData;
133 tess->callCombineData= &__gl_noCombineData;
134
136
137 return tess;
138}
Definition: tess.h:59
void GLAPIENTRY __gl_noErrorData(GLenum errnum, void *polygonData)
Definition: tess.c:74
void GLAPIENTRY __gl_noEdgeFlagData(GLboolean boundaryEdge, void *polygonData)
Definition: tess.c:69
void GLAPIENTRY __gl_noVertexData(void *data, void *polygonData)
Definition: tess.c:71
void GLAPIENTRY __gl_noCombineData(GLdouble coords[3], void *data[4], GLfloat weight[4], void **outData, void *polygonData)
Definition: tess.c:76
static void GLAPIENTRY noCombine(GLdouble coords[3], void *data[4], GLfloat weight[4], void **dataOut)
Definition: tess.c:62
void GLAPIENTRY __gl_noBeginData(GLenum type, void *polygonData)
Definition: tess.c:67
◆ gluNextContour()
| GLAPI void GLAPIENTRY gluNextContour | ( | GLUtesselator * | tess, |
| GLenum | type | ||
| ) |
◆ gluNurbsCallback()
| GLAPI void GLAPIENTRY gluNurbsCallback | ( | GLUnurbs * | nurb, |
| GLenum | which, | ||
| _GLUfuncptr | CallBackFunc | ||
| ) |
Definition at line 430 of file glinterface.cc.
◆ gluNurbsCallbackData()
| GLAPI void GLAPIENTRY gluNurbsCallbackData | ( | GLUnurbs * | nurb, |
| GLvoid * | userData | ||
| ) |
Definition at line 466 of file glinterface.cc.
467{
469}
◆ gluNurbsCallbackDataEXT()
| GLAPI void GLAPIENTRY gluNurbsCallbackDataEXT | ( | GLUnurbs * | nurb, |
| GLvoid * | userData | ||
| ) |
Definition at line 459 of file glinterface.cc.
◆ gluNurbsCurve()
| GLAPI void GLAPIENTRY gluNurbsCurve | ( | GLUnurbs * | nurb, |
| GLint | knotCount, | ||
| GLfloat * | knots, | ||
| GLint | stride, | ||
| GLfloat * | control, | ||
| GLint | order, | ||
| GLenum | type | ||
| ) |
◆ gluNurbsProperty()
Definition at line 243 of file glinterface.cc.
244{
245 GLfloat nurbsValue;
246
250 return;
251
254 nurbsValue = N_CULLINGON;
255 } else {
256 nurbsValue = N_NOCULLING;
257 }
262 return;
263
266 nurbsValue = N_PATHLENGTH;
268 nurbsValue = N_PARAMETRICDISTANCE;
270 nurbsValue = N_DOMAINDISTANCE;
272
274 nurbsValue = N_OBJECTSPACE_PARA;
275 r->setautoloadmode( 0.0 );
276 r->setSamplingMatrixIdentity();
278 nurbsValue = N_OBJECTSPACE_PATH;
279 r->setautoloadmode( 0.0 );
280 r->setSamplingMatrixIdentity();
281 } else {
283 return;
284 }
285
290 return;
291
297 return;
298
304 return;
305
306
308
310 nurbsValue = N_FILL;
312 nurbsValue = N_OUTLINE_POLY;
314 nurbsValue = N_OUTLINE_PATCH;
315 } else {
317 return;
318 }
320
321 break;
322
328
329 //added for optimizing untrimmed case
331 break;
332
338
339 //added for optimizing untrimmed case
341 break;
342
345 r->put_callbackFlag(0);
347 r->put_callbackFlag(1);
348 else
350 break;
351
352 default:
354 return;
355 }
356}
◆ 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.
204{
205#ifdef DOWN_LOAD_NURBS
206 {
207 int dimension;
210 dimension = 3;
211 break;
213 dimension = 4;
214 break;
215 default:
217 exit(1);
218 }
219tempNurb = nurbSurfMake(sknot_count, sknot,
220 tknot_count, tknot,
221 sorder, torder,
222 dimension,
223 ctlarray,
224 s_stride, t_stride);
225
226 }
227#endif
228
229 r->nurbssurface(sknot_count, sknot, tknot_count, tknot,
231 ctlarray, sorder, torder, type);
232}
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
◆ gluOrtho2D()
◆ 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.
434{
439 GLfloat sintemp, costemp;
440 GLfloat deltaRadius;
441 GLfloat radiusLow, radiusHigh;
442 GLfloat texLow = 0.0, texHigh = 0.0;
443 GLfloat angleOffset;
444 GLint slices2;
446
448 if (slices < 2 || loops < 1 || outerRadius <= 0.0 || innerRadius < 0.0 ||
449 innerRadius > outerRadius) {
451 return;
452 }
453
454 if (sweepAngle < -360.0) sweepAngle = 360.0;
455 if (sweepAngle > 360.0) sweepAngle = 360.0;
456 if (sweepAngle < 0) {
457 startAngle += sweepAngle;
458 sweepAngle = -sweepAngle;
459 }
460
461 if (sweepAngle == 360.0) {
462 slices2 = slices;
463 } else {
464 slices2 = slices + 1;
465 }
466
467 /* Compute length (needed for normal calculations) */
468 deltaRadius = outerRadius - innerRadius;
469
470 /* Cache is the vertex locations cache */
471
472 angleOffset = startAngle / 180.0 * PI;
477 }
478
479 if (sweepAngle == 360.0) {
480 sinCache[slices] = sinCache[0];
481 cosCache[slices] = cosCache[0];
482 }
483
484 switch(qobj->normals) {
488 glNormal3f(0.0, 0.0, 1.0);
489 } else {
490 glNormal3f(0.0, 0.0, -1.0);
491 }
492 break;
493 default:
495 break;
496 }
497
498 switch (qobj->drawStyle) {
500 if (innerRadius == 0.0) {
501 finish = loops - 1;
502 /* Triangle strip for inner polygons */
504 if (qobj->textureCoords) {
505 glTexCoord2f(0.5, 0.5);
506 }
507 glVertex3f(0.0, 0.0, 0.0);
508 radiusLow = outerRadius -
509 deltaRadius * ((float) (loops-1) / loops);
510 if (qobj->textureCoords) {
511 texLow = radiusLow / outerRadius / 2;
512 }
513
516 if (qobj->textureCoords) {
518 texLow * cosCache[i] + 0.5);
519 }
521 radiusLow * cosCache[i], 0.0);
522 }
523 } else {
525 if (qobj->textureCoords) {
527 texLow * cosCache[i] + 0.5);
528 }
530 radiusLow * cosCache[i], 0.0);
531 }
532 }
533 glEnd();
534 } else {
535 finish = loops;
536 }
540 if (qobj->textureCoords) {
541 texLow = radiusLow / outerRadius / 2;
542 texHigh = radiusHigh / outerRadius / 2;
543 }
544
548 if (qobj->textureCoords) {
550 texLow * cosCache[i] + 0.5);
551 }
553 radiusLow * cosCache[i], 0.0);
554
555 if (qobj->textureCoords) {
557 texHigh * cosCache[i] + 0.5);
558 }
560 radiusHigh * cosCache[i], 0.0);
561 } else {
562 if (qobj->textureCoords) {
564 texHigh * cosCache[i] + 0.5);
565 }
567 radiusHigh * cosCache[i], 0.0);
568
569 if (qobj->textureCoords) {
571 texLow * cosCache[i] + 0.5);
572 }
574 radiusLow * cosCache[i], 0.0);
575 }
576 }
577 glEnd();
578 }
579 break;
583 sintemp = sinCache[i];
584 costemp = cosCache[i];
587
588 if (qobj->textureCoords) {
589 texLow = radiusLow / outerRadius / 2;
590
592 texLow * cosCache[i] + 0.5);
593 }
594 glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
595 }
596 }
597 glEnd();
598 break;
600 if (innerRadius == outerRadius) {
602
604 if (qobj->textureCoords) {
606 cosCache[i] / 2 + 0.5);
607 }
609 innerRadius * cosCache[i], 0.0);
610 }
611 glEnd();
612 break;
613 }
616 if (qobj->textureCoords) {
617 texLow = radiusLow / outerRadius / 2;
618 }
619
622 if (qobj->textureCoords) {
624 texLow * cosCache[i] + 0.5);
625 }
627 radiusLow * cosCache[i], 0.0);
628 }
629 glEnd();
630 }
632 sintemp = sinCache[i];
633 costemp = cosCache[i];
637 if (qobj->textureCoords) {
638 texLow = radiusLow / outerRadius / 2;
639 }
640
641 if (qobj->textureCoords) {
643 texLow * cosCache[i] + 0.5);
644 }
645 glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
646 }
647 glEnd();
648 }
649 break;
651 if (sweepAngle < 360.0) {
653 sintemp = sinCache[i];
654 costemp = cosCache[i];
658
659 if (qobj->textureCoords) {
660 texLow = radiusLow / outerRadius / 2;
662 texLow * cosCache[i] + 0.5);
663 }
664 glVertex3f(radiusLow * sintemp, radiusLow * costemp, 0.0);
665 }
666 glEnd();
667 }
668 }
671 if (qobj->textureCoords) {
672 texLow = radiusLow / outerRadius / 2;
673 }
674
677 if (qobj->textureCoords) {
679 texLow * cosCache[i] + 0.5);
680 }
682 radiusLow * cosCache[i], 0.0);
683 }
684 glEnd();
685 if (innerRadius == outerRadius) break;
686 }
687 break;
688 default:
689 break;
690 }
691}
◆ gluPerspective()
| GLAPI void GLAPIENTRY gluPerspective | ( | GLdouble | fovy, |
| GLdouble | aspect, | ||
| GLdouble | zNear, | ||
| GLdouble | zFar | ||
| ) |
Definition at line 65 of file project.c.
66{
68 double sine, cotangent, deltaZ;
70
72 sine = sin(radians);
73 if ((deltaZ == 0) || (sine == 0) || (aspect == 0)) {
74 return;
75 }
76 cotangent = COS(radians) / sine;
77
79 m[0][0] = cotangent / aspect;
80 m[1][1] = cotangent;
82 m[2][3] = -1;
84 m[3][3] = 0;
86}
_STLP_DECLSPEC complex< float > _STLP_CALL sin(const complex< float > &)
Definition: complex_trig.cpp:73
GLAPI void GLAPIENTRY glMultMatrixd(const GLdouble *m)
◆ 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 | ||
| ) |
◆ gluQuadricDrawStyle()
| GLAPI void GLAPIENTRY gluQuadricDrawStyle | ( | GLUquadric * | quad, |
| GLenum | draw | ||
| ) |
◆ gluQuadricNormals()
| GLAPI void GLAPIENTRY gluQuadricNormals | ( | GLUquadric * | quad, |
| GLenum | normal | ||
| ) |
◆ gluQuadricOrientation()
| GLAPI void GLAPIENTRY gluQuadricOrientation | ( | GLUquadric * | quad, |
| GLenum | orientation | ||
| ) |
◆ gluQuadricTexture()
| GLAPI void GLAPIENTRY gluQuadricTexture | ( | GLUquadric * | quad, |
| GLboolean | texture | ||
| ) |
◆ 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.
3502{
3504 GLushort *beforeImage;
3505 GLushort *afterImage;
3506 PixelStorageModes psm;
3507
3508 if (widthin == 0 || heightin == 0 || widthout == 0 || heightout == 0) {
3509 return 0;
3510 }
3511 if (widthin < 0 || heightin < 0 || widthout < 0 || heightout < 0) {
3513 }
3516 }
3519 }
3522 }
3523 beforeImage =
3525 afterImage =
3528 free(beforeImage);
3529 free(afterImage);
3531 }
3532
3533 retrieveStoreModes(&psm);
3535 datain, beforeImage);
3538 widthout, heightout, afterImage);
3543
3544 return 0;
3545}
static void scale_internal(GLint components, GLint widthin, GLint heightin, const GLushort *datain, GLint widthout, GLint heightout, GLushort *dataout)
Definition: mipmap.c:1289
static GLint elements_per_group(GLenum format, GLenum type)
Definition: mipmap.c:4770
static GLboolean isLegalFormatForPackedPixelType(GLenum, GLenum)
Definition: mipmap.c:3361
static void fill_image(const PixelStorageModes *, GLint width, GLint height, GLenum format, GLenum type, GLboolean index_format, const void *userdata, GLushort *newimage)
Definition: mipmap.c:4878
static void empty_image(const PixelStorageModes *, GLint width, GLint height, GLenum format, GLenum type, GLboolean index_format, const GLushort *oldimage, void *userdata)
Definition: mipmap.c:5141
static GLint image_size(GLint width, GLint height, GLenum format, GLenum type)
Definition: mipmap.c:4858
Definition: mipmap.c:51
◆ gluSphere()
| GLAPI void GLAPIENTRY gluSphere | ( | GLUquadric * | quad, |
| GLdouble | radius, | ||
| GLint | slices, | ||
| GLint | stacks | ||
| ) |
Definition at line 694 of file quad.c.
695{
710 GLfloat zLow, zHigh;
711 GLfloat sintemp1 = 0.0, sintemp2 = 0.0, sintemp3 = 0.0, sintemp4 = 0.0;
712 GLfloat costemp1 = 0.0, costemp2 = 0.0, costemp3 = 0.0, costemp4 = 0.0;
713 GLboolean needCache2, needCache3;
715
718 if (slices < 2 || stacks < 1 || radius < 0.0) {
720 return;
721 }
722
723 /* Cache is the vertex locations cache */
724 /* Cache2 is the various normals at the vertices themselves */
725 /* Cache3 is the various normals for the faces */
726 needCache2 = needCache3 = GL_FALSE;
727
729 needCache2 = GL_TRUE;
730 }
731
734 needCache3 = GL_TRUE;
735 }
737 needCache2 = GL_TRUE;
738 }
739 }
740
745 if (needCache2) {
748 }
749 }
750
753 if (needCache2) {
757 } else {
760 }
761 }
764 }
765 /* Make sure it comes to a point */
766 sinCache1b[0] = 0;
767 sinCache1b[stacks] = 0;
768
769 if (needCache3) {
774 }
780 } else {
783 }
784 }
785 }
786
787 sinCache1a[slices] = sinCache1a[0];
788 cosCache1a[slices] = cosCache1a[0];
789 if (needCache2) {
790 sinCache2a[slices] = sinCache2a[0];
791 cosCache2a[slices] = cosCache2a[0];
792 }
793 if (needCache3) {
794 sinCache3a[slices] = sinCache3a[0];
795 cosCache3a[slices] = cosCache3a[0];
796 }
797
798 switch (qobj->drawStyle) {
800 /* Do ends of sphere as TRIANGLE_FAN's (if not texturing)
801 ** We don't do it when texturing because we need to respecify the
802 ** texture coordinates of the apex for every adjacent vertex (because
803 ** it isn't a constant for that point)
804 */
805 if (!(qobj->textureCoords)) {
806 start = 1;
807 finish = stacks - 1;
808
809 /* Low end first (j == 0 iteration) */
810 sintemp2 = sinCache1b[1];
811 zHigh = cosCache1b[1];
812 switch(qobj->normals) {
814 sintemp3 = sinCache3b[1];
815 costemp3 = cosCache3b[1];
816 break;
818 sintemp3 = sinCache2b[1];
819 costemp3 = cosCache2b[1];
820 glNormal3f(sinCache2a[0] * sinCache2b[0],
821 cosCache2a[0] * sinCache2b[0],
822 cosCache2b[0]);
823 break;
824 default:
825 break;
826 }
828 glVertex3f(0.0, 0.0, radius);
831 switch(qobj->normals) {
834 cosCache2a[i] * sintemp3,
835 costemp3);
836 break;
840 cosCache3a[i+1] * sintemp3,
841 costemp3);
842 }
843 break;
845 default:
846 break;
847 }
849 sintemp2 * cosCache1a[i], zHigh);
850 }
851 } else {
853 switch(qobj->normals) {
856 cosCache2a[i] * sintemp3,
857 costemp3);
858 break;
861 cosCache3a[i] * sintemp3,
862 costemp3);
863 break;
865 default:
866 break;
867 }
869 sintemp2 * cosCache1a[i], zHigh);
870 }
871 }
872 glEnd();
873
874 /* High end next (j == stacks-1 iteration) */
875 sintemp2 = sinCache1b[stacks-1];
876 zHigh = cosCache1b[stacks-1];
877 switch(qobj->normals) {
879 sintemp3 = sinCache3b[stacks];
880 costemp3 = cosCache3b[stacks];
881 break;
883 sintemp3 = sinCache2b[stacks-1];
884 costemp3 = cosCache2b[stacks-1];
885 glNormal3f(sinCache2a[stacks] * sinCache2b[stacks],
886 cosCache2a[stacks] * sinCache2b[stacks],
887 cosCache2b[stacks]);
888 break;
889 default:
890 break;
891 }
893 glVertex3f(0.0, 0.0, -radius);
896 switch(qobj->normals) {
899 cosCache2a[i] * sintemp3,
900 costemp3);
901 break;
904 cosCache3a[i] * sintemp3,
905 costemp3);
906 break;
908 default:
909 break;
910 }
912 sintemp2 * cosCache1a[i], zHigh);
913 }
914 } else {
916 switch(qobj->normals) {
919 cosCache2a[i] * sintemp3,
920 costemp3);
921 break;
925 cosCache3a[i+1] * sintemp3,
926 costemp3);
927 }
928 break;
930 default:
931 break;
932 }
934 sintemp2 * cosCache1a[i], zHigh);
935 }
936 }
937 glEnd();
938 } else {
939 start = 0;
940 finish = stacks;
941 }
943 zLow = cosCache1b[j];
944 zHigh = cosCache1b[j+1];
945 sintemp1 = sinCache1b[j];
946 sintemp2 = sinCache1b[j+1];
947 switch(qobj->normals) {
949 sintemp4 = sinCache3b[j+1];
950 costemp4 = cosCache3b[j+1];
951 break;
954 sintemp3 = sinCache2b[j+1];
955 costemp3 = cosCache2b[j+1];
956 sintemp4 = sinCache2b[j];
957 costemp4 = cosCache2b[j];
958 } else {
959 sintemp3 = sinCache2b[j];
960 costemp3 = cosCache2b[j];
961 sintemp4 = sinCache2b[j+1];
962 costemp4 = cosCache2b[j+1];
963 }
964 break;
965 default:
966 break;
967 }
968
971 switch(qobj->normals) {
974 cosCache2a[i] * sintemp3,
975 costemp3);
976 break;
979 default:
980 break;
981 }
983 if (qobj->textureCoords) {
986 }
988 sintemp2 * cosCache1a[i], zHigh);
989 } else {
990 if (qobj->textureCoords) {
993 }
995 sintemp1 * cosCache1a[i], zLow);
996 }
997 switch(qobj->normals) {
1000 cosCache2a[i] * sintemp4,
1001 costemp4);
1002 break;
1005 cosCache3a[i] * sintemp4,
1006 costemp4);
1007 break;
1009 default:
1010 break;
1011 }
1013 if (qobj->textureCoords) {
1016 }
1018 sintemp1 * cosCache1a[i], zLow);
1019 } else {
1020 if (qobj->textureCoords) {
1023 }
1025 sintemp2 * cosCache1a[i], zHigh);
1026 }
1027 }
1028 glEnd();
1029 }
1030 break;
1034 sintemp1 = sinCache1b[j];
1035 costemp1 = cosCache1b[j];
1036 switch(qobj->normals) {
1039 sintemp2 = sinCache2b[j];
1040 costemp2 = cosCache2b[j];
1041 break;
1042 default:
1043 break;
1044 }
1046 switch(qobj->normals) {
1050 cosCache2a[i] * sintemp2,
1051 costemp2);
1052 break;
1054 default:
1055 break;
1056 }
1057
1058 zLow = j * radius / stacks;
1059
1060 if (qobj->textureCoords) {
1063 }
1065 sintemp1 * cosCache1a[i], costemp1);
1066 }
1067 }
1068 glEnd();
1069 break;
1073 sintemp1 = sinCache1b[j];
1074 costemp1 = cosCache1b[j];
1075 switch(qobj->normals) {
1078 sintemp2 = sinCache2b[j];
1079 costemp2 = cosCache2b[j];
1080 break;
1081 default:
1082 break;
1083 }
1084
1087 switch(qobj->normals) {
1090 cosCache3a[i] * sintemp2,
1091 costemp2);
1092 break;
1095 cosCache2a[i] * sintemp2,
1096 costemp2);
1097 break;
1099 default:
1100 break;
1101 }
1102 if (qobj->textureCoords) {
1105 }
1107 sintemp1 * cosCache1a[i], costemp1);
1108 }
1109 glEnd();
1110 }
1112 sintemp1 = sinCache1a[i];
1113 costemp1 = cosCache1a[i];
1114 switch(qobj->normals) {
1117 sintemp2 = sinCache2a[i];
1118 costemp2 = cosCache2a[i];
1119 break;
1120 default:
1121 break;
1122 }
1123
1126 switch(qobj->normals) {
1129 costemp2 * sinCache3b[j],
1130 cosCache3b[j]);
1131 break;
1134 costemp2 * sinCache2b[j],
1135 cosCache2b[j]);
1136 break;
1138 default:
1139 break;
1140 }
1141
1142 if (qobj->textureCoords) {
1145 }
1148 }
1149 glEnd();
1150 }
1151 break;
1152 default:
1153 break;
1154 }
1155}
◆ gluTessBeginContour()
| GLAPI void GLAPIENTRY gluTessBeginContour | ( | GLUtesselator * | tess | ) |
◆ gluTessBeginPolygon()
| GLAPI void GLAPIENTRY gluTessBeginPolygon | ( | GLUtesselator * | tess, |
| GLvoid * | data | ||
| ) |
◆ gluTessCallback()
| GLAPI void GLAPIENTRY gluTessCallback | ( | GLUtesselator * | tess, |
| GLenum | which, | ||
| _GLUfuncptr | CallBackFunc | ||
| ) |
Definition at line 276 of file tess.c.
277{
281 return;
285 return;
289 /* If the client wants boundary edges to be flagged,
290 * we render everything as separate triangles (no strips or fans).
291 */
293 return;
297 /* If the client wants boundary edges to be flagged,
298 * we render everything as separate triangles (no strips or fans).
299 */
301 return;
305 return;
309 return;
312 return;
316 return;
319 return;
323 return;
327 return;
331 void *[4],
332 GLfloat [4],
333 void **,
335 return;
338 return;
339 default:
341 return;
342 }
343}
Definition: mesh.h:163
◆ gluTessEndContour()
| GLAPI void GLAPIENTRY gluTessEndContour | ( | GLUtesselator * | tess | ) |
◆ gluTessEndPolygon()
| GLAPI void GLAPIENTRY gluTessEndPolygon | ( | GLUtesselator * | tess | ) |
Definition at line 500 of file tess.c.
501{
503
505 /* come back here if out of memory */
507 return;
508 }
509
512
515
516 /* Try some special code to make the easy cases go quickly
517 * (eg. convex polygons). This code does NOT handle multiple contours,
518 * intersections, edge flags, and of course it does not generate
519 * an explicit mesh either.
520 */
523 return;
524 }
525 }
527 }
528
529 /* Determine the polygon normal and project vertices onto the plane
530 * of the polygon.
531 */
532 __gl_projectPolygon( tess );
533
534 /* __gl_computeInterior( tess ) computes the planar arrangement specified
535 * by the given contours, and further subdivides this arrangement
536 * into regions. Each region is marked "inside" if it belongs
537 * to the polygon, according to the rule given by tess->windingRule.
538 * Each interior region is guaranteed be monotone.
539 */
542 }
543
546 int rc = 1;
547
548 /* If the user wants only the boundary contours, we throw away all edges
549 * except those which separate the interior from the exterior.
550 * Otherwise we tessellate all the regions marked "inside".
551 */
554 } else {
556 }
558
560
563 || tess->callBeginData != &__gl_noBeginData
564 || tess->callEndData != &__gl_noEndData
565 || tess->callVertexData != &__gl_noVertexData
566 || tess->callEdgeFlagData != &__gl_noEdgeFlagData )
567 {
570 } else {
572 }
573 }
575
576 /* Throw away the exterior faces, so that all faces are interior.
577 * This way the user doesn't have to check the "inside" flag,
578 * and we don't need to even reveal its existence. It also leaves
579 * the freedom for an implementation to not generate the exterior
580 * faces in the first place.
581 */
586 return;
587 }
588 }
592}
void __gl_renderBoundary(GLUtesselator *tess, GLUmesh *mesh)
Definition: render.c:339
Definition: mesh.c:198
int __gl_meshSetWindingNumber(GLUmesh *mesh, int value, GLboolean keepOnlyBoundary)
Definition: tessmono.c:179
◆ gluTessNormal()
| GLAPI void GLAPIENTRY gluTessNormal | ( | GLUtesselator * | tess, |
| GLdouble | valueX, | ||
| GLdouble | valueY, | ||
| GLdouble | valueZ | ||
| ) |
◆ gluTessProperty()
| GLAPI void GLAPIENTRY gluTessProperty | ( | GLUtesselator * | tess, |
| GLenum | which, | ||
| GLdouble | data | ||
| ) |
Definition at line 201 of file tess.c.
202{
203 GLenum windingRule;
204
207 if( value < 0.0 || value > 1.0 ) break;
209 return;
210
214
215 switch( windingRule ) {
221 tess->windingRule = windingRule;
222 return;
223 default:
224 break;
225 }
226
229 return;
230
231 default:
233 return;
234 }
236}
◆ gluTessVertex()
| GLAPI void GLAPIENTRY gluTessVertex | ( | GLUtesselator * | tess, |
| GLdouble * | location, | ||
| GLvoid * | data | ||
| ) |
◆ gluUnProject()
| 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 | ||
| ) |
◆ gluUnProject4()
| 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 | ||
| ) |
◆ void()
| typedef void | ( | GLAPIENTRYP | _GLUfuncptr | ) |
