OpenGL 学习笔记（一）

#include <stdio.h>

#include <stdlib.h>

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <math.h>

const int n = 50;

const GLfloat R = 0.5f;

const GLfloat Pi = 3.1415926536f;

const GLfloat factor = 0.1f;

LONG WINAPI WndProc(HWND,UINT,WPARAM,LPARAM);//Window procedure

HGLRC SetUpOpenGL(HWND hwnd);//Initialize OpenGL

void DrawOpenGLScene(void);//Actual Drawing code

//WinMain - the main window entry point

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)

{

static char szAppName[] = "OpenGL";

static char szTitle[]="Getting Started With OpenGL";

WNDCLASS wc; // windows class sruct

MSG msg; // message struct

HWND hWnd; // Main window handle.

// Fill in window class structure with parameters that

// describe the main window.

wc.style =

CS_HREDRAW | CS_VREDRAW;// Class style(s).

wc.lpfnWndProc =

(WNDPROC)WndProc; // Window Procedure

wc.cbClsExtra = 0; // No per-class extra data.

wc.cbWndExtra = 0; // No per-window extra data.

wc.hInstance =

hInstance; // Owner of this class

wc.hIcon = NULL; // Icon name

wc.hCursor =

LoadCursor(NULL, MAKEINTRESOURCE(32649));// Cursor

wc.hbrBackground =

(HBRUSH)(COLOR_WINDOW+1);// Default color

wc.lpszMenuName = NULL; // Menu from .RC

wc.lpszClassName =

szAppName; // Name to register as

// Register the window class

RegisterClass( &wc );

// Create a main window for this application instance.

hWnd = CreateWindow(

szAppName, // app name

szTitle, // Text for window title bar

WS_OVERLAPPEDWINDOW// Window style

// NEED THESE for OpenGL calls to work!

| WS_CLIPCHILDREN | WS_CLIPSIBLINGS,

CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,

NULL, // no parent window

NULL, // Use the window class menu.

hInstance,// This instance owns this window

NULL // We don't use any extra data

);

// If window could not be created, return zero

if ( !hWnd )

{

return( 0 );

}

// Make the window visible & update its client area

ShowWindow( hWnd, 1 );// Show the window

UpdateWindow( hWnd ); // Sends WM_PAINT message

// Enter the Windows message loop

// Get and dispatch messages until WM_QUIT

while (GetMessage(&msg, // message structure

NULL, // handle of window receiving

// the message

0, // lowest message id to examine

0)) // highest message id to examine

{

TranslateMessage( &msg ); // Translates messages

DispatchMessage( &msg ); // then dispatches

}

return( msg.wParam );

}

//WndProc

LONG WINAPI WndProc( HWND hWnd, UINT msg,

WPARAM wParam, LPARAM lParam )

{

HDC hDC;

static HGLRC hRC; // Note this is STATIC!

PAINTSTRUCT ps;

GLdouble gldAspect;

GLsizei glnWidth, glnHeight;

switch(msg)

{

case WM_CREATE:

// Select a pixel format and then

// create a rendering context from it.

hRC = SetUpOpenGL(hWnd);

return 0;

case WM_SIZE:

// Redefine the viewing volume and viewport

// when the window size changes.

// Make the RC current since we're going to

// make an OpenGL call here...

hDC = GetDC(hWnd);

wglMakeCurrent(hDC,hRC);

// get the new size of the client window

// note that we size according to the height,

// not the smaller of the height or width.

glnWidth = (GLsizei) LOWORD (lParam);

glnHeight = (GLsizei) HIWORD (lParam);

gldAspect =

(GLdouble)glnWidth/(GLdouble)glnHeight;

// set up a projection matrix to fill the

// client window

glMatrixMode( GL_PROJECTION );

glLoadIdentity();

// a perspective-view matrix...

gluPerspective(

30.0, // Field-of-view angle

gldAspect, // Aspect ratio of view volume

1.0, // Distance to near clipping plane

10.0 ); // Distance to far clipping plane

glViewport( 0, 0, glnWidth, glnHeight );

wglMakeCurrent( NULL, NULL );

ReleaseDC( hWnd, hDC );

return 0;

case WM_PAINT:

// Draw the scene.

// Get a DC, then make the RC current and

// associate with this DC

hDC = BeginPaint( hWnd, &ps );

wglMakeCurrent( hDC, hRC );

DrawOpenGLScene();

// we're done with the RC, so

// deselect it

// (note: This technique is not recommended!)

wglMakeCurrent( NULL, NULL );

EndPaint( hWnd, &ps );

return 0;

case WM_DESTROY:

// Clean up and terminate.

wglDeleteContext( hRC );

PostQuitMessage( 0 );

return 0;

}

// This function handles any messages that we didn't.

// (Which is most messages) It belongs to the OS.

return DefWindowProc( hWnd, msg, wParam, lParam );

}

