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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
DDEX5.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：11k
源码类别：

Windows编程

开发平台：

Visual C++

DDEX5.CPP：源码内容
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1995-1997 Microsoft Corporation. All Rights Reserved.
  4.  *
  5.  *  File: ddex5.cpp
  6.  *  Content: Direct Draw example program 5. Adds functionality to
  7.  * example program 4.  Uses GetEntries() to read a palette,
  8.  * modifies the entries, and then uses SetEntries() to update
  9.  * the palette.  This program requires 1.2 Meg of video ram.
  10.  *
  11.  ***************************************************************************/
  13. #define NAME "DDExample5"
  14. #define TITLE "Direct Draw Example 5"
  16. #define WIN32_LEAN_AND_MEAN
  17. #include <windows.h>
  18. #include <windowsx.h>
  19. #include <ddraw.h>
  20. #include "resource.h"
  21. #include "ddutil.h"
  23. char szBitmap[] = "ALL";
  25. LPDIRECTDRAW lpDD; // DirectDraw object
  26. LPDIRECTDRAWSURFACE lpDDSPrimary; // DirectDraw primary surface
  27. LPDIRECTDRAWSURFACE lpDDSBack; // DirectDraw back surface
  28. LPDIRECTDRAWSURFACE lpDDSOne; // Offscreen surface 1
  29. LPDIRECTDRAWPALETTE lpDDPal; // The primary surface palette
  30. BOOL bActive; // is application active?
  32. BYTE torusColors[256]; // Marks the colors used in the torus
  34. /*
  35.  * restoreAll
  36.  *
  37.  * restore all lost objects
  38.  */
  39. HRESULT restoreAll( void )
  40. {
  41.     HRESULT ddrval;
  42.     DDSURFACEDESC ddsd;
  44.     ddrval = lpDDSPrimary->Restore();
  45.     if( ddrval == DD_OK )
  46.     {
  47. ddrval = lpDDSOne->Restore();
  48. if( ddrval == DD_OK )
  49.         {
  50.             DDReLoadBitmap(lpDDSOne, szBitmap);
  51. }
  52.     }
  54.     //Loose the old palette
  55.     lpDDPal->Release();
  56.     // create and set the palette (restart cycling from the same place)
  57.     lpDDPal = DDLoadPalette(lpDD, szBitmap);
  59.     if (lpDDPal)
  60.         lpDDSPrimary->SetPalette(lpDDPal);
  61.     //
  62.     // Mark the colors used in the torus frames
  63.     //
  64.     int i,x,y;
  66.     // First, set all colors as unused
  67.     for(i=0; i<256; i++)
  68.     {
  69.         torusColors[i] = 0;
  70.     }
  72.     // lock the surface and scan the lower part (the torus area)
  73.     // and remember all the index's we find.
  74.     ddsd.dwSize = sizeof(ddsd);
  75.     while (lpDDSOne->Lock(NULL, &ddsd, 0, NULL) == DDERR_WASSTILLDRAWING)
  76.         ;
  78.     // Now search through the torus frames and mark used colors
  79.     for( y=480; y<480+384; y++ )
  80.     {
  81.         for( x=0; x<640; x++ )
  82.         {
  83.             torusColors[((BYTE *)ddsd.lpSurface)[y*ddsd.lPitch+x]] = 1;
  84.         }
  85.     }
  87.     lpDDSOne->Unlock(NULL);
  89.     return ddrval;
  91. } /* restoreAll */
  93. /*
  94.  * updateFrame
  95.  * 
  96.  * Decide what needs to be blitted next, wait for flip to complete,
  97.  * then flip the buffers.
  98.  */
  99. void updateFrame( void )
  100. {
  101.     static DWORD lastTickCount[4] = {0,0,0,0};
  102.     static int currentFrame[3] = {0,0,0};
  103.     DWORD thisTickCount;
  104.     RECT rcRect;
  105.     DWORD delay[4] = {50, 78, 13, 93};
  106.     int i;
  107.     int xpos[3] = {288, 190, 416};
  108.     int ypos[3] = {128, 300, 256};
  109.     PALETTEENTRY pe[256];
  110.     HRESULT ddrval;
  112.     // Decide which frame will be blitted next
  113.     thisTickCount = GetTickCount();
  114.     for(i=0; i<3; i++)
  115.     {
  116. if((thisTickCount - lastTickCount[i]) > delay[i])
  117. {
  118.     // Move to next frame;
  119.     lastTickCount[i] = thisTickCount;
  120.     currentFrame[i]++;
  121.     if(currentFrame[i] > 59)
  122. currentFrame[i] = 0;
  123. }
  124.     }
  126.     // Blit the stuff for the next frame
  127.     rcRect.left = 0;
  128.     rcRect.top = 0;
  129.     rcRect.right = 640;
  130.     rcRect.bottom = 480;
  131.     while( 1 )
  132.     {
  133.         ddrval = lpDDSBack->BltFast( 0, 0, lpDDSOne,
  134.             &rcRect, DDBLTFAST_NOCOLORKEY );
  136. if( ddrval == DD_OK )
  137. {
  138.     break;
  139. }
  140. if( ddrval == DDERR_SURFACELOST )
  141. {
  142.     ddrval = restoreAll();
  143.     if( ddrval != DD_OK )
  144.     {
  145. return;
  146.     }
  147. }
  148. if( ddrval != DDERR_WASSTILLDRAWING )
  149. {
  150.     return;
  151. }
  152.     }
  153.     if(ddrval != DD_OK)
  154.     {
  155.     return;
  156.     }
  158.     for(i=0; i<3; i++)
  159.     {
  160.         rcRect.left   = currentFrame[i]%10*64;
  161.         rcRect.top    = currentFrame[i]/10*64 + 480;
  162.         rcRect.right  = currentFrame[i]%10*64 + 64;
  163.         rcRect.bottom = currentFrame[i]/10*64 + 64 + 480;
  165. while( 1 )
  166. {
  167.     ddrval = lpDDSBack->BltFast( xpos[i], ypos[i], lpDDSOne,
  168.                                  &rcRect, DDBLTFAST_SRCCOLORKEY );
  170.     if( ddrval == DD_OK )
  171.     {
  172. break;
  173.     }
  174.     if( ddrval == DDERR_SURFACELOST )
  175.     {
  176. ddrval = restoreAll();
  177. if( ddrval != DD_OK )
  178. {
  179.     return;
  180. }
  181.     }
  182.     if( ddrval != DDERR_WASSTILLDRAWING )
  183.     {
  184. return;
  185.     }
  186. }
  187.     }
  189.     if( (thisTickCount - lastTickCount[3]) > delay[3] )
  190.     {
  191. // Change the palette
  192. if(lpDDPal->GetEntries( 0, 0, 256, pe ) != DD_OK)
  193. {
  194.     return;
  195. }
  197. for(i=1; i<256; i++)
  198. {
  199.     if(!torusColors[i])
  200.     {
  201. continue;
  202.     }
  203.     pe[i].peRed = (pe[i].peRed+2) % 256;
  204.     pe[i].peGreen = (pe[i].peGreen+1) % 256;
  205.     pe[i].peBlue = (pe[i].peBlue+3) % 256;
  206. }
  207. if(lpDDPal->SetEntries( 0, 0, 256, pe) != DD_OK)
  208. {
  209.     return;
  210. }
  211.     
  212. lastTickCount[3] = thisTickCount;
  213.     }
  214.     
  215.     // Flip the surfaces
  216.     while( 1 )
  217.     {
  218. ddrval = lpDDSPrimary->Flip( NULL, 0 );
  219. if( ddrval == DD_OK )
  220. {
  221.     break;
  222. }
  223. if( ddrval == DDERR_SURFACELOST )
  224. {
  225.     ddrval = restoreAll();
  226.     if( ddrval != DD_OK )
  227.     {
  228. break;
  229.     }
  230. }
  231. if( ddrval != DDERR_WASSTILLDRAWING )
  232. {
  233.     break;
  234. }
  235.     }
  237. } /* updateFrame */
  239. /*
  240.  * finiObjects
  241.  *
  242.  * finished with all objects we use; release them
  243.  */
  244. static void finiObjects( void )
  245. {
  246.     if( lpDD != NULL )
  247.     {
  248. if( lpDDSPrimary != NULL )
  249. {
  250.     lpDDSPrimary->Release();
  251.     lpDDSPrimary = NULL;
  252. }
  253. if( lpDDSOne != NULL )
  254. {
  255.     lpDDSOne->Release();
  256.     lpDDSOne = NULL;
  257. }
  258. if( lpDDPal != NULL )
  259. {
  260.     lpDDPal->Release();
  261.     lpDDPal = NULL;
  262. }
  263. lpDD->Release();
  264. lpDD = NULL;
  265.     }
  267. } /* finiObjects */
  269. long FAR PASCAL WindowProc( HWND hWnd, UINT message, 
  270.     WPARAM wParam, LPARAM lParam )
  271. {
  272.     switch( message )
  273.     {
  274.     case WM_ACTIVATEAPP:
  275.      bActive = wParam;
  276. break;
  278.     case WM_SETCURSOR:
  279.         SetCursor(NULL);
  280.         return TRUE;
  282.     case WM_CREATE:
  283. break;
  285.     case WM_KEYDOWN:
  286. switch( wParam )
  287. {
  288. case VK_ESCAPE:
  289.         case VK_F12:
  290.             PostMessage(hWnd, WM_CLOSE, 0, 0);
  291.     break;
  292. }
  293. break;
  295.     case WM_DESTROY:
  296.      finiObjects();
  297. PostQuitMessage( 0 );
  298. break;
  299.     }
  301.     return DefWindowProc(hWnd, message, wParam, lParam);
  303. } /* WindowProc */
  307. /*
  308.  * This function is called if the initialization function fails
  309.  */
  310. BOOL initFail( HWND hwnd )
  311. {
  312.     finiObjects();
  313.     MessageBox( hwnd, "DirectDraw Init FAILED", TITLE, MB_OK );
  314.     DestroyWindow( hwnd );
  315.     return FALSE;
  317. } /* initFail */
  319. /*
  320.  * doInit - do work required for every instance of the application:
  321.  *   create the window, initialize data
  322.  */
  323. static BOOL doInit( HINSTANCE hInstance, int nCmdShow )
  324. {
  325.     HWND hwnd;
  326.     WNDCLASS wc;
  327.     DDSURFACEDESC ddsd;
  328.     DDSCAPS ddscaps;
  329.     HRESULT ddrval;
  331.     /*
  332.      * set up and register window class
  333.      */
  334.     wc.style = CS_HREDRAW | CS_VREDRAW;
  335.     wc.lpfnWndProc = WindowProc;
  336.     wc.cbClsExtra = 0;
  337.     wc.cbWndExtra = 0;
  338.     wc.hInstance = hInstance;
  339.     wc.hIcon = LoadIcon( hInstance, IDI_APPLICATION );
  340.     wc.hCursor = LoadCursor( NULL, IDC_ARROW );
  341.     wc.hbrBackground = GetStockBrush(BLACK_BRUSH);
  342.     wc.lpszMenuName = NAME;
  343.     wc.lpszClassName = NAME;
  344.     RegisterClass( &wc );
  346.     /*
  347.      * create a window
  348.      */
  349.     hwnd = CreateWindowEx(
  350.         0,
  351. NAME,
  352. TITLE,
  353. WS_POPUP,
  354. 0,
  355. 0,
  356.         GetSystemMetrics(SM_CXSCREEN),
  357.         GetSystemMetrics(SM_CYSCREEN),
  358. NULL,
  359. NULL,
  360. hInstance,
  361.         NULL );
  363.     if( !hwnd )
  364.     {
  365. return FALSE;
  366.     }
  368.     ShowWindow( hwnd, nCmdShow );
  369.     UpdateWindow( hwnd );
  370.     SetFocus( hwnd );
  372.     /*
  373.      * create the main DirectDraw object
  374.      */
  375.     ddrval = DirectDrawCreate( NULL, &lpDD, NULL );
  376.     if( ddrval != DD_OK )
  377.     {
  378. return initFail(hwnd);
  379.     }
  381.     // Get exclusive mode
  382.     ddrval = lpDD->SetCooperativeLevel( hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
  383.     if( ddrval != DD_OK )
  384.     {
  385. return initFail(hwnd);
  386.     }
  388.     // Set the video mode to 640x480x8
  389.     ddrval = lpDD->SetDisplayMode( 640, 480, 8);
  390.     if(ddrval != DD_OK)
  391.     {
  392. return initFail(hwnd);
  393.     }
  395.     // Create the primary surface with 1 back buffer
  396.     ddsd.dwSize = sizeof( ddsd );
  397.     ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  398.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE |
  399.   DDSCAPS_FLIP |
  400.   DDSCAPS_COMPLEX;
  401.     ddsd.dwBackBufferCount = 1;
  402.     ddrval = lpDD->CreateSurface( &ddsd, &lpDDSPrimary, NULL );
  403.     if( ddrval != DD_OK )
  404.     {
  405. return initFail(hwnd);
  406.     }
  408.     ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  409.     ddrval = lpDDSPrimary->GetAttachedSurface(&ddscaps, &lpDDSBack);
  410.     if( ddrval != DD_OK )
  411.     {
  412. return initFail(hwnd);
  413.     }
  415.     // create and set the palette
  416.     lpDDPal = DDLoadPalette(lpDD, szBitmap);
  418.     if (lpDDPal)
  419.         lpDDSPrimary->SetPalette(lpDDPal);
  421.     // Create the offscreen surface, by loading our bitmap.
  422.     lpDDSOne = DDLoadBitmap(lpDD, szBitmap, 0, 0);
  424.     if( lpDDSOne == NULL )
  425.     {
  426. return initFail(hwnd);
  427.     }
  429.     // set the color key to black
  430.     DDSetColorKey(lpDDSOne, RGB(0,0,0));
  432.     //
  433.     // Mark the colors used in the torus frames
  434.     //
  435.     int i,x,y;
  437.     // First, set all colors as unused
  438.     for(i=0; i<256; i++)
  439.     {
  440.         torusColors[i] = 0;
  441.     }
  443.     // lock the surface and scan the lower part (the torus area)
  444.     // and remember all the index's we find.
  445.     ddsd.dwSize = sizeof(ddsd);
  446.     while (lpDDSOne->Lock(NULL, &ddsd, 0, NULL) == DDERR_WASSTILLDRAWING)
  447.         ;
  449.     // Now search through the torus frames and mark used colors
  450.     for( y=480; y<480+384; y++ )
  451.     {
  452.         for( x=0; x<640; x++ )
  453.         {
  454.             torusColors[((BYTE *)ddsd.lpSurface)[y*ddsd.lPitch+x]] = 1;
  455.         }
  456.     }
  458.     lpDDSOne->Unlock(NULL);
  460.     return TRUE;
  462. } /* doInit */
  464. /*
  465.  * WinMain - initialization, message loop
  466.  */
  467. int PASCAL WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
  468. LPSTR lpCmdLine, int nCmdShow)
  469. {
  470.     MSG msg;
  472.     lpCmdLine = lpCmdLine;
  473.     hPrevInstance = hPrevInstance;
  475.     if( !doInit( hInstance, nCmdShow ) )
  476.     {
  477. return FALSE;
  478.     }
  480.     while( 1 )
  481.     {
  482. if( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
  483. {
  484.     if( !GetMessage( &msg, NULL, 0, 0 ) )
  485.     {
  486. return msg.wParam;
  487.     }
  488.     TranslateMessage(&msg); 
  489.     DispatchMessage(&msg);
  490. }
  491. else if( bActive )
  492. {
  493.     updateFrame();
  494.         }
  495.         else
  496.         {
  497.             // make sure we go to sleep if we have nothing else to do
  498.             WaitMessage();
  499.         }
  500.     }
  501. } /* WinMain */