home *** CD-ROM | disk | FTP | other *** search
/ Total Destruction / Total_Destruction.iso / addons / Lccwin32.exe / Lccwin32 / lccpub / demo / ddraw / wormhole / wormhole.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-08  |  10.7 KB  |  438 lines
  1. /***************************************************************************
  2.  *  Copyright (C) 1995-1996 Microsoft Corporation. All Rights Reserved.
  3.  ***************************************************************************/
  4. #define _WCHAR_T_DEFINED
  5. #include <windows.h>
  6. #include "ddraw.h"
  7.  
  8. HWND            hWnd;
  9. PALETTEENTRY    pe[256];
  10. BOOL            bActive;                                            
  11. BOOL            bIsInitialized=FALSE;
  12.  
  13. LPDIRECTDRAW            lpDD;           
  14. LPDIRECTDRAWSURFACE     lpDDSPrimary;   
  15. LPDIRECTDRAWSURFACE     lpDDSOne;       
  16. LPDIRECTDRAWCLIPPER     lpClipper;      
  17. LPDIRECTDRAWPALETTE     lpDDPal;        
  18.  
  19. BOOL restoreAll();
  20. void updateFrame();
  21. static void finiObjects();
  22. long FAR PASCAL WindowProc(HWND,UINT,WPARAM,LPARAM);
  23. BOOL initFail(HWND);
  24. static BOOL doInit(HINSTANCE, int);
  25. void CyclePalette();
  26. BOOL readBMPIntoSurfaces();
  27. int PASCAL WinMain(HINSTANCE,HINSTANCE,LPSTR,int);
  28.  
  29. BOOL restoreAll()
  30. {
  31.     BOOL bResult;
  32.  
  33.     bResult=IDirectDrawSurface_Restore(lpDDSPrimary) == DD_OK &&
  34.             IDirectDrawSurface_Restore(lpDDSOne)     == DD_OK;
  35.  
  36.     readBMPIntoSurfaces();
  37.  
  38.     return(bResult);
  39. } 
  40.  
  41. void updateFrame()
  42. {
  43.     RECT                rcRect;
  44.     RECT                destRect;
  45.     HRESULT             ddrval;
  46.     POINT               pt;
  47.  
  48.     rcRect.left=0;
  49.     rcRect.top=0;
  50.     rcRect.right=640;
  51.     rcRect.bottom=480;
  52.  
  53.     GetClientRect(hWnd,&destRect);
  54.  
  55.     pt.x=pt.y=0;
  56.     ClientToScreen(hWnd,&pt);
  57.     OffsetRect(&destRect,pt.x,pt.y);
  58.  
  59.     while(1)
  60.     {
  61.         ddrval=IDirectDrawSurface_Blt(lpDDSPrimary,&destRect,lpDDSOne,&rcRect,0,NULL);
  62.  
  63.         if(ddrval==DD_OK)
  64.         {
  65.             break;
  66.         }
  67.         if(ddrval==DDERR_SURFACELOST)
  68.         {
  69.             if(!restoreAll())
  70.             {
  71.                 return;
  72.             }
  73.             continue;
  74.         }
  75.         if(ddrval!=DDERR_WASSTILLDRAWING)
  76.         {
  77.             return;
  78.         }
  79.     }
  80. } 
  81.  
  82. static void finiObjects()
  83. {
  84.     if(lpDD!=NULL)
  85.     {
  86.         if(lpDDSPrimary!=NULL)
  87.         {
  88.             IDirectDrawSurface_Release(lpDDSPrimary);
  89.             lpDDSPrimary=NULL;
  90.         }
  91.         if(lpDDSOne!=NULL)
  92.         {
  93.             IDirectDrawSurface_Release(lpDDSOne);
  94.             lpDDSOne=NULL;
  95.         }
  96.         if(lpDDPal!=NULL)
  97.         {
  98.             IDirectDrawSurface_Release(lpDDPal);
  99.             lpDDPal=NULL;
  100.         }
  101.         IDirectDrawSurface_Release(lpDD);
  102.         lpDD=NULL;
  103.     }
  104. } 
  105.  
  106. long FAR PASCAL WindowProc(HWND hWnd,UINT message, 
  107.                            WPARAM wParam,LPARAM lParam )
  108. {
  109.     switch(message)
  110.     {
  111.         case WM_ACTIVATE:
  112.             bActive = wParam;
  113.             break;
  114.  
  115.         case WM_CREATE:
  116.  
  117.             break;
  118.  
  119.         case WM_SETCURSOR:
  120.  
  121.             SetCursor(NULL);
  122.             if( bIsInitialized )
  123.             {
  124.                 updateFrame();
  125.                 IDirectDrawPalette_GetEntries(lpDDPal,0,0,256,pe);
  126.             }
  127.             break;
  128.  
  129.         case WM_KEYDOWN:
  130.  
  131.             switch(wParam)
  132.             {
  133.                 case VK_ESCAPE:
  134.                 
  135.                 case VK_F12:
  136.                     
  137.                     PostMessage(hWnd,WM_CLOSE,0,0);
  138.                     break;
  139.             }
  140.             break;
  141.   
  142.         case WM_DESTROY:
  143.  
  144.             finiObjects();
  145.             PostQuitMessage(0);
  146.             break;
  147.     }
  148.     return DefWindowProc(hWnd,message,wParam,lParam);
  149. } 
  150.  
  151. BOOL initFail(HWND hWnd)
  152. {
  153.     finiObjects();
  154.     MessageBox(hWnd,"DirectDraw Init FAILED","WormHole",MB_OK);
  155.     DestroyWindow(hWnd);
  156.     return FALSE;
  157. } 
  158.  
  159. static BOOL doInit(HINSTANCE hInstance,int nCmdShow)
  160. {
  161.     WNDCLASS            wc;
  162.     DDSURFACEDESC       ddsd;
  163.     HRESULT             ddrval;
  164.  
  165.     wc.style=          CS_HREDRAW|CS_VREDRAW;
  166.     wc.lpfnWndProc=    WindowProc;
  167.     wc.cbClsExtra=     0;
  168.     wc.cbWndExtra=     0;
  169.     wc.hInstance=      hInstance;
  170.     wc.hIcon=          LoadIcon(hInstance,IDI_APPLICATION);
  171.     wc.hCursor=        LoadCursor(NULL,IDC_ARROW);
  172.     wc.hbrBackground=  NULL;
  173.     wc.lpszMenuName=   NULL;
  174.     wc.lpszClassName=  "WormHole";
  175.     RegisterClass(&wc);
  176.     
  177.     hWnd=CreateWindowEx(
  178.         0,
  179.         "WormHole",
  180.         "WormHole",
  181.         WS_POPUP,
  182.         0,
  183.         0,
  184.         GetSystemMetrics(SM_CXSCREEN),
  185.         GetSystemMetrics(SM_CYSCREEN),
  186.         NULL,
  187.         NULL,
  188.         hInstance,
  189.         NULL );
  190.  
  191.     if(!hWnd)
  192.     {
  193.         return FALSE;
  194.     }
  195.  
  196.     ShowWindow(hWnd,nCmdShow);
  197.     UpdateWindow(hWnd);
  198.  
  199.     ddrval=DirectDrawCreate(NULL,&lpDD,NULL);
  200.  
  201.     if(ddrval!=DD_OK)
  202.     {
  203.         return initFail(hWnd);
  204.     }
  205.  
  206.     ddrval=IDirectDraw_SetCooperativeLevel(lpDD,hWnd,DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN);
  207.     ddrval=IDirectDraw_SetDisplayMode(lpDD,640,480,8);
  208.  
  209.     if(ddrval!=DD_OK)
  210.     {
  211.         return initFail(hWnd);
  212.     }
  213.  
  214.     ddsd.dwSize=sizeof(ddsd);
  215.     ddsd.dwFlags=DDSD_CAPS;
  216.     ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE;
  217.  
  218.     ddrval=IDirectDraw_CreateSurface(lpDD,&ddsd,&lpDDSPrimary,NULL);
  219.  
  220.     if(ddrval!=DD_OK)
  221.     {
  222.         return initFail(hWnd);
  223.     }
  224.  
  225.     ddsd.dwSize=sizeof(ddsd);
  226.     ddsd.dwFlags=DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH;
  227.     ddsd.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN;
  228.     ddsd.dwWidth=640;
  229.     ddsd.dwHeight=480;
  230.  
  231.     IDirectDraw_CreateSurface(lpDD,&ddsd,&lpDDSOne,NULL);    
  232.     if(lpDDSOne==NULL)
  233.     {
  234.         return initFail(hWnd);
  235.     }
  236.  
  237.     bIsInitialized = TRUE;
  238.     return TRUE;
  239. } 
  240.  
  241. void CyclePalette()
  242. {
  243.     int                 reg[15];
  244.     int                 k;
  245.        
  246.     for(k=0;k<15;k++)
  247.     {
  248.         reg[k]=pe[k+30].peRed;
  249.     }
  250.     for(k=45;k<255;k++)
  251.     {                                                            
  252.         pe[k-15].peRed=pe[k].peRed;
  253.     }
  254.     for(k=0;k<15;k++)
  255.     {
  256.         pe[k+240].peRed=reg[k];
  257.     }
  258.     for(k=0;k<15;k++)
  259.     {
  260.         reg[k]=pe[k+30].peGreen;
  261.     }
  262.     for(k=45;k<255;k++)
  263.     {
  264.         pe[k-15].peGreen=pe[k].peGreen;
  265.     }
  266.     for(k=0;k<15;k++)
  267.     {
  268.         pe[k+240].peGreen=reg[k];
  269.     }
  270.     for(k=0;k<15;k++)
  271.     {
  272.         reg[k]=pe[k+30].peBlue;
  273.     }
  274.     for(k=45;k<255;k++)
  275.     {
  276.         pe[k-15].peBlue=pe[k].peBlue;
  277.     }
  278.     for(k=0;k<15;k++)
  279.     {
  280.         pe[k+240].peBlue=reg[k];
  281.     }
  282.  
  283.     for(k=2;k<17;k++)
  284.     {
  285.         reg[k-2]=pe[15*k+14].peRed;
  286.         pe[15*k+14].peRed=pe[15*k+13].peRed;
  287.         pe[15*k+13].peRed=pe[15*k+12].peRed;
  288.         pe[15*k+12].peRed=pe[15*k+11].peRed;
  289.         pe[15*k+11].peRed=pe[15*k+10].peRed;
  290.         pe[15*k+10].peRed=pe[15*k+9].peRed;
  291.         pe[15*k+9].peRed=pe[15*k+8].peRed;
  292.         pe[15*k+8].peRed=pe[15*k+7].peRed;
  293.         pe[15*k+7].peRed=pe[15*k+6].peRed;
  294.         pe[15*k+6].peRed=pe[15*k+5].peRed;
  295.         pe[15*k+5].peRed=pe[15*k+4].peRed;
  296.         pe[15*k+4].peRed=pe[15*k+3].peRed;
  297.         pe[15*k+3].peRed=pe[15*k+2].peRed;
  298.         pe[15*k+2].peRed=pe[15*k+1].peRed;
  299.         pe[15*k+1].peRed=pe[15*k].peRed;
  300.         pe[15*k].peRed=reg[k-2];
  301.         reg[k-2]=pe[15*k+14].peGreen;
  302.         pe[15*k+14].peGreen=pe[15*k+13].peGreen;
  303.         pe[15*k+13].peGreen=pe[15*k+12].peGreen;
  304.         pe[15*k+12].peGreen=pe[15*k+11].peGreen;
  305.         pe[15*k+11].peGreen=pe[15*k+10].peGreen;
  306.         pe[15*k+10].peGreen=pe[15*k+9].peGreen;
  307.         pe[15*k+9].peGreen=pe[15*k+8].peGreen;
  308.         pe[15*k+8].peGreen=pe[15*k+7].peGreen;
  309.         pe[15*k+7].peGreen=pe[15*k+6].peGreen;
  310.         pe[15*k+6].peGreen=pe[15*k+5].peGreen;
  311.         pe[15*k+5].peGreen=pe[15*k+4].peGreen;
  312.         pe[15*k+4].peGreen=pe[15*k+3].peGreen;
  313.         pe[15*k+3].peGreen=pe[15*k+2].peGreen;
  314.         pe[15*k+2].peGreen=pe[15*k+1].peGreen;
  315.         pe[15*k+1].peGreen=pe[15*k].peGreen;
  316.         pe[15*k].peGreen=reg[k-2];
  317.         reg[k-2]=pe[15*k+14].peBlue;
  318.         pe[15*k+14].peBlue=pe[15*k+13].peBlue;
  319.         pe[15*k+13].peBlue=pe[15*k+12].peBlue;
  320.         pe[15*k+12].peBlue=pe[15*k+11].peBlue;
  321.         pe[15*k+11].peBlue=pe[15*k+10].peBlue;
  322.         pe[15*k+10].peBlue=pe[15*k+9].peBlue;
  323.         pe[15*k+9].peBlue=pe[15*k+8].peBlue;
  324.         pe[15*k+8].peBlue=pe[15*k+7].peBlue;
  325.         pe[15*k+7].peBlue=pe[15*k+6].peBlue;
  326.         pe[15*k+6].peBlue=pe[15*k+5].peBlue;
  327.         pe[15*k+5].peBlue=pe[15*k+4].peBlue;
  328.         pe[15*k+4].peBlue=pe[15*k+3].peBlue;
  329.         pe[15*k+3].peBlue=pe[15*k+2].peBlue;
  330.         pe[15*k+2].peBlue=pe[15*k+1].peBlue;
  331.         pe[15*k+1].peBlue=pe[15*k].peBlue;
  332.         pe[15*k].peBlue=reg[k-2];
  333.     }
  334.             
  335.     IDirectDraw_WaitForVerticalBlank(lpDD,DDWAITVB_BLOCKBEGIN,NULL);
  336.  
  337.     if(IDirectDrawPalette_SetEntries(lpDDPal,0,0,256,pe)!=DD_OK)
  338.     {
  339.         return;
  340.     }
  341. }
  342.  
  343. BOOL readBMPIntoSurfaces()
  344. {
  345.     HRESULT             ddrval;
  346.     HRSRC               hBMP;
  347.     RGBQUAD             Palette[256];
  348.     PALETTEENTRY        pe[256];
  349.     DDSURFACEDESC       DDSDesc;
  350.     LPSTR               lpBits;
  351.     LPSTR               lpSrc;
  352.     BYTE                *lpBMP;
  353.     int                 i;
  354.  
  355.     hBMP=FindResource(NULL,MAKEINTRESOURCE(10),RT_BITMAP);    
  356.     if( hBMP == NULL )
  357.     {
  358.         return FALSE;
  359.     }
  360.  
  361.     lpBMP=(BYTE *)LockResource(LoadResource(NULL, hBMP));
  362.     
  363.     memcpy(Palette,&lpBMP[sizeof(BITMAPINFOHEADER)],sizeof(Palette));
  364.  
  365.     FreeResource(hBMP);
  366.  
  367.     for(i=0;i<256;i++)
  368.     {
  369.         pe[i].peRed=Palette[i].rgbRed;
  370.         pe[i].peGreen=Palette[i].rgbGreen;
  371.         pe[i].peBlue=Palette[i].rgbBlue;
  372.     }   
  373.  
  374.     ddrval=IDirectDraw_CreatePalette(lpDD,DDPCAPS_8BIT,pe,&lpDDPal,NULL);
  375.  
  376.     if(ddrval!=DD_OK)
  377.     {
  378.         return FALSE;
  379.     }
  380.  
  381.     IDirectDrawSurface_SetPalette(lpDDSPrimary,lpDDPal);
  382.  
  383.     DDSDesc.dwSize=sizeof(DDSDesc);
  384.     ddrval=IDirectDrawSurface_Lock(lpDDSOne,NULL,&DDSDesc,0,NULL);
  385.     if(ddrval!=DD_OK)
  386.     {
  387.         return FALSE;
  388.     }
  389.  
  390.     lpBits=(LPSTR)DDSDesc.lpSurface;
  391.     lpSrc=(LPSTR)
  392.           (&lpBMP[sizeof(BITMAPINFOHEADER)+sizeof(Palette)+(640*480)]);
  393.     for(i=0;i<480;i++)
  394.     {
  395.         memcpy(lpBits,lpSrc,640);
  396.         lpBits+=DDSDesc.lPitch;
  397.         lpSrc-=640;
  398.     }
  399.     IDirectDrawSurface_Unlock(lpDDSOne,NULL);
  400.  
  401.     return TRUE;
  402. }
  403.  
  404. int PASCAL WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
  405.                    LPSTR lpCmdLine,int nCmdShow)
  406. {
  407.     MSG         msg;
  408.  
  409.     if(!doInit(hInstance,nCmdShow))
  410.     {
  411.         return FALSE;
  412.     }
  413.  
  414.     readBMPIntoSurfaces();    
  415.     updateFrame();
  416.  
  417.     while(1)
  418.     {
  419.         if(PeekMessage(&msg,NULL,0,0,PM_NOREMOVE))
  420.         {
  421.             if(!GetMessage(&msg,NULL,0,0))
  422.             {
  423.                 return msg.wParam;
  424.             }
  425.             TranslateMessage(&msg);
  426.             DispatchMessage(&msg);
  427.         }
  428.         else if(bActive)
  429.         {
  430.             CyclePalette();
  431.         }
  432.         else
  433.         {
  434.             WaitMessage();
  435.         }
  436.     }
  437. } 
  438.