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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
ddcalls.cpp
资源名称：3D_OnlineGame_Humen.rar　[点击查看]
上传用户：garry_shen
上传日期：2015-04-15
资源大小：45647k
文件大小：33k
源码类别：

游戏引擎

开发平台：

Visual C++

ddcalls.cpp：源码内容
  1. /*
  2. *  Copyright (C) 1998 Microsoft Corporation. All Rights Reserved.
  3. *
  4. *  File: ddcalls.c
  5. *
  6. *  Manages DirectDraw objects needed for rendering.  Part of D3DApp.
  7. *
  8. *  D3DApp is a collection of helper functions for Direct3D applications.
  9. *  D3DApp consists of the following files:
  10. *      d3dapp.h    Main D3DApp header to be included by application
  11. *      d3dappi.h   Internal header
  12. *      d3dapp.c    D3DApp functions seen by application.
  13. *      ddcalls.c   All calls to DirectDraw objects except textures
  14. *      d3dcalls.c  All calls to Direct3D objects except textures
  15. *      texture.c   Texture loading and managing texture list
  16. *      misc.c      Miscellaneous calls
  17. */
  19. // Borland CBuilder3 doesn't support nameless unions...
  20. #include "stdafx.h"
  21. #include "XMudClient.h"
  22. #include "d3dappi.h"
  24. /***************************************************************************/
  25. /*                         Direct Draw Enumeration                         */
  26. /***************************************************************************/
  28. typedef struct {
  29.   D3DAppDDDriver* driver;
  30.   int             numdriver;
  31. } DDEnumCallbackContext;
  33. /*
  34. * D3DAppIDDEnumCallback
  35. * Callback function used during enumeration of DirectDraw drivers.
  36. */
  37. BOOL FAR PASCAL D3DAppIDDEnumCallback(GUID FAR* lpGUID, LPSTR lpDriverDesc, LPSTR lpDriverName, LPVOID lpContext)
  38. {
  39.   LPDIRECTDRAW lpDD;
  40.   DDCAPS DriverCaps, HELCaps;
  41.   DDEnumCallbackContext *context = (DDEnumCallbackContext*)lpContext;
  42.   D3DAppDDDriver* driver = &context->driver[context->numdriver];
  43.   
  44.   /*
  45.   * Create the DirectDraw device using this driver.  If it fails,
  46.   * just move on to the next driver.
  47.   */
  48. #ifdef _DIRECTX7
  49.   if (FAILED(DirectDrawCreateEx(lpGUID, (LPVOID *)&lpDD, IID_IDirectDraw7, NULL))) {
  50.     return DDENUMRET_OK;
  51.   }
  52. #else
  53.   if (FAILED(DirectDrawCreate(lpGUID, &lpDD, NULL))) {
  54.     return DDENUMRET_OK;
  55.   }
  56. #endif
  57.   /*
  58.   * Get the capabilities of this DirectDraw driver.  If it fails,
  59.   * just move on to the next driver.
  60.   */
  61.   memset(&DriverCaps, 0, sizeof(DDCAPS));
  62.   DriverCaps.dwSize = sizeof(DDCAPS);
  63.   memset(&HELCaps, 0, sizeof(DDCAPS));
  64.   HELCaps.dwSize = sizeof(DDCAPS);
  65.   if (FAILED(lpDD->GetCaps(&DriverCaps, &HELCaps)))
  66.   {
  67.     lpDD->Release( );
  68.     return DDENUMRET_OK;
  69.   }
  70.   if (lpGUID && (DriverCaps.dwCaps & DDCAPS_3D))
  71.   {
  72.   /*
  73.   * We have found a secondary 3d hardware device.  Return the DD object
  74.   * and stop enumeration.
  75.     */
  76.     memcpy(&driver->Guid, lpGUID, sizeof(GUID));
  77.     memcpy(&driver->HWCaps, &DriverCaps, sizeof(DDCAPS));
  78.     lstrcpy(driver->Name, lpDriverName);
  79.     driver->bIsPrimary = FALSE;
  80.     context->numdriver++;
  81.   } else {
  82.   /*
  83.   * It's the primary, fill in some fields.
  84.     */
  85.     memset(&driver->Guid, 0, sizeof(GUID));
  86.     memcpy(&driver->HWCaps, &DriverCaps, sizeof(DDCAPS));
  87.     lstrcpy(driver->Name, "Primary Device");
  88.     driver->bIsPrimary = TRUE;
  89.     context->numdriver++;
  90.   }
  91.   lpDD->Release( );
  92.   if (context->numdriver >= D3DAPP_MAXDDDRIVERS)
  93.     return DDENUMRET_CANCEL;
  94.   else
  95.     return DDENUMRET_OK;
  96. }
  98. /*
  99. * D3DAppIEnumDDDevices
  100. * Enumerate all 3D capable devices and the primary display, filling in
  101. * the driver information variables.  lpDriver must point to a region
  102. * with enough room for the maximum DD drivers.
  103. */
  104. BOOL
  105. D3DAppIEnumDDDevices(int* NumDriver, D3DAppDDDriver* lpDriver)
  106. {
  107.   DDEnumCallbackContext context;
  108.   
  109.   context.numdriver = 0;
  110.   context.driver = lpDriver;
  111.   LastError = DirectDrawEnumerate(D3DAppIDDEnumCallback, &context);
  112.   if (LastError != DD_OK) {
  113.     D3DAppISetErrorString("DirectDrawEnumerate failed.n%s",
  114.       D3DAppErrorToString(LastError));
  115.     return FALSE;
  116.   }
  117.   *NumDriver = context.numdriver;
  118.   return TRUE;
  119. }
  121. /***************************************************************************/
  122. /*                         Direct Draw Creation                            */
  123. /***************************************************************************/
  125. /*
  126. * D3DAppICreateDD
  127. * Creates the DirectDraw device and saves the current palette.
  128. * It is assumed that a 3D capable secondary DD driver is not the
  129. * primary device and hence cannot operate in a window (ie it's a
  130. * fullscreen only device displaying on a second monitor).  Valid flags:
  131. *     D3DAPP_ONLYDDEMULATION    Always use the DirectDraw HEL
  132. */
  133. BOOL D3DAppICreateDD(DWORD flags, LPGUID lpGuid)
  134. {
  135.   HDC hdc;
  136.   int i;
  137.   LPDIRECTDRAW lpDD = NULL;
  138.   
  139.   if (flags & D3DAPP_ONLYDDEMULATION)
  140.     lpGuid = NULL;
  141.   
  142.   if (!lpGuid)
  143.     d3dappi.bIsPrimary = TRUE;
  144.   else
  145.     d3dappi.bIsPrimary = FALSE;
  146.   //*/
  148. #ifdef _DIRECTX7
  149.   LastError = DirectDrawCreateEx(lpGuid, (LPVOID *)&d3dappi.lpDD, IID_IDirectDraw7, NULL);
  150. #else
  151.   LastError = DirectDrawCreate(lpGuid, &d3dappi.lpDD, NULL);
  152. #endif
  153.   if (LastError != DD_OK) {
  154.     D3DAppISetErrorString("DirectDrawCreate failed.n%s",
  155.       D3DAppErrorToString(LastError));
  156.     return FALSE;
  157.   }
  158.   /*/
  159.   LastError = DirectDrawCreate(lpGuid, &lpDD, NULL);
  160.   if (LastError != DD_OK)
  161.   {
  162.   D3DAppISetErrorString("DirectDrawCreate failed.n%s",
  163.   D3DAppErrorToString(LastError));
  164.   return FALSE;
  165.   }
  166.   
  167.     LastError = lpDD->QueryInterface( IID_IDirectDraw, (VOID**)&d3dappi.lpDD );
  168.     if (LastError != DD_OK)
  169.     {
  170.     lpDD->Release();
  171.     D3DAppISetErrorString("Couldn't query for DirectDraw4.n%s",
  172.     D3DAppErrorToString(LastError));
  173.     return FALSE;
  174.     }
  175.     lpDD->Release();
  176.   //*/
  177.   //
  178.   // Save the original palette for when we are paused.  Just in case we
  179.   // start in a fullscreen mode, put them in ppe.
  180.   //
  181.   hdc = GetDC(NULL);
  182.   GetSystemPaletteEntries(hdc, 0, (1 << 8),
  183.     (LPPALETTEENTRY)(&Originalppe[0]));
  184.   for (i = 0; i < 256; i++)
  185.     ppe[i] = Originalppe[i];
  186.   ReleaseDC(NULL, hdc);
  187.   return TRUE;
  188. }
  190. /***************************************************************************/
  191. /*                   Enumerating the display modes                         */
  192. /***************************************************************************/
  193. /*
  194. * EnumDisplayModesCallback
  195. * Callback to save the display mode information.
  196. */
  197. static HRESULT
  198. CALLBACK EnumDisplayModesCallback(LPDDSURFACEDESC pddsd, LPVOID lpContext)
  199. {
  200. /*
  201. * Very large resolutions cause problems on some hardware.  They are also
  202. * not very useful for real-time rendering.  We have chosen to disable
  203. * them by not reporting them as available.
  204.   */
  205.   if (pddsd->dwWidth > 1024 || pddsd->dwHeight > 768)
  206.     return DDENUMRET_OK;
  207.     /*
  208.     * Save this mode at the end of the mode array and increment mode count
  209.   */
  210.   d3dappi.Mode[d3dappi.NumModes].w = pddsd->dwWidth;
  211.   d3dappi.Mode[d3dappi.NumModes].h = pddsd->dwHeight;
  212.   d3dappi.Mode[d3dappi.NumModes].bpp = pddsd->ddpfPixelFormat.dwRGBBitCount;
  213.   d3dappi.Mode[d3dappi.NumModes].bThisDriverCanDo = FALSE;
  214.   d3dappi.NumModes++;
  215.   if (d3dappi.NumModes == D3DAPP_MAXMODES)
  216.     return DDENUMRET_CANCEL;
  217.   else
  218.     return DDENUMRET_OK;
  219. }
  221. /*
  222. * CompareModes
  223. * Compare two display modes during sorting.  Modes are sorted by depth and
  224. * then resolution.
  225. */
  226. static int
  227. _cdecl CompareModes(const void* element1, const void* element2) {
  228.   D3DAppMode *lpMode1, *lpMode2;
  229.   
  230.   lpMode1 = (D3DAppMode*)element1;
  231.   lpMode2 = (D3DAppMode*)element2;
  232.   
  233.   if (lpMode1->bpp > lpMode2->bpp)
  234.     return -1;
  235.   else if (lpMode2->bpp > lpMode1->bpp)
  236.     return 1;
  237.   else if (lpMode1->w > lpMode2->w)
  238.     return -1;
  239.   else if (lpMode2->w > lpMode1->w)
  240.     return 1;
  241.   else if (lpMode1->h > lpMode2->h)
  242.     return -1;
  243.   else if (lpMode2->h > lpMode1->h)
  244.     return 1;
  245.   else
  246.     return 0;
  247. }
  249. /*
  250. * EnumerateDisplayModes
  251. * Generates the list of available display modes.
  252. */
  253. BOOL D3DAppIEnumDisplayModes(void)
  254. {
  255.   int i;
  256.   /*
  257.   * Get a list of available display modes from DirectDraw
  258.   */
  259.   d3dappi.NumModes = 0;
  260.   LastError = d3dappi.lpDD->EnumDisplayModes( 0, NULL, 0, EnumDisplayModesCallback);
  261.   if(LastError != DD_OK ) {
  262.     D3DAppISetErrorString("EnumDisplayModes failed.n%s",
  263.       D3DAppErrorToString(LastError));
  264.     d3dappi.NumModes = 0;
  265.     return FALSE;
  266.   }
  267.   /*
  268.   * Sort the list of display modes
  269.   */
  270.   qsort((void *)&d3dappi.Mode[0], (size_t)d3dappi.NumModes, sizeof(D3DAppMode),
  271.     CompareModes);
  272.     /*
  273.     * Pick a default display mode.  640x480x16 is a very good mode for
  274.     * rendering, so choose it over all others.  Otherwise, just take the
  275.     * first one.  This selection may be overriden later if a driver is
  276.     * created which cannot render in this mode.
  277.   */
  278.   d3dappi.CurrMode = 0;
  279.   for (i = 0; i < d3dappi.NumModes; i++) {
  280.     if (d3dappi.Mode[i].w == DEFULTWND_WIDTH && d3dappi.Mode[i].h == DEFULTWND_HEIGHT &&
  281.       d3dappi.Mode[i].bpp == 16)
  282.       d3dappi.CurrMode = i;
  283.   }
  284.   memcpy(&d3dappi.ThisMode, &d3dappi.Mode[d3dappi.CurrMode],
  285.     sizeof(D3DAppMode));
  286.   return TRUE;
  287. }
  289. /***************************************************************************/
  290. /*               Creating Front and Back Buffers (and misc surf funcs)     */
  291. /***************************************************************************/
  292. //
  293. // D3DAppICreateSurface
  294. // Create a DirectDraw Surface of the given description.  Using this function
  295. // ensures that all surfaces end up in system memory if that option was set.
  296. // Returns the result of the CreateSurface call.
  297. //
  298. HRESULT D3DAppICreateSurface(LPDDSURFACEDESC lpDDSurfDesc,
  299.                              LPDIRECTDRAWSURFACE FAR *lpDDSurface)
  300. {
  301.   HRESULT result;
  302.   if (d3dappi.bOnlySystemMemory)
  303.     lpDDSurfDesc->ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  304.   result = d3dappi.lpDD->CreateSurface(lpDDSurfDesc,
  305.     lpDDSurface, NULL);
  306.   return result;
  307. }
  309. /*
  310. * D3DAppIGetSurfDesc
  311. * Get the description of the given surface.  Returns the result of the
  312. * GetSurfaceDesc call.
  313. */
  314. HRESULT
  315. D3DAppIGetSurfDesc(LPDDSURFACEDESC lpDDSurfDesc,LPDIRECTDRAWSURFACE lpDDSurf)
  316. {
  317.   HRESULT result;
  318.   memset(lpDDSurfDesc, 0, sizeof(DDSURFACEDESC));
  319.   lpDDSurfDesc->dwSize = sizeof(DDSURFACEDESC);
  320.   result = lpDDSurf->GetSurfaceDesc(lpDDSurfDesc);
  321.   return result;
  322. }
  324. /*
  325. * D3DAppICreateBuffers
  326. * Creates the front and back buffers for the window or fullscreen case
  327. * depending on the bFullscreen flag.  In the window case, bpp is ignored.
  328. */
  329. BOOL D3DAppICreateBuffers(HWND hwnd, int w, int h, int bpp, BOOL bFullscreen, BOOL bIsHardware)
  330. {
  331.   DDSURFACEDESC ddsd;
  332.   DDSCAPS ddscaps;
  333.   
  334.   /*
  335.   * Release any old objects that might be lying around.  This should have
  336.   * already been taken care of, but just in case...
  337.   */
  338.   RELEASE(lpClipper);
  339.   RELEASE(d3dappi.lpBackBuffer);
  340.   RELEASE(d3dappi.lpFrontBuffer);
  341.   /*
  342.   * The size of the buffers is going to be w x h, so record it now
  343.   */
  344.   if (w < D3DAPP_WINDOWMINIMUM)
  345.     w = D3DAPP_WINDOWMINIMUM;
  346.   if (h < D3DAPP_WINDOWMINIMUM)
  347.     h = D3DAPP_WINDOWMINIMUM;
  348.   szBuffers.cx = w;
  349.   szBuffers.cy = h;
  350.   
  351.   if (bFullscreen)
  352.   {
  353.     //
  354.     // Create a complex flipping surface for fullscreen mode with one
  355.     // back buffer.
  356.     //
  357.     memset(&ddsd,0,sizeof(ddsd));
  358.     ddsd.dwSize = sizeof(ddsd);
  359.     ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
  360.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
  361.       DDSCAPS_3DDEVICE | DDSCAPS_COMPLEX;
  362.     ddsd.dwBackBufferCount = 1;
  363.     if (bIsHardware)
  364.       ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
  365.     LastError = D3DAppICreateSurface(&ddsd, &d3dappi.lpFrontBuffer);
  366.     if(LastError != DD_OK) {
  367.       if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
  368.         D3DAppISetErrorString("There was not enough video memory to create the rendering surface.nPlease restart the program and try another fullscreen mode with less resolution or lower bit depth.");
  369.       } else {
  370.         D3DAppISetErrorString("CreateSurface for fullscreen flipping surface failed.n%s",
  371.           D3DAppErrorToString(LastError));
  372.       }
  373.       goto exit_with_error;
  374.     }
  375.     //
  376.     // Obtain a pointer to the back buffer surface created above so we
  377.     // can use it later.  For now, just check to see if it ended up in
  378.     // video memory (FYI).
  379.     //
  380.     ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
  381.     LastError = d3dappi.lpFrontBuffer->GetAttachedSurface(&ddscaps, &d3dappi.lpBackBuffer);
  382.     if(LastError != DD_OK)
  383.     {
  384.       D3DAppISetErrorString("GetAttachedSurface failed to get back buffer.n%s",
  385.         D3DAppErrorToString(LastError));
  386.       goto exit_with_error;
  387.     }
  388.     LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
  389.     if (LastError != DD_OK) {
  390.       D3DAppISetErrorString("Failed to get surface description of back buffer.n%s",
  391.         D3DAppErrorToString(LastError));
  392.       goto exit_with_error;
  393.     }
  394.     d3dappi.bBackBufferInVideo =
  395.       (ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) ? TRUE : FALSE;
  396.   }
  397.   else {
  398.     //
  399.     // In the window case, create a front buffer which is the primary
  400.     // surface and a back buffer which is an offscreen plane surface.
  401.     //
  402.     memset(&ddsd,0,sizeof(ddsd));
  403.     ddsd.dwSize = sizeof(ddsd);
  404.     ddsd.dwFlags = DDSD_CAPS;
  405.     ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  406.     /*
  407.     * If we specify system memory when creating a primary surface, we
  408.     * won't get the actual primary surface in video memory.  So, don't
  409.     * use D3DAppICreateSurface().
  410.     */
  411.     LastError = d3dappi.lpDD->CreateSurface(&ddsd, &d3dappi.lpFrontBuffer, NULL);
  412.     if(LastError != DD_OK )
  413.     {
  414.       if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
  415.         D3DAppISetErrorString("There was not enough video memory to create the rendering surface.nTo run this program in a window of this size, please adjust your display settings for a smaller desktop area or a lower palette size and restart the program.");
  416.       } else {
  417.         D3DAppISetErrorString("CreateSurface for window front buffer failed.n%s",
  418.           D3DAppErrorToString(LastError));
  419.       }
  420.       goto exit_with_error;
  421.     }
  422.     ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
  423.     ddsd.dwWidth = w;
  424.     ddsd.dwHeight = h;
  425.     ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
  426.     if (bIsHardware)
  427.       ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
  428.     else
  429.       ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  430.     LastError = D3DAppICreateSurface(&ddsd, &d3dappi.lpBackBuffer);
  431.     if (LastError != DD_OK) {
  432.       if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) {
  433.         D3DAppISetErrorString("There was not enough video memory to create the rendering surface.nTo run this program in a window of this size, please adjust your display settings for a smaller desktop area or a lower palette size and restart the program.");
  434.       } else {
  435.         D3DAppISetErrorString("CreateSurface for window back buffer failed.n%s",
  436.           D3DAppErrorToString(LastError));
  437.       }
  438.       goto exit_with_error;
  439.     }
  440.     //
  441.     // Check to see if the back buffer is in video memory (FYI).
  442.     //
  443.     LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
  444.     if (LastError != DD_OK) {
  445.       D3DAppISetErrorString("Failed to get surface description for back buffer.n%s",
  446.         D3DAppErrorToString(LastError));
  447.       goto exit_with_error;
  448.     }
  449.     d3dappi.bBackBufferInVideo =
  450.       (ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) ? TRUE : FALSE;
  451.       /*
  452.       * Create the DirectDraw Clipper object and attach it to the window
  453.       * and front buffer.
  454.     */
  455.     LastError = d3dappi.lpDD->CreateClipper( 0,&lpClipper, NULL);
  456.     if(LastError != DD_OK )
  457.     {
  458.       D3DAppISetErrorString("CreateClipper failed.n%s",
  459.         D3DAppErrorToString(LastError));
  460.       goto exit_with_error;
  461.     }
  462.     LastError = lpClipper->SetHWnd(0, hwnd);
  463.     if(LastError != DD_OK )
  464.     {
  465.       D3DAppISetErrorString("Attaching clipper to window failed.n%s",
  466.         D3DAppErrorToString(LastError));
  467.       goto exit_with_error;
  468.     }
  469.     LastError =
  470.       d3dappi.lpFrontBuffer->SetClipper(lpClipper);
  471.     if(LastError != DD_OK )
  472.     {
  473.       D3DAppISetErrorString("Attaching clipper to front buffer failed.n%s",
  474.         D3DAppErrorToString(LastError));
  475.       goto exit_with_error;
  476.     }
  477.   }
  478.   
  479.   D3DAppIClearBuffers();
  480.   return TRUE;
  481.   
  482. exit_with_error:
  483.   RELEASE(d3dappi.lpFrontBuffer);
  484.   RELEASE(d3dappi.lpBackBuffer);
  485.   RELEASE(lpClipper);
  486.   return FALSE;
  487. }
  489. /*
  490. * D3DAppICheckForPalettized
  491. * If the front/back buffer is palettized, we need to create a palette.
  492. */
  493. BOOL
  494. D3DAppICheckForPalettized(void)
  495. {
  496.   DDSURFACEDESC ddsd;
  497.   /*
  498.   * Get the back buffer surface description and check to see if it's
  499.   * palettized
  500.   */
  501.   LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
  502.   if (LastError != DD_OK) {
  503.     D3DAppISetErrorString("Failed to get surface description for back buffer for palettizing.n%s",
  504.       D3DAppErrorToString(LastError));
  505.     goto exit_with_error;
  506.   }
  507.   bPrimaryPalettized =
  508.     (ddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) ? TRUE : FALSE;
  509.   
  510.   if (bPrimaryPalettized) {
  511.     int i;
  512.     /*
  513.     * Get the current palette.
  514.     */
  515.     HDC hdc = GetDC(NULL);
  516.     GetSystemPaletteEntries(hdc, 0, (1 << 8), ppe);
  517.     ReleaseDC(NULL, hdc);
  518.     /*
  519.     * Change the flags on the palette entries to allow D3D to change
  520.     * some of them.  In the window case, we must not change the top and
  521.     * bottom ten (system colors), but in a fullscreen mode we can have
  522.     * all but the first and last.
  523.     */
  524.     if (!d3dappi.bFullscreen) {
  525.       for (i = 0; i < 10; i++) ppe[i].peFlags = D3DPAL_READONLY;
  526.       for (i = 10; i < 256 - 10; i++) ppe[i].peFlags = D3DPAL_FREE | PC_RESERVED;
  527.       for (i = 256 - 10; i < 256; i++) ppe[i].peFlags = D3DPAL_READONLY;
  528.     } else {
  529.       ppe[0].peFlags = D3DPAL_READONLY;
  530.       for (i = 1; i < 255; i++) ppe[i].peFlags = D3DPAL_FREE | PC_RESERVED;
  531.       ppe[255].peFlags = D3DPAL_READONLY;
  532.     }
  533.     /*
  534.     * Create a palette using the old colors and new flags
  535.     */
  536.     LastError = d3dappi.lpDD->CreatePalette(DDPCAPS_8BIT | DDPCAPS_INITIALIZE,
  537.       ppe, &lpPalette, NULL);
  538.     if (LastError != DD_OK)
  539.     {
  540.       D3DAppISetErrorString("CreatePalette failed.n%s",
  541.         D3DAppErrorToString(LastError));
  542.       goto exit_with_error;
  543.     }
  544.     /*
  545.     * Set this as the front and back buffers' palette
  546.     */
  547.     LastError =
  548.       d3dappi.lpBackBuffer->SetPalette(lpPalette);
  549.     if(LastError != DD_OK )
  550.     {
  551.       D3DAppISetErrorString("SetPalette failed on back buffer.n%s",
  552.         D3DAppErrorToString(LastError));
  553.       goto exit_with_error;
  554.     }
  555.     LastError =
  556.       d3dappi.lpFrontBuffer->SetPalette(lpPalette);
  557.     if(LastError != DD_OK )
  558.     {
  559.       D3DAppISetErrorString("SetPalette failed on front buffer.n%s",
  560.         D3DAppErrorToString(LastError));
  561.       goto exit_with_error;
  562.     }
  563.     /*
  564.     * The palette is now valid, so set it again on anyt WM_ACTIVATE
  565.     */
  566.     bPaletteActivate = TRUE;
  567.   }
  568.   return TRUE;
  569. exit_with_error:
  570.   RELEASE(lpPalette);
  571.   return FALSE;
  572. }
  574. /***************************************************************************/
  575. /*                           Creation of Z-Buffer                          */
  576. /***************************************************************************/
  577. /*
  578. * D3DAppICreateZBuffer
  579. * Create a Z-Buffer of the appropriate depth and attach it to the back
  580. * buffer.
  581. */
  582. BOOL
  583. D3DAppICreateZBuffer(int w, int h, int driver)
  584. {
  585.   DDSURFACEDESC ddsd;
  586.   DWORD devDepth;
  587.   /*
  588.   * Release any Z-Buffer that might be around just in case.
  589.   */
  590.   RELEASE(d3dappi.lpZBuffer);
  591.   
  592.   /*
  593.   * If this driver does not do z-buffering, don't create a z-buffer
  594.   */
  595.   if (!d3dappi.Driver[driver].bDoesZBuffer) return TRUE;
  596.   
  597.   memset(&ddsd, 0 ,sizeof(ddsd));
  598.   ddsd.dwSize = sizeof(ddsd);
  599.   ddsd.dwFlags = DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS|DDSD_ZBUFFERBITDEPTH;
  600.   ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
  601.   ddsd.dwHeight = h;
  602.   ddsd.dwWidth = w;
  603.   /*
  604.   * If this is a hardware D3D driver, the Z-Buffer MUST end up in video
  605.   * memory.  Otherwise, it MUST end up in system memory.
  606.   */
  607.   if (d3dappi.Driver[driver].bIsHardware)
  608.     ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
  609.   else
  610.     ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
  611.     /*
  612.     * Get the Z buffer bit depth from this driver's D3D device description
  613.   */
  614.   devDepth = d3dappi.Driver[driver].Desc.dwDeviceZBufferBitDepth;
  615. #ifdef _DIRECTX7
  616.   if (devDepth & DDBD_32)
  617.     ddsd.ddpfPixelFormat.dwZBufferBitDepth = 32;
  618.   else if (devDepth & DDBD_24)
  619.     ddsd.ddpfPixelFormat.dwZBufferBitDepth = 24;
  620.   else if (devDepth & DDBD_16)
  621.     ddsd.ddpfPixelFormat.dwZBufferBitDepth = 16;
  622.   else if (devDepth & DDBD_8)
  623.     ddsd.ddpfPixelFormat.dwZBufferBitDepth = 8;
  624. #else
  625.   if (devDepth & DDBD_32)
  626.     ddsd.dwZBufferBitDepth = 32;
  627.   else if (devDepth & DDBD_24)
  628.     ddsd.dwZBufferBitDepth = 24;
  629.   else if (devDepth & DDBD_16)
  630.     ddsd.dwZBufferBitDepth = 16;
  631.   else if (devDepth & DDBD_8)
  632.     ddsd.dwZBufferBitDepth = 8;
  633. #endif
  634.   else 
  635.   {
  636.     D3DAppISetErrorString("Unsupported Z-buffer depth requested by device.n");
  637.     return FALSE;
  638.   }
  639.   LastError = d3dappi.lpDD->CreateSurface(&ddsd,&d3dappi.lpZBuffer,NULL);
  640.   if(LastError != DD_OK)
  641.   {
  642.     if (LastError == DDERR_OUTOFMEMORY || LastError == DDERR_OUTOFVIDEOMEMORY) 
  643.     {
  644.       if (d3dappi.bFullscreen) 
  645.       {
  646.         D3DAppISetErrorString("There was not enough video memory to create the Z-buffer surface.nPlease restart the program and try another fullscreen mode with less resolution or lower bit depth.");
  647.       }
  648.       else 
  649.       {
  650.         D3DAppISetErrorString("There was not enough video memory to create the Z-buffer surface.nTo run this program in a window of this size, please adjust your display settings for a smaller desktop area or a lower palette size and restart the program.");
  651.       }
  652.     } 
  653.     else 
  654.     {
  655.       D3DAppISetErrorString("CreateSurface for Z-buffer failed.n%s",
  656.         D3DAppErrorToString(LastError));
  657.     }
  658.     goto exit_with_error;
  659.   }
  660.   /*
  661.   * Attach the Z-buffer to the back buffer so D3D will find it
  662.   */
  663.   LastError = d3dappi.lpBackBuffer->AddAttachedSurface(d3dappi.lpZBuffer);
  664.   if(LastError != DD_OK)
  665.   {
  666.     D3DAppISetErrorString("AddAttachedBuffer failed for Z-Buffer.n%s",
  667.       D3DAppErrorToString(LastError));
  668.     goto exit_with_error;
  669.   }
  670.   //
  671.   // Find out if it ended up in video memory.
  672.   //
  673.   LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpZBuffer);
  674.   if (LastError != DD_OK) 
  675.   {
  676.     D3DAppISetErrorString("Failed to get surface description of Z buffer.n%s",
  677.       D3DAppErrorToString(LastError));
  678.     goto exit_with_error;
  679.   }
  680.   d3dappi.bZBufferInVideo = (ddsd.ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) ? TRUE : FALSE;
  681.   if (d3dappi.Driver[driver].bIsHardware && !d3dappi.bZBufferInVideo) 
  682.   {
  683.     D3DAppISetErrorString("Could not fit the Z-buffer in video memory for this hardware device.n");
  684.     goto exit_with_error;
  685.   }
  686.   
  687.   return TRUE;
  688.   
  689. exit_with_error:
  690.   RELEASE(d3dappi.lpZBuffer);
  691.   return FALSE;
  692. }
  694. /***************************************************************************/
  695. /*                             WM_SIZE Handler                             */
  696. /***************************************************************************/
  697. /*
  698. * D3DAppIHandleWM_SIZE
  699. * Processes the WM_SIZE message.  Resizes all the buffers and re-creates
  700. * device if necessary.
  701. */
  702. BOOL
  703. D3DAppIHandleWM_SIZE(LRESULT* lresult, HWND hwnd, UINT message,
  704.                      WPARAM wParam, LPARAM lParam)
  705. {
  706.   int w, h, i;
  707.   /*
  708.   * If we have minimzied, take note and call the default window proc
  709.   */
  710.   if (wParam == SIZE_MINIMIZED) {
  711.     d3dappi.bMinimized = TRUE;
  712.     *lresult = DefWindowProc(hwnd, message, wParam, lParam);
  713.     return TRUE;
  714.   }
  715.   /*
  716.   * In fullscreen mode, restore our surfaces and let DDraw take
  717.   * care of the rest.
  718.   */
  719.   if (d3dappi.bFullscreen) {
  720.     D3DAppIValidateDirtyRects();
  721.     D3DAppCheckForLostSurfaces();
  722.     d3dappi.bMinimized = FALSE;
  723.     *lresult = DefWindowProc(hwnd, message, wParam, lParam);
  724.     return TRUE;
  725.   }
  726.   /*
  727.   * If we are minimized, this is the un-minimized size message.
  728.   */
  729.   if (d3dappi.bMinimized) {
  730.   /*
  731.   * Restore our surfaces and update the dirty rectangle info
  732.     */
  733.     D3DAppIValidateDirtyRects();
  734.     D3DAppCheckForLostSurfaces();
  735.     d3dappi.bMinimized = FALSE;
  736.     *lresult = DefWindowProc(hwnd, message, wParam, lParam);
  737.     return TRUE;
  738.   }
  739.   /*
  740.   * Since we are still here, this must be a regular, window resize
  741.   * message.  A new viewport will definitely be needed, but the
  742.   * device and buffers will only be re-created if they have gotten bigger
  743.   * or change size by a very large amount.
  744.   */
  745.   D3DAppIGetClientWin(hwnd);
  746.   w = LOWORD(lParam);
  747.   h = HIWORD(lParam);
  748.   /*
  749.   * If w and h are under the minimum, create buffers of the minimum size
  750.   */
  751.   if (w < D3DAPP_WINDOWMINIMUM)
  752.     w = D3DAPP_WINDOWMINIMUM;
  753.   if (h < D3DAPP_WINDOWMINIMUM)
  754.     h = D3DAPP_WINDOWMINIMUM;
  755.     /*
  756.     * Destroy the viewport and all execute buffers
  757.   */
  758.   d3dappi.bRenderingIsOK = FALSE;
  759.   ATTEMPT(D3DAppICallDeviceDestroyCallback());
  760.   /*
  761.   * Only create a new device and buffers if they changed significantly,
  762.   * otherwise just make sure the old buffers aren't lost.
  763.   */
  764.   if ((w > szBuffers.cx || h > szBuffers.cy) ||
  765.     (w < szBuffers.cx / 2 || h < szBuffers.cy / 2)) {
  766.     /*
  767.     * Release the device
  768.     */
  769.     RELEASE(d3dappi.lpD3DDevice);
  770.     /*
  771.     * Release the old buffers
  772.     */
  773.     RELEASE(d3dappi.lpZBuffer);
  774.     RELEASE(lpPalette);
  775.     RELEASE(lpClipper);
  776.     RELEASE(d3dappi.lpBackBuffer);
  777.     RELEASE(d3dappi.lpFrontBuffer);
  778.     /*
  779.     * Create new ones
  780.     */
  781.     ATTEMPT(D3DAppICreateBuffers(hwnd, w, h, D3DAPP_BOGUS, FALSE, d3dappi.ThisDriver.bIsHardware));
  782.     ATTEMPT(D3DAppICheckForPalettized());
  783.     ATTEMPT(D3DAppICreateZBuffer(w, h, d3dappi.CurrDriver));
  784.     /*
  785.     * Create the driver
  786.     */
  787.     ATTEMPT(D3DAppICreateDevice(d3dappi.CurrDriver));
  788.     /*
  789.     * Since the driver did not change, the texture surfaces are still valid.
  790.     * We just need to get new handles.
  791.     */
  792.     if (d3dappi.ThisDriver.bDoesTextures) {
  793.       for (i = 0; i < d3dappi.NumUsableTextures; i++) {
  794.         D3DAppIGetTextureHandle(i);
  795.       }
  796.     }
  797.   } else {
  798.     D3DAppCheckForLostSurfaces();
  799.   }
  800.   /*
  801.   * Call the device create callback to create the viewport, set the render
  802.   * state and clear the dirty rectangle info
  803.   */
  804.   ATTEMPT(D3DAppICallDeviceCreateCallback(w, h));
  805.   ATTEMPT(D3DAppISetRenderState());
  806.   D3DAppIValidateDirtyRects();
  807.   d3dappi.bRenderingIsOK = TRUE;
  808.   /*
  809.   * Call the default window proc
  810.   */
  811.   *lresult = DefWindowProc(hwnd, message, wParam, lParam);
  812.   return TRUE;
  813. exit_with_error:
  814.   D3DAppICallDeviceDestroyCallback();
  815.   RELEASE(d3dappi.lpD3DDevice);
  816.   RELEASE(d3dappi.lpZBuffer);
  817.   RELEASE(lpPalette);
  818.   RELEASE(lpClipper);
  819.   RELEASE(d3dappi.lpBackBuffer);
  820.   RELEASE(d3dappi.lpFrontBuffer);
  821.   return FALSE;
  822. }
  824. /***************************************************************************/
  825. /*              Setting the display mode and cooperative level             */
  826. /***************************************************************************/
  827. /*
  828. * D3DAppISetCoopLevel
  829. * Set the cooperative level to exclusive mode for fullscreen and normal for
  830. * a window.  Set the bIgnoreWM_SIZE flag because SetCooperativeLevel
  831. * generates a WM_SIZE message you do not have to resize the buffers on.
  832. */
  833. BOOL D3DAppISetCoopLevel(HWND hwnd, BOOL bFullscreen)
  834. {
  835.   if (bFullscreen)
  836.   {
  837.     bIgnoreWM_SIZE = TRUE;
  838.     LastError = d3dappi.lpDD->SetCooperativeLevel(hwnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN );
  839.     bIgnoreWM_SIZE = FALSE;
  840.     if(LastError != DD_OK )
  841.     {
  842.       D3DAppISetErrorString("SetCooperativeLevel to fullscreen failed.n%s",
  843.         D3DAppErrorToString(LastError));
  844.       return FALSE;
  845.     }
  846.     
  847.     d3dappi.bFullscreen = TRUE;
  848.   }
  849.   else
  850.   {
  851.     bIgnoreWM_SIZE = TRUE;
  852.     LastError = d3dappi.lpDD->SetCooperativeLevel(hwnd, DDSCL_NORMAL);
  853.     bIgnoreWM_SIZE = FALSE;
  854.     if(LastError != DD_OK ) {
  855.       D3DAppISetErrorString("SetCooperativeLevel to normal failed.n%s",
  856.         D3DAppErrorToString(LastError));
  857.       return FALSE;
  858.     }
  859.     d3dappi.bFullscreen = FALSE;
  860.   }
  861.   return TRUE;
  862. }
  864. //
  865. // D3DAppISetDisplayMode
  866. // Set the display mode to the given dimensions and bits per pixel.  The
  867. // bIgnoreWM_SIZE message is set because the display change generates a
  868. // WM_SIZE message which we don't want to resize the buffers on.
  869. //
  870. BOOL D3DAppISetDisplayMode(int w, int h, int bpp)
  871. {
  872.   d3dappi.ThisMode.w = w; d3dappi.ThisMode.h = h;
  873.   d3dappi.ThisMode.bpp = bpp;
  874.   bIgnoreWM_SIZE = TRUE;
  875. #ifdef _DIRECTX7
  876.   LastError = d3dappi.lpDD->SetDisplayMode(w, h,bpp,0,0);
  877. #else
  878.   LastError = d3dappi.lpDD->SetDisplayMode(w, h,bpp);
  879. #endif
  880.   bIgnoreWM_SIZE = FALSE;
  881.   if(LastError != DD_OK )
  882.   {
  883.     D3DAppISetErrorString("SetDisplayMode to %dx%dx%d failedn%s",
  884.       w, h, bpp, D3DAppErrorToString(LastError));
  885.     return FALSE;
  886.   }
  887.   return TRUE;
  888. }
  890. /*
  891. * D3DAppIRestoreDispMode
  892. * Restores the display mode to the current windows display mode.  The
  893. * bIgnoreWM_SIZE message is set because the display change generates a
  894. * WM_SIZE message which we don't want to resize the buffers on.
  895. */
  896. BOOL D3DAppIRestoreDispMode(void)
  897. {
  898.   bIgnoreWM_SIZE = TRUE;
  899.   LastError = d3dappi.lpDD->RestoreDisplayMode( );
  900.   if (LastError != DD_OK)
  901.   {
  902.     D3DAppISetErrorString("RestoreDisplayMode failed.n%s",
  903.       D3DAppErrorToString(LastError));
  904.     return FALSE;
  905.   }
  906.   bIgnoreWM_SIZE = FALSE;
  907.   return TRUE;
  908. }
  910. /*
  911. * D3DAppRememberWindowsMode
  912. * Record the current display mode in d3dappi.WindowsDisplay
  913. */
  914. BOOL D3DAppIRememberWindowsMode(void)
  915. {
  916.   DDSURFACEDESC ddsd;
  917.   
  918.   memset(&ddsd, 0, sizeof(ddsd));
  919.   ddsd.dwSize = sizeof(ddsd);
  920.   LastError = d3dappi.lpDD->GetDisplayMode(&ddsd);
  921.   if (LastError != DD_OK) {
  922.     D3DAppISetErrorString("Getting the current display mode failed.n%s",
  923.       D3DAppErrorToString(LastError));
  924.     return FALSE;
  925.   }
  926.   d3dappi.WindowsDisplay.w = ddsd.dwWidth;
  927.   d3dappi.WindowsDisplay.h = ddsd.dwHeight;
  928.   d3dappi.WindowsDisplay.bpp = ddsd.ddpfPixelFormat.dwRGBBitCount;
  929.   return TRUE;
  930. }
  932. /***************************************************************************/
  933. /*                          Misc DD Utilities                              */
  934. /***************************************************************************/
  936. //
  937. // D3DAppIClearBuffers
  938. // Clear the front and back buffers to black
  939. //
  940. BOOL D3DAppIClearBuffers(void)
  941. {
  942.   DDSURFACEDESC ddsd;
  943.   RECT dst;
  944.   DDBLTFX ddbltfx;
  945.   /*
  946.   * Find the width and height of the front buffer by getting its
  947.   * DDSURFACEDESC
  948.   */
  949.   if (d3dappi.lpFrontBuffer) {
  950.     LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpFrontBuffer);
  951.     if (LastError != DD_OK) {
  952.       D3DAppISetErrorString("Failure getting the surface description of the front buffer before clearing.n%s",
  953.         D3DAppErrorToString(LastError));
  954.       return FALSE;
  955.     }
  956.     /*
  957.     * Clear the front buffer to black
  958.     */
  959.     memset(&ddbltfx, 0, sizeof(ddbltfx));
  960.     ddbltfx.dwSize = sizeof(DDBLTFX);
  961.     SetRect(&dst, 0, 0, ddsd.dwWidth, ddsd.dwHeight);
  962.     LastError = d3dappi.lpFrontBuffer->Blt(&dst, NULL, NULL,
  963.       DDBLT_COLORFILL | DDBLT_WAIT,
  964.       &ddbltfx);
  965.     if (LastError != DD_OK) {
  966.       D3DAppISetErrorString("Clearing the front buffer failed.n%s",
  967.         D3DAppErrorToString(LastError));
  968.       return FALSE;
  969.     }
  970.   }
  971.   if (d3dappi.lpBackBuffer) {
  972.   /*
  973.   * Find the width and height of the back buffer by getting its
  974.   * DDSURFACEDESC
  975.     */
  976.     LastError = D3DAppIGetSurfDesc(&ddsd, d3dappi.lpBackBuffer);
  977.     if (LastError != DD_OK) {
  978.       D3DAppISetErrorString("Failure while getting the surface description of the back buffer before clearing.n%s",
  979.         D3DAppErrorToString(LastError));
  980.       return FALSE;
  981.     }
  982.     /*
  983.     * Clear the back buffer to black
  984.     */
  985.     memset(&ddbltfx, 0, sizeof(ddbltfx));
  986.     ddbltfx.dwSize = sizeof(DDBLTFX);
  987.     SetRect(&dst, 0, 0, ddsd.dwWidth, ddsd.dwHeight);
  988.     LastError = d3dappi.lpBackBuffer->Blt( &dst,NULL, NULL,
  989.       DDBLT_COLORFILL | DDBLT_WAIT,
  990.       &ddbltfx);
  991.     if (LastError != DD_OK) {
  992.       D3DAppISetErrorString("Clearing the front buffer failed.n%s",
  993.         D3DAppErrorToString(LastError));
  994.       return FALSE;
  995.     }
  996.   }
  997.   return TRUE;
  998. }
  1000. /*
  1001. * D3DAppIBPPToDDBD
  1002. * Convert an integer bit per pixel number to a DirectDraw bit depth flag
  1003. */
  1004. DWORD
  1005. D3DAppIBPPToDDBD(int bpp)
  1006. {
  1007.   switch(bpp) {
  1008.   case 1:
  1009.     return DDBD_1;
  1010.   case 2:
  1011.     return DDBD_2;
  1012.   case 4:
  1013.     return DDBD_4;
  1014.   case 8:
  1015.     return DDBD_8;
  1016.   case 16:
  1017.     return DDBD_16;
  1018.   case 24:
  1019.     return DDBD_24;
  1020.   case 32:
  1021.     return DDBD_32;
  1022.   default:
  1023.     return (DWORD)D3DAPP_BOGUS;
  1024.   }
  1025. }
  1027. /*
  1028. * D3DAppTotalVideoMemory
  1029. * Returns the amount of total video memory supported (not free)
  1030. */
  1031. DWORD
  1032. D3DAppTotalVideoMemory(void)
  1033. {
  1034.   DDCAPS DriverCaps, HELCaps;
  1035.   memset (&DriverCaps, 0, sizeof(DDCAPS));
  1036.   DriverCaps.dwSize = sizeof(DDCAPS);
  1037.   memset (&HELCaps, 0, sizeof(DDCAPS));
  1038.   HELCaps.dwSize = sizeof(DDCAPS);
  1039.   LastError = d3dappi.lpDD->GetCaps( &DriverCaps,&HELCaps);
  1040.   if (LastError != DD_OK) {
  1041.     D3DAppISetErrorString("Getting DD capabilities failed while checking total video memory.n%s",
  1042.       D3DAppErrorToString(LastError));
  1043.     return 0L;
  1044.   }
  1045.   if (DriverCaps.dwVidMemTotal)
  1046.     return DriverCaps.dwVidMemTotal;
  1047.   else
  1048.     return HELCaps.dwVidMemTotal;
  1049. }