圖解opengl 3D 圖形繪製例項

阿新 • • 發佈：2019-02-04

VC6 下載
http://blog.csdn.net/bcbobo21cn/article/details/44200205

opengl環境配置
http://blog.csdn.net/bcbobo21cn/article/details/51044614#t4

以下的demo工程

http://pan.baidu.com/s/1pLgmScj

一 3D旋轉物體

碼碼：

//在視窗和全屏模式下切換，按ESC退出。

#include <Windows.h> //Windows的標頭檔案
#include <gl/glut.h> //包含OpenGL實用庫

HGLRC hRC=NULL; //視窗著色描述表控制代碼
HDC hDC=NULL;//OpenGL渲染描述表控制代碼
HWND hWnd=NULL; //儲存視窗控制代碼
HINSTANCE hInstance; //儲存程式例項

bool keys[256];//儲存鍵盤按鍵的陣列
bool active=TRUE;//視窗的活動標誌，預設為TRUE
bool fullscreen=TRUE; //全屏標誌預設，預設設定成全屏模式

GLfloat rtri;//用於三角形的角度
GLfloat rquad;//用於四邊形的角度

LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);//WndProc的定義

//重置OpenGL視窗大小
GLvoid ResizeGLScene(GLsizei width,GLsizei height)
{
if (height == 0) //防止被零除
{
height =1;//將height設為1
}

glViewport(0,0,width,height);//重置當前的視口
glMatrixMode(GL_PROJECTION);//旋轉投影矩陣
glLoadIdentity();//重置投影矩陣

//設定視口的大小
gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

glMatrixMode(GL_MODELVIEW);//選擇模型觀察矩陣
glLoadIdentity();//重置模型觀察矩陣
}

int InitGL(GLvoid)//對OpenGL進行設定
{
glShadeModel(GL_SMOOTH);//啟用陰影平滑
glClearColor(0.0f,0.0f,0.0f,0.0f);//黑色背景
glClearDepth(1.0f);//設定深度快取
glEnable(GL_DEPTH_TEST);//啟用深度測試
glDepthFunc(GL_LEQUAL);//所作深度測試的型別
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);//告訴系統對透視進行修正

return TRUE;
}

//進行繪製
int DrawGLScene(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);//清除螢幕和深度快取
glLoadIdentity();//重置當前的模型觀察矩陣
glTranslatef(-1.5f,0.0f,-6.0f);//左移1.5單位，並移入螢幕6.0

glRotatef(rtri,0.0f,1.0f,0.0f);//繞Y軸旋轉金字塔
glBegin(GL_TRIANGLES); //繪製金字塔各面

glColor3f(1.0f,0.0f,0.0f);//設定當前色為紅色
glVertex3f(0.0f,1.0f,0.0f);//上頂點(前側面)
glColor3f(0.0f,1.0f,0.0f);//設定當前色為綠色
glVertex3f(-1.0f,-1.0f,1.0f);//左下(前側面)
glColor3f(0.0f,0.0f,1.0f);//設定當前色為藍色
glVertex3f(1.0f,-1.0f,1.0f);//右下(前側面)

glColor3f(1.0f,0.0f,0.0f);//設定當前色為紅色
glVertex3f(0.0f,1.0f,0.0f);//上頂點(右側面)
glColor3f(0.0f,1.0f,0.0f);//設定當前色為綠色
glVertex3f(1.0f,-1.0f,1.0f);//左下(右側面)
glColor3f(0.0f,0.0f,1.0f);//設定當前色為藍色
glVertex3f(1.0f,-1.0f,-1.0f);//右下(右側面)

glColor3f(1.0f,0.0f,0.0f);//設定當前色為紅色
glVertex3f(0.0f,1.0f,0.0f);//上頂點(後側面)
glColor3f(0.0f,1.0f,0.0f);//設定當前色為綠色
glVertex3f(1.0f,-1.0f,-1.0f);//左下(後側面)
glColor3f(0.0f,0.0f,1.0f);//設定當前色為藍色
glVertex3f(-1.0f,-1.0f,-1.0f);//右下(後側面)

glColor3f(1.0f,0.0f,0.0f);//設定當前色為紅色
glVertex3f(0.0f,1.0f,0.0f);//上頂點(左側面)
glColor3f(0.0f,1.0f,0.0f);//設定當前色為綠色
glVertex3f(-1.0f,-1.0f,-1.0f);//左下(左側面)
glColor3f(0.0f,0.0f,1.0f);//設定當前色為藍色
glVertex3f(-1.0f,-1.0f,1.0f);//右下(左側面)

glEnd();//三角形繪製結束

glLoadIdentity();//重置模型觀察矩陣
glTranslatef(1.5f,0.0f,-7.0f);//先右移再移入螢幕
glRotatef(rquad,1.0f,1.0f,1.0f);//繞XYZ軸旋轉立方體

glBegin(GL_QUADS); //繪製正方形
glColor3f(0.0f,1.0f,0.0f);//將當前色設定為綠色
//頂面
glVertex3f(1.0f,1.0f,-1.0f);//右上
glVertex3f(-1.0f,1.0f,-1.0f);//左上
glVertex3f(-1.0f,1.0f,1.0f);//左下
glVertex3f(1.0f,1.0f,1.0f);//右下

//橙色
glColor3f(1.0f,0.5f,0.0f);
    //底面
glVertex3f(1.0f,-1.0f,-1.0f);//右上
glVertex3f(-1.0f,-1.0f,-1.0f);//左上
glVertex3f(-1.0f,-1.0f,1.0f);//左下
glVertex3f(1.0f,-1.0f,1.0f);//右下

//紅色
glColor3f(1.0f,0.0f,0.0f);
//前面
glVertex3f(1.0f,1.0f,1.0f);//右上
glVertex3f(-1.0f,1.0f,1.0f);//左上
glVertex3f(-1.0f,-1.0f,1.0f);//左下
glVertex3f(1.0f,-1.0f,1.0f);//右下

//黃色
glColor3f(1.0f,1.0f,0.0f);
//後面
glVertex3f(1.0f,1.0f,-1.0f);//右上
glVertex3f(-1.0f,1.0f,-1.0f);//左上
glVertex3f(-1.0f,-1.0f,-1.0f);//左下
glVertex3f(1.0f,-1.0f,-1.0f);//右下

//藍色
glColor3f(0.0f,0.0f,1.0f);
//左面
glVertex3f(-1.0f,1.0f,1.0f);//右上
glVertex3f(-1.0f,1.0f,-1.0f);//左上
glVertex3f(-1.0f,-1.0f,-1.0f);//左下
glVertex3f(-1.0f,-1.0f,1.0f);//右下

