#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <float.h>
#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>
// #define PROFILE 1
#ifdef PROFILE
#include <icapexp.h>
#endif
typedef struct
{
float x, y, z;
float nx, ny, nz;
float tu, tv;
DWORD color;
} D3DVERTEX;
typedef D3DVERTEX *LPD3DVERTEX;
typedef struct
{
int v1;
int v2;
int v3;
} D3DTRIANGLE;
typedef D3DTRIANGLE *LPD3DTRIANGLE;
#define D3DVAL(f) ((float)(f))
#define RGB_MAKE(r, g, b) \
(((DWORD)((r) & 0xff) << 0) | \
((DWORD)((g) & 0xff) << 8) | \
((DWORD)((b) & 0xff) << 16) | \
((DWORD)(0xff) << 24))
typedef float __GLfloat;
typedef struct
{
__GLfloat matrix[4][4];
} __GLmatrix;
__GLmatrix identity =
{
1.0f, 0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
void __glMultMatrix(__GLmatrix *r, const __GLmatrix *a, const __GLmatrix *b)
{
__GLfloat b00, b01, b02, b03;
__GLfloat b10, b11, b12, b13;
__GLfloat b20, b21, b22, b23;
__GLfloat b30, b31, b32, b33;
GLint i;
b00 = b->matrix[0][0]; b01 = b->matrix[0][1];
b02 = b->matrix[0][2]; b03 = b->matrix[0][3];
b10 = b->matrix[1][0]; b11 = b->matrix[1][1];
b12 = b->matrix[1][2]; b13 = b->matrix[1][3];
b20 = b->matrix[2][0]; b21 = b->matrix[2][1];
b22 = b->matrix[2][2]; b23 = b->matrix[2][3];
b30 = b->matrix[3][0]; b31 = b->matrix[3][1];
b32 = b->matrix[3][2]; b33 = b->matrix[3][3];
for (i = 0; i < 4; i++) {
r->matrix[i][0] = a->matrix[i][0]*b00 + a->matrix[i][1]*b10
+ a->matrix[i][2]*b20 + a->matrix[i][3]*b30;
r->matrix[i][1] = a->matrix[i][0]*b01 + a->matrix[i][1]*b11
+ a->matrix[i][2]*b21 + a->matrix[i][3]*b31;
r->matrix[i][2] = a->matrix[i][0]*b02 + a->matrix[i][1]*b12
+ a->matrix[i][2]*b22 + a->matrix[i][3]*b32;
r->matrix[i][3] = a->matrix[i][0]*b03 + a->matrix[i][1]*b13
+ a->matrix[i][2]*b23 + a->matrix[i][3]*b33;
}
}
void MakePosMatrix(__GLmatrix *lpM, float x, float y, float z)
{
memcpy(lpM, &identity, sizeof(__GLmatrix));
lpM->matrix[3][0] = D3DVAL(x);
lpM->matrix[3][1] = D3DVAL(y);
lpM->matrix[3][2] = D3DVAL(z);
}
void MakeRotMatrix(__GLmatrix *lpM, float rx, float ry, float rz)
{
float ct, st;
__GLmatrix My, Mx, Mz, T;
memcpy(&My, &identity, sizeof(__GLmatrix));
ct = D3DVAL(cos(ry));
st = D3DVAL(sin(ry));
My.matrix[0][0] = ct;
My.matrix[0][2] = -st;
My.matrix[2][0] = st;
My.matrix[2][2] = ct;
memcpy(&Mx, &identity, sizeof(__GLmatrix));
ct = D3DVAL(cos(rx));
st = D3DVAL(sin(rx));
Mx.matrix[1][1] = ct;
Mx.matrix[1][2] = st;
Mx.matrix[2][1] = -st;
Mx.matrix[2][2] = ct;
memcpy(&Mz, &identity, sizeof(__GLmatrix));
ct = D3DVAL(cos(rz));
st = D3DVAL(sin(rz));
Mz.matrix[0][0] = ct;
Mz.matrix[0][1] = st;
Mz.matrix[1][0] = -st;
Mz.matrix[1][1] = ct;
__glMultMatrix(&T, &My, &Mx);
__glMultMatrix(lpM, &T, &Mz);
}
void *Malloc(size_t bytes)
{
void *pv;
pv = malloc(bytes);
if (pv == NULL)
{
printf("Unable to alloc %d bytes\n", bytes);
exit(1);
}
return pv;
}
#define PI ((float)3.14159265358979323846)
#define WIDTH 400
#define HEIGHT 400
#define SPWIDTH 140
#define SPHEIGHT 140
#define MAWIDTH 90
#define MAHEIGHT 75
#define LAWIDTH 230
#define LAHEIGHT 190
int iSwapWidth, iSwapHeight;
#define SRADIUS 0.4f
#define DMINUSR 0.6
#define DV 0.05
#define DR 0.3
#define DEPTH 0.6f
#define random(x) (((float)rand() / RAND_MAX) * (x))
#define FILL_TRIANGLES 50
#define MEDIUM_AREA 3000
#define LARGE_AREA 20000
#define FRONT_TO_BACK 0
#define BACK_TO_FRONT 1
#define ORDER_COUNT 2
int iOrder = FRONT_TO_BACK;
char *pszOrders[] =
{
"front-to-back",
"back-to-front"
};
#define AREA_LARGE 0
#define AREA_MEDIUM 1
#define AREA_COUNT 2
int iFillSize = AREA_MEDIUM;
int iTriangleArea;
typedef struct _Sphere
{
GLfloat xrv, yrv, zrv;
__GLmatrix pos, dpos;
__GLmatrix rot, drot;
} Sphere;
#define NSPHERES 8
Sphere spheres[NSPHERES];
BOOL fSingle = FALSE;
BOOL fRotate = TRUE;
BOOL fBounce = TRUE;
BOOL fSwap = TRUE;
BOOL fPaused = FALSE;
BOOL fUseScissor = TRUE;
BOOL fSpread = FALSE;
BOOL fExit = FALSE;
BOOL fSingleColor = TRUE;
BOOL fVerbose = FALSE;
BOOL fDisplayList = TRUE;
int iMultiLoop = 1;
int nRings = 30;
int nSections = 30;
GLint iDlist;
#define TEXOBJ
#ifdef TEXOBJ
GLuint uiTexObj;
#endif
PFNGLADDSWAPHINTRECTWINPROC glAddSwapHintRectWIN;
#define TEST_FILL 0
#define TEST_POLYS 1
#define TEST_COUNT 2
int iTest = TEST_POLYS;
AUX_RGBImageRec *pTexture;
#define TEXMODE_REPLACE 0
#define TEXMODE_DECAL 1
#define TEXMODE_MODULATE 2
#define TEXMODE_COUNT 3
int iTexMode = TEXMODE_REPLACE;
char *pszTexModes[] =
{
"replace", "decal", "modulate"
};
GLenum eTexModes[] =
{
GL_REPLACE, GL_DECAL, GL_MODULATE
};
BOOL fPerspective = TRUE;
//--------------------------------------------------------------------------;
//
// FunctionName: GenerateSphere()
//
// Purpose:
// Generate the geometry of a sphere.
//
// Returns BOOL
//
// History:
// 11/17/95 RichGr
//
//--------------------------------------------------------------------------;
/*
* Generates a sphere around the y-axis centered at the origin including
* normals and texture coordinates. Returns TRUE on success and FALSE on
* failure.
* sphere_r Radius of the sphere.
* num_rings Number of full rings not including the top and bottom
* caps.
* num_sections Number of sections each ring is divided into. Each
* section contains two triangles on full rings and one
* on top and bottom caps.
* sx, sy, sz Scaling along each axis. Set each to 1.0 for a
* perfect sphere.
* plpv On exit points to the vertices of the sphere. The
* function allocates this space. Not allocated if
* function fails.
* plptri On exit points to the triangles of the sphere which
* reference vertices in the vertex list. The function
* allocates this space. Not allocated if function fails.
* pnum_v On exit contains the number of vertices.
* pnum_tri On exit contains the number of triangles.
*/
BOOL GenerateSphere(float sphere_r, int num_rings, int num_sections,
float sx, float sy, float sz, LPD3DVERTEX* plpv,
LPD3DTRIANGLE* plptri, int* pnum_v, int* pnum_tri)
{
float theta, phi; /* Angles used to sweep around sphere */
float dtheta, dphi; /* Angle between each section and ring */
float x, y, z, v, rsintheta; /* Temporary variables */
int i, j, n, m; /* counters */
int num_v, num_tri; /* Internal vertex and triangle count */
LPD3DVERTEX lpv; /* Internal pointer for vertices */
LPD3DTRIANGLE lptri; /* Internal pointer for trianlges */
/*
* Check the parameters to make sure they are valid.
*/
if ((sphere_r <= 0)
|| (num_rings < 1)
|| (num_sections < 3)
|| (sx <= 0) || (sy <= 0) || (sz <= 0))
return FALSE;
/*
* Generate space for the required triangles and vertices.
*/
num_tri = (num_rings + 1) * num_sections * 2;
num_v = (num_rings + 1) * num_sections + 2;
*plpv = (LPD3DVERTEX)Malloc(sizeof(D3DVERTEX) * num_v);
*plptri = (LPD3DTRIANGLE)Malloc(sizeof(D3DTRIANGLE) * num_tri);
lpv = *plpv;
lptri = *plptri;
*pnum_v = num_v;
*pnum_tri = num_tri;
/*
* Generate vertices at the top and bottom points.
*/
lpv[0].x = D3DVAL(0.0f);
lpv[0].y = D3DVAL(sy * sphere_r);
lpv[0].z = D3DVAL(0.0f);
lpv[0].nx = D3DVAL(0.0f);
lpv[0].ny = D3DVAL(1.0f);
lpv[0].nz = D3DVAL(0.0f);
lpv[0].color = RGB_MAKE(0, 0, 255);
lpv[0].tu = D3DVAL(0.0f);
lpv[0].tv = D3DVAL(0.0f);
lpv[num_v - 1].x = D3DVAL(0.0f);
lpv[num_v - 1].y = D3DVAL(sy * -sphere_r);
lpv[num_v - 1].z = D3DVAL(0.0f);
lpv[num_v - 1].nx = D3DVAL(0.0f);
lpv[num_v - 1].ny = D3DVAL(-1.0f);
lpv[num_v - 1].nz = D3DVAL(0.0f);
lpv[num_v - 1].tu = D3DVAL(0.0f);
lpv[num_v - 1].tv = D3DVAL(1.0f);
lpv[num_v - 1].color = RGB_MAKE(0, 255, 0);
/*
* Generate vertex points for rings
*/
dtheta = PI / (float) (num_rings + 2);
dphi = 2.0f * PI / (float) num_sections;
n = 1; /* vertex being generated, begins at 1 to skip top point */
theta = dtheta;
for (i = 0; i <= num_rings; i++)
{
y = (float)(sphere_r * cos(theta)); /* y is the same for each ring */
v = theta / PI; /* v is the same for each ring */
rsintheta = (float)(sphere_r * sin(theta));
phi = 0.0f;
for (j = 0; j < num_sections; j++)
{
x = (float)(rsintheta * sin(phi));
z = (float)(rsintheta * cos(phi));
lpv[n].x = D3DVAL(sx * x);
lpv[n].z = D3DVAL(sz * z);
lpv[n].y = D3DVAL(sy * y);
lpv[n].nx = D3DVAL(x / sphere_r);
lpv[n].ny = D3DVAL(y / sphere_r);
lpv[n].nz = D3DVAL(z / sphere_r);
lpv[n].tv = D3DVAL(v);
lpv[n].tu = D3DVAL(1.0f - phi / (2.0f * PI));
if (n & 1)
{
lpv[n].color = RGB_MAKE(0, 0, 255);
}
else
{
lpv[n].color = RGB_MAKE(0, 255, 0);
}
phi += dphi;
++n;
}
theta += dtheta;
}
/*
* Generate triangles for top and bottom caps.
*/
for (i = 0; i < num_sections; i++)
{
lptri[i].v1 = 0;
lptri[i].v2 = i + 1;
lptri[i].v3 = 1 + ((i + 1) % num_sections);
// lptri[i].flags = D3D_EDGE_ENABLE_TRIANGLE;
lptri[num_tri - num_sections + i].v1 = num_v - 1;
lptri[num_tri - num_sections + i].v2 = num_v - 2 - i;
lptri[num_tri - num_sections + i].v3 = num_v - 2 - ((1 + i) % num_sections);
// lptri[num_tri - num_sections + i].flags= D3D_EDGE_ENABLE_TRIANGLE;
}
/*
* Generate triangles for the rings
*/
m = 1; /* first vertex in current ring,begins at 1 to skip top point*/
n = num_sections; /* triangle being generated, skip the top cap */
for (i = 0; i < num_rings; i++)
{
for (j = 0; j < num_sections; j++)
{
lptri[n].v1 = m + j;
lptri[n].v2 = m + num_sections + j;
lptri[n].v3 = m + num_sections + ((j + 1) % num_sections);
// lptri[n].flags = D3D_EDGE_ENABLE_TRIANGLE;
lptri[n + 1].v1 = lptri[n].v1;
lptri[n + 1].v2 = lptri[n].v3;
lptri[n + 1].v3 = m + ((j + 1) % num_sections);
// lptri[n + 1].flags = D3D_EDGE_ENABLE_TRIANGLE;
n += 2;
}
m += num_sections;
}
return TRUE;
}
// Creates triangle and quad strip index sets for vertex data generated
// by GenerateSphere. The top and bottom triangle fans are omitted because
// they're degenerate cases for strips
int CreateStrip(int nSections, int **ppiStrip)
{
int nPts;
int *piIdx, iIdxBase;
int iRing, iSection;
// Stick to a single strip for now
nRings = 1;
nPts = nRings*(nSections+1)*2;
*ppiStrip = (int *)Malloc(sizeof(int)*nPts);
piIdx = *ppiStrip;
iIdxBase = 1;
for (iRing = 0; iRing < nRings; iRing++)
{
for (iSection = 0; iSection <= nSections; iSection++)
{
*piIdx++ = iIdxBase+(iSection % nSections);
*piIdx++ = iIdxBase+(iSection % nSections)+nSections;
}
iIdxBase += nSections;
}
return nPts;
}
float fltCenter[NSPHERES][2] =
{
-SRADIUS, 0.0f,
0.0f, SRADIUS,
SRADIUS, 0.0f,
0.0f, -SRADIUS
};
void InitSpheres(void)
{
int i;
Sphere *sp;
float x, y, z;
#if 0
srand(time(NULL));
#else
srand( (unsigned)8269362521);
#endif
for (i = 0; i < NSPHERES; i++)
{
sp = &spheres[i];
if (fBounce)
{
x = (float)DMINUSR - (float)random(2 * DMINUSR);
y = (float)DMINUSR - (float)random(2 * DMINUSR);
z = (float)-DEPTH + (float)random(2 * DEPTH);
}
else
{
x = fltCenter[i][0];
y = fltCenter[i][1];
z = 0.0f;
}
MakePosMatrix(&sp->pos, x, y, z);
x = (float)DV - (float)random(2 * DV);
y = (float)DV - (float)random(2 * DV);
z = (float)DV - (float)random(2 * DV);
MakePosMatrix(&sp->dpos, x, y, z);
MakeRotMatrix(&sp->rot, 0.0f, 0.0f, 0.0f);
sp->xrv = (float)DR - (float)random(2 * DR);
sp->yrv = (float)DR - (float)random(2 * DR);
sp->zrv = (float)DR - (float)random(2 * DR);
MakeRotMatrix(&sp->drot, sp->xrv, sp->yrv, sp->zrv);
}
}
void UpdateSphere(Sphere *sp)
{
GLboolean newRot;
if (fBounce)
{
newRot = GL_FALSE;
if (sp->pos.matrix[3][0] > DMINUSR || sp->pos.matrix[3][0] < -DMINUSR)
{
sp->dpos.matrix[3][0] = -sp->dpos.matrix[3][0];
sp->zrv = -sp->zrv;
sp->yrv = -sp->yrv;
newRot = GL_TRUE;
}
if (sp->pos.matrix[3][1] > DMINUSR || sp->pos.matrix[3][1] < -DMINUSR)
{
sp->dpos.matrix[3][1] = -sp->dpos.matrix[3][1];
sp->zrv = -sp->zrv;
sp->xrv = -sp->xrv;
newRot = GL_TRUE;
}
if (sp->pos.matrix[3][2] > DEPTH || sp->pos.matrix[3][2] < -DEPTH)
{
sp->dpos.matrix[3][2] = -sp->dpos.matrix[3][2];
sp->xrv = -sp->xrv;
sp->yrv = -sp->yrv;
newRot = GL_TRUE;
}
if (newRot)
{
MakeRotMatrix(&sp->drot, sp->xrv, sp->yrv, sp->zrv);
}
__glMultMatrix(&sp->pos, &sp->dpos, &sp->pos);
}
if (fRotate)
{
__glMultMatrix(&sp->rot, &sp->drot, &sp->rot);
}
}
#define TAN_60 1.732
void SetTriangleVertices(LPD3DVERTEX v, float z, UINT ww, UINT wh, float a,
int ox, int oy)
{
float dx, dy;
float b = (float)sqrt((4 * a) / TAN_60);
float h = (2 * a) / b;
float x = (float)((b / 2) * (TAN_60 / 2));
float cx, cy;
dx = (float)ww;
dy = (float)wh;
cx = dx / 2 + ox;
cy = dy / 2 + oy;
/* V 0 */
v[0].x = cx;
v[0].y = cy + (h - x);
v[0].z = z;
v[0].color = RGB_MAKE(255, 0, 0);
v[0].tu = D3DVAL(0.5);
v[0].tv = D3DVAL(0.0);
/* V 1 */
v[1].x = cx + (b / 2);
v[1].y = cy - x;
v[1].z = z;
v[1].color = RGB_MAKE(255, 255, 255);
v[1].tu = D3DVAL(1.0);
v[1].tv = D3DVAL(1.0);
/* V 2 */
v[2].x = cx - (b / 2);
v[2].y = cy - x;
v[2].z = z;
v[2].color = RGB_MAKE(255, 255, 0);
v[2].tu = D3DVAL(0.0);
v[2].tv = D3DVAL(1.0);
}
void InitFill(LPD3DVERTEX *ppVertices, LPD3DTRIANGLE *ppTriangles)
{
*ppVertices = (LPD3DVERTEX)Malloc(3 * FILL_TRIANGLES * sizeof(D3DVERTEX));
*ppTriangles = (LPD3DTRIANGLE)Malloc(FILL_TRIANGLES * sizeof(D3DTRIANGLE));
}
D3DVERTEX *pPolyVertices;
D3DTRIANGLE *pPolyTriangles;
int nNumVertices, nNumFaces;
int *pPolyStrip;
int nStripIndices;
D3DVERTEX *pFillVertices;
D3DTRIANGLE *pFillTriangles;
int *pIndices;
int nIndices;
int nTriangles;
#define POLYMODE_POINT 0
#define POLYMODE_LINE 1
#define POLYMODE_FILL 2
#define POLYMODE_COUNT 3
GLenum ePolygonModes[] =
{
GL_POINT, GL_LINE, GL_FILL
};
int iPolygonMode = POLYMODE_FILL;
#define SMODEL_SMOOTH 0
#define SMODEL_FLAT 1
#define SMODEL_COUNT 2
GLenum eShadeModels[] =
{
GL_SMOOTH, GL_FLAT
};
char *pszShadeModels[] =
{
"smooth", "flat"
};
int iShadeModel = SMODEL_SMOOTH;
#define PRIM_TRIANGLES 0
#define PRIM_TSTRIP 1
#define PRIM_QSTRIP 2
#define PRIM_COUNT 3
GLenum ePrimTypes[] =
{
GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_QUAD_STRIP
};
char *pszPrimTypes[] =
{
"Tris",
"TStrip",
"QStrip"
};
int iPrimType = PRIM_TRIANGLES;
int total_ms = 0;
int total_tris = 0 ;
double peak_tri = 0, peak_fill = 0, avg_tri = 0, avg_fill = 0;
int avg_cnt = 0;
void ModeChange(void)
{
total_ms = 0;
total_tris = 0;
avg_tri = 0;
avg_fill = 0;
avg_cnt = 0;
}
void SetPrim(int iNew)
{
ModeChange();
iPrimType = iNew;
switch(iTest)
{
case TEST_POLYS:
switch(iPrimType)
{
case PRIM_TRIANGLES:
pIndices = (int *)pPolyTriangles;
nIndices = nNumFaces*3;
nTriangles = nNumFaces;
break;
case PRIM_TSTRIP:
case PRIM_QSTRIP:
pIndices = pPolyStrip;
nIndices = nStripIndices;
nTriangles = nSections*2;
break;
}
nTriangles *= NSPHERES;
break;
case TEST_FILL:
pIndices = (int *)pFillTriangles;
nIndices = FILL_TRIANGLES*3;
nTriangles = FILL_TRIANGLES;
break;
}
}
void SetVertexArrayVertices(LPD3DVERTEX pVertices)
{
glVertexPointer(3, GL_FLOAT, sizeof(D3DVERTEX), &pVertices[0].x);
glNormalPointer(GL_FLOAT, sizeof(D3DVERTEX), &pVertices[0].nx);
glTexCoordPointer(2, GL_FLOAT, sizeof(D3DVERTEX), &pVertices[0].tu);
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(D3DVERTEX),
&pVertices[0].color);
}
void SetFill(int iNewSize, int iNewOrder)
{
int i;
float z;
int NumTri;
LPD3DVERTEX pVert;
LPD3DTRIANGLE pTri;
UINT w, h;
float area;
int ox, oy, dox, doy;
RECT rct;
ModeChange();
iFillSize = iNewSize;
iOrder = iNewOrder;
switch(iFillSize)
{
case AREA_LARGE:
iTriangleArea = LARGE_AREA;
iSwapWidth = LAWIDTH;
iSwapHeight = LAHEIGHT;
break;
case AREA_MEDIUM:
iTriangleArea = MEDIUM_AREA;
iSwapWidth = MAWIDTH;
iSwapHeight = MAHEIGHT;
break;
}
glScissor((WIDTH-iSwapWidth)/2, (HEIGHT-iSwapHeight)/2,
iSwapWidth, iSwapHeight);
w = WIDTH;
h = HEIGHT;
NumTri = FILL_TRIANGLES;
pVert = pFillVertices;
if (fSpread)
{
ox = -NumTri*2;
oy = -NumTri*2;
dox = 4;
doy = 4;
}
else
{
ox = 0;
oy = 0;
dox = 0;
doy = 0;
}
if (iOrder == FRONT_TO_BACK)
{
for (i = 0, z = (float)0.0; i < NumTri; i++, z -= (float)0.9 / NumTri)
{
SetTriangleVertices(pVert, z, w, h, (float)iTriangleArea,
ox, oy);
pVert += 3;
ox += dox;
oy += doy;
}
}
else
{
for (i = 0, z = (float)-0.9; i < NumTri; i++, z += (float)0.9 / NumTri)
{
SetTriangleVertices(pVert, z, w, h, (float)iTriangleArea,
ox, oy);
pVert += 3;
ox += dox;
oy += doy;
}
}
pTri = pFillTriangles;
for (i = 0; i < NumTri; i++)
{
pTri->v1 = i*3;
pTri->v2 = i*3+1;
pTri->v3 = i*3+2;
pTri++;
}
GetClientRect(auxGetHWND(), &rct);
FillRect(auxGetHDC(), &rct, GetStockObject(BLACK_BRUSH));
}
static __GLmatrix proj = {
D3DVAL(2.0), D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0),
D3DVAL(0.0), D3DVAL(2.0), D3DVAL(0.0), D3DVAL(0.0),
D3DVAL(0.0), D3DVAL(0.0), D3DVAL(1.0), D3DVAL(1.0),
D3DVAL(0.0), D3DVAL(0.0), D3DVAL(-1.0), D3DVAL(0.0)
};
static __GLmatrix view = {
D3DVAL(1.0), D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0),
D3DVAL(0.0), D3DVAL(1.0), D3DVAL(0.0), D3DVAL(0.0),
D3DVAL(0.0), D3DVAL(0.0), D3DVAL(1.0), D3DVAL(0.0),
D3DVAL(0.0), D3DVAL(0.0), D3DVAL(7.0), D3DVAL(1.0)
};
void SetTest(int iNew)
{
RECT rct;
ModeChange();
iTest = iNew;
switch(iTest)
{
case TEST_POLYS:
glDisableClientState(GL_COLOR_ARRAY);
glEnable(GL_LIGHTING);
glEnable(GL_CULL_FACE);
iTexMode = TEXMODE_REPLACE;
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, eTexModes[iTexMode]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
#if 0
gluPerspective(45, 1, .01, 15);
gluLookAt(0, 0, 8, 0, 0, 0, 0, 1, 0);
#else
glLoadMatrixf((float *)&proj);
glMultMatrixf((float *)&view);
glDepthRange(1, 0);
#endif
glMatrixMode(GL_MODELVIEW);
SetVertexArrayVertices(pPolyVertices);
iSwapWidth = SPWIDTH;
iSwapHeight = SPHEIGHT;
glScissor((WIDTH-iSwapWidth)/2, (HEIGHT-iSwapHeight)/2,
iSwapWidth, iSwapHeight);
break;
case TEST_FILL:
glEnableClientState(GL_COLOR_ARRAY);
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
iTexMode = TEXMODE_MODULATE;
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, eTexModes[iTexMode]);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, WIDTH, 0, HEIGHT, 0.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
SetVertexArrayVertices(pFillVertices);
SetFill(iFillSize, iOrder);
break;
}
SetPrim(iPrimType);
GetClientRect(auxGetHWND(), &rct);
FillRect(auxGetHDC(), &rct, GetStockObject(BLACK_BRUSH));
}
void Init(void)
{
float fv4[4];
int iPrim, iOldPrim;
if (!GenerateSphere(SRADIUS, nRings, nSections, 1.0f, 1.0f, 1.0f,
&pPolyVertices, &pPolyTriangles,
&nNumVertices, &nNumFaces))
{
printf("Unable to generate sphere data\n");
exit(1);
}
nStripIndices = CreateStrip(nSections, &pPolyStrip);
InitSpheres();
InitFill(&pFillVertices, &pFillTriangles);
fv4[0] = 0.05f;
fv4[1] = 0.05f;
fv4[2] = 0.05f;
fv4[3] = 1.0f;
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, fv4);
fv4[0] = 0.0f;
fv4[1] = 1.0f;
fv4[2] = 1.0f;
fv4[3] = 0.0f;
glLightfv(GL_LIGHT0, GL_POSITION, fv4);
fv4[0] = 0.9f;
fv4[1] = 0.9f;
fv4[2] = 0.9f;
fv4[3] = 1.0f;
glLightfv(GL_LIGHT0, GL_DIFFUSE, fv4);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (!fSingleColor)
{
glEnableClientState(GL_COLOR_ARRAY);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
}
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
#ifdef TEXOBJ
glGenTextures(1, &uiTexObj);
glBindTexture(GL_TEXTURE_2D, uiTexObj);
#endif
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, 3, pTexture->sizeX, pTexture->sizeY, 0,
GL_RGB, GL_UNSIGNED_BYTE, pTexture->data);
glEnable(GL_TEXTURE_2D);
glDisable(GL_DITHER);
#ifdef GL_EXT_clip_volume
glHint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT, GL_FASTEST);
#endif
SetTest(iTest);
glClear(GL_COLOR_BUFFER_BIT);
if (fDisplayList)
{
iDlist = glGenLists(3);
iOldPrim = iPrimType;
for (iPrim = 0; iPrim < PRIM_COUNT; iPrim++)
{
SetPrim(iPrim);
glNewList(iDlist+iPrim, GL_COMPILE);
glDrawElements(ePrimTypes[iPrim], nIndices,
GL_UNSIGNED_INT, pIndices);
glEndList();
}
SetPrim(iOldPrim);
}
}
void Redraw(void)
{
DWORD ms;
int i;
Sphere *sp;
float fv4[4];
int iv1[1];
int loop;
__GLmatrix xform;
ms = GetTickCount();
for (loop = 0; loop < iMultiLoop; loop++)
{
#if PROFILE
if (loop > 0)
{
StartCAP();
}
#endif
if (fUseScissor)
{
glEnable(GL_SCISSOR_TEST);
if (glAddSwapHintRectWIN != NULL)
{
glAddSwapHintRectWIN((WIDTH-iSwapWidth)/2,
(HEIGHT-iSwapHeight)/2,
iSwapWidth, iSwapHeight);
}
}
if (glIsEnabled(GL_DEPTH_TEST))
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
else
{
glClear(GL_COLOR_BUFFER_BIT);
}
if (fUseScissor)
{
glDisable(GL_SCISSOR_TEST);
}
if (fSingleColor && iTest == TEST_POLYS)
{
fv4[0] = 1.0f;
fv4[1] = 1.0f;
fv4[2] = 1.0f;
fv4[3] = 1.0f;
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, fv4);
}
fv4[0] = 0.6f;
fv4[1] = 0.6f;
fv4[2] = 0.6f;
fv4[3] = 1.0f;
glMaterialfv(GL_FRONT, GL_SPECULAR, fv4);
iv1[0] = 40;
glMaterialiv(GL_FRONT, GL_SHININESS, iv1);
switch(iTest)
{
case TEST_POLYS:
sp = &spheres[0];
for (i = 0; i < NSPHERES; i++)
{
UpdateSphere(sp);
// Always done to even out timings
#if 1
__glMultMatrix(&xform, &sp->rot, &sp->pos);
#else
__glMultMatrix(&xform, &sp->pos, &sp->rot);
#endif
if (fBounce && fRotate)
{
glLoadMatrixf(&xform.matrix[0][0]);
}
else if (fRotate)
{
glLoadMatrixf(&sp->rot.matrix[0][0]);
}
else
{
glLoadMatrixf(&sp->pos.matrix[0][0]);
}
#if 1
glVertexPointer(3, GL_FLOAT, sizeof(D3DVERTEX), &pPolyVertices[0].x);
glNormalPointer(GL_FLOAT, sizeof(D3DVERTEX), &pPolyVertices[0].nx);
glTexCoordPointer(2, GL_FLOAT, sizeof(D3DVERTEX), &pPolyVertices[0].tu);
fv4[0] = 1.0f;
fv4[1] = 1.0f;
fv4[2] = 1.0f;
fv4[3] = 1.0f;
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, fv4);
fv4[0] = 0.6f;
fv4[1] = 0.6f;
fv4[2] = 0.6f;
fv4[3] = 1.0f;
glMaterialfv(GL_FRONT, GL_SPECULAR, fv4);
iv1[0] = 40;
glMaterialiv(GL_FRONT, GL_SHININESS, iv1);
glBindTexture(GL_TEXTURE_2D, uiTexObj);
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glEnable(GL_TEXTURE_2D);
glDepthRange(1, 0);
glEnableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glEnable(GL_LIGHTING);
#endif
if (fDisplayList)
{
glCallList(iDlist+iPrimType);
}
else
{
glDrawElements(ePrimTypes[iPrimType], nIndices,
GL_UNSIGNED_INT, pIndices);
}
sp++;
}
break;
case TEST_FILL:
glDrawElements(GL_TRIANGLES, nIndices, GL_UNSIGNED_INT, pIndices);
break;
}
if (fSwap && !fSingle)
{
auxSwapBuffers();
}
else
{
glFinish();
}
}
#ifdef PROFILE
if (iMultiLoop > 1)
{
StopCAP();
}
#endif
ms = GetTickCount()-ms;
total_ms += ms;
total_tris += nTriangles*iMultiLoop;
if (total_ms > 2000)
{
double val;
switch(iTest)
{
case TEST_POLYS:
val = (double)total_tris*1000.0/total_ms;
if (val > peak_tri)
{
peak_tri = val;
}
avg_tri += val;
break;
case TEST_FILL:
val = (double)iTriangleArea*total_tris*1000.0/total_ms;
if (val > peak_fill)
{
peak_fill = val;
}
avg_fill += val;
break;
}
avg_cnt++;
if (fVerbose)
{
printf("%s, %s", pszPrimTypes[iPrimType],
pszShadeModels[iShadeModel]);
if (glIsEnabled(GL_CULL_FACE))
{
printf(", cull");
}
if (glIsEnabled(GL_LIGHTING))
{
printf(", lit");
}
if (glIsEnabled(GL_TEXTURE_2D))
{
printf(", %s", pszTexModes[iTexMode]);
}
if (glIsEnabled(GL_DITHER))
{
printf(", dither");
}
if (glIsEnabled(GL_DEPTH_TEST))
{
printf(", z");
}
#ifdef GL_EXT_clip_volume
glGetIntegerv(GL_CLIP_VOLUME_CLIPPING_HINT_EXT, &iv1[0]);
if (iv1[0] != GL_FASTEST)
#endif
{
printf(", clip");
}
if (fSwap)
{
printf(", swap");
}
if (fRotate)
{
printf(", rotate");
}
if (fBounce)
{
printf(", bounce");
}
if (fPerspective)
{
printf(", persp");
}
printf(", %d tri/frame\n", nTriangles);
switch(iTest)
{
case TEST_POLYS:
printf("%d ms, %d tri, %.3lf tri/sec, %.3lf peak, %.3lf avg\n",
total_ms, total_tris, val, peak_tri,
avg_tri/avg_cnt);
break;
case TEST_FILL:
printf("%d ms, %s, area %d, %.3lf pix/sec, "
"%.3lf peak, %.3lf avg\n",
total_ms, pszOrders[iOrder], iTriangleArea,
val, peak_fill, avg_fill/avg_cnt);
break;
}
}
else
{
char msg[80];
switch(iTest)
{
case TEST_POLYS:
sprintf(msg, "%.3lf tri/sec, %.3lf peak, %.3lf avg",
val, peak_tri, avg_tri/avg_cnt);
break;
case TEST_FILL:
sprintf(msg, "%.3lf pix/sec, %.3lf peak, %.3lf avg",
val, peak_fill, avg_fill/avg_cnt);
break;
}
SetWindowText(auxGetHWND(), msg);
}
total_ms = 0;
total_tris = 0;
}
}
void Reshape(GLsizei w, GLsizei h)
{
glViewport(0, 0, w, h);
}
void Step(void)
{
Redraw();
}
void KeyB(void)
{
ModeChange();
fBounce = !fBounce;
}
void Keyc(void)
{
ModeChange();
if (glIsEnabled(GL_CULL_FACE))
{
glDisable(GL_CULL_FACE);
}
else
{
glEnable(GL_CULL_FACE);
}
}
void KeyC(void)
{
ModeChange();
fUseScissor = !fUseScissor;
}
void Keyh(void)
{
ModeChange();
if (glIsEnabled(GL_DITHER))
{
glDisable(GL_DITHER);
}
else
{
glEnable(GL_DITHER);
}
}
void Keyi(void)
{
iFillSize = (iFillSize+1) % AREA_COUNT;
SetFill(iFillSize, iOrder);
}
void Keyl(void)
{
ModeChange();
if (glIsEnabled(GL_LIGHTING))
{
glDisable(GL_LIGHTING);
}
else
{
glEnable(GL_LIGHTING);
}
}
void Keym(void)
{
ModeChange();
iPolygonMode = (iPolygonMode+1) % POLYMODE_COUNT;
glPolygonMode(GL_FRONT_AND_BACK, ePolygonModes[iPolygonMode]);
}
void Keyo(void)
{
iOrder = (iOrder+1) % ORDER_COUNT;
SetFill(iFillSize, iOrder);
}
void Keyp(void)
{
ModeChange();
fPerspective = !fPerspective;
glHint(GL_PERSPECTIVE_CORRECTION_HINT,
fPerspective ? GL_NICEST : GL_FASTEST);
}
void KeyP(void)
{
#ifdef GL_EXT_clip_volume
int iv1[1];
ModeChange();
glGetIntegerv(GL_CLIP_VOLUME_CLIPPING_HINT_EXT, &iv1[0]);
if (iv1[0] == GL_FASTEST)
{
glHint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT, GL_DONT_CARE);
}
else
{
glHint(GL_CLIP_VOLUME_CLIPPING_HINT_EXT, GL_FASTEST);
}
#endif
}
void KeyR(void)
{
ModeChange();
fRotate = !fRotate;
}
void Keys(void)
{
ModeChange();
iShadeModel = (iShadeModel+1) % SMODEL_COUNT;
glShadeModel(eShadeModels[iShadeModel]);
}
void KeyS(void)
{
fSpread = !fSpread;
SetFill(iFillSize, iOrder);
}
void Keyt(void)
{
SetPrim((iPrimType+1) % PRIM_COUNT);
}
void KeyT(void)
{
iTest = (iTest+1) % TEST_COUNT;
SetTest(iTest);
}
void Keyw(void)
{
ModeChange();
fSwap = !fSwap;
}
void Keyx(void)
{
ModeChange();
if (glIsEnabled(GL_TEXTURE_2D))
{
glDisable(GL_TEXTURE_2D);
}
else
{
glEnable(GL_TEXTURE_2D);
}
}
void KeyX(void)
{
ModeChange();
iTexMode = (iTexMode+1) % TEXMODE_COUNT;
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, eTexModes[iTexMode]);
}
void Keyz(void)
{
ModeChange();
if (glIsEnabled(GL_DEPTH_TEST))
{
glDisable(GL_DEPTH_TEST);
}
else
{
glEnable(GL_DEPTH_TEST);
}
}
void KeySPACE(void)
{
fPaused = !fPaused;
if (fPaused)
{
auxIdleFunc(NULL);
}
else
{
auxIdleFunc(Step);
}
}
void __cdecl main(int argc, char **argv)
{
int mode;
int wd, ht;
char szWinDir[256];
int l;
wd = WIDTH;
ht = HEIGHT;
while (--argc > 0)
{
argv++;
if (!strcmp(*argv, "-sb"))
{
fSingle = TRUE;
}
else if (!strcmp(*argv, "-paused"))
{
fPaused = TRUE;
}
else if (!strcmp(*argv, "-exit"))
{
fExit = TRUE;
}
else if (!strcmp(*argv, "-cols"))
{
fSingleColor = FALSE;
}
else if (!strcmp(*argv, "-v"))
{
fVerbose = TRUE;
}
else if (!strcmp(*argv, "-nodlist"))
{
fDisplayList = FALSE;
}
else if (!strcmp(*argv, "-norotate"))
{
fRotate = FALSE;
}
else if (!strcmp(*argv, "-nobounce"))
{
fBounce = FALSE;
}
else if (!strcmp(*argv, "-noscissor"))
{
fUseScissor = FALSE;
}
else if (!strncmp(*argv, "-multi", 6))
{
sscanf(*argv+6, "%d", &iMultiLoop);
}
else if (!strncmp(*argv, "-wd", 3))
{
sscanf(*argv+3, "%d", &wd);
}
else if (!strncmp(*argv, "-ht", 3))
{
sscanf(*argv+3, "%d", &ht);
}
else if (!strncmp(*argv, "-rings", 6))
{
sscanf(*argv+6, "%d", &nRings);
}
else if (!strncmp(*argv, "-sections", 9))
{
sscanf(*argv+9, "%d", &nSections);
}
else if (!strncmp(*argv, "-tst", 4))
{
sscanf(*argv+4, "%d", &iTest);
}
else if (!strncmp(*argv, "-fsz", 4))
{
sscanf(*argv+4, "%d", &iFillSize);
}
}
auxInitPosition(10, 10, wd, ht);
mode = AUX_RGB | AUX_DEPTH16;
if (!fSingle)
{
mode |= AUX_DOUBLE;
}
auxInitDisplayMode(mode);
auxInitWindow("DrawElements Performance Test");
auxReshapeFunc(Reshape);
if (!fPaused)
{
auxIdleFunc(Step);
}
l = GetWindowsDirectory(szWinDir, sizeof(szWinDir));
if (l == 0)
{
printf("Unable to get windows directory\n");
exit(1);
}
strcpy(szWinDir+l, "\\cover8.bmp");
pTexture = auxDIBImageLoad(szWinDir);
if (pTexture == NULL)
{
printf("Unable to load texture\n");
exit(1);
}
auxKeyFunc(AUX_B, KeyB);
auxKeyFunc(AUX_c, Keyc);
auxKeyFunc(AUX_C, KeyC);
auxKeyFunc(AUX_h, Keyh);
auxKeyFunc(AUX_i, Keyi);
auxKeyFunc(AUX_l, Keyl);
auxKeyFunc(AUX_m, Keym);
auxKeyFunc(AUX_o, Keyo);
auxKeyFunc(AUX_p, Keyp);
auxKeyFunc(AUX_P, KeyP);
auxKeyFunc(AUX_R, KeyR);
auxKeyFunc(AUX_s, Keys);
auxKeyFunc(AUX_S, KeyS);
auxKeyFunc(AUX_t, Keyt);
auxKeyFunc(AUX_T, KeyT);
auxKeyFunc(AUX_w, Keyw);
auxKeyFunc(AUX_x, Keyx);
auxKeyFunc(AUX_X, KeyX);
auxKeyFunc(AUX_z, Keyz);
auxKeyFunc(AUX_SPACE, KeySPACE);
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)
wglGetProcAddress("glAddSwapHintRectWIN");
#if 0
_controlfp((unsigned int)
(~(_EM_ZERODIVIDE | _EM_OVERFLOW | _EM_UNDERFLOW)), _MCW_EM);
#endif
Init();
if (fExit)
{
Redraw();
}
else
{
auxMainLoop(Redraw);
}
}