开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
glapp.cpp
资源名称：Engine_v0.2.tar.gz　[点击查看]
上传用户：qccn516
上传日期：2013-05-02
资源大小：3382k
文件大小：20k
源码类别：

游戏引擎

开发平台：

Visual C++

glapp.cpp：源码内容
  1. /* OpenGL App
  2.  *
  3.  * Copyright (C) 2003-2004, Alexander Zaprjagaev <frustum@frustum.org>
  4.  *
  5.  * This program is free software; you can redistribute it and/or modify
  6.  * it under the terms of the GNU General Public License as published by
  7.  * the Free Software Foundation; either version 2 of the License, or
  8.  * (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18.  */
  20. #ifndef _WIN32
  22. /* linux
  23.  */
  24. #include <stdio.h>
  25. #include <string.h>
  26. #include <stdlib.h>
  27. #include <stdarg.h>
  28. #include <sys/time.h>
  29. #include <X11/Xlib.h>
  30. #include <X11/keysym.h>
  31. #include <X11/extensions/xf86vmode.h>
  32. #include <GL/gl.h>
  33. #include <GL/glu.h>
  34. #include <GL/glx.h>
  35. #ifdef HAVE_GTK
  36. #include <gtk/gtk.h>
  37. #include <gdk/gdkx.h>
  38. #endif
  39. #include "glapp.h"
  41. static Display *display;
  42. static int screen;
  43. static XF86VidModeModeInfo **modes;
  44. static Window window;
  45. static GLXContext context;
  46. static Atom WM_DELETE_WINDOW;
  47. static Cursor cursor;
  48. static int done;
  50. /*
  51.  */
  52. GLApp::GLApp() {
  53. memset(this,0,sizeof(GLApp));
  54. #ifdef HAVE_GTK
  55. gtk_init(NULL,NULL);
  56. display = GDK_DISPLAY();
  57. #else
  58. display = XOpenDisplay(NULL);
  59. if(!display) exit("couldn`t open display");
  60. #endif
  61. }
  63. GLApp::~GLApp() {
  64. if(context) glXDestroyContext(display,context);
  65. if(window) XDestroyWindow(display,window);
  66. if(modes) XF86VidModeSwitchToMode(display,screen,modes[0]);
  67. if(display) XCloseDisplay(display);
  68. }
  70. /*
  71.  */
  72. static int modescmp(const void *pa,const void *pb) {
  73. XF86VidModeModeInfo *a = *(XF86VidModeModeInfo**)pa;
  74. XF86VidModeModeInfo *b = *(XF86VidModeModeInfo**)pb;
  75. if(a->hdisplay > b->hdisplay) return -1;
  76. return b->vdisplay - a->vdisplay;
  77. }
  79. /*
  80.  */
  81. int GLApp::setVideoMode(int w,int h,int fs) {
  83. if(window) {
  84. XDestroyWindow(display,window);
  85. if(modes) XF86VidModeSwitchToMode(display,screen,modes[0]);
  86. }
  88. windowWidth = w;
  89. windowHeight = h;
  90. fullScreen = fs;
  92. try {
  93. int attrib[] = {
  94. GLX_RGBA,
  95. GLX_RED_SIZE,8,
  96. GLX_GREEN_SIZE,8,
  97. GLX_BLUE_SIZE,8,
  98. GLX_ALPHA_SIZE,8,
  99. GLX_DEPTH_SIZE,24,
  100. GLX_STENCIL_SIZE,8,
  101. GLX_DOUBLEBUFFER,
  102. None
  103. };
  104. screen = DefaultScreen(display);
  105. Window rootWindow = RootWindow(display,screen);
  107. XVisualInfo *visual = glXChooseVisual(display,screen,attrib);
  108. if(!visual) throw("couldn`t get an RGBA, double-buffered visual");
  110. if(fullScreen) {
  111. int i,nmodes;
  112. XF86VidModeModeLine mode;
  113. if(XF86VidModeGetModeLine(display,screen,&nmodes,&mode) && XF86VidModeGetAllModeLines(display,screen,&nmodes,&modes)) {
  114. qsort(modes,nmodes,sizeof(XF86VidModeModeInfo*),modescmp);
  115. for(i = nmodes - 1; i > 0; i--) if (modes[i]->hdisplay >= windowWidth && modes[i]->vdisplay >= windowHeight) break;
  116. if(modes[i]->hdisplay != mode.hdisplay || modes[i]->vdisplay != mode.vdisplay) {
  117. windowWidth = modes[i]->hdisplay;
  118. windowHeight = modes[i]->vdisplay;
  119. XF86VidModeSwitchToMode(display,screen,modes[i]);
  120. }
  121. XF86VidModeSetViewPort(display,screen,0,0);
  122. } else fullScreen = 0;
  123. }
  125. XSetWindowAttributes attr;
  126. unsigned long mask;
  127. attr.background_pixel = 0;
  128. attr.border_pixel = 0;
  129. attr.colormap = XCreateColormap(display,rootWindow,visual->visual,AllocNone);
  130. attr.event_mask = StructureNotifyMask | KeyPressMask | KeyReleaseMask | PointerMotionMask | ButtonPressMask | ButtonReleaseMask;
  131. if(fullScreen) {
  132. mask = CWBackPixel | CWColormap | CWOverrideRedirect | CWSaveUnder | CWBackingStore | CWEventMask;
  133. attr.override_redirect = True;
  134. attr.backing_store = NotUseful;
  135. attr.save_under = False;
  136. } else {
  137. mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
  138. }
  140. window = XCreateWindow(display,rootWindow,0,0,windowWidth,windowHeight,0,visual->depth,InputOutput,visual->visual,mask,&attr);
  141. XMapWindow(display,window);
  143. if(fullScreen) {
  144. XMoveWindow(display,window,0,0);
  145. XRaiseWindow(display,window);
  146. XWarpPointer(display,None,window,0,0,0,0,windowWidth / 2,windowHeight / 2);
  147. XFlush(display);
  148. XF86VidModeSetViewPort(display,screen,0,0);
  149. XGrabPointer(display,window,True,0,GrabModeAsync,GrabModeAsync,window,None,CurrentTime);
  150. XGrabKeyboard(display,window,True,GrabModeAsync,GrabModeAsync,CurrentTime);
  151. } else {
  152. WM_DELETE_WINDOW = XInternAtom(display,"WM_DELETE_WINDOW",False);
  153. XSetWMProtocols(display,window,&WM_DELETE_WINDOW,1);
  154. }
  156. XFlush(display);
  158. if(!context) context = glXCreateContext(display,visual,NULL,True);
  159. if(!context) throw("glXCreateContext failed");
  161. glXMakeCurrent(display,window,context);
  162. glViewport(0,0,windowWidth,windowHeight);
  163. }
  164. catch(const char *error) {
  165. window = 0;
  166. exit(error);
  167. return 0;
  168. }
  169. return 1;
  170. }
  172. /*
  173.  */
  174. void GLApp::setTitle(const char *title) {
  175. strcpy(this->title,title);
  176. XStoreName(display,window,title);
  177. XSetIconName(display,window,title);
  178. }
  180. /*
  181.  */
  182. void GLApp::setCursor(int x,int y) {
  183. XWarpPointer(display,None,window,0,0,0,0,x,y);
  184. XFlush(display);
  185. }
  187. /*
  188.  */
  189. void GLApp::showCursor(int show) {
  190. if(show) XDefineCursor(display,window,0);
  191. else {
  192. if(!cursor) {
  193. char data[] = { 0 };
  194. Pixmap blank;
  195. XColor dummy;
  196. blank = XCreateBitmapFromData(display,window,data,1,1);
  197. cursor = XCreatePixmapCursor(display,blank,blank,&dummy,&dummy,0,0);
  198. XFreePixmap(display,blank);
  199. }
  200. XDefineCursor(display,window,cursor);
  201. }
  202. }
  204. /*
  205.  */
  206. void GLApp::checkExtension(const char *extension) {
  207. static char *extensions = NULL;
  208. if(!extensions) extensions = (char*)glGetString(GL_EXTENSIONS);
  209. if(strstr(extensions,extension)) return;
  210. char error[1024];
  211. sprintf(error,"OpenGL extension "%s" is not supported by current hardware",extension);
  212. exit(error);
  213. }
  215. /*
  216.  */
  217. void GLApp::error() {
  218. GLenum error;
  219. while((error = glGetError()) != GL_NO_ERROR) {
  220. #ifdef HAVE_GTK_2
  221. GtkWidget *dialog = gtk_message_dialog_new(NULL,GTK_DIALOG_MODAL,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,"OpenGL error 0x%04X: %sn",error,gluErrorString(error));
  222. gtk_dialog_run(GTK_DIALOG(dialog));
  223. gtk_widget_destroy(dialog);
  224. #else
  225. fprintf(stderr,"OpenGL error 0x%04X: %sn",error,gluErrorString(error));
  226. #endif
  227. }
  228. }
  230. /*
  231.  */
  232. void GLApp::exit(const char *error,...) {
  233. if(error) {
  234. char buf[1024];
  235. va_list arg;
  236. va_start(arg,error);
  237. vsprintf(buf,error,arg);
  238. va_end(arg);
  239. #ifdef HAVE_GTK_2
  240. GtkWidget *dialog = gtk_message_dialog_new(NULL,GTK_DIALOG_MODAL,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,"GLApp exit: %sn",buf);
  241. gtk_dialog_run(GTK_DIALOG(dialog));
  242. gtk_widget_destroy(dialog);
  243. #else
  244. fprintf(stderr,"GLApp exit: %sn",buf);
  245. #endif
  246. }
  247. done = 1;
  248. }
  250. /*
  251.  */
  252. #ifdef HAVE_GTK
  254. static int ret;
  255. static char *name;
  257. static void signal_ok(GtkWidget *widget) {
  258. ret = 1;
  259. strcpy(name,gtk_file_selection_get_filename(GTK_FILE_SELECTION(widget)));
  260. gtk_widget_destroy(widget);
  261. gtk_main_quit();
  262. }
  264. static void signal_cancel(GtkWidget *widget) {
  265. gtk_widget_destroy(widget);
  266. gtk_main_quit();
  267. }
  269. int GLApp::selectFile(const char *title,char *name) {
  270. ret = 0;
  271. ::name = name;
  272. GtkWidget *window = gtk_file_selection_new(title);
  273. gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
  274. gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(signal_cancel),&window);
  275. gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(window)->ok_button),"clicked",GTK_SIGNAL_FUNC(signal_ok),GTK_OBJECT(window));
  276. gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(window)->cancel_button),"clicked",GTK_SIGNAL_FUNC(signal_cancel),GTK_OBJECT(window));
  277. gtk_widget_show(window);
  278. gtk_main();
  279. return ret;
  280. }
  282. #else
  284. int GLApp::selectFile(const char *title,char *name) {
  285. printf("%sn",title);
  286. fscanf(stdin,"%s",name);
  287. return 1;
  288. }
  290. #endif /* HAVE_GTK */
  292. /*
  293.  */
  294. static int getTime() {
  295. struct timeval tval;
  296. struct timezone tzone;
  297. gettimeofday(&tval,&tzone);
  298. return tval.tv_sec * 1000 + tval.tv_usec / 1000;
  299. }
  301. /*
  302.  */
  304. static int translateKey(int key) {
  305. int ret;
  306. if(key & 0xff00) {
  307. switch(key) {
  308. case XK_Escape: ret = GLApp::KEY_ESC; break;
  309. case XK_Tab: ret = GLApp::KEY_TAB; break;
  310. case XK_Return: ret = GLApp::KEY_RETURN; break;
  311. case XK_BackSpace: ret = GLApp::KEY_BACKSPACE; break;
  312. case XK_Delete: ret = GLApp::KEY_DELETE; break;
  313. case XK_Home: ret = GLApp::KEY_HOME; break;
  314. case XK_End: ret = GLApp::KEY_END; break;
  315. case XK_Page_Up: ret = GLApp::KEY_PGUP; break;
  316. case XK_Page_Down: ret = GLApp::KEY_PGDOWN; break;
  317. case XK_Left: ret = GLApp::KEY_LEFT; break;
  318. case XK_Right: ret = GLApp::KEY_RIGHT; break;
  319. case XK_Up: ret = GLApp::KEY_UP; break;
  320. case XK_Down: ret = GLApp::KEY_DOWN; break;
  321. case XK_Shift_L: case XK_Shift_R: ret = GLApp::KEY_SHIFT; break;
  322. case XK_Control_L: case XK_Control_R: ret = GLApp::KEY_CTRL; break;
  323. case XK_Alt_L: case XK_Alt_R: ret = GLApp::KEY_ALT; break;
  324. default: ret = (key < 0x06ff) ? (key & 0x00ff) : 0;
  325. }
  326. } else {
  327. ret = key;
  328. }
  329. return ret;
  330. }
  332. /*
  333.  */
  334. void GLApp::main() {
  335. KeySym key;
  336. int startTime = getTime(),endTime = 0,counter = 0;
  337.     fps = 60;
  338. while(window && !done) {
  339. while(XPending(display) > 0) {
  340. XEvent event;
  341. XNextEvent(display,&event);
  342. switch(event.type) {
  343. case ClientMessage:
  344. if(event.xclient.format == 32 && event.xclient.data.l[0] == (long)WM_DELETE_WINDOW) exit();
  345. break;
  346. case ConfigureNotify:
  347. windowWidth = event.xconfigure.width;
  348. windowHeight = event.xconfigure.height;
  349. glViewport(0,0,windowWidth,windowHeight);
  350. break;
  351. case KeyPress:
  352. XLookupString(&event.xkey,NULL,0,&key,NULL);
  353. key = translateKey(key);
  354. keys[key] = 1;
  355. if(keys[KEY_ALT] && keys[KEY_RETURN]) {
  356. keys[KEY_ALT] = 0;
  357. keys[KEY_RETURN] = 0;
  358. setVideoMode(windowWidth,windowHeight,!fullScreen);
  359. setTitle(title);
  360. }
  361. if(key) keyPress(key);
  362. break;
  363. case KeyRelease:
  364. XLookupString(&event.xkey,NULL,0,&key,NULL);
  365. key = translateKey(key);
  366. keys[key] = 0;
  367. if(key) keyRelease(key);
  368. break;
  369. case MotionNotify:
  370. mouseX = event.xmotion.x;
  371. mouseY = event.xmotion.y;
  372. break;
  373. case ButtonPress:
  374. mouseButton |= 1 << ((event.xbutton.button - 1));
  375. buttonPress(1 << (event.xbutton.button - 1));
  376. break;
  377. case ButtonRelease:
  378. if(event.xbutton.button < 4) mouseButton &= ~(1 << (event.xbutton.button - 1));
  379. buttonRelease(1 << (event.xbutton.button - 1));
  380. break;
  381. }
  382. }
  384. if(counter++ == 10) {
  385. endTime = startTime;
  386. startTime = getTime(); 
  387. fps = counter * 1000.0 / (float)(startTime - endTime);
  388. counter = 0;
  389. }
  390. ifps = 1.0 / fps;
  392. idle();
  393. render();
  395. glXSwapBuffers(display,window);
  396. mouseButton &= ~(BUTTON_UP | BUTTON_DOWN);
  397. }
  398. }
  400. #else
  402. /* windows
  403.  */
  404. #include <stdio.h>
  405. #include <string.h>
  406. #include <stdlib.h>
  407. #include <stdarg.h>
  408. #include <windows.h>
  409. #include <GL/gl.h>
  410. #include <GL/glu.h>
  411. #include "glapp.h"
  413. #pragma comment (lib,"opengl32.lib")
  414. #pragma comment (lib,"glu32.lib")
  415. #pragma comment (lib,"winmm.lib")
  417. extern int main(int argc,char **argv);
  419. static GLApp *glApp;
  420. static HWND window;
  421. static HGLRC context;
  422. static HCURSOR cursor;
  423. static int done;
  425. /*
  426.  */
  427. GLApp::GLApp() {
  428. memset(this,0,sizeof(GLApp));
  429. }
  431. GLApp::~GLApp() {
  432. if(window) {
  433. HDC hdc = GetDC(window);
  434. wglMakeCurrent(hdc,0);
  435. wglDeleteContext(context);
  436. ReleaseDC(window,hdc);
  437. DestroyWindow(window);
  438. if(fullScreen) {
  439. ChangeDisplaySettings(NULL,0);
  440. ShowCursor(true);
  441. }
  442. }
  443. }
  445. /*
  446.  */
  447. static int translateKey(int key) {
  448. int ret;
  449. switch(key) {
  450. case VK_ESCAPE : ret = GLApp::KEY_ESC; break;
  451. case VK_TAB: ret = GLApp::KEY_TAB; break;
  452. case VK_RETURN: ret = GLApp::KEY_RETURN; break;
  453. case VK_BACK: ret = GLApp::KEY_BACKSPACE; break;
  454. case VK_DELETE: ret = GLApp::KEY_DELETE; break;
  455. case VK_HOME: ret = GLApp::KEY_HOME; break;
  456. case VK_END: ret = GLApp::KEY_END; break;
  457. case VK_PRIOR: ret = GLApp::KEY_PGUP; break;
  458. case VK_NEXT: ret = GLApp::KEY_PGDOWN; break;
  459. case VK_LEFT: ret = GLApp::KEY_LEFT; break;
  460. case VK_RIGHT: ret = GLApp::KEY_RIGHT; break;
  461. case VK_UP: ret = GLApp::KEY_UP; break;
  462. case VK_DOWN: ret = GLApp::KEY_DOWN; break;
  463. case VK_SHIFT: ret = GLApp::KEY_SHIFT; break;
  464. case VK_CONTROL: ret = GLApp::KEY_CTRL; break;
  465. default:
  466. ret = MapVirtualKey(key,2);
  467. if(strchr("1234567890-=",ret)) {
  468. if(glApp->keys[GLApp::KEY_SHIFT]) {
  469. if(ret == '1') ret = '!';
  470. else if(ret == '2') ret = '@';
  471. else if(ret == '3') ret = '#';
  472. else if(ret == '4') ret = '$';
  473. else if(ret == '5') ret = '%';
  474. else if(ret == '6') ret = '^';
  475. else if(ret == '7') ret = '&';
  476. else if(ret == '8') ret = '*';
  477. else if(ret == '9') ret = '(';
  478. else if(ret == '0') ret = ')';
  479. else if(ret == '-') ret = '_';
  480. else if(ret == '=') ret = '+';
  481. }
  482. } else if(isascii(ret)) {
  483. if(glApp->keys[GLApp::KEY_SHIFT]) ret = toupper(ret);
  484. else ret = tolower(ret);
  485. }
  486. else ret = 0;
  487. }
  488. return ret;
  489. }
  491. /*
  492.  */
  493. LRESULT CALLBACK windowProc(HWND window,UINT message,WPARAM wparam,LPARAM lparam) {
  494. switch(message) {
  495. case WM_SIZE:
  496. glApp->windowWidth = LOWORD(lparam);
  497. glApp->windowHeight = HIWORD(lparam);
  498. glViewport(0,0,glApp->windowWidth,glApp->windowHeight);
  499. break;
  500. case WM_KEYDOWN: {
  501. int key = translateKey((int)wparam);
  502. glApp->keys[key] = 1;
  503. glApp->keyPress(key);
  504. }
  505. break;
  506. case WM_KEYUP: {
  507. int key = translateKey((int)wparam);
  508. glApp->keys[key] = 0;
  509. glApp->keyRelease(key);
  510. }
  511. break;
  512. case WM_CLOSE:
  513. glApp->exit();
  514. break;
  515. case WM_LBUTTONDOWN:
  516. glApp->mouseButton |= GLApp::BUTTON_LEFT;
  517. glApp->buttonPress(GLApp::BUTTON_LEFT);
  518. break;
  519. case WM_LBUTTONUP:
  520. glApp->mouseButton &= ~GLApp::BUTTON_LEFT;
  521. glApp->buttonRelease(GLApp::BUTTON_LEFT);
  522. break;
  523. case WM_MBUTTONDOWN:
  524. glApp->mouseButton |= GLApp::BUTTON_MIDDLE;
  525. glApp->buttonPress(GLApp::BUTTON_MIDDLE);
  526. break;
  527. case WM_MBUTTONUP:
  528. glApp->mouseButton &= ~GLApp::BUTTON_MIDDLE;
  529. glApp->buttonRelease(GLApp::BUTTON_MIDDLE);
  530. break;
  531. case WM_RBUTTONDOWN:
  532. glApp->mouseButton |= GLApp::BUTTON_RIGHT;
  533. glApp->buttonPress(GLApp::BUTTON_RIGHT);
  534. break;
  535. case WM_RBUTTONUP:
  536. glApp->mouseButton &= ~GLApp::BUTTON_RIGHT;
  537. glApp->buttonRelease(GLApp::BUTTON_RIGHT);
  538. break;
  539. case 0x020A: //WM_MOUSEWHEEL:
  540. if((short)HIWORD(wparam) > 0) {
  541. glApp->mouseButton |= GLApp::BUTTON_UP;
  542. glApp->buttonPress(GLApp::BUTTON_UP);
  543. glApp->buttonRelease(GLApp::BUTTON_UP);
  544. } else {
  545. glApp->mouseButton |= GLApp::BUTTON_DOWN;
  546. glApp->buttonPress(GLApp::BUTTON_DOWN);
  547. glApp->buttonRelease(GLApp::BUTTON_DOWN);
  548. }
  549. break;
  550. case WM_MOUSEMOVE:
  551. glApp->mouseX = LOWORD(lparam);
  552. glApp->mouseY = HIWORD(lparam);
  553. if(glApp->mouseX & 1 << 15) glApp->mouseX -= (1 << 16);
  554. if(glApp->mouseY & 1 << 15) glApp->mouseY -= (1 << 16);
  555. break;
  556. }
  557. return DefWindowProc(window,message,wparam,lparam);
  558. }
  560. /*
  561.  */
  562. int GLApp::setVideoMode(int w,int h,int fs) {
  564. if(window) {
  565. DestroyWindow(window);
  566. if(fullScreen) {
  567. ChangeDisplaySettings(NULL,0);
  568. ShowCursor(true);
  569. }
  570. }
  572. windowWidth = w;
  573. windowHeight = h;
  574. fullScreen = fs;
  575. glApp = this;
  577. try {
  578. HDC hdc;
  579. int pixelformat;
  580. PIXELFORMATDESCRIPTOR pfd = {
  581. sizeof(PIXELFORMATDESCRIPTOR), 1, PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
  582. PFD_TYPE_RGBA, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 8, 0, PFD_MAIN_PLANE, 0, 0, 0, 0
  583. };
  585. HINSTANCE hInstance = GetModuleHandle(NULL);
  586. if(!window) {
  587. WNDCLASS wc;
  588. wc.style = 0;
  589. wc.lpfnWndProc = (WNDPROC)windowProc;
  590. wc.cbClsExtra = 0;
  591. wc.cbWndExtra = 0;
  592. wc.hInstance = hInstance;
  593. wc.hIcon = 0;
  594. wc.hCursor = LoadCursor(NULL,IDC_ARROW);
  595. wc.hbrBackground = NULL;
  596. wc.lpszMenuName = NULL;
  597. wc.lpszClassName = "GLApp";
  598. if(!RegisterClass(&wc)) throw("RegisterClass() fail");
  599. }
  601. if(fullScreen) {
  602. DEVMODE settings;
  603. memset(&settings,0,sizeof(DEVMODE));
  604. settings.dmSize = sizeof(DEVMODE);
  605. settings.dmPelsWidth = w;
  606. settings.dmPelsHeight = h;
  607. settings.dmBitsPerPel = 32;
  608. settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
  609. if(ChangeDisplaySettings(&settings,CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL) throw("ChangeDisplaySettings() fail");
  610. window = CreateWindowEx(0,"GLApp","GLApp",WS_POPUP,0,0,windowWidth,windowHeight,NULL,NULL,hInstance,NULL);
  611. } else {
  612. RECT windowRect = {0, 0, windowWidth, windowHeight };
  613. AdjustWindowRectEx(&windowRect,WS_OVERLAPPEDWINDOW,0,0);
  614. windowWidth = windowRect.right - windowRect.left;
  615. windowHeight = windowRect.bottom - windowRect.top;
  616. window = CreateWindowEx(0,"GLApp","GLApp",WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,windowWidth,windowHeight,NULL,NULL,hInstance,NULL);
  617. }
  619. if(!window) throw("CreateWindowEx() fail");
  620. if(!(hdc = GetDC(window))) throw("GetDC() fail");
  622. if(!(pixelformat = ChoosePixelFormat(hdc,&pfd))) throw("ChoosePixelFormat() fail");
  623. if(!(SetPixelFormat(hdc,pixelformat,&pfd))) throw("SetPixelFormat() fail");
  625. if(!context) context = wglCreateContext(hdc);
  626. if(!context) throw("wglCreateContext() fail");
  627. if(!wglMakeCurrent(hdc,context)) throw("wglMakeCurrent() fail");
  628. glViewport(0,0,glApp->windowWidth,glApp->windowHeight);
  629. }
  630. catch(const char *error) {
  631. window = 0;
  632. exit(error);
  633. return 0;
  634. }
  635. ShowWindow(window,SW_SHOW);
  636. UpdateWindow(window);
  637. SetForegroundWindow(window);
  638. SetFocus(window);
  639. return 1;
  640. }
  642. /*
  643.  */
  644. void GLApp::setTitle(const char *title) {
  645. SetWindowText(window,title);
  646. }
  648. /*
  649.  */
  650. void GLApp::setCursor(int x,int y) {
  651. POINT pt;
  652. pt.x = x;
  653. pt.y = y;
  654. ClientToScreen(window,&pt);
  655. SetCursorPos(pt.x,pt.y);
  656. }
  658. /*
  659.  */
  660. void GLApp::showCursor(int show) {
  661. if(!cursor) cursor = GetCursor();
  662. if(show) SetCursor(cursor);
  663. else SetCursor(NULL);
  664. }
  666. /*
  667.  */
  668. void GLApp::checkExtension(const char *extension) {
  669. static char *extensions = NULL;
  670. if(!extensions) extensions = (char*)glGetString(GL_EXTENSIONS);
  671. if(strstr(extensions,extension)) return;
  672. char error[1024];
  673. sprintf(error,"OpenGL extension "%s" is not supported by current hardware",extension);
  674. exit(error);
  675. }
  677. /*
  678.  */
  679. void GLApp::error() {
  680. GLenum error;
  681. while((error = glGetError()) != GL_NO_ERROR) {
  682. MessageBox(0,(char*)gluErrorString(error),"OpenGL error",MB_OK);
  683. }
  684. }
  686. /*
  687.  */
  688. void GLApp::exit(const char *error,...) {
  689. if(error) {
  690. char buf[1024];
  691. va_list arg;
  692. va_start(arg,error);
  693. vsprintf(buf,error,arg);
  694. va_end(arg);
  695. MessageBox(0,buf,"GLApp exit",MB_OK);
  696. }
  697. done = 1;
  698. }
  700. /*
  701.  */
  702. int GLApp::selectFile(const char *title,char *name) {
  703. OPENFILENAME ofn;
  704. memset(&ofn,0,sizeof(ofn));
  705. ofn.lStructSize = sizeof(OPENFILENAME);
  706. ofn.hwndOwner = window;
  707. ofn.lpstrFileTitle = name;
  708. ofn.nMaxFileTitle = 512;
  709. ofn.lpstrFilter = "*.*";
  710. ofn.nFilterIndex = 1;
  711. ofn.lpstrTitle = title;
  712. ofn.Flags = OFN_FILEMUSTEXIST;
  713. return GetOpenFileName(&ofn);
  714. }
  716. /*
  717.  */
  718. static int getTime() {
  719. static int base;
  720. static int initialized = 0;
  721. if(!initialized) {
  722. base = timeGetTime();
  723. initialized = 1;
  724. }
  725. return timeGetTime() - base;
  726. }
  728. /*
  729.  */
  730. void GLApp::main() {
  731. int startTime = 0,endTime = 0,counter = 0;
  732. fps = 60;
  733. MSG msg;
  734. while(window && !done) {
  735. if(PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) {
  736. if(!GetMessage(&msg,NULL,0,0)) return;
  737. TranslateMessage(&msg);
  738. DispatchMessage(&msg);
  739. } else {
  740. if(counter++ == 10) {
  741. endTime = startTime;
  742. startTime = getTime();
  743. fps = counter * 1000.0f / (float)(startTime - endTime);
  744. counter = 0;
  745. }
  746. ifps = 1.0f / fps;
  748. idle();
  749. render();
  751. SwapBuffers(wglGetCurrentDC());
  752. mouseButton &= ~(BUTTON_UP | BUTTON_DOWN);
  753. }
  754. }
  755. }
  757. /*
  758.  */
  759. int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow) {
  760. int argc = 1;
  761. char *argv[256];
  762. argv[0] = "none";
  763. while(*lpCmdLine && argc < 256) {
  764. while(*lpCmdLine && *lpCmdLine <= ' ') lpCmdLine++;
  765. if(*lpCmdLine) {
  766. argv[argc++] = lpCmdLine;
  767. while(*lpCmdLine && *lpCmdLine > ' ') lpCmdLine++;
  768. if(*lpCmdLine) *(lpCmdLine++) = 0;
  769. }
  770. }
  771. main(argc,argv);
  772. return 0;
  773. }
  775. #endif