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