myGLUI.cpp
上传用户:kaiyuangj
上传日期:2022-01-01
资源大小:35k
文件大小:13k
源码类别:

屏幕保护

开发平台:

Visual C++

  1. /*
  2.  *      Windows Frame Code Was Published By Jeff Molofee 2000. 
  3.  *      Thanks to the Creator  of Screen Saver of Lesson31_SS. 
  4.  * Both of You Helped me A Lots.
  5.  * If You've Found This Code Useful, Please Send Me a Copy At
  6.  * gan_kim_heng@yahoo.com.
  7.  */
  8. #include <windows.h> // Header File For Windows
  9. #include <stdio.h> // Header File For Standard Input/Output
  10. #include <math.h>
  11. #include <glgl.h> // Header File For The OpenGL32 Library
  12. #include <glglu.h> // Header File For The GLu32 Library
  13. #include <scrnsave.h>
  14. #include "resource.h"
  15. #include "myGLUI.h"
  16. #pragma comment( lib, "opengl32.lib") // Search For OpenGL32.lib While Linking
  17. #pragma comment( lib, "glu32.lib")
  18. #pragma comment( lib, "scrnsave.lib")
  19. HDC hDC=NULL; // Private GDI Device Context
  20. HGLRC hRC=NULL; // Permanent Rendering Context
  21. HWND hWnd=NULL; // Holds Our Window Handle
  22. HINSTANCE hInstance; // Holds The Instance Of The Application
  23. DEVMODE DMsaved; // Saves the previous screen settings (NEW)
  24. UINT uTimer; // timer identifier
  25. bool keys[256]; // Array Used For The Keyboard Routine
  26. bool active=TRUE; // Window Active Flag Set To TRUE By Default
  27. bool fullscreen=TRUE; // Fullscreen Flag Set To Fullscreen Mode By Default
  28. const num=50; // Number Of Stars To Draw
  29. GLuint loop; // General Loop Variable
  30. float flag=0.0; // Flag to Create the Sprinkling Effect at the Initiate State 
  31. typedef struct // Create A Structure For Star
  32. {
  33. int r, g, b; // Bubbles Color
  34. GLfloat x,velox,y,veloy,z,veloz;
  35. }
  36. bubbles;
  37. bubbles bubble[num]; // Need To Keep Track Of 'num' bubbles
  38. GLuint texture[1]; // Storage For One Texture
  39. void LoadGLTextures();
  40. GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Resize And Initialize The GL Window
  41. {
  42. if (height==0) // Prevent A Divide By Zero By
  43. {
  44. height=1; // Making Height Equal One
  45. }
  46. glViewport(0,0,width,height); // Reset The Current Viewport
  47. glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
  48. glLoadIdentity(); // Reset The Projection Matrix
  49. // Calculate The Aspect Ratio Of The Window
  50. gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
  51. glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
  52. glLoadIdentity(); // Reset The Modelview Matrix
  53. }
  54. void SetBubbles(int loop) // Sets The Initial Value Of Each Object (Random)
  55. {
  56. bubble[loop].r=rand()%256;
  57. bubble[loop].g=rand()%256;
  58. bubble[loop].b=rand()%256;
  59. flag=(float)0.0; // Reset
  60. bubble[loop].x=float(sin(rand()/330.0));
  61. bubble[loop].y=float(-25.0 + rand()/2000.0);
  62. bubble[loop].z=float(rand()/3000.0);
  63. bubble[loop].velox=0.0;
  64. bubble[loop].veloy=0.0;
  65. bubble[loop].veloz=0.0;
  66. }
  67. int InitGL(GLvoid) // All Setup For OpenGL Goes Here
  68. {
  69. glEnable(GL_TEXTURE_2D); // Enable Texture Mapping 
  70. glShadeModel(GL_SMOOTH); // Enable Smooth Shading
  71. glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
  72. glClearDepth(1.0f); // Depth Buffer Setup
  73. glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
  74. glBlendFunc(GL_SRC_ALPHA,GL_ONE); // Set The Blending Function For Translucency
  75. glEnable(GL_BLEND);
  76. LoadGLTextures();
  77. for (loop=0; loop<num; loop++)
  78. {
  79. SetBubbles(loop);
  80. }
  81. return TRUE;
  82. }
  83. int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing
  84. {
  85. glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
  86. glBindTexture(GL_TEXTURE_2D, texture[0]);
  87. for (loop=0; loop<num; loop++) // Loop Through All The bubbles
  88. {
  89. glLoadIdentity(); // Reset The View
  90. glTranslatef(0.0f,0.0f,-50.0f);
  91. //glTranslatef(float(3*sin(rand()/330.0)),float(rand()/2000.0),float(rand()/3000.0));
  92. glTranslatef(bubble[loop].x,bubble[loop].y,bubble[loop].z);
  93. glBindTexture(GL_TEXTURE_2D, texture[0]);
  94. glColor4ub(bubble[loop].r,bubble[loop].g,bubble[loop].b,255);
  95. glBegin(GL_QUADS);
  96. glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
  97. glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
  98. glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
  99. glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
  100. glEnd();
  101. bubble[loop].velox=float(sin(rand()/1000.0*flag));
  102. bubble[loop].veloy=float(rand()/40000.0);
  103. bubble[loop].veloz=float(rand()/30000.0);
  104. bubble[loop].x+=bubble[loop].velox;
  105. bubble[loop].y+=bubble[loop].veloy;
  106. bubble[loop].z+=bubble[loop].veloz;
  107. flag+=(float)10.0;
  108. if(flag>1000)
  109. {
  110. flag=(float)0.0;
  111. }
  112. Sleep(5);
  113. if (bubble[loop].y>18.0f) // Is bubble Off The Screen?
  114. {
  115. SetBubbles(loop); // If So, Reassign New Values
  116. }
  117. }
  118. return TRUE; // Keep Going
  119. }
  120. /************************************************************************************/
  121. GLvoid KillGLWindow(GLvoid) // Properly Kill The Window
  122. {
  123. if (hRC) // Do We Have A Rendering Context?
  124. {
  125. if (!wglMakeCurrent(NULL,NULL)) // Are We Able To Release The DC And RC Contexts?
  126. {
  127. MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  128. }
  129. if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC?
  130. {
  131. MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  132. }
  133. hRC=NULL; // Set RC To NULL
  134. }
  135. if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able To Release The DC
  136. {
  137. MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
  138. hDC=NULL; // Set DC To NULL
  139. }
  140. }
  141. /************************************************************************************/
  142. /* This Code Creates Our OpenGL Window.  Parameters Are: *
  143.  * title - Title To Appear At The Top Of The Window *
  144.  * width - Width Of The GL Window Or Fullscreen Mode *
  145.  * height - Height Of The GL Window Or Fullscreen Mode *
  146.  * bits - Number Of Bits To Use For Color (8/16/24/32) *
  147.  * fullscreenflag - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE) */
  148.  
  149. BOOL CreateGLWindow(HWND hWnd, int bits)
  150. {
  151. GLuint PixelFormat; // Holds The Results After Searching For A Match
  152. RECT WindowRect; // Grabs Rectangle Upper Left / Lower Right Values
  153. int width;
  154. int height;
  155. hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
  156. EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &DMsaved); // save the current display state (NEW)
  157. static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be
  158. {
  159. sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
  160. 1, // Version Number
  161. PFD_DRAW_TO_WINDOW | // Format Must Support Window
  162. PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
  163. PFD_DOUBLEBUFFER, // Must Support Double Buffering
  164. PFD_TYPE_RGBA, // Request An RGBA Format
  165. bits, // Select Our Color Depth
  166. 0, 0, 0, 0, 0, 0, // Color Bits Ignored
  167. 0, // No Alpha Buffer
  168. 0, // Shift Bit Ignored
  169. 0, // No Accumulation Buffer
  170. 0, 0, 0, 0, // Accumulation Bits Ignored
  171. 16, // 16Bit Z-Buffer (Depth Buffer)  
  172. 0, // No Stencil Buffer
  173. 0, // No Auxiliary Buffer
  174. PFD_MAIN_PLANE, // Main Drawing Layer
  175. 0, // Reserved
  176. 0, 0, 0 // Layer Masks Ignored
  177. };
  178. if (!(hDC=GetDC(hWnd))) // Did We Get A Device Context?
  179. {
  180. KillGLWindow(); // Reset The Display
  181. MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  182. return FALSE; // Return FALSE
  183. }
  184. if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format?
  185. {
  186. KillGLWindow(); // Reset The Display
  187. MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  188. return FALSE; // Return FALSE
  189. }
  190. if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format?
  191. {
  192. KillGLWindow(); // Reset The Display
  193. MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  194. return FALSE; // Return FALSE
  195. }
  196. if (!(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
  197. {
  198. KillGLWindow(); // Reset The Display
  199. MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  200. return FALSE; // Return FALSE
  201. }
  202. if(!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context
  203. {
  204. KillGLWindow(); // Reset The Display
  205. MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  206. return FALSE; // Return FALSE
  207. }
  208.     GetClientRect (hWnd, &WindowRect); 
  209. width = WindowRect.right - WindowRect.left;
  210. height = WindowRect.bottom - WindowRect.top;
  211. ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen
  212.     if (!InitGL()) // Initialize Our Newly Created GL Window
  213. {
  214. KillGLWindow(); // Reset The Display
  215. MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
  216. return FALSE; // Return FALSE
  217. }
  218. return TRUE; // Success
  219. }
  220. /************************************************************************************/
  221. // (no changes)
  222. LRESULT WINAPI ScreenSaverProc (HWND hWnd,
  223. UINT uMsg,
  224. WPARAM wParam,
  225. LPARAM lParam)
  226. {
  227. switch (uMsg) // Check For Windows Messages
  228. {
  229.         case WM_CREATE:
  230. {
  231. if (!CreateGLWindow(hWnd,16))
  232. {
  233. return -1; // Quit If Window Was Not Created
  234. }
  235.             uTimer = SetTimer(hWnd, 1, 10, NULL); 
  236. return 0;
  237. }
  238.         case WM_TIMER: 
  239. DrawGLScene();                      // Draw Scene
  240. SwapBuffers(hDC); // Swap Buffers (Double Buffering)
  241. break;
  242.         case WM_DESTROY: 
  243.             if (uTimer) 
  244.                 KillTimer(hWnd, uTimer); 
  245. KillGLWindow(); // Kill The Window
  246. glDeleteTextures(4,texture);
  247.             break; 
  248. }
  249. // Pass All Unhandled Messages To DefScreenSaverProc
  250.     return DefScreenSaverProc(hWnd, uMsg, wParam, lParam); 
  251. }
  252. BOOL WINAPI ScreenSaverConfigureDialog (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) 
  253.     return FALSE; 
  254. BOOL WINAPI RegisterDialogClasses(HANDLE hInst)
  255.     return TRUE; 
  256. int ImageLoadFromResource(LPCTSTR lpszName, Image *image) {
  257. HANDLE hBmp = LoadImage(hInstance, lpszName, IMAGE_BITMAP,
  258. LR_DEFAULTSIZE, LR_DEFAULTSIZE, LR_DEFAULTCOLOR);
  259. if(!hBmp)
  260. return 0;
  261. // Get the bitmap dimensions.
  262. BITMAP bmp;
  263. if(!GetObject((HBITMAP)hBmp, sizeof(bmp), &bmp))
  264. return 0;
  265. // First try to get how much memory we need.
  266. BITMAPINFO bi = {0};
  267. bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  268. bi.bmiHeader.biWidth = bmp.bmWidth;
  269. bi.bmiHeader.biHeight = bmp.bmHeight;
  270. bi.bmiHeader.biPlanes = bmp.bmPlanes;
  271. bi.bmiHeader.biBitCount = 24;
  272. if(!GetDIBits(hDC, (HBITMAP)hBmp, 0, 1, NULL, &bi, DIB_PAL_COLORS))
  273. return 0;
  274. // Allocate memory for the required number of bytes. 
  275. image->sizeX = bi.bmiHeader.biWidth;
  276. image->sizeY = bi.bmiHeader.biHeight;
  277. image->data = (char*)malloc(bi.bmiHeader.biSizeImage);
  278. // Get the bits in 24 bit format.
  279. if(!GetDIBits(hDC, (HBITMAP)hBmp, 0, bi.bmiHeader.biHeight, (LPVOID)image->data, &bi, DIB_PAL_COLORS))
  280. return 0;
  281.     for (unsigned long i=0;i<bi.bmiHeader.biSizeImage;i+=3) { /* reverse all of the colors. (bgr -> rgb)*/
  282. char temp = image->data[i];
  283. image->data[i] = image->data[i+2];
  284. image->data[i+2] = temp;
  285.     }
  286. return 1;
  287. }
  288. /*************************************************************************************/
  289. /***        Load Bitmaps And Convert To Textures                                  ****/
  290. /*************************************************************************************/
  291. void LoadGLTextures() {
  292.     /* Load Texture*/
  293.     Image *image1;
  294.     
  295.     /* allocate space for texture*/
  296.     image1 = (Image *) malloc(sizeof(Image));
  297.     if (image1 == NULL) {
  298. printf("Error allocating space for image");
  299. exit(0);
  300.     }
  301.     if (!ImageLoadFromResource(MAKEINTRESOURCE(IDB_BITMAP1), image1)) {
  302. exit(1);
  303.     } 
  304.     /* Create Texture *****************************************/
  305.     glGenTextures(2, &texture[0]);
  306.     glBindTexture(GL_TEXTURE_2D, texture[0]);   /* 2d texture (x and y size)*/
  307.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); /* scale linearly when image bigger than texture*/
  308.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); /* scale linearly when image smalled than texture*/
  309. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_REPEAT);
  310. glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_REPEAT);
  311.     /* 2d texture, level of detail 0 (normal), 3 components (red, green, blue), x size from image, y size from image, */
  312.     /* border 0 (normal), rgb color data, unsigned byte data, and finally the data itself.*/
  313.     glTexImage2D(GL_TEXTURE_2D, 0, 3, image1->sizeX, image1->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, image1->data);
  314. free(image1->data);
  315. free(image1);
  316. };
  317. /*************************************************************************************/