//紫羅蘭色
glColor3f(1.0f,0.0f,1.0f);
//右面
glVertex3f(1.0f,1.0f,1.0f);//右上
glVertex3f(1.0f,1.0f,-1.0f);//左上
glVertex3f(1.0f,-1.0f,-1.0f);//左下
glVertex3f(1.0f,-1.0f,1.0f);//右下

glEnd();

//<控制旋轉速度>
rtri +=0.02f;   //增加三角形的旋轉變數
rquad -=0.015f; //減少四邊形的旋轉變數

return TRUE;
}

GLvoid KillGLWindow(GLvoid)//正常銷燬視窗
{
if(fullscreen)//是否處於全屏模式
{
ChangeDisplaySettings(NULL,0); //是的話，切換回桌面
ShowCursor(TRUE);//顯示滑鼠指標
}

if(hRC)//是否擁有OpenGL渲染描述表
{
if(!wglMakeCurrent(NULL,NULL)) //能否是否DC和RC描述表
{
MessageBox(NULL,"釋放DC或RC失敗。","關閉錯誤",MB_OK | MB_ICONINFORMATION );
}

if(!wglDeleteContext(hRC)) //能否刪除RC
{
MessageBox(NULL,"釋放RC失敗。","關閉錯誤",MB_OK | MB_ICONINFORMATION );
}

hRC = NULL;
}

if(hDC && !ReleaseDC(hWnd,hDC)) //能否釋放DC
{
MessageBox(NULL,"釋放DC失敗。","關閉錯誤",MB_OK | MB_ICONINFORMATION );
hDC = NULL;
}

if(hWnd && !DestroyWindow(hWnd)) //能否銷燬視窗
{
MessageBox(NULL,"釋放視窗控制代碼失敗。","關閉錯誤",MB_OK | MB_ICONINFORMATION );
hWnd = NULL;
}

if(!UnregisterClass("OpenGL",hInstance)) //能否登出視窗類
{
MessageBox(NULL,"不能登出視窗類。","關閉錯誤",MB_OK | MB_ICONINFORMATION );
hInstance = NULL;
}
}

