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

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

游戏引擎

开发平台：

Visual C++

d3dapp.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "XMudClient.h"
  3. #include "d3dappi.h"
  6. D3DAppInfo d3dappi;
  9. D3DAppRenderState d3dapprs;
  12. BOOL(*D3DDeviceDestroyCallback)(LPVOID);
  13. LPVOID D3DDeviceDestroyCallbackContext;
  14. BOOL(*D3DDeviceCreateCallback)(int, int, LPDIRECT3DVIEWPORT*, LPVOID);
  15. LPVOID D3DDeviceCreateCallbackContext;
  17. HRESULT LastError;
  18. char LastErrorString[256];
  20. int NumDirtyClientRects, NumDirtyBackRects, NumDirtyZRects;
  21. D3DRECT DirtyClient[D3DAPP_MAXCLEARRECTS];
  22. D3DRECT DirtyBack[D3DAPP_MAXCLEARRECTS];
  23. D3DRECT DirtyZ[D3DAPP_MAXCLEARRECTS];
  25. D3DTEXTUREHANDLE MasterTextureHandle[D3DAPP_MAXTEXTURES];
  27. LPDIRECTDRAWCLIPPER lpClipper;
  28. LPDIRECTDRAWPALETTE lpPalette;
  29. PALETTEENTRY ppe[256];
  30. PALETTEENTRY Originalppe[256];
  31. BOOL bD3DAppInitialized;
  32. BOOL bPrimaryPalettized;
  33. BOOL bPaletteActivate;
  34. BOOL bIgnoreWM_SIZE;
  35. SIZE szLastClient;
  36. SIZE szBuffers;
  37. int CallbackRefCount; 
  39. BOOL D3DAppEnumerateDDDevices(int* NumDevices, D3DAppDDDriver* lpDriver)
  40. {
  41.   if (!NumDevices || !lpDriver) {
  42.     D3DAppISetErrorString("Invalid parameters passe to D3DAppEnumerateDDDevices.n");
  43.     return FALSE;
  44.   }
  45.   return D3DAppIEnumDDDevices(NumDevices, lpDriver);
  46. }
  48. BOOL D3DAppCreateFromHWND(DWORD flags, HWND hwnd, LPGUID lpDDGuid,
  49.                           BOOL(*DeviceCreateCallback)(int, int,
  50.                           LPDIRECT3DVIEWPORT*,
  51.                           LPVOID),
  52.                           LPVOID lpCreateContext,
  53.                           BOOL(*DeviceDestroyCallback)(LPVOID),
  54.                           LPVOID lpDestroyContext,
  55.                           D3DAppInfo** D3DApp)
  56. {
  57.   int driver, mode, w, h;
  58.   D3DAppISetDefaults();
  59.   
  60.   if (flags & D3DAPP_ONLYSYSTEMMEMORY)
  61.   {
  62.     d3dappi.bOnlySystemMemory = TRUE;
  63.     d3dappi.bOnlyEmulation = TRUE;
  64.   }
  65.   if (flags & D3DAPP_ONLYD3DEMULATION)
  66.     d3dappi.bOnlyEmulation = TRUE;
  67.   ATTEMPT(D3DAppICreateDD(d3dappi.bOnlyEmulation ? D3DAPP_ONLYDDEMULATION : 0L, lpDDGuid));
  68.   ATTEMPT(D3DAppIRememberWindowsMode());
  69.   ATTEMPT(D3DAppIEnumDisplayModes());
  70.  
  71.   ATTEMPT(D3DAppICreateD3D());
  72.   ATTEMPT(D3DAppIEnumDevices());
  73.  
  74.   D3DDeviceDestroyCallback = DeviceDestroyCallback;
  75.   D3DDeviceDestroyCallbackContext = lpDestroyContext;
  76.   D3DDeviceCreateCallback = DeviceCreateCallback;
  77.   D3DDeviceCreateCallbackContext = lpCreateContext;
  78.   *D3DApp = &d3dappi;
  79.   d3dappi.hwnd = hwnd;
  81.   driver = D3DAPP_YOUDECIDE;
  82.   mode = D3DAPP_YOUDECIDE;
  83.   ATTEMPT(D3DAppIVerifyDriverAndMode(&driver, &mode));
  84.   D3DAppIGetClientWin(hwnd);
  85.   if (mode == D3DAPP_USEWINDOW)
  86.   {
  87.     w = d3dappi.szClient.cx;
  88.     h = d3dappi.szClient.cy;
  89.     ATTEMPT(D3DAppISetCoopLevel(hwnd, FALSE));
  90.     ATTEMPT(D3DAppICreateBuffers(hwnd, w, h, D3DAPP_BOGUS, FALSE,
  91.       d3dappi.Driver[driver].bIsHardware));
  92.     if (!(d3dappi.Driver[driver].Desc.dwDeviceRenderBitDepth &
  93.       D3DAppIBPPToDDBD(d3dappi.Mode[d3dappi.CurrMode].bpp)))
  94.     {
  95.       ATTEMPT(D3DAppIPickDisplayMode(&d3dappi.CurrMode,
  96.         d3dappi.Driver[driver].Desc.dwDeviceRenderBitDepth));
  97.     }
  98.   }
  99.   else
  100.   {
  101.     szLastClient = d3dappi.szClient;
  102.     w = d3dappi.Mode[mode].w;
  103.     h = d3dappi.Mode[mode].h;
  104.     d3dappi.szClient.cx = w; d3dappi.szClient.cy = h;
  105.     ATTEMPT(D3DAppISetCoopLevel(hwnd, TRUE));
  106.     ATTEMPT(D3DAppISetDisplayMode(w, h, d3dappi.Mode[mode].bpp));
  107.     d3dappi.CurrMode = mode;
  108.     ATTEMPT(D3DAppICreateBuffers(hwnd, w, h, d3dappi.Mode[mode].bpp, TRUE,
  109.       d3dappi.Driver[driver].bIsHardware));
  110.   }
  112.   ATTEMPT(D3DAppICheckForPalettized());
  114.   ATTEMPT(D3DAppICreateZBuffer(w, h, driver));
  116.   ATTEMPT(D3DAppICreateDevice(driver));
  117.   ATTEMPT(D3DAppILoadAllTextures());
  118.   ATTEMPT(D3DAppIFilterDisplayModes(driver));
  119.   ATTEMPT(D3DAppICallDeviceCreateCallback(w, h));
  120.   ATTEMPT(D3DAppISetRenderState());
  122.   D3DAppIValidateDirtyRects();
  123.   
  125.   bD3DAppInitialized = TRUE;
  126.   d3dappi.bRenderingIsOK = TRUE;
  128.   return TRUE;
  129.   
  130. exit_with_error:
  131.   D3DAppICallDeviceDestroyCallback();
  132.   RELEASE(d3dappi.lpD3DDevice);
  133.   RELEASE(d3dappi.lpZBuffer);
  134.   RELEASE(lpPalette);
  135.   RELEASE(lpClipper);
  136.   RELEASE(d3dappi.lpBackBuffer);
  137.   RELEASE(d3dappi.lpFrontBuffer);
  138.   if (d3dappi.bFullscreen)
  139.   {
  140.     D3DAppIRestoreDispMode();
  141.     D3DAppISetCoopLevel(hwnd, FALSE);
  142.   }
  143.   RELEASE(d3dappi.lpD3D);
  144.   RELEASE(d3dappi.lpDD);
  145.   return FALSE;
  146. }
  148. BOOL D3DAppFullscreen(int mode)
  149. {
  150.   int w, h, bpp;
  151.   BOOL b;
  152.   
  153.   d3dappi.bRenderingIsOK = FALSE;
  155.   ATTEMPT(D3DAppIVerifyDriverAndMode(&d3dappi.CurrDriver, &mode));
  156.   ATTEMPT(D3DAppICallDeviceDestroyCallback());
  157.   if (d3dappi.bFullscreen)
  158.     ATTEMPT(D3DAppIClearBuffers());
  159.   
  160.   D3DAppIReleaseAllTextures();
  161.   RELEASE(d3dappi.lpD3DDevice);
  162.   RELEASE(d3dappi.lpZBuffer);
  163.   RELEASE(lpPalette);
  164.   RELEASE(lpClipper);
  165.   RELEASE(d3dappi.lpBackBuffer);
  166.   RELEASE(d3dappi.lpFrontBuffer);
  168.   b = d3dappi.bFullscreen;
  169.   w = d3dappi.Mode[mode].w;
  170.   h = d3dappi.Mode[mode].h;
  171.   bpp = d3dappi.Mode[mode].bpp;
  172.   if (!b)
  173.   {
  175.     szLastClient = d3dappi.szClient;
  176.   }
  177.   
  178.   d3dappi.szClient.cx = w; d3dappi.szClient.cy = h;
  179.   ATTEMPT(D3DAppISetCoopLevel(d3dappi.hwnd, TRUE));
  180.   ATTEMPT(D3DAppISetDisplayMode(w, h, bpp));
  181.   d3dappi.CurrMode = mode;
  182.   ATTEMPT(D3DAppICreateBuffers(d3dappi.hwnd, w, h, bpp, TRUE,
  183.     d3dappi.Driver[d3dappi.CurrDriver].bIsHardware));
  184.   ATTEMPT(D3DAppICheckForPalettized());
  186.   ATTEMPT(D3DAppICreateZBuffer(w, h, d3dappi.CurrDriver));
  188.   ATTEMPT(D3DAppICreateDevice(d3dappi.CurrDriver));
  189.   ATTEMPT(D3DAppILoadAllTextures());
  190.   ATTEMPT(D3DAppICallDeviceCreateCallback(w, h));
  191.   ATTEMPT(D3DAppISetRenderState());
  192.   d3dappi.CurrMode = mode;
  193.   D3DAppIValidateDirtyRects();
  194.   d3dappi.bRenderingIsOK = TRUE;
  195.   return TRUE;
  196.   
  197. exit_with_error:
  198.   D3DAppICallDeviceDestroyCallback();
  199.   RELEASE(d3dappi.lpD3DDevice);
  200.   RELEASE(d3dappi.lpZBuffer);
  201.   RELEASE(lpPalette);
  202.   RELEASE(lpClipper);
  203.   RELEASE(d3dappi.lpBackBuffer);
  204.   RELEASE(d3dappi.lpFrontBuffer);
  205.   if (!b) {
  206.     D3DAppIRestoreDispMode();
  207.     D3DAppISetCoopLevel(d3dappi.hwnd, FALSE);
  208.   }
  209.   return FALSE;
  210. }
  212. BOOL D3DAppWindow(int w, int h)
  213. {
  214.   BOOL b;
  215.   if (!d3dappi.bIsPrimary){
  216.     D3DAppISetErrorString("It is not possible to create a D3D window with a hardware DirectDraw device.  Check the bIsPrimary flag before calling D3DAppWindow.");
  217.     return FALSE;
  218.   }
  219.   b = d3dappi.bFullscreen;
  221.   if (w == D3DAPP_YOUDECIDE){
  222.     w = b ? szLastClient.cx : D3DAPP_DEFAULTWINDOWDIM;
  223.   }
  224.   if (h == D3DAPP_YOUDECIDE){
  225.     h = b ? szLastClient.cy : D3DAPP_DEFAULTWINDOWDIM;
  226.   }
  228.   d3dappi.bRenderingIsOK = FALSE;
  229.   ATTEMPT(D3DAppICallDeviceDestroyCallback());
  230.   if (b) {
  231.     ATTEMPT(D3DAppIClearBuffers());
  232.   }
  233.   D3DAppIReleaseAllTextures();
  234.   RELEASE(d3dappi.lpD3DDevice);
  235.   RELEASE(d3dappi.lpZBuffer);
  236.   RELEASE(lpPalette);
  237.   RELEASE(lpClipper);
  238.   RELEASE(d3dappi.lpBackBuffer);
  239.   RELEASE(d3dappi.lpFrontBuffer);
  240.   if (b)
  241.     D3DAppIRestoreDispMode();
  242.   
  243.   D3DAppISetCoopLevel(d3dappi.hwnd, FALSE);
  244.   D3DAppISetClientSize(d3dappi.hwnd, w, h, b);
  245.   ATTEMPT(D3DAppICreateBuffers(d3dappi.hwnd, w, h, D3DAPP_BOGUS, FALSE,
  246.     d3dappi.Driver[d3dappi.CurrDriver].bIsHardware));
  247.   ATTEMPT(D3DAppICheckForPalettized());
  248.   ATTEMPT(D3DAppICreateZBuffer(szBuffers.cx, szBuffers.cy, d3dappi.CurrDriver));
  249.   ATTEMPT(D3DAppICreateDevice(d3dappi.CurrDriver));
  250.   ATTEMPT(D3DAppILoadAllTextures());
  251.   ATTEMPT(D3DAppICallDeviceCreateCallback(szBuffers.cx, szBuffers.cy));
  252.   ATTEMPT(D3DAppISetRenderState());
  253.   D3DAppIValidateDirtyRects();
  254.   d3dappi.bRenderingIsOK = TRUE;
  255.   return TRUE;
  256.   
  257. exit_with_error:
  258.   D3DAppICallDeviceDestroyCallback();
  259.   RELEASE(d3dappi.lpD3DDevice);
  260.   RELEASE(d3dappi.lpZBuffer);
  261.   RELEASE(lpPalette);
  262.   RELEASE(lpClipper);
  263.   RELEASE(d3dappi.lpBackBuffer);
  264.   RELEASE(d3dappi.lpFrontBuffer);
  265.   return FALSE;
  266. }
  268. BOOL D3DAppChangeDriver(int driver, DWORD flags)
  269. {
  270.   int mode;
  271.   
  272.   d3dappi.bRenderingIsOK = FALSE;
  273.   if (d3dappi.bFullscreen)
  274.     mode = d3dappi.CurrMode;
  275.   else
  276.     mode = D3DAPP_USEWINDOW;
  277.   ATTEMPT(D3DAppIVerifyDriverAndMode(&driver, &mode));
  278.   if (driver == D3DAPP_BOGUS || mode == D3DAPP_BOGUS)
  279.     goto exit_with_error;
  280.   d3dappi.CurrDriver = driver;
  281.   ATTEMPT(D3DAppIFilterDisplayModes(driver));
  283.   if (mode == D3DAPP_USEWINDOW){
  284.     if (d3dappi.bFullscreen){
  285.       ATTEMPT(D3DAppWindow(D3DAPP_YOUDECIDE, D3DAPP_YOUDECIDE));
  286.     }else {
  287.       ATTEMPT(D3DAppWindow(d3dappi.szClient.cx, d3dappi.szClient.cy));
  288.     }
  289.     if (!(d3dappi.Driver[driver].Desc.dwDeviceRenderBitDepth &
  290.       D3DAppIBPPToDDBD(d3dappi.Mode[d3dappi.CurrMode].bpp))){
  291.       ATTEMPT(D3DAppIPickDisplayMode(&d3dappi.CurrMode,
  292.         d3dappi.Driver[driver].Desc.dwDeviceRenderBitDepth));
  293.     }
  294.     d3dappi.bRenderingIsOK = TRUE;
  295.     return TRUE;
  296.   }else {
  297.     ATTEMPT(D3DAppFullscreen(mode));
  298.     d3dappi.bRenderingIsOK = TRUE;
  299.     return TRUE;
  300.   }
  301.   
  302. exit_with_error:
  303.   return FALSE;
  304. }
  306. BOOL D3DAppWindowProc(BOOL* bStopProcessing, LRESULT* lresult, HWND hwnd,
  307.                       UINT message, WPARAM wParam, LPARAM lParam)
  308. {
  309.   PAINTSTRUCT ps;
  310.   *bStopProcessing = FALSE;
  311.   if (!bD3DAppInitialized)
  312.     return TRUE;
  313.   switch(message){
  314.   case WM_SIZE:
  315.     if (!bIgnoreWM_SIZE && d3dappi.bRenderingIsOK && d3dappi.lpD3DDevice){
  316.       d3dappi.bRenderingIsOK = FALSE;
  317.       ATTEMPT(D3DAppIHandleWM_SIZE(lresult, d3dappi.hwnd, message,
  318.         wParam, lParam));
  319.       *bStopProcessing = TRUE;
  320.       d3dappi.bRenderingIsOK = TRUE;
  321.     }
  322.     break;
  323.   case WM_MOVE:
  324.     d3dappi.pClientOnPrimary.x = d3dappi.pClientOnPrimary.y = 0;
  325.     ClientToScreen(hwnd, &d3dappi.pClientOnPrimary);
  326.     break;
  327.   case WM_ACTIVATE:
  328.     if (bPaletteActivate && bPrimaryPalettized &&
  329.       d3dappi.lpFrontBuffer){
  330.       d3dappi.lpFrontBuffer->SetPalette(lpPalette);
  331.     }
  332.     break;
  333.   case WM_ACTIVATEAPP:
  334.     d3dappi.bAppActive = (BOOL)wParam;
  335.     break;
  336.   case WM_SETCURSOR:
  337.     if (d3dappi.bFullscreen && !d3dappi.bPaused){
  338.       SetCursor(NULL);
  339.       *lresult = 1;
  340.       *bStopProcessing = TRUE;
  341.       return TRUE;
  342.     }
  343.     break;
  344.   case WM_MOVING:
  345.     if (d3dappi.bFullscreen){
  346.       GetWindowRect(hwnd, (LPRECT)lParam);
  347.       *lresult = 1;
  348.       *bStopProcessing = TRUE;
  349.       return TRUE;
  350.     }
  351.     break;
  352.   case WM_GETMINMAXINFO:
  353.     if (d3dappi.bFullscreen){
  354.       ((LPMINMAXINFO)lParam)->ptMaxTrackSize.x= d3dappi.ThisMode.w;
  355.       ((LPMINMAXINFO)lParam)->ptMaxTrackSize.y= d3dappi.ThisMode.h;
  356.       ((LPMINMAXINFO)lParam)->ptMinTrackSize.x= d3dappi.ThisMode.w;
  357.       ((LPMINMAXINFO)lParam)->ptMinTrackSize.y= d3dappi.ThisMode.h;
  358.       *lresult = 0;
  359.       *bStopProcessing = TRUE;
  360.       return TRUE;
  361.     }else{
  362.       ((LPMINMAXINFO)lParam)->ptMaxTrackSize.x = d3dappi.WindowsDisplay.w;
  363.       ((LPMINMAXINFO)lParam)->ptMaxTrackSize.y = d3dappi.WindowsDisplay.h;
  364.       *lresult = 0;
  365.       *bStopProcessing = TRUE;
  366.       return TRUE;
  367.     }
  368.     break;
  369.   case WM_PAINT:
  370.     BeginPaint(hwnd, &ps);
  371.     if (d3dappi.bRenderingIsOK && !d3dappi.bFullscreen){
  372.       D3DAppShowBackBuffer(D3DAPP_SHOWALL);
  373.     }
  374.     D3DAppIValidateDirtyRects();
  375.     EndPaint(hwnd, &ps);
  376.     *lresult = 1;
  377.     *bStopProcessing = TRUE;
  378.     return TRUE;
  379.   case WM_NCPAINT:
  380. if (d3dappi.bFullscreen && !d3dappi.bPaused){
  381.   *lresult = 0;
  382.   *bStopProcessing = TRUE;
  383.   return TRUE;
  384. }
  385.     break;
  386.     }
  387.     return TRUE;
  388. exit_with_error:
  389.     return FALSE;
  390. }
  391. BOOL D3DAppAddTexture(const char* imagefile)
  392. {
  393.   if (d3dappi.NumTextures == D3DAPP_MAXTEXTURES - 1){
  394.     D3DAppISetErrorString("Can only load %i textures.", D3DAPP_MAXTEXTURES);
  395.     return FALSE;
  396.   }
  397.   
  398.   lstrcpy(d3dappi.ImageFile[d3dappi.NumTextures], imagefile);
  399.   if (d3dappi.ThisDriver.bDoesTextures && d3dappi.NumUsableTextures == d3dappi.NumTextures)
  400.   {
  401.     BOOL bInVideo;
  402.     ATTEMPT(D3DAppILoadTextureSurf(d3dappi.NumTextures, &bInVideo));
  403.     if (!bInVideo && d3dappi.ThisDriver.bIsHardware){
  404.       D3DAppIReleaseTexture(d3dappi.NumTextures);
  405.     }else{
  406.       ATTEMPT(D3DAppIGetTextureHandle(d3dappi.NumTextures));
  407.       ++d3dappi.NumUsableTextures;
  408.     }
  409.   }
  410.   d3dappi.NumTextures++;
  411.   return TRUE;
  412.   
  413. exit_with_error:
  414.   d3dappi.ImageFile[d3dappi.NumTextures][0] = 0;
  415.   return FALSE;
  416. }
  418. BOOL D3DAppChangeTextureFormat(int format)
  419. {
  420.   d3dappi.bRenderingIsOK = FALSE;
  421.   D3DAppIReleaseAllTextures();
  422.   d3dappi.CurrTextureFormat = format;
  423.   memcpy(&d3dappi.ThisTextureFormat, &d3dappi.TextureFormat[format],
  424.     sizeof(D3DAppTextureFormat));
  425.   ATTEMPT(D3DAppILoadAllTextures());
  426.   d3dappi.bRenderingIsOK = TRUE;
  427.   return TRUE;
  428.   
  429. exit_with_error:
  430.   D3DAppIReleaseAllTextures();
  431.   return FALSE;
  432. }
  434. BOOL D3DAppDisableTextures(BOOL flag)
  435. {
  436.   int i;
  437.   if (flag == d3dappi.bTexturesDisabled)
  438.     return TRUE;
  439.   if (flag){
  440.     d3dappi.bTexturesDisabled = TRUE;
  441.     for (i = 0; i < d3dappi.NumTextures; i++)
  442.       d3dappi.TextureHandle[i] = 0;
  443.   }else{
  444.     d3dappi.bTexturesDisabled = FALSE;
  445.     memcpy(d3dappi.TextureHandle, MasterTextureHandle,
  446.       sizeof(D3DTEXTUREHANDLE) * D3DAPP_MAXTEXTURES);
  447.   }
  448.   return TRUE;
  449. }
  451. BOOL D3DAppSwapTextures()
  452. {
  453.   int i;
  454.   char tempfile[30];
  455.   LPDIRECT3DTEXTURE2 lptempTexture;
  456.   LPDIRECTDRAWSURFACE lptempSurface;
  457.   if (d3dappi.bTexturesDisabled || d3dappi.NumTextures == 0){
  458.     D3DAppISetErrorString("Cannot swap textures which are disable or not loaded.n");
  459.     goto exit_with_error;
  460.   }
  461.   if (!d3dappi.ThisDriver.bDoesTextures)
  462.     return TRUE;
  463.   for (i = 0; i < d3dappi.NumUsableTextures - 1; i++){
  464.     lstrcpy(tempfile, d3dappi.ImageFile[i]);
  465.     lstrcpy(d3dappi.ImageFile[i], d3dappi.ImageFile[i+1]);
  466.     lstrcpy(d3dappi.ImageFile[i+1], tempfile);
  467.     d3dappi.lpD3DDevice->SwapTextureHandles(d3dappi.lpTexture[i],
  468.       d3dappi.lpTexture[i+1]);
  469.     lptempTexture = d3dappi.lpTexture[i];
  470.     d3dappi.lpTexture[i] = d3dappi.lpTexture[i+1];
  471.     d3dappi.lpTexture[i+1] = lptempTexture;
  472.     lptempSurface = d3dappi.lpTextureSurf[i];
  473.     d3dappi.lpTextureSurf[i] = d3dappi.lpTextureSurf[i+1];
  474.     d3dappi.lpTextureSurf[i+1] = lptempSurface;
  475.   }
  476.   return TRUE;
  477. exit_with_error:
  478.   return FALSE;
  479. }
  481. #include <vfw.h> 
  483.          BOOL bAnimationOK=FALSE;
  484.    PAVISTREAM lpaviStream=NULL;
  485.     PGETFRAME lpgfFrame=NULL;
  486. AVISTREAMINFO lpsiStreamInfo;
  488. HRESULT CreateEmptyTexture(LPDIRECT3DRM3 lpD3DRM,DWORD dwWidth,DWORD dwHeight,LPDIRECT3DRMTEXTURE3 *lpD3DRMTexture3)
  489. {
  490.   HRESULT hr;
  491.   DDSURFACEDESC ddsd;
  492.   LPDIRECTDRAWSURFACE lpDDS;
  494.   ddsd.dwSize=sizeof(ddsd);
  495.   ddsd.dwFlags =DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS;
  496.   ddsd.dwWidth =dwWidth;
  497.   ddsd.dwHeight=dwHeight;
  498.   ddsd.ddsCaps.dwCaps=DDSCAPS_3DDEVICE|DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY;
  499.   hr=d3dappi.lpDD->CreateSurface(&ddsd,&lpDDS,NULL);
  500.   if(FAILED(hr)) return hr;
  501.   hr=lpD3DRM->CreateTextureFromSurface(lpDDS,lpD3DRMTexture3);
  502.   if(FAILED(hr)) return hr;
  503.   return S_OK;
  504. }
  506. HRESULT AVITextureInit(char *AVIFileName)
  507. {
  508.   HRESULT hr;
  509.   AVIFileInit();
  510.   if(FAILED(hr=AVIStreamOpenFromFile(&lpaviStream,AVIFileName,streamtypeVIDEO,0,OF_READ,NULL)))
  511.   {
  512.     return E_FAIL;
  513.   }
  514.   if(NULL==(lpgfFrame=AVIStreamGetFrameOpen(lpaviStream,NULL))) return E_FAIL;
  515.   if(FAILED(hr=AVIStreamInfo(lpaviStream,&lpsiStreamInfo,sizeof(AVISTREAMINFO)))) return E_FAIL;
  516.   return S_OK;
  517. }
  519. static DWORD dwOldFrame=-1;
  520. static DWORD dwCurrFrame=-1;
  522. BOOL CheckFrameChanged(void)
  523. {
  524.   static FLOAT fAVIStartTime=((FLOAT)clock())/CLOCKS_PER_SEC;
  525.   FLOAT fCurrTime    =((FLOAT)clock())/CLOCKS_PER_SEC;
  526.   FLOAT fElapsedTime =fCurrTime-fAVIStartTime;
  527.   FLOAT fAVITimeScale=((FLOAT)lpsiStreamInfo.dwRate)/lpsiStreamInfo.dwScale;
  528.   dwCurrFrame  =(DWORD)(fElapsedTime*fAVITimeScale);
  529.   if(dwCurrFrame>=lpsiStreamInfo.dwLength){
  530.     fAVIStartTime=((FLOAT)clock())/CLOCKS_PER_SEC;
  531.     dwCurrFrame  =lpsiStreamInfo.dwStart+1;
  532.   }
  533.   if(dwCurrFrame!=dwOldFrame){
  534.     dwOldFrame=dwCurrFrame;
  535.     return TRUE;
  536.   }else{
  537.     return FALSE;
  538.   }
  539. }
  541. HRESULT AVIUpdateTexture(LPDIRECT3DRM3 lpD3DRM,LPDIRECT3DRMTEXTURE3 *lpD3DRMTexture3)
  542. {
  543.   BITMAPINFO* lpbmi;
  544.   if(!lpgfFrame) return E_FAIL;
  545.   if(FAILED(lpbmi=(BITMAPINFO*)AVIStreamGetFrame(lpgfFrame,dwCurrFrame))) return E_FAIL;
  546.   LPBITMAPINFOHEADER lpMapInfoHeader=(LPBITMAPINFOHEADER)&lpbmi->bmiHeader;
  548.   HRESULT hr;
  549.   hr=CreateEmptyTexture(lpD3DRM,lpMapInfoHeader->biWidth,lpMapInfoHeader->biHeight,lpD3DRMTexture3);
  550.   if(FAILED(hr)) return hr;
  551.   LPDIRECTDRAWSURFACE lpddsTexture;
  552.   hr=(*lpD3DRMTexture3)->GetSurface(0,&lpddsTexture);
  553.   if(FAILED(hr)) return hr;
  554.   DDSURFACEDESC ddsd;
  555.   ddsd.dwSize=sizeof(ddsd);
  556.   hr=lpddsTexture->Lock(NULL,&ddsd,DDLOCK_WAIT|DDLOCK_WRITEONLY,NULL);
  557.   if(FAILED(hr)) return hr;
  558.   BOOL bTextureIs565=(ddsd.ddpfPixelFormat.dwGBitMask==0x7E0)?TRUE:FALSE;
  559.   WORD* lpwSrc =(WORD*)((BYTE*)lpbmi+lpMapInfoHeader->biSize);
  560.   WORD* lpDest=(WORD*)ddsd.lpSurface;
  561.   if(lpMapInfoHeader->biBitCount==24){
  562.     if(ddsd.ddpfPixelFormat.dwRGBBitCount==16){
  563.       long i,j,d;
  564.       WORD R,G,B;
  565.       d=lpMapInfoHeader->biWidth*lpMapInfoHeader->biBitCount/8;
  566.       BYTE *lpbSrc=(BYTE*)lpwSrc+d*(lpMapInfoHeader->biHeight-1);
  567.       if(bTextureIs565){
  568.         for(i=0;i<lpMapInfoHeader->biHeight;i++){
  569.           for(j=0;j<lpMapInfoHeader->biWidth;j++){
  570.             B=((*lpbSrc++&0xF8)>>3);
  571.             G=((*lpbSrc++&0xFC)<<3);
  572.             R=((*lpbSrc++&0xF8)<<8);
  573.             *lpDest++=R|G|B;
  574.           }
  575.           lpbSrc-=d*2;
  576.         }
  577.       }else{
  578.         for(i=0;i<lpMapInfoHeader->biHeight;i++){
  579.           for(j=0;j<lpMapInfoHeader->biWidth;j++){
  580.             B=((*lpbSrc++&0xF8)>>3);
  581.             G=((*lpbSrc++&0xF8)<<2);
  582.             R=((*lpbSrc++&0xF8)<<7);
  583.             *lpDest++=R|G|B;
  584.           }
  585.           lpbSrc-=d*2;
  586.         }
  587.       }
  588.     }
  589.   }else if(lpMapInfoHeader->biBitCount==16){
  590.     if(bTextureIs565){
  591.       for(DWORD i=0;i<128*128;i++){
  592.         WORD color=*lpwSrc++;
  593.         *lpDest++=((color&0x1F)|((color&0xFFE0)<<1));
  594.       }
  595.     }else{
  596.       memcpy(lpDest,lpwSrc,128*128*2);
  597.     }
  598.   }
  599.   lpddsTexture->Unlock(NULL);
  600.   bAnimationOK=TRUE;
  601.   return S_OK;
  602. }
  604. HRESULT AVITextureQuit(void)
  605. {
  606.   if(lpaviStream) AVIStreamRelease(lpaviStream);
  607.   AVIFileExit();
  608.   bAnimationOK=FALSE;
  609.   return S_OK;
  610. }
  612. extern rmfullglobals myglobs;
  613. extern LPDIRECT3DRM3 g_lpD3DRM;
  614. extern char g_tszPathName[256];
  616. LPDIRECT3DRMTEXTURE3 g_TreeDecalTex=NULL;
  617. LPDIRECT3DRMFRAME3 g_TreeDecal=NULL;
  619. BOOL CreateTreeDecal(LPDIRECT3DRM3 pD3DRM,LPDIRECT3DRMFRAME3 pScene,D3DVALUE x,D3DVALUE y,D3DVALUE z)
  620. {
  621.   LPDIRECT3DRMTEXTURE3 TreeDecalTex=NULL;
  622.   LPDIRECT3DRMFRAME3 TreeDecal=NULL;
  623.   TCHAR  strPath[MAX_PATH];
  624.   lstrcpy( strPath, g_tszPathName );
  625.   lstrcat( strPath, "\Media" );
  626.   lstrcat( strPath, "\Fire.avi" );
  628.   if (FAILED(AVITextureInit(strPath)))
  629.     goto generic_error;
  630.   if (FAILED(pD3DRM->CreateFrame(pScene,&TreeDecal)))
  631.     goto generic_error;
  632.   CheckFrameChanged();
  633.   if (FAILED(AVIUpdateTexture(pD3DRM,&TreeDecalTex)))
  634.     goto generic_error;
  635.   if (FAILED(TreeDecalTex->SetDecalScale(TRUE)))
  636.     goto generic_error;
  637.   if (FAILED(TreeDecalTex->SetDecalSize(D3DVAL(2.0),D3DVAL(2.0))))
  638.     goto generic_error;
  639.   if (FAILED(TreeDecalTex->SetDecalOrigin(128,0)))
  640.     goto generic_error;
  641.   if (FAILED(TreeDecalTex->SetDecalTransparentColor(RGB_MAKE(255,0,0))))
  642.     goto generic_error;
  643.   if (FAILED(TreeDecalTex->SetDecalTransparency(TRUE)))
  644.     goto generic_error;
  645.   if (FAILED(TreeDecal->SetPosition(pScene,x,y,z)))
  646.     goto generic_error;
  647.   if (FAILED(TreeDecal->AddVisual((LPDIRECT3DRMVISUAL)TreeDecalTex)))
  648.     goto generic_error;
  649.   g_TreeDecalTex=TreeDecalTex;
  650.   g_TreeDecal=TreeDecal;
  651. SAFE_RELEASE( TreeDecalTex );
  652. SAFE_RELEASE( TreeDecal );
  653.   return TRUE;
  654. generic_error:
  655. Msg("A failure has occurred while building the scene.n");
  656. SAFE_RELEASE( TreeDecalTex );
  657. SAFE_RELEASE( TreeDecal );
  658.   return FALSE;
  659. }
  661. BOOL AVIUpdateDecal(void)
  662. {
  663.   LPDIRECT3DRMTEXTURE3 TreeDecalTex;
  665.   if(!bAnimationOK) return FALSE;
  666.   if(!CheckFrameChanged()) return FALSE;
  667.   if (FAILED(g_TreeDecal->DeleteVisual(g_TreeDecalTex)))
  668.     goto generic_error;
  669.   if (FAILED(AVIUpdateTexture(g_lpD3DRM,&TreeDecalTex)))
  670.     goto generic_error;
  671.   if (FAILED(TreeDecalTex->SetDecalScale(TRUE)))
  672.     goto generic_error;
  673.   if (FAILED(TreeDecalTex->SetDecalSize(D3DVAL(2.0),D3DVAL(2.0))))
  674.     goto generic_error;
  675.   if (FAILED(TreeDecalTex->SetDecalOrigin(128,0)))
  676.     goto generic_error;
  677.   if (FAILED(TreeDecalTex->SetDecalTransparentColor(RGB_MAKE(255,0,0))))
  678.     goto generic_error;
  679.   if (FAILED(TreeDecalTex->SetDecalTransparency(TRUE)))
  680.     goto generic_error;
  681.   if (FAILED(g_TreeDecal->AddVisual((LPDIRECT3DRMVISUAL)TreeDecalTex)))
  682.     goto generic_error;
  683.   g_TreeDecalTex=TreeDecalTex;
  684. SAFE_RELEASE( TreeDecalTex );
  685.   return TRUE;
  686. generic_error:
  687. SAFE_RELEASE( TreeDecalTex );
  688.   return FALSE;
  689. }
  691. typedef struct _TEXTURESEARCHINFO
  692. {
  693.   DWORD dwDesiredBPP;
  694.    BOOL bUseAlpha;
  695.    BOOL bUsePalette;
  696.    BOOL bFoundGoodFormat;
  697.   
  698.   DDPIXELFORMAT *lpddpf;
  699. } TEXTURESEARCHINFO, *LPTEXTURESEARCHINFO, **LPPTEXTURESEARCHINFO;
  701. static HRESULT CALLBACK TextureSearchCallback(DDSURFACEDESC *lpddsd,VOID *param)
  702. {
  703.   DDPIXELFORMAT *lpddpf=&(lpddsd->ddpfPixelFormat);
  704.   if(NULL==lpddpf||NULL==param) return DDENUMRET_OK;
  705.   
  706.   TEXTURESEARCHINFO *lptsi=(TEXTURESEARCHINFO *)param;
  707.   if(lpddpf->dwFlags&(DDPF_LUMINANCE|DDPF_BUMPLUMINANCE|DDPF_BUMPDUDV)) return DDENUMRET_OK;
  708.   if(lptsi->bUsePalette){
  709.     if(!(lpddpf->dwFlags&DDPF_PALETTEINDEXED8)) return DDENUMRET_OK;
  710.     memcpy(lptsi->lpddpf,lpddpf,sizeof(DDPIXELFORMAT));
  711.     lptsi->bFoundGoodFormat=TRUE;
  712.     return DDENUMRET_CANCEL;
  713.   }
  714.   if(lpddpf->dwRGBBitCount<16) return DDENUMRET_OK;
  715.   if(lpddpf->dwFourCC!=0) return DDENUMRET_OK;
  716.   if(lpddpf->dwRGBAlphaBitMask==0x00008000) return DDENUMRET_OK;
  717.   if((lptsi->bUseAlpha==TRUE)&&!(lpddpf->dwFlags&DDPF_ALPHAPIXELS)) return DDENUMRET_OK;
  718.   if((lptsi->bUseAlpha==FALSE)&&(lpddpf->dwFlags&DDPF_ALPHAPIXELS)) return DDENUMRET_OK;
  719.   if(lpddpf->dwRGBBitCount==lptsi->dwDesiredBPP){
  720.     memcpy(lptsi->lpddpf,lpddpf,sizeof(DDPIXELFORMAT));
  721.     lptsi->bFoundGoodFormat=TRUE;
  722.     return DDENUMRET_CANCEL;
  723.   }
  724.   return DDENUMRET_OK;
  725. }
  728. HRESULT CreateRGBASurface(LPDIRECT3DRM3 lpD3DRM,LPDIRECT3DRMTEXTURE3 *lpD3DRMTexture3)
  729. {
  730.   HRESULT hr;
  731.   LPDIRECTDRAWSURFACE lpddsTexture;
  732.   DDSURFACEDESC ddsd;
  733.   TEXTURESEARCHINFO tsi;
  735.   tsi.bFoundGoodFormat = FALSE;
  736.   tsi.dwDesiredBPP     = 16;
  737.   tsi.bUsePalette      = FALSE;
  738.   tsi.bUseAlpha        = TRUE;
  739.   tsi.lpddpf           = &ddsd.ddpfPixelFormat;
  740.   d3dappi.lpD3DDevice->EnumTextureFormats(TextureSearchCallback,&tsi);
  741.   if(!tsi.bFoundGoodFormat) return E_FAIL;
  742.   ddsd.dwSize=sizeof(ddsd);
  743.   ddsd.dwFlags =DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS|DDSD_PIXELFORMAT;
  744.   ddsd.dwWidth =256;
  745.   ddsd.dwHeight=256;
  746.   ddsd.ddsCaps.dwCaps=DDSCAPS_3DDEVICE|DDSCAPS_TEXTURE|DDSCAPS_SYSTEMMEMORY;
  747.   hr=d3dappi.lpDD->CreateSurface(&ddsd,&lpddsTexture,NULL);
  748.   if(FAILED(hr)) return hr;
  749.   hr=lpD3DRM->CreateTextureFromSurface(lpddsTexture,lpD3DRMTexture3);
  750.   if(FAILED(hr)) return hr;
  752.   while(lpddsTexture->Lock(NULL,&ddsd,0,0)==DDERR_WASSTILLDRAWING);
  753.   DWORD lPitch=ddsd.lPitch;
  754.   BYTE* pBytes=(BYTE*)ddsd.lpSurface;
  755.   
  756.   DWORD dwRMask=ddsd.ddpfPixelFormat.dwRBitMask;
  757.   DWORD dwGMask=ddsd.ddpfPixelFormat.dwGBitMask;
  758.   DWORD dwBMask=ddsd.ddpfPixelFormat.dwBBitMask;
  759.   DWORD dwAMask=ddsd.ddpfPixelFormat.dwRGBAlphaBitMask;
  760.   
  761.   DWORD dwRShiftL=8,dwRShiftR=0;
  762.   DWORD dwGShiftL=8,dwGShiftR=0;
  763.   DWORD dwBShiftL=8,dwBShiftR=0;
  764.   DWORD dwAShiftL=8,dwAShiftR=0;
  765.   
  766.   DWORD dwMask;
  767.   for(dwMask=dwRMask;dwMask&&!(dwMask&0x1);dwMask>>=1) dwRShiftR++;
  768.   for(;dwMask;dwMask>>=1)dwRShiftL--;
  769.   for(dwMask=dwGMask;dwMask&&!(dwMask&0x1);dwMask>>=1) dwGShiftR++;
  770.   for(;dwMask;dwMask>>=1)dwGShiftL--;
  771.   for(dwMask=dwBMask;dwMask&&!(dwMask&0x1);dwMask>>=1) dwBShiftR++;
  772.   for(;dwMask;dwMask>>=1)dwBShiftL--;
  773.   for(dwMask=dwAMask;dwMask&&!(dwMask&0x1);dwMask>>=1) dwAShiftR++;
  774.   for(;dwMask;dwMask>>=1)dwAShiftL--;
  775.   for(DWORD y=0;y<ddsd.dwHeight;y++){
  776.     DWORD* pDstData32=(DWORD*)pBytes;
  777.      WORD* pDstData16=( WORD*)pBytes;
  778.     for(DWORD x=0;x<ddsd.dwWidth;x++){
  779.       DWORD dwPixel = 0xFF000000;
  780.       dwPixel|=x;
  781.       BYTE r=(BYTE)((dwPixel>>24)&0x000000ff);
  782.       BYTE g=(BYTE)((dwPixel>>16)&0x000000ff);
  783.       BYTE b=(BYTE)((dwPixel>> 8)&0x000000ff);
  784.       BYTE a=(BYTE)((dwPixel>> 0)&0x000000ff);
  785.       DWORD dr=((r>>(dwRShiftL))<<dwRShiftR)&dwRMask;
  786.       DWORD dg=((g>>(dwGShiftL))<<dwGShiftR)&dwGMask;
  787.       DWORD db=((b>>(dwBShiftL))<<dwBShiftR)&dwBMask;
  788.       DWORD da=((a>>(dwAShiftL))<<dwAShiftR)&dwAMask;
  789.       if(32==ddsd.ddpfPixelFormat.dwRGBBitCount) pDstData32[x] = (DWORD)(dr+dg+db+da);
  790.       else                                       pDstData16[x] = ( WORD)(dr+dg+db+da);
  791.     }
  792.     pBytes += ddsd.lPitch;
  793.   }
  794.   lpddsTexture->Unlock(0);
  795.   return DD_OK;
  796. }
  799. BOOL CreateTreeDecalAlpha(LPDIRECT3DRM3 pD3DRM,LPDIRECT3DRMFRAME3 pScene,D3DVALUE x,D3DVALUE y,D3DVALUE z)
  800. {
  801.   LPDIRECT3DRMTEXTURE3 TreeDecalTex=NULL;
  802.   LPDIRECT3DRMFRAME3 TreeDecal=NULL;
  803.   if (FAILED(pD3DRM->CreateFrame(pScene,&TreeDecal)))
  804.     goto generic_error;
  805.   if (FAILED(CreateRGBASurface(pD3DRM,&TreeDecalTex)))
  806.     goto generic_error;
  807.   if (FAILED(TreeDecalTex->SetDecalScale(TRUE)))
  808.     goto generic_error;
  809.   if (FAILED(TreeDecalTex->SetDecalSize(D3DVAL(2.0),D3DVAL(2.0))))
  810.     goto generic_error;
  811.   if (FAILED(TreeDecalTex->SetDecalOrigin(128,0)))
  812.     goto generic_error;
  813.   if (FAILED(TreeDecalTex->SetDecalTransparency(TRUE)))
  814.     goto generic_error;
  815.   if (FAILED(TreeDecal->SetPosition(pScene,x,y,z)))
  816.     goto generic_error;
  817.   if (FAILED(TreeDecal->AddVisual((LPDIRECT3DRMVISUAL)TreeDecalTex)))
  818.     goto generic_error;
  819.   g_TreeDecalTex=TreeDecalTex;
  820.   g_TreeDecal=TreeDecal;
  821. SAFE_RELEASE( TreeDecalTex );
  822. SAFE_RELEASE( TreeDecal );
  823.   return TRUE;
  824. generic_error:
  825. Msg("A failure has occurred while building the scene.n");
  826. SAFE_RELEASE( TreeDecalTex );
  827. SAFE_RELEASE( TreeDecal );
  828.   return FALSE;
  829. }
  830. BOOL D3DAppSetRenderState(D3DAppRenderState* lpState)
  831. {
  832.   if (!lpState)
  833.     lpState = &d3dapprs;
  834.   if (lpState != &d3dapprs)
  835.     memcpy(&d3dapprs, lpState, sizeof(D3DAppRenderState));
  836.   if (d3dappi.bRenderingIsOK){
  837.     ATTEMPT(D3DAppISetRenderState());
  838.   }
  839.   return TRUE;
  840. exit_with_error:
  841.   return FALSE;
  842. }
  844. BOOL D3DAppGetRenderState(D3DAppRenderState* lpState)
  845. {
  846.   memcpy(lpState, &d3dapprs, sizeof(D3DAppRenderState));
  847.   return TRUE;
  848. }
  849. BOOL D3DAppShowBackBuffer(DWORD flags)
  850. {
  851.   if (!d3dappi.bRenderingIsOK){
  852.     D3DAppISetErrorString("Cannot call D3DAppShowBackBuffer while bRenderingIsOK is FALSE.n");
  853.     return FALSE;
  854.   }
  855.   if (d3dappi.bPaused)
  856.     return TRUE;
  857.   if (d3dappi.bFullscreen){
  858.     int numtemp;
  859.     D3DRECT temp[D3DAPP_MAXCLEARRECTS];
  860.     LastError = d3dappi.lpFrontBuffer->Flip(d3dappi.lpBackBuffer,1);
  861.     if (LastError == DDERR_SURFACELOST){
  862.       d3dappi.lpFrontBuffer->Restore( );
  863.       d3dappi.lpBackBuffer->Restore( );
  864.       D3DAppIClearBuffers();
  865.     }else if (LastError != DD_OK){
  866.       D3DAppISetErrorString("Flipping complex display surface failed.n%s", D3DAppErrorToString(LastError));
  867.       return FALSE;
  868.     }
  869.     if (d3dappi.bBackBufferInVideo){
  870.       D3DAppICopyRectList(&numtemp, temp, NumDirtyClientRects,
  871. DirtyClient);
  872.       D3DAppICopyRectList(&NumDirtyClientRects, DirtyClient,
  873. NumDirtyBackRects, DirtyBack);
  874.       D3DAppICopyRectList(&NumDirtyBackRects, DirtyBack, numtemp, temp);
  875.     }else{
  876.       D3DAppICopyRectList(&NumDirtyClientRects, DirtyClient,
  877.         NumDirtyBackRects, DirtyBack);
  878.     }
  879.   }
  880.   else{
  881.     int NumFrontRects, NumBufferRects, i;
  882.     RECT front[D3DAPP_MAXCLEARRECTS];
  883.     RECT buffer[D3DAPP_MAXCLEARRECTS];
  884.     if (flags & D3DAPP_SHOWALL){
  885.       NumBufferRects = 1;
  886.       SetRect(&buffer[0], 0, 0, d3dappi.szClient.cx,
  887.         d3dappi.szClient.cy);
  888.       SetRect(&front[0],
  889.         d3dappi.pClientOnPrimary.x, d3dappi.pClientOnPrimary.y,
  890.         d3dappi.szClient.cx + d3dappi.pClientOnPrimary.x,
  891.         d3dappi.szClient.cy + d3dappi.pClientOnPrimary.y);
  892.     }else{
  893.       D3DAppIMergeRectLists(&NumBufferRects, (LPD3DRECT)buffer,
  894.         NumDirtyClientRects, DirtyClient,
  895.         NumDirtyBackRects, DirtyBack);
  896.       D3DAppICopyRectList(&NumFrontRects, (LPD3DRECT)front,
  897.         NumBufferRects, (LPD3DRECT)buffer);
  898.       for (i = 0; i < NumFrontRects; i++){
  899.         front[i].top += d3dappi.pClientOnPrimary.y;
  900.         front[i].left += d3dappi.pClientOnPrimary.x;
  901.         front[i].bottom += d3dappi.pClientOnPrimary.y;
  902.         front[i].right += d3dappi.pClientOnPrimary.x;
  903.       }
  904.     }
  905.     for (i = 0; i < NumBufferRects; i++){
  906.       LastError = d3dappi.lpFrontBuffer->Blt(&front[i], d3dappi.lpBackBuffer, &buffer[i], DDBLT_WAIT, NULL);
  907.       if (LastError == DDERR_SURFACELOST){
  908.         d3dappi.lpFrontBuffer->Restore( );
  909.         d3dappi.lpBackBuffer->Restore( );
  910.         D3DAppIClearBuffers();
  911.       }else if (LastError != DD_OK){
  912.         D3DAppISetErrorString("Blt of back buffer to front buffer failed.n%s", D3DAppErrorToString(LastError));
  913.         return FALSE;
  914.       }
  915.     }
  916.     D3DAppICopyRectList(&NumDirtyClientRects, DirtyClient,
  917.       NumDirtyBackRects, DirtyBack);
  918.   }
  919.   return TRUE;
  920. }
  922. BOOL D3DAppRenderExtents(DWORD dwCount, LPD3DRECT extent, DWORD flags)
  923. {
  924.   if (dwCount > D3DAPP_MAXCLEARRECTS){
  925.     D3DAppISetErrorString("The number of clear rectangles exceeded D3DAPP_MAXCLEARRECTS.");
  926.     return FALSE;
  927.   }
  928.   if (flags & D3DAPP_CLEARALL){
  929.     D3DRECT dummy;
  930.     dummy.x1 = dummy.y1 = 0;
  931.     dummy.x2 = d3dappi.szClient.cx;
  932.     dummy.y2 = d3dappi.szClient.cy;
  933.     D3DAppICopyRectList(&NumDirtyBackRects, DirtyBack, 1, &dummy);
  934.     D3DAppICopyRectList(&NumDirtyClientRects, DirtyClient, 1, &dummy);
  935.     D3DAppICopyRectList(&NumDirtyZRects, DirtyZ, 1, &dummy);
  936.   }else{
  937.     D3DAppICopyRectList(&NumDirtyBackRects, DirtyBack, dwCount, extent);
  938.     D3DAppICopyRectList(&NumDirtyZRects, DirtyZ, dwCount, extent);
  939.   }
  940.   return TRUE;
  941. }
  942. BOOL D3DAppClearBackBuffer(DWORD flags)
  943. {
  944.   if (!d3dappi.bRenderingIsOK){
  945.     D3DAppISetErrorString("Cannot call D3DAppClearBackBuffer while bRenderingIsOK is FALSE.n");
  946.     return FALSE;
  947.   }
  948.   if (flags & D3DAPP_CLEARALL){
  949.     int clearflags;
  950.     D3DRECT dummy;
  951.     clearflags = D3DCLEAR_TARGET;
  952.     if (d3dapprs.bZBufferOn)
  953.       clearflags |= D3DCLEAR_ZBUFFER;
  954.     dummy.x1 = dummy.y1 = 0;
  955.     dummy.x2 = d3dappi.szClient.cx;
  956.     dummy.y2 = d3dappi.szClient.cy;
  957.     LastError =
  958.       d3dappi.lpD3DViewport->Clear(1, &dummy,
  959.       clearflags);
  960.     if (LastError != D3D_OK){
  961.       D3DAppISetErrorString("Viewport clear failed.n%s",
  962.         D3DAppErrorToString(LastError));
  963.       return FALSE;
  964.     }
  965.   }else{
  966.     LastError =
  967.       d3dappi.lpD3DViewport->Clear(NumDirtyBackRects,
  968.       DirtyBack, D3DCLEAR_TARGET);
  969.     if (LastError != D3D_OK){
  970.       D3DAppISetErrorString("Viewport clear of back buffer failed.n%s",
  971.         D3DAppErrorToString(LastError));
  972.       return FALSE;
  973.     }
  974.     LastError =d3dappi.lpD3DViewport->Clear(NumDirtyZRects,
  975.       DirtyZ, D3DCLEAR_ZBUFFER);
  976.     if (LastError != D3D_OK){
  977.       D3DAppISetErrorString("Viewport clear of Z buffer failed.n%s",
  978.         D3DAppErrorToString(LastError));
  979.       return FALSE;
  980.     }
  981.   }
  982.   return TRUE;
  983. }
  985. #define CHECKSURF(x) if (x) {
  986.   if (x->IsLost( ) == DDERR_SURFACELOST) {    
  987.   LastError = x->Restore( );              
  988.   if (LastError != DD_OK) goto exit_with_error;   
  989.   b = TRUE;                                       
  990.   }                                                   
  991. }
  993. BOOL D3DAppCheckForLostSurfaces(void)
  994. {
  995.   int i;
  996.   BOOL b = FALSE;
  997.   CHECKSURF(d3dappi.lpFrontBuffer);
  998.   CHECKSURF(d3dappi.lpBackBuffer);
  999.   CHECKSURF(d3dappi.lpZBuffer);
  1000.   if (b){
  1001.     D3DAppIClearBuffers();
  1002.   }
  1003.   for (i = 0; i < d3dappi.NumUsableTextures; i++){
  1004.     b = FALSE;
  1005.     CHECKSURF(d3dappi.lpTextureSurf[i]);
  1006.     if (b){
  1007.       ATTEMPT(D3DAppIReloadTextureSurf(i));
  1008.     }
  1009.   }
  1010.   return TRUE;
  1011. exit_with_error:
  1012.   D3DAppISetErrorString("Restoring of a lost surface failed.n%s",
  1013.     D3DAppErrorToString(LastError));
  1014.   return FALSE;
  1015. }
  1017. BOOL D3DAppPause(BOOL flag)
  1018. {
  1019.   static int pausecount;
  1021.   if (pausecount != 0){
  1022.     if (flag){
  1023.       ++pausecount;
  1024.       return TRUE;
  1025.     }else{
  1026.       --pausecount;
  1027.       if (pausecount != 0)
  1028.         return TRUE;
  1029.     }
  1030.   }
  1031.   
  1032.   d3dappi.bPaused = flag;
  1033.   if (!flag) {
  1034.     if (d3dappi.bFullscreen && bPrimaryPalettized && lpPalette){
  1035.       LastError = lpPalette->SetEntries(0, 0, 256,&ppe[0]);
  1036.       if (LastError != DD_OK){
  1037.         D3DAppISetErrorString("Setting palette entries during unpause failed.n%s", D3DAppErrorToString(LastError));
  1038.         goto exit_with_error;
  1039.       }
  1040.     }
  1041.     D3DAppIValidateDirtyRects();
  1042.   }
  1043.   if (flag && d3dappi.bFullscreen) {
  1044.     if (bPrimaryPalettized && lpPalette){
  1045.       int i;
  1046.       LastError = lpPalette->GetEntries(0, 0, 256,&ppe[0]);
  1047.       if (LastError != DD_OK)
  1048.       {
  1049.         D3DAppISetErrorString("Getting palette entries before a pause failed.n%s", D3DAppErrorToString(LastError));
  1050.         goto exit_with_error;
  1051.       }
  1052.       for (i = 10; i < 246; i++)
  1053.         Originalppe[i] = ppe[i];
  1054.       LastError = lpPalette->SetEntries(0, 0, 256,&Originalppe[0]);
  1055.       if (LastError != DD_OK){
  1056.         D3DAppISetErrorString("Returning palette entries to defaults failed.n%s", D3DAppErrorToString(LastError));
  1057.         goto exit_with_error;
  1058.       }
  1059.     }
  1060.     if (d3dappi.lpDD){
  1061.       LastError = d3dappi.lpDD->FlipToGDISurface( );
  1062.       if (LastError != DD_OK){
  1063.         D3DAppISetErrorString("Flipping to GDI surface failed.n%s", D3DAppErrorToString(LastError));
  1064.         goto exit_with_error;
  1065.       }
  1066.     }
  1067.     DrawMenuBar(d3dappi.hwnd);
  1068.     RedrawWindow(d3dappi.hwnd, NULL, NULL, RDW_FRAME);
  1069.   }
  1070.   return TRUE;
  1071. exit_with_error:
  1072.   return FALSE;
  1073. }
  1074. BOOL D3DAppCreateSurface(DDSURFACEDESC *ddsd, LPDIRECTDRAWSURFACE *lplpSurf)
  1075. {
  1076.   return D3DAppICreateSurface(ddsd, lplpSurf);
  1077. }
  1079. HRESULT D3DAppLastError(void)
  1080. {
  1081.   return LastError;
  1082. }
  1084. char*
  1085. D3DAppLastErrorString(void)
  1086. {
  1087.   return LastErrorString;
  1088. }
  1090. BOOL D3DAppDestroy(void)
  1091. {
  1092.   bD3DAppInitialized = FALSE;
  1093.   d3dappi.bRenderingIsOK = FALSE;
  1094.   d3dappi.hwnd = NULL;
  1095.   ATTEMPT(D3DAppICallDeviceDestroyCallback());
  1096.   D3DAppIReleaseAllTextures();
  1097.   RELEASE(d3dappi.lpD3DDevice);
  1098.   RELEASE(d3dappi.lpZBuffer);
  1099.   RELEASE(lpPalette);
  1100.   RELEASE(lpClipper);
  1101.   RELEASE(d3dappi.lpBackBuffer);
  1102.   RELEASE(d3dappi.lpFrontBuffer);
  1103.   if (d3dappi.bFullscreen) {
  1104.     D3DAppIRestoreDispMode();
  1105.     D3DAppISetCoopLevel(d3dappi.hwnd, FALSE);
  1106.   }
  1107.   D3DAppIReleasePathList();
  1108.   RELEASE(d3dappi.lpD3D);
  1109.   RELEASE(d3dappi.lpDD);
  1110.   memset(&d3dappi, 0, sizeof(d3dappi));
  1111.   return TRUE;
  1112. exit_with_error:
  1113.   return FALSE;
  1114. }
  1116. char* D3DAppErrorToString(HRESULT error)
  1117. {
  1118.   switch(error){
  1119.   case DD_OK:
  1120.     return "No error.";
  1121.   case DDERR_ALREADYINITIALIZED:
  1122.     return "This object is already initialized.";
  1123.   case DDERR_BLTFASTCANTCLIP:
  1124.     return "Return if a clipper object is attached to the source surface passed into a BltFast call.";
  1125.   case DDERR_CANNOTATTACHSURFACE:
  1126.     return "This surface can not be attached to the requested surface.";
  1127.   case DDERR_CANNOTDETACHSURFACE:
  1128.     return "This surface can not be detached from the requested surface.";
  1129.   case DDERR_CANTCREATEDC:
  1130.     return "Windows can not create any more DCs.";
  1131.   case DDERR_CANTDUPLICATE:
  1132.     return "Can't duplicate primary & 3D surfaces, or surfaces that are implicitly created.";
  1133.   case DDERR_CLIPPERISUSINGHWND:
  1134.     return "An attempt was made to set a cliplist for a clipper object that is already monitoring an hwnd.";
  1135.   case DDERR_COLORKEYNOTSET:
  1136.     return "No src color key specified for this operation.";
  1137.   case DDERR_CURRENTLYNOTAVAIL:
  1138.     return "Support is currently not available.";
  1139.   case DDERR_DIRECTDRAWALREADYCREATED:
  1140.     return "A DirectDraw object representing this driver has already been created for this process.";
  1141.   case DDERR_EXCEPTION:
  1142.     return "An exception was encountered while performing the requested operation.";
  1143.   case DDERR_EXCLUSIVEMODEALREADYSET:
  1144.     return "An attempt was made to set the cooperative level when it was already set to exclusive.";
  1145.   case DDERR_GENERIC:
  1146.     return "Generic failure.";
  1147.   case DDERR_HEIGHTALIGN:
  1148.     return "Height of rectangle provided is not a multiple of reqd alignment.";
  1149.   case DDERR_HWNDALREADYSET:
  1150.     return "The CooperativeLevel HWND has already been set. It can not be reset while the process has surfaces or palettes created.";
  1151.   case DDERR_HWNDSUBCLASSED:
  1152.     return "HWND used by DirectDraw CooperativeLevel has been subclassed, this prevents DirectDraw from restoring state.";
  1153.   case DDERR_IMPLICITLYCREATED:
  1154.     return "This surface can not be restored because it is an implicitly created surface.";
  1155.   case DDERR_INCOMPATIBLEPRIMARY:
  1156.     return "Unable to match primary surface creation request with existing primary surface.";
  1157.   case DDERR_INVALIDCAPS:
  1158.     return "One or more of the caps bits passed to the callback are incorrect.";
  1159.   case DDERR_INVALIDCLIPLIST:
  1160.     return "DirectDraw does not support the provided cliplist.";
  1161.   case DDERR_INVALIDDIRECTDRAWGUID:
  1162.     return "The GUID passed to DirectDrawCreate is not a valid DirectDraw driver identifier.";
  1163.   case DDERR_INVALIDMODE:
  1164.     return "DirectDraw does not support the requested mode.";
  1165.   case DDERR_INVALIDOBJECT:
  1166.     return "DirectDraw received a pointer that was an invalid DIRECTDRAW object.";
  1167.   case DDERR_INVALIDPARAMS:
  1168.     return "One or more of the parameters passed to the function are incorrect.";
  1169.   case DDERR_INVALIDPIXELFORMAT:
  1170.     return "The pixel format was invalid as specified.";
  1171.   case DDERR_INVALIDPOSITION:
  1172.     return "Returned when the position of the overlay on the destination is no longer legal for that destination.";
  1173.   case DDERR_INVALIDRECT:
  1174.     return "Rectangle provided was invalid.";
  1175.   case DDERR_LOCKEDSURFACES:
  1176.     return "Operation could not be carried out because one or more surfaces are locked.";
  1177.   case DDERR_NO3D:
  1178.     return "There is no 3D present.";
  1179.   case DDERR_NOALPHAHW:
  1180.     return "Operation could not be carried out because there is no alpha accleration hardware present or available.";
  1181.   case DDERR_NOBLTHW:
  1182.     return "No blitter hardware present.";
  1183.   case DDERR_NOCLIPLIST:
  1184.     return "No cliplist available.";
  1185.   case DDERR_NOCLIPPERATTACHED:
  1186.     return "No clipper object attached to surface object.";
  1187.   case DDERR_NOCOLORCONVHW:
  1188.     return "Operation could not be carried out because there is no color conversion hardware present or available.";
  1189.   case DDERR_NOCOLORKEY:
  1190.     return "Surface doesn't currently have a color key";
  1191.   case DDERR_NOCOLORKEYHW:
  1192.     return "Operation could not be carried out because there is no hardware support of the destination color key.";
  1193.   case DDERR_NOCOOPERATIVELEVELSET:
  1194.     return "Create function called without DirectDraw object method SetCooperativeLevel being called.";
  1195.   case DDERR_NODC:
  1196.     return "No DC was ever created for this surface.";
  1197.   case DDERR_NODDROPSHW:
  1198.     return "No DirectDraw ROP hardware.";
  1199.   case DDERR_NODIRECTDRAWHW:
  1200.     return "A hardware-only DirectDraw object creation was attempted but the driver did not support any hardware.";
  1201.   case DDERR_NOEMULATION:
  1202.     return "Software emulation not available.";
  1203.   case DDERR_NOEXCLUSIVEMODE:
  1204.     return "Operation requires the application to have exclusive mode but the applic.hation does not have exclusive mode.";
  1205.   case DDERR_NOFLIPHW:
  1206.     return "Flipping visible surfaces is not supported.";
  1207.   case DDERR_NOGDI:
  1208.     return "There is no GDI present.";
  1209.   case DDERR_NOHWND:
  1210.     return "Clipper notification requires an HWND or no HWND has previously been set as the CooperativeLevel HWND.";
  1211.   case DDERR_NOMIRRORHW:
  1212.     return "Operation could not be carried out because there is no hardware present or available.";
  1213.   case DDERR_NOOVERLAYDEST:
  1214.     return "Returned when GetOverlayPosition is called on an overlay that UpdateOverlay has never been called on to establish a destination.";
  1215.   case DDERR_NOOVERLAYHW:
  1216.     return "Operation could not be carried out because there is no overlay hardware present or available.";
  1217.   case DDERR_NOPALETTEATTACHED:
  1218.     return "No palette object attached to this surface.";
  1219.   case DDERR_NOPALETTEHW:
  1220.     return "No hardware support for 16 or 256 col palettes.";
  1221.   case DDERR_NORASTEROPHW:
  1222.     return "Operation could not be carried out because there is no appropriate raster op hardware present or available.";
  1223.   case DDERR_NOROTATIONHW:
  1224.     return "Operation could not be carried out because there is no rotation hardware present or available.";
  1225.   case DDERR_NOSTRETCHHW:
  1226.     return "Operation could not be carried out because there is no hardware support for stretching.";
  1227.   case DDERR_NOT4BITCOLOR:
  1228.     return "DirectDrawSurface is not in 4 bit color palette and the requested operation requires 4 bit color palette.";
  1229.   case DDERR_NOT4BITCOLORINDEX:
  1230.     return "DirectDrawSurface is not in 4 bit color index palette and the requested operation requires 4 bit color index palette.";
  1231.   case DDERR_NOT8BITCOLOR:
  1232.     return "DirectDrawSurface is not in 8 bit color mode and the requested operation requires 8 bit color.";
  1233.   case DDERR_NOTAOVERLAYSURFACE:
  1234.     return "Returned when an overlay member is called for a non-overlay surface.";
  1235.   case DDERR_NOTEXTUREHW:
  1236.     return "Operation could not be carried out because there is no texture mapping hardware present or available.";
  1237.   case DDERR_NOTFLIPPABLE:
  1238.     return "An attempt has been made to flip a surface that is not flippable.";
  1239.   case DDERR_NOTFOUND:
  1240.     return "Requested item was not found.";
  1241.   case DDERR_NOTLOCKED:
  1242.     return "Surface was not locked.  An attempt to unlock a surface that was not locked at all, or by this process, has been attempted.";
  1243.   case DDERR_NOTPALETTIZED:
  1244.     return "The surface being used is not a palette-based surface.";
  1245.   case DDERR_NOVSYNCHW:
  1246.     return "Operation could not be carried out because there is no hardware support for vertical blank synchronized operations.";
  1247.   case DDERR_NOZBUFFERHW:
  1248.     return "Operation could not be carried out because there is no hardware support for zbuffer blitting.";
  1249.   case DDERR_NOZOVERLAYHW:
  1250.     return "Overlay surfaces could not be z layered based on their BltOrder because the hardware does not support z layering of overlays.";
  1251.   case DDERR_OUTOFCAPS:
  1252.     return "The hardware needed for the requested operation has already been allocated.";
  1253.   case DDERR_OUTOFMEMORY:
  1254.     return "DirectDraw does not have enough memory to perform the operation.";
  1255.   case DDERR_OUTOFVIDEOMEMORY:
  1256.     return "DirectDraw does not have enough memory to perform the operation.";
  1257.   case DDERR_OVERLAYCANTCLIP:
  1258.     return "The hardware does not support clipped overlays.";
  1259.   case DDERR_OVERLAYCOLORKEYONLYONEACTIVE:
  1260.     return "Can only have ony color key active at one time for overlays.";
  1261.   case DDERR_OVERLAYNOTVISIBLE:
  1262.     return "Returned when GetOverlayPosition is called on a hidden overlay.";
  1263.   case DDERR_PALETTEBUSY:
  1264.     return "Access to this palette is being refused because the palette is already locked by another thread.";
  1265.   case DDERR_PRIMARYSURFACEALREADYEXISTS:
  1266.     return "This process already has created a primary surface.";
  1267.   case DDERR_REGIONTOOSMALL:
  1268.     return "Region passed to Clipper::GetClipList is too small.";
  1269.   case DDERR_SURFACEALREADYATTACHED:
  1270.     return "This surface is already attached to the surface it is being attached to.";
  1271.   case DDERR_SURFACEALREADYDEPENDENT:
  1272.     return "This surface is already a dependency of the surface it is being made a dependency of.";
  1273.   case DDERR_SURFACEBUSY:
  1274.     return "Access to this surface is being refused because the surface is already locked by another thread.";
  1275.   case DDERR_SURFACEISOBSCURED:
  1276.     return "Access to surface refused because the surface is obscured.";
  1277.   case DDERR_SURFACELOST:
  1278.     return "Access to this surface is being refused because the surface memory is gone. The DirectDrawSurface object representing this surface should have Restore called on it.";
  1279.   case DDERR_SURFACENOTATTACHED:
  1280.     return "The requested surface is not attached.";
  1281.   case DDERR_TOOBIGHEIGHT:
  1282.     return "Height requested by DirectDraw is too large.";
  1283.   case DDERR_TOOBIGSIZE:
  1284.     return "Size requested by DirectDraw is too large, but the individual height and width are OK.";
  1285.   case DDERR_TOOBIGWIDTH:
  1286.     return "Width requested by DirectDraw is too large.";
  1287.   case DDERR_UNSUPPORTED:
  1288.     return "Action not supported.";
  1289.   case DDERR_UNSUPPORTEDFORMAT:
  1290.     return "FOURCC format requested is unsupported by DirectDraw.";
  1291.   case DDERR_UNSUPPORTEDMASK:
  1292.     return "Bitmask in the pixel format requested is unsupported by DirectDraw.";
  1293.   case DDERR_VERTICALBLANKINPROGRESS:
  1294.     return "Vertical blank is in progress.";
  1295.   case DDERR_WASSTILLDRAWING:
  1296.     return "Informs DirectDraw that the previous Blt which is transfering information to or from this Surface is incomplete.";
  1297.   case DDERR_WRONGMODE:
  1298.     return "This surface can not be restored because it was created in a different mode.";
  1299.   case DDERR_XALIGN:
  1300.     return "Rectangle provided was not horizontally aligned on required boundary.";
  1301.   case D3DERR_BADMAJORVERSION:
  1302.     return "D3DERR_BADMAJORVERSION";
  1303.   case D3DERR_BADMINORVERSION:
  1304.     return "D3DERR_BADMINORVERSION";
  1305.   case D3DERR_EXECUTE_LOCKED:
  1306.     return "D3DERR_EXECUTE_LOCKED";
  1307.   case D3DERR_EXECUTE_NOT_LOCKED:
  1308.     return "D3DERR_EXECUTE_NOT_LOCKED";
  1309.   case D3DERR_EXECUTE_CREATE_FAILED:
  1310.     return "D3DERR_EXECUTE_CREATE_FAILED";
  1311.   case D3DERR_EXECUTE_DESTROY_FAILED:
  1312.     return "D3DERR_EXECUTE_DESTROY_FAILED";
  1313.   case D3DERR_EXECUTE_LOCK_FAILED:
  1314.     return "D3DERR_EXECUTE_LOCK_FAILED";
  1315.   case D3DERR_EXECUTE_UNLOCK_FAILED:
  1316.     return "D3DERR_EXECUTE_UNLOCK_FAILED";
  1317.   case D3DERR_EXECUTE_FAILED:
  1318.     return "D3DERR_EXECUTE_FAILED";
  1319.   case D3DERR_EXECUTE_CLIPPED_FAILED:
  1320.     return "D3DERR_EXECUTE_CLIPPED_FAILED";
  1321.   case D3DERR_TEXTURE_NO_SUPPORT:
  1322.     return "D3DERR_TEXTURE_NO_SUPPORT";
  1323.   case D3DERR_TEXTURE_NOT_LOCKED:
  1324.     return "D3DERR_TEXTURE_NOT_LOCKED";
  1325.   case D3DERR_TEXTURE_LOCKED:
  1326.     return "D3DERR_TEXTURELOCKED";
  1327.   case D3DERR_TEXTURE_CREATE_FAILED:
  1328.     return "D3DERR_TEXTURE_CREATE_FAILED";
  1329.   case D3DERR_TEXTURE_DESTROY_FAILED:
  1330.     return "D3DERR_TEXTURE_DESTROY_FAILED";
  1331.   case D3DERR_TEXTURE_LOCK_FAILED:
  1332.     return "D3DERR_TEXTURE_LOCK_FAILED";
  1333.   case D3DERR_TEXTURE_UNLOCK_FAILED:
  1334.     return "D3DERR_TEXTURE_UNLOCK_FAILED";
  1335.   case D3DERR_TEXTURE_LOAD_FAILED:
  1336.     return "D3DERR_TEXTURE_LOAD_FAILED";
  1337.   case D3DERR_MATRIX_CREATE_FAILED:
  1338.     return "D3DERR_MATRIX_CREATE_FAILED";
  1339.   case D3DERR_MATRIX_DESTROY_FAILED:
  1340.     return "D3DERR_MATRIX_DESTROY_FAILED";
  1341.   case D3DERR_MATRIX_SETDATA_FAILED:
  1342.     return "D3DERR_MATRIX_SETDATA_FAILED";
  1343.   case D3DERR_SETVIEWPORTDATA_FAILED:
  1344.     return "D3DERR_SETVIEWPORTDATA_FAILED";
  1345.   case D3DERR_MATERIAL_CREATE_FAILED:
  1346.     return "D3DERR_MATERIAL_CREATE_FAILED";
  1347.   case D3DERR_MATERIAL_DESTROY_FAILED:
  1348.     return "D3DERR_MATERIAL_DESTROY_FAILED";
  1349.   case D3DERR_MATERIAL_SETDATA_FAILED:
  1350.     return "D3DERR_MATERIAL_SETDATA_FAILED";
  1351.   case D3DERR_LIGHT_SET_FAILED:
  1352.     return "D3DERR_LIGHT_SET_FAILED";
  1353.   case D3DRMERR_BADOBJECT:
  1354.     return "D3DRMERR_BADOBJECT";
  1355.   case D3DRMERR_BADTYPE:
  1356.     return "D3DRMERR_BADTYPE";
  1357.   case D3DRMERR_BADALLOC:
  1358.     return "D3DRMERR_BADALLOC";
  1359.   case D3DRMERR_FACEUSED:
  1360.     return "D3DRMERR_FACEUSED";
  1361.   case D3DRMERR_NOTFOUND:
  1362.     return "D3DRMERR_NOTFOUND";
  1363.   case D3DRMERR_NOTDONEYET:
  1364.     return "D3DRMERR_NOTDONEYET";
  1365.   case D3DRMERR_FILENOTFOUND:
  1366.     return "The file was not found.";
  1367.   case D3DRMERR_BADFILE:
  1368.     return "D3DRMERR_BADFILE";
  1369.   case D3DRMERR_BADDEVICE:
  1370.     return "D3DRMERR_BADDEVICE";
  1371.   case D3DRMERR_BADVALUE:
  1372.     return "D3DRMERR_BADVALUE";
  1373.   case D3DRMERR_BADMAJORVERSION:
  1374.     return "D3DRMERR_BADMAJORVERSION";
  1375.   case D3DRMERR_BADMINORVERSION:
  1376.     return "D3DRMERR_BADMINORVERSION";
  1377.   case D3DRMERR_UNABLETOEXECUTE:
  1378.     return "D3DRMERR_UNABLETOEXECUTE";
  1379.   default:
  1380.     return "Unrecognized error value.";
  1381.   }
  1382. }