1165 lines
31 KiB
C++
1165 lines
31 KiB
C++
/*
|
|
* This program renders a wireframe Bezier surface,
|
|
* using two-dimensional evaluators.
|
|
*/
|
|
|
|
#include "testres.h"
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <malloc.h>
|
|
#include <windows.h>
|
|
#include <GL/gl.h>
|
|
#include <GL/glu.h>
|
|
#include <GL/glaux.h>
|
|
#include "auxtea.h"
|
|
#include "vector.h"
|
|
|
|
/****************************************************************/
|
|
/* Macros */
|
|
/****************************************************************/
|
|
#define MIN_SAMPLE 5
|
|
#define IMAGE_WIDTH 64
|
|
#define IMAGE_HEIGHT 64
|
|
#define POLY_TEAPOT 11
|
|
#define BEZ_TEAPOT 12
|
|
#define COORD_SYS 14
|
|
|
|
#define MAX_NUM_FRAMES 24
|
|
#define __glPi ((GLfloat) 3.14159265358979323846)
|
|
#define __glDegreesToRadians (__glPi / (GLfloat) 180.0)
|
|
|
|
|
|
/****************************************************************/
|
|
/* Typedefs */
|
|
/****************************************************************/
|
|
typedef struct
|
|
{
|
|
GLdouble x, y, z;
|
|
} Vertex;
|
|
|
|
enum _render_type {POLYGON_TEAPOT, GLAUX_TEAPOT, BEZIER_TEAPOT,
|
|
GLAUX_SSPHERE, GLAUX_WSPHERE, TRIANGLES, LINE, LINES,
|
|
SQUARE, EVAL};
|
|
/****************************************************************/
|
|
/* Globals */
|
|
/****************************************************************/
|
|
HWND g_hWnd;
|
|
HMENU g_hMenu;
|
|
HANDLE OutputHandle;
|
|
|
|
GLenum shade_model = GL_PHONG_WIN;
|
|
GLenum phong_hint = GL_NICEST;
|
|
|
|
GLenum cull_face = GL_BACK;
|
|
GLenum front_face = GL_CCW;
|
|
BOOL cull_enable = FALSE;
|
|
BOOL depth_mode = TRUE;
|
|
BOOL timing_enable = FALSE;
|
|
BOOL bValidConsole = FALSE;
|
|
BOOL doSpin = FALSE;
|
|
|
|
GLfloat curr_angle=0.0, scale, scale2;
|
|
GLint sample = MIN_SAMPLE;
|
|
GLint sampleEval = 32;
|
|
char drawwithpolys=GL_FALSE ;
|
|
BOOL bTexEnable = GL_FALSE, bLightEnable = GL_TRUE;
|
|
BOOL bTwoSided = FALSE;
|
|
BOOL bColorMaterial = FALSE;
|
|
BOOL bNormalize = TRUE;
|
|
BOOL bAntiAlias = FALSE;
|
|
BOOL bAux = GL_FALSE;
|
|
GLfloat sc_x = 1.0, sc_y = 1.0, sc_z = 1.0;
|
|
|
|
GLint width = IMAGE_WIDTH, height = IMAGE_HEIGHT ;
|
|
GLubyte image[3*IMAGE_WIDTH*IMAGE_HEIGHT] ;
|
|
GLdouble VTemp ;
|
|
|
|
GLfloat ctrlpoints[4][4][3] = {
|
|
{{-1.5, -1.5, 0.0}, {-0.5, -1.5, 1.0}, {0.5, -1.5, 1.0}, {1.5, -1.5, 0.0}},
|
|
{{-1.5, -0.5, 1.0}, {-0.5, -0.5, 3.0}, {0.5, -0.5, 3.0}, {1.5, -0.5, 0.0}},
|
|
{{-1.5, 0.5, 1.0}, {-0.5, 0.5, 3.0}, {0.5, 0.5, 3.0}, {1.5, 0.5, 0.0}},
|
|
{{-1.5, 1.5, 0.0}, {-0.5, 1.5, 1.0}, {0.5, 1.5, 1.0}, {1.5, 1.5, 0.0}}
|
|
};
|
|
|
|
#if 0
|
|
GLfloat ctrlpoints[4][4][3] = {
|
|
{{-1.5, -1.5, 4.0}, {-0.5, -1.5, 2.0},
|
|
{0.5, -1.5, -1.0}, {1.5, -1.5, 2.0}},
|
|
{{-1.5, -0.5, 1.0}, {-0.5, -0.5, 3.0},
|
|
{0.5, -0.5, 0.0}, {1.5, -0.5, -1.0}},
|
|
{{-1.5, 0.5, 4.0}, {-0.5, 0.5, 0.0},
|
|
{0.5, 0.5, 3.0}, {1.5, 0.5, 4.0}},
|
|
{{-1.5, 1.5, -2.0}, {-0.5, 1.5, -2.0},
|
|
{0.5, 1.5, 0.0}, {1.5, 1.5, -1.0}}
|
|
};
|
|
#endif
|
|
|
|
static DWORD startelapsed, endelapsed;
|
|
float bsecs=0.0, bavg=0.0, bcum=0.0;
|
|
DWORD bnum_frames=0;
|
|
float psecs=0.0, pavg=0.0, pcum=0.0;
|
|
DWORD pnum_frames=0;
|
|
|
|
GLfloat texpts[2][2][2] = {{{0.0, 0.0}, {0.0, 1.0}},
|
|
{{1.0, 0.0}, {1.0, 1.0}}} ;
|
|
|
|
enum _render_type render_type = TRIANGLES;
|
|
|
|
|
|
/****************************************************************/
|
|
/* Prototypes */
|
|
/****************************************************************/
|
|
void display() ;
|
|
void BezTeapot(GLfloat) ;
|
|
void MouseWheel(AUX_MOUSEWHEEL_EVENTREC *);
|
|
void CustomizeWnd (HINSTANCE);
|
|
LONG APIENTRY MyWndProc(HWND, UINT, UINT, LONG);
|
|
void SubclassWindow (HWND, WNDPROC);
|
|
ULONG DbgPrint(PSZ Format, ...);
|
|
void DrawTris(void);
|
|
void DrawSquare(void);
|
|
void DrawLines(void);
|
|
void DrawEval(void);
|
|
void initEval(void);
|
|
void init_texture(void);
|
|
/****************************************************************/
|
|
/* Code */
|
|
/****************************************************************/
|
|
void
|
|
MouseWheel(AUX_MOUSEWHEEL_EVENTREC *mw)
|
|
//MouseWheel (int fwKeys, int zDelta, int xPos, int yPos)
|
|
{
|
|
if (mw->zDelta > 0)
|
|
{
|
|
sc_x *=1.1;
|
|
sc_y *=1.1;
|
|
sc_z *=1.1;
|
|
}
|
|
else
|
|
{
|
|
sc_x *=0.9;
|
|
sc_y *=0.9;
|
|
sc_z *=0.9;
|
|
}
|
|
}
|
|
|
|
|
|
void loadImage(void)
|
|
{
|
|
int i, j ;
|
|
GLubyte col = 0 ;
|
|
|
|
for(i=0; i<width; i++)
|
|
for(j=0; j<height; j++)
|
|
if( ((j/8)%2 && (i/8)%2) || (!((j/8)%2) && !((i/8)%2)) )
|
|
{
|
|
image[(i*height+j)*3] = 127 ;
|
|
image[(i*height+j)*3+1] = 127 ;
|
|
image[(i*height+j)*3+2] = 127 ;
|
|
}
|
|
else
|
|
{
|
|
image[(i*height+j)*3] = 0 ;
|
|
image[(i*height+j)*3+1] = 0 ;
|
|
image[(i*height+j)*3+2] = 0 ;
|
|
}
|
|
}
|
|
|
|
|
|
void PolyTeapot(GLfloat scale)
|
|
{
|
|
FILE *fd;
|
|
Vertex *vertices;
|
|
int index[3];
|
|
int i, dummy;
|
|
int num_vertices, num_triangles;
|
|
Vertex v1, v2, normal ;
|
|
|
|
fd = fopen("teapot.geom","r");
|
|
fscanf(fd, "%d %d %d", &num_vertices, &num_triangles, &dummy);
|
|
|
|
vertices = (Vertex *)malloc(num_vertices*sizeof(Vertex));
|
|
|
|
for (i=0; i < num_vertices; i++)
|
|
fscanf(fd, "%lf %lf %lf", &vertices[i].x, &vertices[i].y,
|
|
&vertices[i].z);
|
|
|
|
glNewList(POLY_TEAPOT, GL_COMPILE) ;
|
|
glPushMatrix ();
|
|
glScalef (scale, scale, scale);
|
|
glTranslatef (0.0, -1.4, 0.0);
|
|
for (i=0; i < num_triangles; i++)
|
|
{
|
|
//glBegin(GL_POLYGON);
|
|
glBegin(GL_TRIANGLES);
|
|
fscanf(fd, "%d %d %d %d", &dummy, &index[0], &index[1], &index[2]);
|
|
index[0]--; index[1]--; index[2]--;
|
|
|
|
VSub(v1, vertices[index[1]], vertices[index[0]]) ;
|
|
VSub(v2, vertices[index[2]], vertices[index[1]]) ;
|
|
VCross(normal, v2, v1) ;
|
|
VNormalize(normal, normal) ;
|
|
glNormal3d(normal.x, normal.y, normal.z) ;
|
|
glVertex3d(vertices[index[0]].x, vertices[index[0]].y,
|
|
vertices[index[0]].z);
|
|
glVertex3d(vertices[index[1]].x, vertices[index[1]].y,
|
|
vertices[index[1]].z);
|
|
glVertex3d(vertices[index[2]].x, vertices[index[2]].y,
|
|
vertices[index[2]].z);
|
|
glEnd();
|
|
}
|
|
glPopMatrix ();
|
|
glEndList() ;
|
|
DbgPrint("Done, Initializing the displaylist\n") ;
|
|
fclose(fd);
|
|
}
|
|
|
|
|
|
|
|
void spin(void)
|
|
{
|
|
curr_angle+=10.0 ;
|
|
if(curr_angle > 360.0) curr_angle-=360.0 ;
|
|
display() ;
|
|
|
|
if (drawwithpolys)
|
|
{
|
|
pnum_frames++;
|
|
pcum += psecs;
|
|
if (pnum_frames == MAX_NUM_FRAMES)
|
|
{
|
|
pavg = pcum/(float)MAX_NUM_FRAMES;
|
|
DbgPrint("Average over %d poly frames: %f secs per frame\n",
|
|
MAX_NUM_FRAMES, pavg);
|
|
pnum_frames = 0;
|
|
pcum = 0.0; pavg = 0.0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bnum_frames++;
|
|
bcum += bsecs;
|
|
if (bnum_frames == MAX_NUM_FRAMES)
|
|
{
|
|
bavg = bcum/(float)MAX_NUM_FRAMES;
|
|
DbgPrint("Average over %d poly frames: %f secs per frame\n",
|
|
MAX_NUM_FRAMES, bavg);
|
|
bnum_frames = 0;
|
|
bcum = 0.0; bavg = 0.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void toggle(void)
|
|
{
|
|
doSpin = !(doSpin) ;
|
|
if (doSpin)
|
|
auxIdleFunc(spin) ;
|
|
else
|
|
auxIdleFunc(NULL) ;
|
|
}
|
|
|
|
void scale_up(void)
|
|
{
|
|
sc_x *=1.1;
|
|
sc_y *=1.1;
|
|
sc_z *=1.1;
|
|
}
|
|
void scale_down(void)
|
|
{
|
|
sc_x *=0.9;
|
|
sc_y *=0.9;
|
|
sc_z *=0.9;
|
|
}
|
|
|
|
void beztype(void)
|
|
{
|
|
bAux = !(bAux) ;
|
|
}
|
|
|
|
|
|
void cull (void)
|
|
{
|
|
if (cull_enable)
|
|
glEnable(GL_CULL_FACE);
|
|
else
|
|
glDisable(GL_CULL_FACE);
|
|
}
|
|
|
|
|
|
void depth(void)
|
|
{
|
|
if (depth_mode)
|
|
{
|
|
glEnable(GL_DEPTH_TEST);
|
|
glDepthFunc(GL_LESS);
|
|
glDepthMask(GL_TRUE);
|
|
}
|
|
else
|
|
{
|
|
glDisable(GL_DEPTH_TEST);
|
|
glDepthMask(GL_FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
void lighting(void)
|
|
{
|
|
if (bLightEnable)
|
|
{
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_LIGHT0);
|
|
}
|
|
else
|
|
{
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_LIGHT0);
|
|
}
|
|
}
|
|
|
|
|
|
void texture(void)
|
|
{
|
|
if (bTexEnable)
|
|
glEnable(GL_TEXTURE_2D);
|
|
else
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
void init_texture(void)
|
|
{
|
|
/* Texture stuff */
|
|
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL) ;
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT) ;
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT) ;
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) ;
|
|
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) ;
|
|
glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB,
|
|
GL_UNSIGNED_BYTE, image) ;
|
|
texture();
|
|
}
|
|
|
|
|
|
void initlights(void)
|
|
{
|
|
//GLfloat ambient[] = { 0.2, 0.2, 0.2, 1.0 };
|
|
GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 };
|
|
GLfloat position[] = { 0.0, 0.0, 2.0, 0.0 };
|
|
//GLfloat position[] = { 0.0, 0.0, 2.0, 0.0 };
|
|
GLfloat mat_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
|
|
GLfloat mat_diffuse[] = { 0.6, 0.6, 0.6, 1.0 };
|
|
GLfloat mat_diffuse1[] = { 0.8, 0.5, 0.2, 1.0 };
|
|
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
|
|
GLfloat mat_shininess[] = { 60.0 };
|
|
|
|
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
|
|
glLightfv(GL_LIGHT0, GL_POSITION, position);
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
|
|
//glMaterialfv(GL_BACK_AND_BACK, GL_DIFFUSE, mat_diffuse1);
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
|
|
}
|
|
|
|
|
|
void DrawCoordSys(GLfloat size)
|
|
{
|
|
glNewList(COORD_SYS, GL_COMPILE) ;
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_LIGHT0);
|
|
glDisable(GL_TEXTURE_2D);
|
|
glBegin(GL_LINES) ;
|
|
glColor3f(1.0, 0.0, 0.0) ;
|
|
glVertex3f(0.0, 0.0, 0.0) ;
|
|
glVertex3f(1.0*size, 0.0, 0.0) ;
|
|
|
|
glColor3f(0.0, 1.0, 0.0) ;
|
|
glVertex3f(0.0, 0.0, 0.0) ;
|
|
glVertex3f(0.0, 1.0*size, 0.0) ;
|
|
|
|
glColor3f(0.0, 0.0, 1.0) ;
|
|
glVertex3f(0.0, 0.0, 0.0) ;
|
|
glVertex3f(0.0, 0.0, 1.0*size) ;
|
|
glEnd() ;
|
|
glEndList() ;
|
|
}
|
|
|
|
|
|
|
|
void display(void)
|
|
{
|
|
int i, j;
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glPushMatrix ();
|
|
//glRotatef(curr_angle, 1.0, 1.0, 1.0);
|
|
glRotatef(curr_angle, 0.0, 0.0, 1.0);
|
|
glScalef (sc_x, sc_y, sc_z);
|
|
|
|
if (timing_enable)
|
|
startelapsed = GetTickCount();
|
|
|
|
switch (render_type)
|
|
{
|
|
case GLAUX_TEAPOT:
|
|
auxSolidTeapot(scale2);
|
|
break;
|
|
case BEZIER_TEAPOT:
|
|
BezTeapot(scale) ;
|
|
break;
|
|
case POLYGON_TEAPOT:
|
|
glCallList(POLY_TEAPOT) ;
|
|
break;
|
|
case GLAUX_SSPHERE:
|
|
auxSolidSphere(scale2);
|
|
break;
|
|
case GLAUX_WSPHERE:
|
|
auxWireSphere(scale2);
|
|
break;
|
|
case TRIANGLES:
|
|
DrawTris();
|
|
break;
|
|
case SQUARE:
|
|
DrawSquare();
|
|
break;
|
|
case LINES:
|
|
DrawLines();
|
|
break;
|
|
case EVAL:
|
|
DrawEval();
|
|
break;
|
|
default:
|
|
break;
|
|
};
|
|
glFlush() ;
|
|
|
|
if (timing_enable)
|
|
{
|
|
endelapsed = GetTickCount();
|
|
bsecs = (endelapsed - startelapsed) / (float)1000;
|
|
DbgPrint ("Time to draw bezier tpot frame = %f\n", bsecs);
|
|
}
|
|
|
|
glPopMatrix ();
|
|
auxSwapBuffers();
|
|
}
|
|
|
|
void myinit(void)
|
|
{
|
|
glClearColor (0.7, 0.3, 0.1, 1.0);
|
|
glColor3f(0.2, 0.5, 0.8);
|
|
loadImage() ;
|
|
|
|
//DrawCoordSys(5.0) ;
|
|
// BezTeapot(scale) ;
|
|
PolyTeapot(1.0) ;
|
|
auxSolidTeapot(scale2);
|
|
|
|
glEnable(GL_AUTO_NORMAL);
|
|
if (bNormalize)
|
|
glEnable(GL_NORMALIZE);
|
|
else
|
|
glDisable(GL_NORMALIZE);
|
|
|
|
glShadeModel(shade_model);
|
|
//glHint (GL_PHONG_HINT_WIN, phong_hint);
|
|
|
|
glFrontFace(front_face);
|
|
glCullFace(cull_face);
|
|
|
|
if (bAntiAlias)
|
|
{
|
|
glEnable (GL_POLYGON_SMOOTH);
|
|
glEnable (GL_LINE_SMOOTH);
|
|
glEnable (GL_POINT_SMOOTH);
|
|
}
|
|
else
|
|
{
|
|
glDisable (GL_POLYGON_SMOOTH);
|
|
glDisable (GL_LINE_SMOOTH);
|
|
glDisable (GL_POINT_SMOOTH);
|
|
}
|
|
|
|
depth ();
|
|
cull ();
|
|
initlights ();
|
|
lighting ();
|
|
init_texture ();
|
|
initEval ();
|
|
|
|
if (bTwoSided)
|
|
glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
|
|
else
|
|
glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
|
|
|
|
glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
|
|
|
|
if (bColorMaterial)
|
|
glEnable(GL_COLOR_MATERIAL);
|
|
else
|
|
glDisable(GL_COLOR_MATERIAL);
|
|
}
|
|
|
|
|
|
void myReshape(GLsizei w, GLsizei h)
|
|
{
|
|
glViewport(0, 0, w, h);
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
if (w <= h)
|
|
glOrtho(-4.0, 4.0, -4.0*(GLfloat)h/(GLfloat)w,
|
|
4.0*(GLfloat)h/(GLfloat)w, -4.0, 4.0);
|
|
else
|
|
glOrtho(-4.0*(GLfloat)w/(GLfloat)h,
|
|
4.0*(GLfloat)w/(GLfloat)h, -4.0, 4.0, -4.0, 4.0);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
}
|
|
|
|
void initEval (void)
|
|
{
|
|
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
|
|
0, 1, 12, 4, &ctrlpoints[0][0][0]);
|
|
glEnable(GL_MAP2_VERTEX_3);
|
|
|
|
glMapGrid2f((GLfloat)sampleEval, 0.0, 1.0, (GLfloat)sampleEval, 0.0, 1.0);
|
|
glEnable(GL_AUTO_NORMAL);
|
|
}
|
|
|
|
|
|
BOOL CheckExtension(char *extName, char *extString)
|
|
{
|
|
/*
|
|
** Search for extName in the extensions string. Use of strstr()
|
|
** is not sufficient because extension names can be prefixes of
|
|
** other extension names. Could use strtok() but the constant
|
|
** string returned by glGetString can be in read-only memory.
|
|
*/
|
|
char *p = (char *)extString;
|
|
char *end;
|
|
int extNameLen;
|
|
|
|
extNameLen = strlen(extName);
|
|
end = p + strlen(p);
|
|
|
|
while (p < end) {
|
|
int n = strcspn(p, " ");
|
|
if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) {
|
|
return GL_TRUE;
|
|
}
|
|
p += (n + 1);
|
|
}
|
|
return GL_FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
//*------------------------------------------------------------------------
|
|
//| WinMain:
|
|
//| Parameters:
|
|
//| hInstance - Handle to current Data Segment
|
|
//| hPrevInstance - Always NULL in Win32
|
|
//| lpszCmdLine - Pointer to command line info
|
|
//| nCmdShow - Integer value specifying how to start app.,
|
|
//| (Iconic [7] or Normal [1,5])
|
|
//*------------------------------------------------------------------------
|
|
int WINAPI WinMain (HINSTANCE hInstance,
|
|
HINSTANCE hPrevInstance,
|
|
LPSTR lpszCmdLine,
|
|
int nCmdShow)
|
|
{
|
|
int nReturn = 0;
|
|
char *exts;
|
|
const char *ext_string;
|
|
int new_ext_supported = GL_FALSE;
|
|
|
|
scale = 1.0;
|
|
scale2 = 2.0;
|
|
|
|
auxInitDisplayMode (AUX_RGB | AUX_DEPTH16 | AUX_DOUBLE);
|
|
//auxInitDisplayMode (AUX_RGB | AUX_DEPTH16 | AUX_SINGLE);
|
|
auxInitPosition (10, 10, 500, 500);
|
|
auxInitWindow ("Test");
|
|
myinit();
|
|
|
|
exts = (char *) glGetString (GL_EXTENSIONS);
|
|
DbgPrint ("The extensions available are : %s\n", exts);
|
|
if ( CheckExtension("GL_EXT_bgra", exts) )
|
|
DbgPrint ("GL_EXT_new_extension available\n");
|
|
else
|
|
DbgPrint ("GL_EXT_new_extension not available\n");
|
|
|
|
CustomizeWnd(hInstance);
|
|
|
|
//bValidConsole = AllocConsole();
|
|
if (bValidConsole)
|
|
OutputHandle = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
|
|
auxReshapeFunc (myReshape);
|
|
if (doSpin)
|
|
auxIdleFunc(spin) ;
|
|
else
|
|
auxIdleFunc(NULL) ;
|
|
auxKeyFunc(AUX_p, toggle) ;
|
|
auxKeyFunc(AUX_l, lighting) ;
|
|
auxKeyFunc(AUX_t, texture) ;
|
|
auxKeyFunc(AUX_a, beztype) ;
|
|
auxKeyFunc(AUX_j, scale_up) ;
|
|
auxKeyFunc(AUX_k, scale_down) ;
|
|
auxMouseWheelFunc(MouseWheel) ;
|
|
auxMainLoop(display);
|
|
return (0);
|
|
}
|
|
|
|
|
|
|
|
void BezTeapot(GLfloat scale)
|
|
{
|
|
float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3];
|
|
long i, j, k, l;
|
|
|
|
//glNewList(BEZ_TEAPOT, GL_COMPILE);
|
|
glPushMatrix ();
|
|
glRotatef(270.0, 1.0, 0.0, 0.0);
|
|
glScalef (scale, scale, scale);
|
|
glTranslatef ((GLfloat)0.0, (GLfloat)0.0, (GLfloat)-1.5);
|
|
for (i = 0; i < 10; i++)
|
|
{
|
|
for (j = 0; j < 4; j++)
|
|
for (k = 0; k < 4; k++)
|
|
for (l = 0; l < 3; l++)
|
|
{
|
|
p[j][k][l] = cpdata[patchdata[i][j*4+k]][l];
|
|
q[j][k][l] = cpdata[patchdata[i][j*4+(3-k)]][l];
|
|
if (l == 1) q[j][k][l] *= (float)-1.0;
|
|
if (i < 6) {
|
|
r[j][k][l] = cpdata[patchdata[i][j*4+(3-k)]][l];
|
|
if (l == 0) r[j][k][l] *= (float)-1.0;
|
|
s[j][k][l] = cpdata[patchdata[i][j*4+k]][l];
|
|
if (l == 0) s[j][k][l] *= (float)-1.0;
|
|
if (l == 1) s[j][k][l] *= (float)-1.0;
|
|
}
|
|
}
|
|
glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, &texpts[0][0][0]);
|
|
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &p[0][0][0]);
|
|
glEnable(GL_MAP2_VERTEX_3); glEnable(GL_MAP2_TEXTURE_COORD_2);
|
|
glMapGrid2f((GLfloat)sample, 0.0, 1.0, (GLfloat)sample, 0.0, 1.0);
|
|
glEvalMesh2(GL_FILL, 0, sample, 0, sample);
|
|
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &q[0][0][0]);
|
|
glEvalMesh2(GL_FILL, 0, sample, 0, sample);
|
|
if (i < 6) {
|
|
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &r[0][0][0]);
|
|
glEvalMesh2(GL_FILL, 0, sample, 0, sample);
|
|
glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &s[0][0][0]);
|
|
glEvalMesh2(GL_FILL, 0, sample, 0, sample);
|
|
}
|
|
}
|
|
glDisable(GL_MAP2_VERTEX_3); glDisable(GL_MAP2_TEXTURE_COORD_2);
|
|
glPopMatrix ();
|
|
// glEndList();
|
|
}
|
|
|
|
void CustomizeWnd(HINSTANCE hInstance)
|
|
{
|
|
if ((g_hWnd = auxGetHWND()) == NULL)
|
|
{
|
|
OutputDebugString("auxGetHWND() failed\n");
|
|
return;
|
|
}
|
|
|
|
SubclassWindow (g_hWnd, (WNDPROC) MyWndProc);
|
|
SendMessage(g_hWnd, WM_USER, 0L, 0L);
|
|
g_hMenu = LoadMenu(GetModuleHandle(NULL), MAKEINTRESOURCE(APPMENU));
|
|
SetMenu(g_hWnd, g_hMenu);
|
|
DrawMenuBar(g_hWnd);
|
|
|
|
return;
|
|
}
|
|
|
|
/**************************************************************************\
|
|
* function: SubclassWindow
|
|
*
|
|
* input parameters:
|
|
* hwnd - window handle to be subclassed,
|
|
* SubclassWndProc - the new window procedure.
|
|
*
|
|
\**************************************************************************/
|
|
VOID SubclassWindow (HWND hwnd, WNDPROC SubclassWndProc)
|
|
{
|
|
LONG pfnOldProc;
|
|
|
|
pfnOldProc = GetWindowLong (hwnd, GWL_WNDPROC);
|
|
|
|
SetWindowLong (hwnd, GWL_USERDATA, (LONG) pfnOldProc);
|
|
SetWindowLong (hwnd, GWL_WNDPROC, (LONG) SubclassWndProc);
|
|
}
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* function: MyWndProc
|
|
*
|
|
* input parameters: normal window procedure parameters.
|
|
*
|
|
\**************************************************************************/
|
|
LONG APIENTRY MyWndProc(HWND hwnd, UINT message, UINT wParam, LONG lParam)
|
|
{
|
|
WNDPROC pfnOldProc;
|
|
static UINT uiTmID = 0;
|
|
|
|
pfnOldProc = (WNDPROC) GetWindowLong (hwnd, GWL_USERDATA);
|
|
switch (message) {
|
|
|
|
case WM_INITMENUPOPUP:
|
|
CheckMenuItem (g_hMenu, MENU_FLAT,
|
|
((shade_model == GL_FLAT)? MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_GOURAUD,
|
|
((shade_model == GL_SMOOTH)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_PHONG_NICEST,
|
|
(((shade_model == GL_PHONG_WIN) &&
|
|
(phong_hint == GL_NICEST)) ? MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_PHONG_FASTEST,
|
|
(((shade_model == GL_PHONG_WIN) &&
|
|
(phong_hint == GL_FASTEST)) ? MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_PHONG_DONT_CARE,
|
|
(((shade_model == GL_PHONG_WIN) &&
|
|
(phong_hint == GL_DONT_CARE)) ? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_LIGHTING,
|
|
((bLightEnable)? MF_CHECKED:MF_UNCHECKED));
|
|
if (!bLightEnable)
|
|
{
|
|
EnableMenuItem (g_hMenu, MENU_TWO_SIDED, MF_GRAYED);
|
|
EnableMenuItem (g_hMenu, MENU_COLORMATERIAL, MF_GRAYED);
|
|
EnableMenuItem (g_hMenu, MENU_NORMALIZE, MF_GRAYED);
|
|
}
|
|
else
|
|
{
|
|
EnableMenuItem (g_hMenu, MENU_TWO_SIDED, MF_ENABLED);
|
|
EnableMenuItem (g_hMenu, MENU_COLORMATERIAL, MF_ENABLED);
|
|
EnableMenuItem (g_hMenu, MENU_NORMALIZE, MF_ENABLED);
|
|
}
|
|
CheckMenuItem (g_hMenu, MENU_TWO_SIDED,
|
|
((bTwoSided)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_COLORMATERIAL,
|
|
((bColorMaterial)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_NORMALIZE,
|
|
((bNormalize)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_POLY,
|
|
((render_type == POLYGON_TEAPOT)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_BEZ,
|
|
((render_type == BEZIER_TEAPOT)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_AUX,
|
|
((render_type == GLAUX_TEAPOT)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_SOLID_SPHERE,
|
|
((render_type == GLAUX_SSPHERE)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_WIRE_SPHERE,
|
|
((render_type == GLAUX_WSPHERE)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_SQUARE,
|
|
((render_type == SQUARE)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_TRIANGLES,
|
|
((render_type == TRIANGLES)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_LINES,
|
|
((render_type == LINES)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_EVAL,
|
|
((render_type == EVAL)?
|
|
MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_DEPTH,
|
|
((depth_mode)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_ANTIALIAS,
|
|
((bAntiAlias)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_TIMING,
|
|
((timing_enable)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_TEXTURE_TOGGLE,
|
|
((bTexEnable)? MF_CHECKED:MF_UNCHECKED));
|
|
EnableMenuItem (g_hMenu, MENU_TEXTURE_SWAP, MF_GRAYED);
|
|
EnableMenuItem (g_hMenu, MENU_POINT_FILTER, MF_GRAYED);
|
|
EnableMenuItem (g_hMenu, MENU_LINEAR_FILTER, MF_GRAYED);
|
|
|
|
if (!cull_enable)
|
|
{
|
|
EnableMenuItem (g_hMenu, MENU_FRONTFACE, MF_GRAYED);
|
|
EnableMenuItem (g_hMenu, MENU_BACKFACE, MF_GRAYED);
|
|
CheckMenuItem (g_hMenu, MENU_CULL, MF_UNCHECKED);
|
|
}
|
|
else
|
|
{
|
|
EnableMenuItem (g_hMenu, MENU_FRONTFACE, MF_ENABLED);
|
|
EnableMenuItem (g_hMenu, MENU_BACKFACE, MF_ENABLED);
|
|
CheckMenuItem (g_hMenu, MENU_CULL, MF_CHECKED);
|
|
}
|
|
|
|
CheckMenuItem (g_hMenu, MENU_BACKFACE,
|
|
((cull_face==GL_BACK)? MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_FRONTFACE,
|
|
((cull_face==GL_FRONT)? MF_CHECKED:MF_UNCHECKED));
|
|
|
|
CheckMenuItem (g_hMenu, MENU_CCW,
|
|
((front_face==GL_CCW)? MF_CHECKED:MF_UNCHECKED));
|
|
CheckMenuItem (g_hMenu, MENU_CW,
|
|
((front_face==GL_CW)? MF_CHECKED:MF_UNCHECKED));
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case MENU_CULL:
|
|
cull_enable = !cull_enable;
|
|
cull ();
|
|
break;
|
|
case MENU_BACKFACE:
|
|
cull_face = GL_BACK;
|
|
if (cull_enable) glCullFace (cull_face);
|
|
break;
|
|
case MENU_FRONTFACE:
|
|
cull_face = GL_FRONT;
|
|
if (cull_enable) glCullFace (cull_face);
|
|
break;
|
|
case MENU_CCW:
|
|
front_face = GL_CCW;
|
|
glFrontFace (front_face);
|
|
break;
|
|
case MENU_CW:
|
|
front_face = GL_CW;
|
|
glFrontFace (front_face);
|
|
break;
|
|
case MENU_FLAT:
|
|
shade_model = GL_FLAT;
|
|
glShadeModel (GL_FLAT);
|
|
break;
|
|
case MENU_GOURAUD:
|
|
shade_model = GL_SMOOTH;
|
|
glShadeModel (GL_SMOOTH);
|
|
break;
|
|
case MENU_PHONG_NICEST:
|
|
shade_model = GL_PHONG_WIN;
|
|
phong_hint = GL_NICEST;
|
|
glShadeModel (GL_PHONG_WIN);
|
|
glHint (GL_PHONG_HINT_WIN, GL_NICEST);
|
|
break;
|
|
case MENU_PHONG_FASTEST:
|
|
shade_model = GL_PHONG_WIN;
|
|
phong_hint = GL_FASTEST;
|
|
glShadeModel (GL_PHONG_WIN);
|
|
glHint (GL_PHONG_HINT_WIN, GL_FASTEST);
|
|
break;
|
|
case MENU_PHONG_DONT_CARE:
|
|
shade_model = GL_PHONG_WIN;
|
|
phong_hint = GL_DONT_CARE;
|
|
glShadeModel (GL_PHONG_WIN);
|
|
glHint (GL_PHONG_HINT_WIN, GL_DONT_CARE);
|
|
break;
|
|
case MENU_LIGHTING:
|
|
bLightEnable = !bLightEnable;
|
|
lighting ();
|
|
break;
|
|
case MENU_COLORMATERIAL:
|
|
bColorMaterial = !bColorMaterial;
|
|
if (bColorMaterial)
|
|
glEnable (GL_COLOR_MATERIAL);
|
|
else
|
|
glDisable (GL_COLOR_MATERIAL);
|
|
break;
|
|
case MENU_NORMALIZE:
|
|
bNormalize = !bNormalize;
|
|
if (bNormalize)
|
|
glEnable (GL_NORMALIZE);
|
|
else
|
|
glDisable (GL_NORMALIZE);
|
|
break;
|
|
case MENU_TWO_SIDED:
|
|
bTwoSided = !bTwoSided;
|
|
if (bTwoSided)
|
|
glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
|
|
else
|
|
glLightModeli (GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
|
|
case MENU_DEPTH:
|
|
depth_mode = !depth_mode;
|
|
depth ();
|
|
break;
|
|
case MENU_ANTIALIAS:
|
|
bAntiAlias = !bAntiAlias;
|
|
if (bAntiAlias)
|
|
{
|
|
glEnable (GL_POLYGON_SMOOTH);
|
|
glEnable (GL_LINE_SMOOTH);
|
|
glEnable (GL_POINT_SMOOTH);
|
|
}
|
|
else
|
|
{
|
|
glDisable (GL_POLYGON_SMOOTH);
|
|
glDisable (GL_LINE_SMOOTH);
|
|
glDisable (GL_POINT_SMOOTH);
|
|
}
|
|
break;
|
|
case MENU_TEXTURE_TOGGLE:
|
|
bTexEnable = !bTexEnable;
|
|
texture ();
|
|
break;
|
|
case MENU_TIMING:
|
|
timing_enable = !timing_enable;
|
|
break;
|
|
case MENU_POLY:
|
|
render_type = POLYGON_TEAPOT;
|
|
break;
|
|
case MENU_AUX:
|
|
render_type = GLAUX_TEAPOT;
|
|
break;
|
|
case MENU_SOLID_SPHERE:
|
|
render_type = GLAUX_SSPHERE;
|
|
break;
|
|
case MENU_WIRE_SPHERE:
|
|
render_type = GLAUX_WSPHERE;
|
|
break;
|
|
case MENU_TRIANGLES:
|
|
render_type = TRIANGLES;
|
|
break;
|
|
case MENU_SQUARE:
|
|
render_type = SQUARE;
|
|
break;
|
|
case MENU_LINES:
|
|
render_type = LINES;
|
|
break;
|
|
case MENU_EVAL:
|
|
render_type = EVAL;
|
|
break;
|
|
case MENU_BEZ:
|
|
render_type = BEZIER_TEAPOT;
|
|
break;
|
|
default:
|
|
MessageBox (NULL, "Not yet implemented\r\n", "Warning", MB_OK);
|
|
return 0;
|
|
}
|
|
if (!doSpin)
|
|
InvalidateRect (hwnd, NULL, TRUE);
|
|
break;
|
|
|
|
case WM_USER:
|
|
case WM_DESTROY:
|
|
default:
|
|
return (pfnOldProc)(hwnd, message, wParam, lParam);
|
|
|
|
} /* end switch */
|
|
//DoGlStuff ();
|
|
|
|
return 0;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* DbgPrint
|
|
*
|
|
* Formatted string output to the debugger.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
ULONG
|
|
DbgPrint(PCH DebugMessage, ...)
|
|
{
|
|
va_list ap;
|
|
char buffer[256];
|
|
BOOL success;
|
|
DWORD num_written;
|
|
|
|
va_start(ap, DebugMessage);
|
|
|
|
vsprintf(buffer, DebugMessage, ap);
|
|
|
|
if (!bValidConsole)
|
|
OutputDebugStringA(buffer);
|
|
else
|
|
success = WriteConsole (OutputHandle, buffer, strlen(buffer),
|
|
&num_written, NULL);
|
|
|
|
va_end(ap);
|
|
|
|
return(0);
|
|
}
|
|
|
|
void
|
|
DrawTris(void)
|
|
{
|
|
GLfloat mat_specular[] = { 1.0, 0.0, 0.0, 0.0 };
|
|
|
|
glBegin (GL_TRIANGLES);
|
|
glColor3f(1.0, 0.0, 0.0);
|
|
//glNormal3d (-0.75, 0.01, 0.0);
|
|
glNormal3d (0.0, 0.0, 1.0);
|
|
glVertex3f (-3.7, 0.1, -0.1);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
//glNormal3d (0.8, 0.0, 0.0);
|
|
glNormal3d (0.0, -1.0, 0.0);
|
|
glVertex3f (-3.7, -4.0, -0.1);
|
|
|
|
glColor3f(0.0, 0.0, 1.0);
|
|
//glNormal3d (0.0, 0.0, 1.0);
|
|
glNormal3d (0.0, 0.0, 1.0);
|
|
glVertex3f (0.0, 0.1, -0.1);
|
|
glEnd ();
|
|
|
|
|
|
#if 0
|
|
//glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
|
|
glBegin (GL_TRIANGLES);
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
//glNormal3d (-0.75, 0.01, 0.0);
|
|
glVertex3f (3.7, 0.1, -0.1);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d (0.8, 0.0, 0.0);
|
|
glVertex3f (3.7, -4.1, -0.1);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d (0.0, 0.0, 1.0);
|
|
glVertex3f (0.0, 0.1, -0.1);
|
|
glEnd ();
|
|
#endif
|
|
|
|
glColor3f(0.2, 0.5, 0.8);
|
|
}
|
|
|
|
//Drawn CCW
|
|
void
|
|
DrawSquare(void)
|
|
{
|
|
GLfloat mat_specular[] = { 1.0, 0.0, 0.0, 0.0 };
|
|
GLfloat lx, ly, lz;
|
|
GLdouble angle = 60.000 * __glDegreesToRadians;
|
|
|
|
|
|
lz = (GLfloat) cos (angle);
|
|
lx = ly = (GLfloat) sin (angle) * 0.7071067;
|
|
|
|
glBegin (GL_POLYGON);
|
|
//glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
|
|
glColor3f(1.0, 0.0, 0.0);
|
|
glTexCoord2f (0.0, 0.0);
|
|
glNormal3f (-lx, ly, lz);
|
|
glVertex3f (-1.5, 1.5, -0.1);
|
|
//glNormal3d (0.0, 0.0, 1.0);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glTexCoord2f (0.0, 1.0);
|
|
glNormal3f (-lx, -ly, lz);
|
|
glVertex3f (-1.5, -1.5, -0.1);
|
|
//glNormal3d (0.0, -1.0, 0.0);
|
|
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glTexCoord2f (1.0, 1.0);
|
|
glNormal3f (lx, -ly, lz);
|
|
glVertex3f (1.5, -1.5, -0.1);
|
|
//glNormal3d (0.0, -1.0, 0.0);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glTexCoord2f (1.0, 0.0);
|
|
glNormal3f (lx, ly, lz);
|
|
glVertex3f (1.5, 1.5, -0.1);
|
|
//glNormal3d (0.0, 0.0, 1.0);
|
|
|
|
glEnd ();
|
|
|
|
glColor3f(0.2, 0.5, 0.8);
|
|
}
|
|
#if 0
|
|
void
|
|
DrawSquare(void)
|
|
{
|
|
GLfloat mat_specular[] = { 1.0, 0.0, 0.0, 0.0 };
|
|
|
|
glBegin (GL_POLYGON);
|
|
//glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
|
|
glColor3f(1.0, 0.0, 0.0);
|
|
//glNormal3d (-0.5, 0.5, 0.0);
|
|
glNormal3d (0.0, 0.0, 1.0);
|
|
glVertex3f (-3.7, 3.1, -0.1);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d (0.0, -1.0, 0.0);
|
|
//glNormal3d (-0.5, -0.5, 0.1);
|
|
glVertex3f (-3.7, -3.1, -0.1);
|
|
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d (0.0, -1.0, 0.0);
|
|
//glNormal3d (0.5, -0.5, 0.0);
|
|
glVertex3f (3.7, -3.1, -0.1);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d (0.0, 0.0, 1.0);
|
|
//glNormal3d (0.5, 0.5, 0.0);
|
|
glVertex3f (3.7, 3.1, -0.1);
|
|
|
|
glEnd ();
|
|
|
|
glColor3f(0.2, 0.5, 0.8);
|
|
}
|
|
#endif
|
|
|
|
|
|
void
|
|
DrawLines(void)
|
|
{
|
|
glBegin (GL_LINES);
|
|
glColor3f(1.0, 0.0, 0.0);
|
|
glNormal3d(0.0, 1.0, 0.0);
|
|
glVertex3f (-1.7, 0.1, -0.1);
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d(0.0, 0.0, 1.0);
|
|
glVertex3f (-1.7, -1.1, -0.1);
|
|
|
|
glColor3f(0.0, 0.0, 1.0);
|
|
glNormal3d(0.0, 1.0, 0.0);
|
|
glVertex3f (0.0, 0.0, -0.1);
|
|
glColor3f(0.0, 0.0, 1.0);
|
|
glNormal3d(0.0, 0.0, 1.0);
|
|
glVertex3f (5.0, 0.0, -0.1);
|
|
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d(0.0, 1.0, 0.0);
|
|
glVertex3f (0.0, 0.0, -0.1);
|
|
glColor3f(0.0, 1.0, 0.0);
|
|
glNormal3d(0.0, 0.0, 1.0);
|
|
glVertex3f (0.0, 5.0, -0.1);
|
|
|
|
glColor3f(1.0, 0.0, 0.0);
|
|
glNormal3d(0.0, 1.0, 0.0);
|
|
glVertex3f (0.0, 0.0, -0.1);
|
|
glColor3f(0.0, 0.0, 1.0);
|
|
glNormal3d(0.0, 0.0, 1.0);
|
|
glVertex3f (0.0, 0.0, -5.1);
|
|
glEnd ();
|
|
|
|
glColor3f(0.2, 0.5, 0.8);
|
|
}
|
|
|
|
void
|
|
DrawEval (void)
|
|
{
|
|
//glMapGrid2f((GLfloat)sampleEval, 0.0, 1.0, (GLfloat)sampleEval, 0.0, 1.0);
|
|
initEval ();
|
|
glEvalMesh2(GL_FILL,0,sampleEval,0,sampleEval) ;
|
|
}
|