BOOL CreateGLWindow(char * title,int width,int height,int bits,bool fullscreenflag)
{
GLuint PixelFormat;//儲存查詢匹配的結果
WNDCLASS wc;//視窗類結構
DWORD dwExStyle; //擴充套件視窗風格
DWORD dwStyle;//視窗風格
RECT WindowRect;//取得矩形的左上角和右下角的座標值
WindowRect.left=(long)0;//將Left設為0
WindowRect.right=(long)width;//將Right設為要求的寬度
WindowRect.top=(long)0;
WindowRect.bottom=(long)height;

fullscreen = fullscreenflag;//設定全域性全屏標誌

hInstance         = GetModuleHandle(NULL);//取得視窗的例項
wc.style          = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;//移動時重畫，併為視窗取得DC
wc.lpfnWndProc    = WndProc;//WndProc處理訊息
wc.cbClsExtra     = 0;//無額外視窗資料Specifies the number of extra bytes to allocate following the window-class structure. 
wc.cbWndExtra     = 0; //無額外視窗資料Specifies the number of extra bytes to allocate following the window instance.
wc.hInstance      = hInstance;//設定例項
wc.hIcon          = LoadIcon(NULL,IDI_WINLOGO);//裝入預設圖示
wc.hCursor        = LoadCursor(NULL,IDC_ARROW);//裝入滑鼠指標
wc.hbrBackground  = NULL;         //GL不需要背景
wc.lpszMenuName   = NULL ;         //不需要選單
wc.lpszClassName  = "OpenGL";     //設定類名字

if(!RegisterClass(&wc)) //嘗試註冊視窗類
{
MessageBox(NULL,"註冊視窗失敗","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

if(fullscreen)
{
DEVMODE dmScreenSettings; //裝置模式
memset(&dmScreenSettings,0,sizeof(dmScreenSettings));//確保記憶體清空為零
dmScreenSettings.dmSize=sizeof(dmScreenSettings);//Devmode結構的大小
dmScreenSettings.dmPelsWidth = width;//所選螢幕寬度
dmScreenSettings.dmPelsHeight = height;//所選螢幕高度
dmScreenSettings.dmBitsPerPel = bits; //每畫素所選的色彩濃度
dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

//嘗試設定顯示模式並返回結果。注：CDS_FULLSCREEN移去了狀態條。
if(ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
{
//若模式失敗，提供兩個選項：退出或在視窗內執行。
if(MessageBox(NULL,"全屏模式在當前顯示卡上設定失敗!\n使用視窗模式?",
"提示",MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
{
fullscreen = FALSE;//選擇視窗模式
}
else
{
//彈出一個對話方塊，告訴使用者程式結束
MessageBox(NULL,"程式將被關閉","錯誤",MB_OK | MB_ICONSTOP);
return FALSE;
}
}
}

if(fullscreen)
{
dwExStyle = WS_EX_APPWINDOW; //擴充套件窗體風格
dwStyle = WS_POPUP; //窗體風格
ShowCursor(FALSE); //隱藏滑鼠指標
}
else
{
dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;//擴充套件窗體風格
dwStyle = WS_OVERLAPPEDWINDOW; //窗體風格
}

AdjustWindowRectEx(&WindowRect,dwStyle,FALSE,dwExStyle);//調整視窗達到真正要求的大小

//窗體自適應各種解析度以居中方式顯示
LONG nX, nY;

nX = (::GetSystemMetrics(SM_CXSCREEN) - width) / 2;
nY = (::GetSystemMetrics(SM_CYSCREEN) - height) / 2;

if(!(hWnd = CreateWindowEx(dwExStyle, //擴充套件窗體風格
"OpenGL", //類名字
title,    //視窗標題
WS_CLIPSIBLINGS | WS_CLIPCHILDREN| //必須的窗體風格屬性
dwStyle,   //選擇的窗體屬性
nX,nY,   //視窗位置
WindowRect.right - WindowRect.left, //計算調整好的視窗寬度
WindowRect.bottom - WindowRect.top, //計算調整好的窗體高度
NULL, //無父視窗
NULL, //無選單
hInstance, //例項
NULL))) //不向WM_CREATE傳遞任何東西
{
KillGLWindow();//重置顯示區
MessageBox(NULL,"不能建立一個視窗裝置描述表","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

static PIXELFORMATDESCRIPTOR pfd = //pdf告訴視窗希望的東西，即視窗使用的畫素格式
{
sizeof(PIXELFORMATDESCRIPTOR), //上述格式描述符的大小
1,       //版本號
PFD_DRAW_TO_WINDOW |  //格式支援視窗
PFD_SUPPORT_OPENGL |  //格式支援OpenGL
PFD_DOUBLEBUFFER,  //支援雙緩衝
PFD_TYPE_RGBA,     //申請RGBA格式
bits,              //選定色彩深度
0,0,0,0,0,0,       //忽略的色彩位
0,                 //無Alpha快取
0,                 //忽略Shift Bit
0,                 //無累加快取
0,0,0,0,           //忽略聚集位
16,                //16位Z-快取(深度快取)
0,                 //無蒙板快取
0,                 //無輔助快取
PFD_MAIN_PLANE,    //主繪圖層
0,                 //Reserved
0,0,0              //忽略層遮罩
};

if(!(hDC = GetDC(hWnd))) //是否取得裝置描述表
{
KillGLWindow();//重置顯示區
MessageBox(NULL,"不能建立一種相匹配的畫素格式","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

if(!(PixelFormat = ChoosePixelFormat(hDC,&pfd))) //Windows是否找到相應的畫素格式
{
KillGLWindow();//重置顯示區
MessageBox(NULL,"不能設定畫素格式","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

if(!SetPixelFormat(hDC,PixelFormat,&pfd)) //是否能夠設定畫素格式
{
KillGLWindow();//重置顯示區
MessageBox(NULL,"不能設定畫素格式","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

if (!(hRC = wglCreateContext(hDC))) //能否取得著色描述表
{
KillGLWindow();//重置顯示區
MessageBox(NULL,"不能建立OpenGL渲染描述表","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

if(!wglMakeCurrent(hDC,hRC)) //嘗試啟用著色描述表
{
KillGLWindow();
MessageBox(NULL,"不能啟用當前的OpenGL渲染描述表","錯誤",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

ShowWindow(hWnd,SW_SHOW);//顯示視窗
SetForegroundWindow(hWnd);//提供優先級別
SetFocus(hWnd);//設定鍵盤的焦點至此視窗
ResizeGLScene(width,height);//設定透視GL螢幕

if (!InitGL()) //初始化新建的GL視窗
{
KillGLWindow();
MessageBox(NULL,"Initialization","ERROR",MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}

return TRUE;
}

//處理所有的視窗訊息
LRESULT CALLBACK WndProc(HWND hWnd,//視窗的控制代碼
UINT uMsg,//視窗的訊息
WPARAM wParam,//附加的訊息內容
LPARAM lParam) //附加的訊息內容
{
switch(uMsg) //檢查檢查Windows訊息
{
case WM_ACTIVATE:  //監視視窗啟用訊息
{
if(!HIWORD(wParam)) //檢查最小化狀態
{
active = TRUE; //程式處於啟用狀態
}
else
{
active = FALSE;//程式不再啟用
}

return 0;//返回訊息迴圈
}

case WM_SYSCOMMAND: //系統中斷命令
{
switch(wParam) //檢查系統呼叫
{
case  SC_SCREENSAVE: //屏保執行
case SC_MONITORPOWER: //顯示器進入節電模式
return 0; //阻止發生
}
break; //退出
}
case WM_CLOSE: //收到Close訊息
{
PostQuitMessage(0);//發出退出訊息
return 0;
}
case WM_KEYDOWN: //有鍵按下
{
keys[wParam] = TRUE;
return 0;
}
case WM_KEYUP: //有鍵放開
{
keys[wParam] = FALSE;
return 0;
}
case WM_SIZE: //調整OpenGL視窗大小
{
ResizeGLScene(LOWORD(lParam),HIWORD(lParam));//LOWORD=width,HIWORD=height
return 0;
}
}

//向DefWindowProc傳遞所有未處理的訊息
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

//Windows程式的入口，呼叫視窗建立例程，處理視窗訊息，並監視人機互動。
int WINAPI WinMain(HINSTANCE hInstance,//當前視窗例項
  HINSTANCE hPrevInstance, //前一個視窗例項
  LPSTR lpCmdLine, //命令列引數
  int nCmdShow) //視窗顯示狀態
{
MSG msg;//Windows訊息結構
BOOL done=FALSE;//用來退出迴圈的BOOL變數
//提示使用者選擇執行模式
if (MessageBox(NULL,"你想在全屏模式下執行麼？","設定全屏模式",MB_YESNO | MB_ICONQUESTION) == IDNO)
{
fullscreen = FALSE; //設定為視窗模式
}

//建立OpenGL視窗
if(!CreateGLWindow("OpenGL 3D 旋轉物體",640,480,16,fullscreen))
{
return 0;       //失敗退出
}

while(!done)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) //是否有訊息在等待
{
if(msg.message == WM_QUIT) //收到退出訊息
{
done = TRUE;
}
else //處理視窗訊息
{
TranslateMessage(&msg);  //翻譯訊息
DispatchMessage(&msg);   //傳送訊息
}
}
else //如果沒有訊息
{
//繪製場景。監視ESC鍵和來自DrawGLScene()的退出訊息
if(active)
{
if(keys[VK_ESCAPE])
{
done = TRUE;
}
else //沒有退出，重新整理螢幕
{
DrawGLScene();//繪製場景
SwapBuffers(hDC);//交換快取(雙快取)
}
}
if(keys[VK_F1])
{
keys[VK_F1]=FALSE;
KillGLWindow();
fullscreen = !fullscreen;//切換全屏/視窗模式
//重建OpenGL視窗
if(!CreateGLWindow("3D旋轉例項",640,480,16,fullscreen))
{
return 0;
}
}
}
}

//關閉程式
KillGLWindow(); //銷燬視窗
return (msg.wParam); //退出程式
}

效果：

程式碼比較長；用notepad++摺疊起來看下函式；

二 3D機器人

程式碼：

#include <gl/glut.h>
#include <stdlib.h>
#include <stdio.h>

#define SOLID 1
#define WIRE 2

int moveX,moveY;
int spinX = 0;
int spinY = 0;
int des = 0;

void init() {
   //定義光源的顏色和位置
   GLfloat ambient[] = { 0.5, 0.8, 0.1, 0.1 };  
   GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 };  
   GLfloat position[] = { -80.0, 50.0, 25.0, 1.0 };  
   //選擇光照模型
   GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };  
   GLfloat local_view[] = { 0.0 };  
   glClearColor(0.0, 0.0, 0.0, 0.0);   
   glShadeModel(GL_SMOOTH);  
   //設定環境光
   glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);  
   //設定漫射光
   glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);  
   //設定光源位置
   glLightfv(GL_LIGHT0, GL_POSITION, position);  
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);  
   glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, local_view);  
   //啟動光照
   glEnable(GL_LIGHTING);  
   //啟用光源
   glEnable(GL_LIGHT0);  
}

//畫球
void drawBall(double R, double x, double y,double z, int MODE) {
	glPushMatrix();
	glTranslated(x,y,z);
	if (MODE == SOLID) {
		glutSolidSphere(R,20,20);
	} else if (MODE ==WIRE) {
		glutWireSphere(R,20,20);
	}
	glPopMatrix();
}

//畫半球
void drawHalfBall(double R, double x, double y,double z, int MODE) {
	glPushMatrix();
	glTranslated(x,y,z);
	GLdouble eqn[4]={0.0, 1.0, 0.0, 0.0};
	glClipPlane(GL_CLIP_PLANE0,eqn);
	glEnable(GL_CLIP_PLANE0);
	if (MODE == SOLID) {
		glutSolidSphere(R,20,20);
	} else if (MODE ==WIRE) {
		glutWireSphere(R,20,20);
	}
	glDisable(GL_CLIP_PLANE0);
	glPopMatrix();
}

//畫長方體
void drawSkewed(double l, double w, double h, double x, double y, double z, int MODE) {
	glPushMatrix();
	glScaled(l, w, h);
	glTranslated(x, y, z);
	if (MODE == SOLID) {
		glutSolidCube(1);
	} else if (MODE ==WIRE) {
		glutWireCube(1);
	}
	glPopMatrix();
}

void display(void) {
	//清除緩衝區顏色
	glClear(GL_COLOR_BUFFER_BIT);
	//定義白色
	glColor3f(1.0, 1.0, 1.0); 
	//圓點放座標中心
	glLoadIdentity();  
	//從哪個地方看
	gluLookAt(-2.0, -1.0, 20.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); 
	glPushMatrix();
	glRotated(spinX, 0, 1, 0);
	glRotated(spinY, 1, 0, 0);
	glTranslated(0, 0, des);
	//頭
	drawBall(2, 0, 1, 0, SOLID);
	//身體
	drawSkewed(5, 4.4, 4, 0, -0.75, 0, SOLID);
	//肩膀
	drawHalfBall(1, 3.5, -2.1, 0, SOLID);
	drawHalfBall(1, -3.5, -2.1, 0, SOLID);
	//胳膊
	drawSkewed(1, 3, 1, 3.5, -1.3, 0, SOLID);
	drawSkewed(1, 3, 1, -3.5, -1.3, 0, SOLID);
	//手
	drawBall(1, 3.5, -6.4, 0, SOLID);
	drawBall(1, -3.5, -6.4, 0, SOLID);
	//腿
	drawSkewed(1.2, 3, 2, 1, -2.4, 0, SOLID);
	drawSkewed(1.2, 3, 2, -1, -2.4, 0, SOLID);
	//腳
	drawSkewed(1.5, 1, 3, 0.9, -9.2, 0, SOLID);
	drawSkewed(1.5, 1, 3, -0.9, -9.2, 0, SOLID);
	glPopMatrix();
    glutSwapBuffers();
}
//滑鼠點選事件
void mouseClick(int btn, int state, int x, int y) {
    moveX = x;
	moveY = y;
	GLfloat ambient[] = { (float)rand() / RAND_MAX, (float)rand() / RAND_MAX, (float)rand() / RAND_MAX, 0.1 };  
	 //設定環境光
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);  
	//啟用光源
	glEnable(GL_LIGHT0);  
}

//鍵盤事件
void keyPressed(unsigned char key, int x, int y) {
    switch (key) {
    case 'a':
        spinX -= 2;
        break;
    case 'd':
         spinX += 2;  
        break;
    case 'w':
        des += 2;
        break;
    case 's':
        des -= 2;
		break;
	}
	glutPostRedisplay();
}
// 滑鼠移動事件 
void mouseMove(int x, int y) {
	int dx = x - moveX;
	int dy = y - moveY;
	printf("dx;%dx,dy:%dy\n",dx,dy);
	spinX += dx;
	spinY += dy;
	glutPostRedisplay();
	moveX = x;
	moveY = y;
}

void reshape(int w, int h) {
	//定義視口大小
	glViewport(0, 0, (GLsizei) w, (GLsizei) h); 
	//投影顯示
	glMatrixMode(GL_PROJECTION);
	//座標原點在螢幕中心
	glLoadIdentity();
	//操作模型視景
	gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 20.0);
	glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv) {
	//初始化
	glutInit(&argc, argv);
	//設定顯示模式
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	//初始化視窗大小
	glutInitWindowSize(500, 500); 
	//定義左上角視窗位置
	glutInitWindowPosition(100, 100);
	//建立視窗
	glutCreateWindow(argv[0]);
	//初始化
	init();
	//顯示函式
	glutDisplayFunc(display);
	//視窗大小改變時的響應
	glutReshapeFunc(reshape);
	//滑鼠點選事件，滑鼠點選或者鬆開時呼叫
    glutMouseFunc(mouseClick);
	//滑鼠移動事件，滑鼠按下並移動時呼叫
    glutMotionFunc(mouseMove);
	//鍵盤事件
	glutKeyboardFunc(keyPressed);
	//迴圈
	glutMainLoop();
	return 0;
}

效果;

摺疊其程式碼來看下函式；

三繪製立方體

程式碼：

#include <gl/glut.h>  //引用相關包

void display(void)
{
 
 glClear(GL_COLOR_BUFFER_BIT);  //清空顏色緩衝區
 glColor3f(0,1,1);   //重置顏色
 glLoadIdentity();   //清空矩陣
 glTranslatef(0,0,-5); //將場景中的物體沿z軸負方向移動5個單位長
 glRotatef(40,0,1,0);
 //gluLookAt(0,0,5,0,0,0,0,2,0); //視點變換
 glScalef(1,2,1);  //模型變換
 glutWireCube(1.2); //繪製實心立方體和線框立方體
 glFlush();   //重新整理視窗以顯示當前繪製圖形
} 
void init(void)
{
 glClearColor(0,0,0,0);
 glShadeModel(GL_FLAT); //選擇平面明暗模式或光滑明暗模式
}

void reshape(int w,int h)
{
 glViewport(0,0,(GLsizei)w,(GLsizei)h);   //設定機口
 glMatrixMode(GL_PROJECTION);  //指定哪一個矩陣是當前矩陣
 glLoadIdentity();
    gluPerspective(60,1,1.5,20);   //建立透視投影矩陣(fovy,aspect,zNear,zFar);
 //glFrustum(-1,1,-1,1,1.5,20.0);  //用透視矩陣乘以當前矩陣(left,Right,bottom,top,near,far);
 glMatrixMode(GL_MODELVIEW);
}
int main(int argc, char *argv[])
{
 glutInit(&argc, argv); //固定格式
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);   //快取模式
 glutInitWindowSize(400, 400);    //顯示框的大小
    glutInitWindowPosition(400,400); //確定顯示框左上角的位置
    glutCreateWindow("繪製立方體");
 init();
    glutDisplayFunc(display);
 glutReshapeFunc(reshape);
    glutMainLoop(); //進人GLUT事件處理迴圈
    return 0;
}

效果：

上述分別是

glutWireCube(1.2);

glutWireCube(2.0);

的效果；

四繪製立方體二

程式碼：

#include<windows.h>
#include<math.h>
 
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
 
#include <stdlib.h>
 
void init(void)
{
  glClearColor(0.75,0.75,0.75,0.0);
  glMatrixMode(GL_MODELVIEW);//設定當前矩陣模式為檢視模型矩陣
  glLoadIdentity();
//設定視點的位置，視線的方向和相機的向上方向
  gluLookAt(0,0,0, 0,0,-1, 0,1,0); //該設定為預設設定
  glScalef(0.3,1.0,0.5); //產生比例變換，分別設定物體在x，y，z方向上縮放因子，根據需要自己可以設定
  glRotatef(45,1.0,1.0,1.0);//產生旋轉變換，讓物體繞（1，1，1）軸旋轉45度
  glMatrixMode(GL_PROJECTION);//設定當前矩陣模式為投影矩陣
  glFrustum(-4,4,-4,4,0,20);////設定場景投影時的可視範圍
}
 //float points[8][3] = {{0,0,0},{0,0.5,0},{0.5,0,0},{0.5,0.5,0},{0,0,0.5},{0,0.5,0.5},{0.5,0,0.5},{0.5,0.5,0.5}};
 float points[8][3] = {{0,0,0},{0,0.75,0},{0.75,0,0},{0.75,0.75,0},{0,0,0.75},{0,0.75,0.75},{0.75,0,0.75},{0.75,0.75,0.75}};
 float colors[6][3] = {{0.25,0,0},{0.25,0.25,0.25},{0,0,0.25},{0.5,0.25,0},{0,0.25,0.25},{0.25,0,0.25}};
 
void vertexArray(void)
{
 glClear(GL_COLOR_BUFFER_BIT);
// glColor 3f(1.0,1.0,0.0);
 //glPolygonMode(GL_FRONT, GL_LINE);// 設定多邊形的顯示模式為面填充模式，該設定也是預設設定
 glFrontFace(GL_CCW); //設定前面的面的模式為逆時針模式， 該設定也是預設設定
 //glShadeModel(GL_SHADE_MODEL);// 預設就是此引數，可忽略，為了明確說明特意指定
 
 
void quad(GLint n1,GLint n2,GLint n3,GLint n4,GLint index);
    quad(6,2,3,7,1);
    quad(5,1,0,4,2);
    quad(7,3,1,5,3);
    quad(4,0,2,6,4);
    quad(2,0,1,3,5);
    quad(7,5,4,6,6);
glFlush();
}
 
void quad(GLint n1,GLint n2,GLint n3,GLint n4,GLint index)
{
    glColor3f(0.0,1.0,0.0);
    glEnable(GL_POLYGON_OFFSET_FILL);
    glPolygonOffset(1.0,1.0);
    glDisable(GL_POLYGON_OFFSET_FILL);
    glColor3f(colors[index][0],colors[index][1],colors[index][2]);
    //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    //glPolygonMode(GL_FRONT, GL_LINE);
    glPolygonMode(GL_BACK, GL_LINE);
    //glColor3f(1.0,1.0,0);
    glBegin(GL_QUADS);
        glVertex3fv(points[n1]);
        glVertex3fv(points[n2]);
        glVertex3fv(points[n3]);
        glVertex3fv(points[n4]);
    glEnd();
}
 
int main (int argc, char** argv)
{
 
    glutInit (&argc, argv);                         // Initialize GLUT.
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);   // Set display mode.
    glutInitWindowPosition (50, 100);   // Set top-left display-window position.
    glutInitWindowSize (600, 500);      // Set display-window width and height.
    glutCreateWindow ("An Example OpenGL Program"); // Create display window.
       init();                           // Execute initialization procedure.
    glutDisplayFunc (vertexArray);       // Send graphics to display window.
    glutMainLoop ( );// Send graphics to display window.                  // Display everything and wait.
       return 0;
}

效果：

五任意兩點間畫圓柱體

#include <gl/glut.h>  
#include <cstdio>  
#include <cstdlib>  
#include <cmath>  
void    init(void);  
void    reshape(int w,int h);  
void    display(void);  
  
void RenderBone(float x0, float y0, float z0, float x1, float y1, float z1 );  
int main(int argc, char** argv)  
{  
    glutInit(&argc, argv);  
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);   
    glutInitWindowSize (500, 500);  
    glutInitWindowPosition (100, 100);  
    glutCreateWindow("Sphere");  
    init ();  
    glutReshapeFunc(reshape);  
    glutDisplayFunc(display);  
    glutMainLoop();  
    return 0;  
}  
void init (void)  
{   
    glClearColor (0.6, 0.6, 0.6, 0.0);  
    glClearDepth(1);  
    glShadeModel(GL_SMOOTH);  
    GLfloat _ambient[]={1.0,1.0,1.0,1.0};  
	//GLfloat _ambient[]={2.0,2.0,2.0,2.0};  
    GLfloat _diffuse[]={1.0,1.0,0.0,1.0};  
    GLfloat _specular[]={1.0,1.0,1.0,1.0};  
    GLfloat _position[]={300,300,300,0};  
    glLightfv(GL_LIGHT0,GL_AMBIENT,_ambient);  
    glLightfv(GL_LIGHT0,GL_DIFFUSE,_diffuse);  
    glLightfv(GL_LIGHT0,GL_SPECULAR,_specular);  
    glLightfv(GL_LIGHT0,GL_POSITION,_position);  
    glEnable(GL_TEXTURE_2D);  
    glEnable(GL_LIGHTING);  
    glEnable(GL_LIGHT0);  
    glEnable(GL_DEPTH_TEST);  
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  
}  
void reshape(int w, int h)  
{  
    glViewport (0, 0, (GLsizei) w, (GLsizei) h);  
    glMatrixMode(GL_PROJECTION);  
    glLoadIdentity();  
    glOrtho(0.0, 500, 0.0, 500, -500, 500);  
    glMatrixMode(GL_MODELVIEW);  
    glLoadIdentity();  
}  
void display(void)  
{  
    glMatrixMode(GL_MODELVIEW);  
    glLoadIdentity();  
    glClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);  
    glPushMatrix();  
    {  
        //RenderBone(100, 100, 100, 200, 300, 500);  
		RenderBone(200, 200, 200, 300, 400, 600);  
    } glPopMatrix();  
  
    glFlush();  
    glutPostRedisplay();  
}  
void RenderBone(float x0, float y0, float z0, float x1, float y1, float z1 )  
{  
    GLdouble  dir_x = x1 - x0;  
    GLdouble  dir_y = y1 - y0;  
    GLdouble  dir_z = z1 - z0;  
    GLdouble  bone_length = sqrt( dir_x*dir_x + dir_y*dir_y + dir_z*dir_z );  
    static GLUquadricObj *  quad_obj = NULL;  
    if ( quad_obj == NULL )  
        quad_obj = gluNewQuadric();  
    gluQuadricDrawStyle( quad_obj, GLU_FILL );  
    gluQuadricNormals( quad_obj, GLU_SMOOTH );  
    glPushMatrix();  
    // 平移到起始點  
    glTranslated( x0, y0, z0 );  
    // 計算長度  
    double  length;  
    length = sqrt( dir_x*dir_x + dir_y*dir_y + dir_z*dir_z );  
    if ( length < 0.0001 ) {   
        dir_x = 0.0; dir_y = 0.0; dir_z = 1.0;  length = 1.0;  
    }  
    dir_x /= length;  dir_y /= length;  dir_z /= length;  
    GLdouble  up_x, up_y, up_z;  
    up_x = 0.0;  
    up_y = 1.0;  
    up_z = 0.0;  
    double  side_x, side_y, side_z;  
    side_x = up_y * dir_z - up_z * dir_y;  
    side_y = up_z * dir_x - up_x * dir_z;  
    side_z = up_x * dir_y - up_y * dir_x;  
    length = sqrt( side_x*side_x + side_y*side_y + side_z*side_z );  
    if ( length < 0.0001 ) {  
        side_x = 1.0; side_y = 0.0; side_z = 0.0;  length = 1.0;  
    }  
    side_x /= length;  side_y /= length;  side_z /= length;  
    up_x = dir_y * side_z - dir_z * side_y;  
    up_y = dir_z * side_x - dir_x * side_z;  
    up_z = dir_x * side_y - dir_y * side_x;  
    // 計算變換矩陣  
    GLdouble  m[16] = { side_x, side_y, side_z, 0.0,  
        up_x,   up_y,   up_z,   0.0,  
        dir_x,  dir_y,  dir_z,  0.0,  
        0.0,    0.0,    0.0,    1.0 };  
    glMultMatrixd( m );  
    // 圓柱體引數  
    GLdouble radius= 25;        // 半徑  
    GLdouble slices = 8.0;      //  段數  
    GLdouble stack = 3.0;       // 遞迴次數  
    gluCylinder( quad_obj, radius, radius, bone_length, slices, stack );   
    glPopMatrix();  
}

效果：

修改此句以改變半徑；

GLdouble radius= 25; // 半徑

六球體

#include <windows.h>  
#include <gl/GL.h>  
#include <gl/glu.h>  
#include <gl/glut.h>  
#include <cstdlib>  
const GLfloat lightPosition[] = {10.0,10.0,10.0,0.0};  
const GLfloat whiteLight[] = {0.8,0.8,0.8,1.0};  
GLfloat matSpecular [] = {0.3,0.3,0.3,1.0};  
GLfloat matShininess [] = {20.0};  
GLfloat matEmission [] = {0.3,0.3,0.3,1.0};  
GLfloat spin = 0;  
void init()  
{  
    glClearColor(0.3,0.3,0.3,1.0);  
    glClearDepth(1.0);  
    glShadeModel(GL_SMOOTH);  
    glEnable(GL_LIGHTING);  
    glEnable(GL_LIGHT0);  
    glEnable(GL_DEPTH_TEST);  
    glMatrixMode(GL_MODELVIEW);  
    glLoadIdentity();  
    glLightfv(GL_LIGHT0,GL_POSITION,lightPosition);  
    glLightfv(GL_LIGHT0,GL_DIFFUSE,whiteLight);  
    glLightfv(GL_LIGHT0,GL_SPECULAR,whiteLight);  
}  
void display()  
{     
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);  
    glMatrixMode(GL_PROJECTION);  
    glLoadIdentity();;  
    glOrtho(-10.0,10.0,-10.0,10.0,-10.0,10.0);  
      
    glMatrixMode(GL_MODELVIEW);  
    glPushMatrix();  
    glRotatef(spin,0.0,1.0,0.0);  
    glMaterialfv(GL_FRONT,GL_SPECULAR,matSpecular);  
    glMaterialfv(GL_FRONT,GL_SHININESS,matShininess);  
    glMaterialfv(GL_FRONT,GL_EMISSION,matEmission);  
    //glutSolidSphere(6.0,16,16);  
	glutSolidSphere(3.0,16,16);  
    glPopMatrix();  
    glFlush();  
}  
void reshape(int w,int h)  
{  
    glViewport(0.0,0.0,(GLsizei) w,(GLsizei) h);  
}  
void keyboardFunc(unsigned char key,int x,int y)  
{  
    switch(key)  
    {  
    case 'a':  
        spin +=30;  
        break;  
    case 'd':  
        spin -=30;  
        break;  
    }  
    if(spin<360)  
        spin +=360;  
    else if(spin>=360)  
        spin -=360;  
    glutPostRedisplay();  
}  
void mouseFunc(int button,int state,int x,int y)  
{  
    if(state==GLUT_DOWN){  
    switch (button)  
    {  
    case GLUT_LEFT_BUTTON:  
        matEmission[0]+=1.0;  
        if(matEmission[0]>1.0)  
            matEmission[0]-=1.1;  
        break;  
    case GLUT_MIDDLE_BUTTON:  
        matEmission[1]+=1.0;  
        if(matEmission[1]>1.0)  
            matEmission[1]-=1.1;  
        break;  
    case GLUT_RIGHT_BUTTON:  
        matEmission[2]+=1.0;  
        if(matEmission[2]>1.0)  
            matEmission[2]-=1.1;  
        break;  
    }  
    glutPostRedisplay();      
    }  
}  
int main(int argc,char *argv[])  
{     
    glutInit(&argc,argv);  
    glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA|GLUT_DEPTH);  
    glutInitWindowSize(450,450);  
    glutInitWindowPosition(150,150);  
    glutCreateWindow("rotate sphere");  
    glutDisplayFunc(display);  
    glutReshapeFunc(reshape);  
    glutKeyboardFunc(keyboardFunc);  
    glutMouseFunc(mouseFunc);  
    init();  
    glutMainLoop();  
    return EXIT_SUCCESS;  
}

效果：

上述分別是

//glutSolidSphere(6.0,16,16);
glutSolidSphere(3.0,16,16);

的效果；

七球體，圓圈，茶壺......

#include <gl/glut.h>  
#include <math.h>  
#include <stdio.h>  
//圓周率巨集  
#define GL_PI 3.1415f  
//獲取螢幕的寬度  
GLint SCREEN_WIDTH=0;  
GLint SCREEN_HEIGHT=0;  
//設定程式的視窗大小  
GLint windowWidth=400;  
GLint windowHeight=300;  
//繞x軸旋轉角度  
GLfloat xRotAngle=0.0f;  
//繞y軸旋轉角度  
GLfloat yRotAngle=0.0f;  
//受支援的點大小範圍  
GLfloat sizes[2];  
//受支援的點大小增量  
GLfloat step;  
  
enum MODELS{  
    SPHERE=0,  
    CONE,  
    CUBE,  
    TORUS,  
    DODECAHEDRON,  
    TEAPOT,  
    OCTAHEDRON,  
    TETRAHEDRON,  
    ICOSAHEDRON  
};  
GLint iModel=SPHERE;  
GLboolean bWire=GL_TRUE;  
//選單回撥函式  
void processMenu(int value){  
    switch(value){  
        case 1:  
            iModel=SPHERE;  
            break;  
        case 2:  
            iModel=CONE;  
            break;  
        case 3:  
            iModel=CUBE;  
            break;  
        case 4:  
            iModel=TORUS;  
            break;  
        case 5:  
            iModel=DODECAHEDRON;  
            break;  
        case 6:  
            iModel=TEAPOT;  
            break;  
        case 7:  
            iModel=OCTAHEDRON;  
            break;  
        case 8:  
            iModel=TETRAHEDRON;  
            break;  
        case 9:  
            iModel=ICOSAHEDRON;  
            break;  
        case 10:  
            bWire=GL_TRUE;  
            break;  
        case 11:  
            bWire=GL_FALSE;  
            break;  
        default:  
            break;  
    }  
    //重新繪製  
    glutPostRedisplay();  
}  
//顯示回撥函式  
void renderScreen(void){  
    //將視窗顏色清理為黑色  
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);  
    //將模板緩衝區值全部清理為1  
    glClearStencil(1);  
    //使能模板緩衝區  
    glEnable(GL_STENCIL_TEST);  
    //把整個視窗清理為當前清理顏色：黑色。清除深度緩衝區、模板緩衝區  
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);  
    //將當前Matrix狀態入棧  
    glPushMatrix();  
    //座標系繞x軸旋轉xRotAngle  
    glRotatef(xRotAngle,1.0f,0.0f,0.0f);  
    //座標系繞y軸旋轉yRotAngle  
    glRotatef(yRotAngle,0.0f,1.0f,0.0f);  
    //進行平滑處理　  
    glEnable(GL_POINT_SMOOTH);  
    glHint(GL_POINT_SMOOTH,GL_NICEST);  
    glEnable(GL_LINE_SMOOTH);  
    glHint(GL_LINE_SMOOTH,GL_NICEST);  
    glEnable(GL_POLYGON_SMOOTH);  
    glHint(GL_POLYGON_SMOOTH,GL_NICEST);  
      
    //白色繪製座標系  
    glColor3f(1.0f,1.0f,1.0f);  
    glBegin(GL_LINES);  
        glVertex3f(-9.0f,0.0f,0.0f);  
        glVertex3f(9.0f,0.0f,0.0f);  
        glVertex3f(0.0f,-9.0f,0.0f);  
        glVertex3f(0.0f,9.0f,0.0f);  
        glVertex3f(0.0f,0.0f,-9.0f);  
        glVertex3f(0.0f,0.0f,9.0f);  
    glEnd();  
  
    glPushMatrix();  
    glTranslatef(9.0f,0.0f,0.0f);  
    glRotatef(90.0f,0.0f,1.0f,0.0f);  
    glutSolidCone(0.3,0.6,10,10);  
    glPopMatrix();  
  
    glPushMatrix();  
    glTranslatef(0.0f,9.0f,0.0f);  
    glRotatef(-90.0f,1.0f,0.0f,0.0f);  
    glutSolidCone(0.3,0.6,10,10);  
    glPopMatrix();  
  
    glPushMatrix();  
    glTranslatef(0.0f,0.0f,9.0f);  
    glRotatef(90.0f,0.0f,0.0f,1.0f);  
    glutSolidCone(0.3,0.6,10,10);  
    glPopMatrix();  
  
    //設定繪畫顏色為金色  
    glColor3f(0.0f,1.0f,0.0f);  
    switch(iModel){  
        //球  
        case SPHERE:  
            if(bWire){  
                glutWireSphere(8.0f,20,20);  
            }  
            else{  
                glutSolidSphere(8.0f,20,20);  
            }  
            break;  
        //錐體  
        case CONE:  
            if(bWire){  
                glutWireCone(4.0f,8.0f,20,20);  
            }  
            else{  
                glutSolidCone(4.0f,8.0f,20,20);  
            }  
            break;  
        //立體  
        case CUBE:  
            if(bWire){  
                glutWireCube(8.0f);  
            }  
            else{  
                glutSolidCube(8.0f);  
            }  
            break;  
        //甜圈  
        case TORUS:  
            if(bWire){  
                glutWireTorus(3.0f,6.0f,20,20);  
            }  
            else{  
                glutSolidTorus(3.0f,6.0f,20,20);  
            }  
            break;  
        //十六面體，預設半徑1.0  
        case DODECAHEDRON:  
            glScalef(6.0f,6.0f,6.0f);//x,y,z軸均放大6倍  
            if(bWire){  
                glutWireDodecahedron();  
            }  
            else{  
                glutSolidDodecahedron();  
            }  
            break;  
        //茶壺  
        case TEAPOT:  
            if(bWire){  
                glutWireTeapot(8.0f);  
            }  
            else{  
                glutSolidTeapot(8.0f);  
            }  
            break;  
        //八面體，預設半徑1.0  
        case OCTAHEDRON:  
            glScalef(6.0f,6.0f,6.0f);//x,y,z軸均放大6倍  
            if(bWire){  
                glutWireOctahedron();  
            }  
            else{  
                glutSolidOctahedron();  
            }  
            break;  
        //四面體，預設半徑1.0  
        case TETRAHEDRON:  
            glScalef(6.0f,6.0f,6.0f);//x,y,z軸均放大6倍  
            if(bWire){  
                glutWireTetrahedron();  
            }  
            else{  
                glutSolidTetrahedron();  
            }  
            break;  
        //二十面體，預設半徑1.0  
        case ICOSAHEDRON:  
            glScalef(6.0f,6.0f,6.0f);//x,y,z軸均放大6倍  
            if(bWire){  
                glutWireIcosahedron();  
            }  
            else{  
                glutSolidIcosahedron();  
            }  
            break;  
        default:  
            break;  
    }  
  
    //恢復壓入棧的Matrix  
    glPopMatrix();  
    //交換兩個緩衝區的指標  
    glutSwapBuffers();  
}  
//設定Redering State   
void setupRederingState(void){  
    //設定清理顏色為黑色  
    glClearColor(0.0f,0.0,0.0,1.0f);  
    //設定繪畫顏色為綠色  
    glColor3f(1.0f,1.0f,0.0f);  
    //使能深度測試  
    glEnable(GL_DEPTH_TEST);  
    //獲取受支援的點大小範圍  
    glGetFloatv(GL_POINT_SIZE_RANGE,sizes);  
    //獲取受支援的點大小增量  
    glGetFloatv(GL_POINT_SIZE_GRANULARITY,&step);  
    printf("point size range:%f-%f\n",sizes[0],sizes[1]);  
    printf("point step:%f\n",step);  
}  
//視窗大小變化回撥函式  
void changSize(GLint w,GLint h){  
    //橫寬比率  
    GLfloat ratio;  
    //設定座標系為x(-100.0f,100.0f)、y(-100.0f,100.0f)、z(-100.0f,100.0f)  
    GLfloat coordinatesize=10.0f;  
    //視窗寬高為零直接返回  
    if((w==0)||(h==0))  
        return;  
    //設定視口和視窗大小一致  
    glViewport(0,0,w,h);  
    //對投影矩陣應用隨後的矩陣操作  
    glMatrixMode(GL_PROJECTION);  
    //重置當前指定的矩陣為單位矩陣　  
    glLoadIdentity();  
    ratio=(GLfloat)w/(GLfloat)h;  
    //正交投影  
    if(w<h)  
        glOrtho(-coordinatesize,coordinatesize,-coordinatesize/ratio,coordinatesize/ratio,-coordinatesize,coordinatesize);  
    else  
        glOrtho(-coordinatesize*ratio,coordinatesize*ratio,-coordinatesize,coordinatesize,-coordinatesize,coordinatesize);  
    //對模型檢視矩陣堆疊應用隨後的矩陣操作  
    glMatrixMode(GL_MODELVIEW);  
    //重置當前指定的矩陣為單位矩陣　  
    glLoadIdentity();  
}  
  
//按鍵輸入處理回撥函式  
void specialKey(int key,int x,int y){  
  
    if(key==GLUT_KEY_UP){  
        xRotAngle-=5.0f;  
    }  
    else if(key==GLUT_KEY_DOWN){  
        xRotAngle+=5.0f;  
    }  
    else if(key==GLUT_KEY_LEFT){  
        yRotAngle-=5.0f;  
    }  
    else if(key==GLUT_KEY_RIGHT){  
        yRotAngle+=5.0f;  
    }  
    //重新繪製  
    glutPostRedisplay();  
}  
  
int main(int argc, char* argv[])  
{  
    int nModelMenu;  
    int nWireMenu;  
    int nMainMenu;  
    //初始化glut   
    glutInit(&argc,argv);  
    //使用雙緩衝區、深度緩衝區、模板緩衝區  
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);  
    //獲取系統的寬畫素  
    SCREEN_WIDTH=glutGet(GLUT_SCREEN_WIDTH);  
    //獲取系統的高畫素  
    SCREEN_HEIGHT=glutGet(GLUT_SCREEN_HEIGHT);  
    //建立視窗，視窗名字為OpenGL Glut Demo  
    glutCreateWindow("OpenGL Glut Demo");  
    //設定視窗大小  
    glutReshapeWindow(windowWidth,windowHeight);  
    //視窗居中顯示  
    glutPositionWindow((SCREEN_WIDTH-windowWidth)/2,(SCREEN_HEIGHT-windowHeight)/2);  
    //建立二級選單  
    nModelMenu=glutCreateMenu(processMenu);  
    glutAddMenuEntry("Sphere",1);  
    glutAddMenuEntry("Cone",2);  
    glutAddMenuEntry("Cube",3);  
    glutAddMenuEntry("Torus",4);  
    glutAddMenuEntry("Dodecahedron",5);  
    glutAddMenuEntry("Teapot",6);  
    glutAddMenuEntry("Octahedron",7);  
    glutAddMenuEntry("Tetrahedron",8);  
    glutAddMenuEntry("Icosahedron",9);  
    nWireMenu=glutCreateMenu(processMenu);  
    glutAddMenuEntry("Wire",10);  
    glutAddMenuEntry("Solid",11);  
    nMainMenu=glutCreateMenu(processMenu);  
    glutAddSubMenu("Model",nModelMenu);  
    glutAddSubMenu("WireOrSolid",nWireMenu);  
    //將選單榜定到滑鼠右鍵上  
    glutAttachMenu(GLUT_RIGHT_BUTTON);  
    //視窗大小變化時的處理函式  
    glutReshapeFunc(changSize);  
    //設定顯示回撥函式   
    glutDisplayFunc(renderScreen);  
    //設定按鍵輸入處理回撥函式  
    glutSpecialFunc(specialKey);  
    //設定全域性渲染引數  
    setupRederingState();  
    glutMainLoop();  
    return 0;  
}

