mirror of
git://source.winehq.org/git/wine.git
synced 2024-11-05 18:01:34 +00:00
1173 lines
30 KiB
C
1173 lines
30 KiB
C
/*
|
|
* SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
|
|
* Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice including the dates of first publication and
|
|
* either this permission notice or a reference to
|
|
* http://oss.sgi.com/projects/FreeB/
|
|
* shall be included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
|
|
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of Silicon Graphics, Inc.
|
|
* shall not be used in advertising or otherwise to promote the sale, use or
|
|
* other dealings in this Software without prior written authorization from
|
|
* Silicon Graphics, Inc.
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <math.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "wine/wgl.h"
|
|
#include "wine/glu.h"
|
|
|
|
/* Make it not a power of two to avoid cache thrashing on the chip */
|
|
#define CACHE_SIZE 240
|
|
|
|
struct GLUquadric {
|
|
GLint normals;
|
|
GLboolean textureCoords;
|
|
GLint orientation;
|
|
GLint drawStyle;
|
|
void (GLAPIENTRY *errorCallback)( GLint );
|
|
};
|
|
|
|
/***********************************************************************
|
|
* gluNewQuadric (GLU32.@)
|
|
*/
|
|
GLUquadric * WINAPI gluNewQuadric(void)
|
|
{
|
|
GLUquadric *newstate;
|
|
|
|
newstate = HeapAlloc(GetProcessHeap(), 0, 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;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* gluDeleteQuadric (GLU32.@)
|
|
*/
|
|
void WINAPI gluDeleteQuadric( GLUquadric *state )
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, state);
|
|
}
|
|
|
|
static void gluQuadricError(GLUquadric *qobj, GLenum which)
|
|
{
|
|
if (qobj->errorCallback) {
|
|
qobj->errorCallback(which);
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluQuadricCallback (GLU32.@)
|
|
*/
|
|
void WINAPI gluQuadricCallback( GLUquadric *qobj, GLenum which, void (CALLBACK *fn)(void) )
|
|
{
|
|
switch (which) {
|
|
case GLU_ERROR:
|
|
qobj->errorCallback = (void (GLAPIENTRY *)(GLint)) fn;
|
|
break;
|
|
default:
|
|
gluQuadricError(qobj, GLU_INVALID_ENUM);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluQuadricNormals (GLU32.@)
|
|
*/
|
|
void WINAPI gluQuadricNormals( GLUquadric *qobj, GLenum normals )
|
|
{
|
|
switch (normals) {
|
|
case GLU_SMOOTH:
|
|
case GLU_FLAT:
|
|
case GLU_NONE:
|
|
break;
|
|
default:
|
|
gluQuadricError(qobj, GLU_INVALID_ENUM);
|
|
return;
|
|
}
|
|
qobj->normals = normals;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluQuadricTexture (GLU32.@)
|
|
*/
|
|
void WINAPI gluQuadricTexture( GLUquadric *qobj, GLboolean textureCoords )
|
|
{
|
|
qobj->textureCoords = textureCoords;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluQuadricOrientation (GLU32.@)
|
|
*/
|
|
void WINAPI gluQuadricOrientation( GLUquadric *qobj, GLenum orientation )
|
|
{
|
|
switch(orientation) {
|
|
case GLU_OUTSIDE:
|
|
case GLU_INSIDE:
|
|
break;
|
|
default:
|
|
gluQuadricError(qobj, GLU_INVALID_ENUM);
|
|
return;
|
|
}
|
|
qobj->orientation = orientation;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluQuadricDrawStyle (GLU32.@)
|
|
*/
|
|
void WINAPI gluQuadricDrawStyle( GLUquadric *qobj, GLenum drawStyle )
|
|
{
|
|
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;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluCylinder (GLU32.@)
|
|
*/
|
|
void WINAPI gluCylinder( GLUquadric *qobj, GLdouble baseRadius, GLdouble topRadius,
|
|
GLdouble height, GLint slices, GLint stacks )
|
|
{
|
|
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 = sqrtf(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 * M_PI * i / slices;
|
|
if (needCache2) {
|
|
if (qobj->orientation == GLU_OUTSIDE) {
|
|
sinCache2[i] = xyNormalRatio * sinf(angle);
|
|
cosCache2[i] = xyNormalRatio * cosf(angle);
|
|
} else {
|
|
sinCache2[i] = -xyNormalRatio * sinf(angle);
|
|
cosCache2[i] = -xyNormalRatio * cosf(angle);
|
|
}
|
|
}
|
|
sinCache[i] = sinf(angle);
|
|
cosCache[i] = cosf(angle);
|
|
}
|
|
|
|
if (needCache3) {
|
|
for (i = 0; i < slices; i++) {
|
|
angle = 2 * M_PI * (i-0.5) / slices;
|
|
if (qobj->orientation == GLU_OUTSIDE) {
|
|
sinCache3[i] = xyNormalRatio * sinf(angle);
|
|
cosCache3[i] = xyNormalRatio * cosf(angle);
|
|
} else {
|
|
sinCache3[i] = -xyNormalRatio * sinf(angle);
|
|
cosCache3[i] = -xyNormalRatio * cosf(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;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluDisk (GLU32.@)
|
|
*/
|
|
void WINAPI gluDisk( GLUquadric *qobj, GLdouble innerRadius, GLdouble outerRadius,
|
|
GLint slices, GLint loops )
|
|
{
|
|
gluPartialDisk(qobj, innerRadius, outerRadius, slices, loops, 0.0, 360.0);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluPartialDisk (GLU32.@)
|
|
*/
|
|
void WINAPI gluPartialDisk( GLUquadric *qobj, GLdouble innerRadius, GLdouble outerRadius,
|
|
GLint slices, GLint loops, GLdouble startAngle, GLdouble sweepAngle )
|
|
{
|
|
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 * M_PI;
|
|
for (i = 0; i <= slices; i++) {
|
|
angle = angleOffset + ((M_PI * sweepAngle) / 180.0) * i / slices;
|
|
sinCache[i] = sinf(angle);
|
|
cosCache[i] = cosf(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;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* gluSphere (GLU32.@)
|
|
*/
|
|
void WINAPI gluSphere( GLUquadric *qobj, GLdouble radius, GLint slices, GLint stacks )
|
|
{
|
|
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 * M_PI * i / slices;
|
|
sinCache1a[i] = sinf(angle);
|
|
cosCache1a[i] = cosf(angle);
|
|
if (needCache2) {
|
|
sinCache2a[i] = sinCache1a[i];
|
|
cosCache2a[i] = cosCache1a[i];
|
|
}
|
|
}
|
|
|
|
for (j = 0; j <= stacks; j++) {
|
|
angle = M_PI * j / stacks;
|
|
if (needCache2) {
|
|
if (qobj->orientation == GLU_OUTSIDE) {
|
|
sinCache2b[j] = sinf(angle);
|
|
cosCache2b[j] = cosf(angle);
|
|
} else {
|
|
sinCache2b[j] = -sinf(angle);
|
|
cosCache2b[j] = -cosf(angle);
|
|
}
|
|
}
|
|
sinCache1b[j] = radius * sinf(angle);
|
|
cosCache1b[j] = radius * cosf(angle);
|
|
}
|
|
/* Make sure it comes to a point */
|
|
sinCache1b[0] = 0;
|
|
sinCache1b[stacks] = 0;
|
|
|
|
if (needCache3) {
|
|
for (i = 0; i < slices; i++) {
|
|
angle = 2 * M_PI * (i-0.5) / slices;
|
|
sinCache3a[i] = sinf(angle);
|
|
cosCache3a[i] = cosf(angle);
|
|
}
|
|
for (j = 0; j <= stacks; j++) {
|
|
angle = M_PI * (j - 0.5) / stacks;
|
|
if (qobj->orientation == GLU_OUTSIDE) {
|
|
sinCache3b[j] = sinf(angle);
|
|
cosCache3b[j] = cosf(angle);
|
|
} else {
|
|
sinCache3b[j] = -sinf(angle);
|
|
cosCache3b[j] = -cosf(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;
|
|
}
|
|
}
|