/////////////////////////////////////////////////////////

// SetUpOpenGL sets the pixel format and a rendering

// context then returns the RC

/////////////////////////////////////////////////////////

HGLRC SetUpOpenGL( HWND hWnd )

{

static PIXELFORMATDESCRIPTOR pfd = {

sizeof (PIXELFORMATDESCRIPTOR), // strcut size

1, // Version number

PFD_DRAW_TO_WINDOW | // Flags, draw to a window,

PFD_SUPPORT_OPENGL, // use OpenGL

PFD_TYPE_RGBA, // RGBA pixel values

24, // 24-bit color

0, 0, 0, // RGB bits & shift sizes.

0, 0, 0, // Don't care about them

0, 0, // No alpha buffer info

0, 0, 0, 0, 0, // No accumulation buffer

32, // 32-bit depth buffer

0, // No stencil buffer

0, // No auxiliary buffers

PFD_MAIN_PLANE, // Layer type

0, // Reserved (must be 0)

0, // No layer mask

0, // No visible mask

0 // No damage mask

};

int nMyPixelFormatID;

HDC hDC;

HGLRC hRC;

hDC = GetDC( hWnd );

nMyPixelFormatID = ChoosePixelFormat( hDC, &pfd );

// catch errors here.

// If nMyPixelFormat is zero, then there's

// something wrong... most likely the window's

// style bits are incorrect (in CreateWindow() )

// or OpenGl isn't installed on this machine

SetPixelFormat( hDC, nMyPixelFormatID, &pfd );

hRC = wglCreateContext( hDC );

ReleaseDC( hWnd, hDC );

return hRC;

}

//////////////////////////////////////////////////////////

// DrawScene uses OpenGL commands to draw a triangle.

// This is where the OpenGL drawing commands live

//////////////////////////////////////////////////////////

void DrawOpenGLScene( )

{

//glEnable( GL_DEPTH_TEST );

//

// Define the modelview transformation.

//

glMatrixMode( GL_MODELVIEW );

glLoadIdentity();

// move the viewpoint out to where we can see everything

glTranslatef( 0.0f, 0.0f, -5.0f );

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_TRIANGLES);

glColor3f(1.0,0.0,0.0);//red color for the triangle

glVertex3f(0.0,0.0,0);

glVertex3f(0.0,1.0,0);

glVertex3f(1.0,0.0,0);

glColor3f(0.0,1.0,0.0);//Green color for the triangle

glVertex3f(0.0,0.0,0);

glVertex3f(0.0,1.0,0);

glVertex3f(-1.0,0.0,0);

glColor3f(0.0,0.0,1.0);//Blue color for the triangle

glVertex3f(1.0,0.0,0);

glVertex3f(0.0,-1.0,0);

glVertex3f(-1.0,0.0,0);

glEnd();

int i;

//glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_POLYGON);

for(i=0; i<n; ++i)

{

glVertex2f((GLfloat)(R*cos(2*Pi/n*i)), (GLfloat)(R*sin(2*Pi/n*i)));

glColor3f(3.0,(GLfloat)(i),0.0);

}

glEnd();

GLfloat a = (GLfloat)(1 / (2-2*cos(72*Pi/180)));

GLfloat bx = (GLfloat)(a * cos(18 * Pi/180));

GLfloat by = (GLfloat)(a * sin(18 * Pi/180));

GLfloat cy = (GLfloat)(-a * cos(18 * Pi/180));

GLfloat

PointA[2] = { 0, a },

PointB[2] = { bx, by },

PointC[2] = { 0.5, cy },

PointD[2] = { -0.5, cy },

PointE[2] = { -bx, by };

// 按照A->C->E->B->D->A的顺序，可以一笔将五角星画出

glColor3f(0.0,1.0,0.0);

glLineWidth(5.0f);

glBegin(GL_LINE_LOOP);

glVertex2fv(PointA);

glVertex2fv(PointC);

glVertex2fv(PointE);