右鍵選擇mode檢視不同3d圖形；游標鍵調整角度；
球體；

調整角度；

甜圈；

這隻就是著名的雪山飛壺；

摺疊起程式碼來看下函式;

Glut下提供了一些現成的繪製立體的API，如glutWireSphere繪製球，glutWireCone繪製椎體，glutWireCube繪製立體，glutWireTorus繪製甜圈，glutWireTeapot繪製茶壺，glutWireOctahedron繪製八面體。
Glut提供的多面體API預設半徑是1.0f的，使用glScalef對其進行放大。

八 opengl資源連結

http://blog.csdn.net/one_in_one/article/category/960777
http://blog.csdn.net/yearafteryear/article/category/1442065
http://blog.csdn.net/Augusdi/article/category/685679
http://cuiqingcai.com/category/technique/cc

圖解opengl 3D 圖形繪製例項

一 3D旋轉物體

二 3D機器人

三繪製立方體

四繪製立方體二

五任意兩點間畫圓柱體

六球體

七球體，圓圈，茶壺......

八 opengl資源連結

圖解opengl 3D 圖形繪製例項

OpenGL/3D圖形渲染管線

OpenGL原始碼之五繪製3D圖形

OpenGL ES繪製3D圖形

Android OpenGL ES 簡明開發教程_真正的3D圖形