glVertex2fv(PointB);

glVertex2fv(PointD);

glEnd();

GLfloat x;

glColor3f(255.0,3.0,1.0);

glEnable(GL_LINE_STIPPLE);

glLineStipple(2, 0x0F0F);

glLineWidth(2.0f);

glBegin(GL_LINES);

glVertex2f(-1.0f, 0.0f);

glVertex2f(1.0f, 0.0f); // 以上两个点可以画x轴

glVertex2f(0.0f, -1.0f);

glVertex2f(0.0f, 1.0f); // 以上两个点可以画y轴

glEnd();

glDisable(GL_LINE_STIPPLE);

glBegin(GL_LINE_STRIP);

for(x=-1.0f/factor; x<1.0f/factor; x+=0.01f)

{

glVertex2f((GLfloat)(x*factor), (GLfloat)(sin(x)*factor));

}

glEnd();

//正反面

glClear(GL_COLOR_BUFFER_BIT);

glPolygonMode(GL_FRONT, GL_FILL); // 设置正面为填充模式

glPolygonMode(GL_BACK, GL_LINE); // 设置反面为线形模式

glFrontFace(GL_CCW); // 设置逆时针方向为正面

//glFrontFace(GL_CW); // 设置顺时针方向为正面

glBegin(GL_POLYGON); // 按逆时针绘制一个正方形，在左下方

glVertex2f(-0.5f, -0.5f);

glVertex2f(0.0f, -0.5f);

glVertex2f(0.0f, 0.0f);

glVertex2f(-0.5f, 0.0f);

glEnd();

//glFrontFace(GL_CW); // 设置顺时针方向为正面

glColor3f(0.0,1.0,0.0);

glBegin(GL_POLYGON); // 按顺时针绘制一个正方形，在右上方

glVertex2f(0.0f, 0.0f);

glVertex2f(0.0f, 0.5f);

glVertex2f(0.5f, 0.5f);

glVertex2f(0.5f, 0.0f);

glEnd();

//镂空

static GLubyte Mask[128];

FILE *fp;

fp = fopen("mask.bmp", "rb");

if( !fp )

exit(0);

if( fseek(fp, -(int)sizeof(Mask), SEEK_END) )

exit(0);

if( !fread(Mask, sizeof(Mask), 1, fp) )

exit(0);

fclose(fp);

glClear(GL_COLOR_BUFFER_BIT);

glEnable(GL_POLYGON_STIPPLE);

glPolygonStipple(Mask);

glRectf(-0.5f, -0.5f, 0.0f, 0.0f); // 在左下方绘制一个有镂空效果的正方形

glDisable(GL_POLYGON_STIPPLE);

glRectf(0.0f, 0.0f, 0.5f, 0.5f); // 在右上方绘制一个无镂空效果的正方形

glFlush();

}

/*////////////////////////////////////////////////////////////////////////

mask.bmp文件制作

用Windows自带的画笔程序新建一副图片，取名为mask.bmp，注意保存时，应该选择“单色位图”。在“图象”->“属性”对话框中，设置图片的高度和宽度均为32。

用放大镜观察图片，并编辑之。黑色对应二进制零（镂空），白色对应二进制一（不镂空），编辑完毕后保存。

然后，就可以使用以下代码来获得这个Mask数组了。

static GLubyte Mask[128];

FILE *fp;

fp = fopen("mask.bmp", "rb");

if( !fp )

exit(0);

// 移动文件指针到这个位置，使得再读sizeof(Mask)个字节就会遇到文件结束

// 注意-(int)sizeof(Mask)虽然不是什么好的写法，但这里它确实是正确有效的

// 如果直接写-sizeof(Mask)的话，因为sizeof取得的是一个无符号数，取负号会有问题

if( fseek(fp, -(int)sizeof(Mask), SEEK_END) )

exit(0);

// 读取sizeof(Mask)个字节到Mask

if( !fread(Mask, sizeof(Mask), 1, fp) )

exit(0);

fclose(fp);

在glBegin和glEnd之间，只有以下函数是有效的，其它函数全部会被忽略。

glVertex*

glColor*

glIndex*

glSecondaryColor*

glNormal*

glMaterial*

glFogCood*

glTexCood*

glMultiTexCood*

glEdgeFlag*

glArrayElement*

glEvalCoord*

glEvalPoint*

glCallList

glCallLists

////////////////////////////////////////////////////////////////////////*/