python matlibplot繪製3D圖形

圖解opengl曲線和曲面繪製

opengl使用glDrawElements繪製圖形（IBO）

OpenGL（二）圖形繪製之平面多面體的繪製

計算機圖形學02一一OpenGL 程式碼實現繪製一條線

OpenGL_Qt學習筆記之_04(3D圖形的繪製和旋轉)

(十)利用processing繪製3D圖形

OpenGL基礎圖形程式設計（一）OpenGL與3D圖形世界

[轉]C語言圖形程式設計(六) －圖形程式設計例項：零件圖形的繪製

Qt OpenGL:學習現代3D圖形程式設計之二，玩轉色彩

安卓中繪製2D、3D圖形

從零開始openGL—— 二、基本圖形繪製

使用 DirectX 創建 3D 圖形

3D圖形學理論入門指南

開源3D圖形渲染引擎OGRE學習筆記

圖解opengl 3D 圖形繪製例項

一 3D旋轉物體

二 3D機器人

三 繪製立方體

四 繪製立方體二

五 任意兩點間畫圓柱體

六 球體

七 球體，圓圈，茶壺......

八 opengl資源連結

相關推薦

三繪製立方體

四繪製立方體二

五任意兩點間畫圓柱體

六球體

七球體，圓圈，茶壺......