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

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

Windows编程

开发平台：

Visual C++

RMFULL.CPP：源码内容
  1. /*
  2.  *  Copyright (C) 1995, 1996 Microsoft Corporation. All Rights Reserved.
  3.  *
  4.  *  File: rmfull.cpp
  5.  *
  6.  *  Each of the Direct3D retained mode (D3DRM) samples may be linked with
  7.  *  this file.  It contains the code which allows them to run in the Windows
  8.  *  environment as a window or fullscreen.  It is a modified version of
  9.  *  d3dmain.cpp.  Comparing these two files is instructive.
  10.  *
  11.  *  A window is created using rmfull.res which allows the user to select the
  12.  *  Direct3D driver to use and change the render options.  The D3DApp
  13.  *  collection of functions is used to initialize DirectDraw, Direct3D and
  14.  *  keep surfaces and D3D devices available for rendering.
  15.  *
  16.  *  Frame rate and a screen mode information buffer is Blt'ed to the screen
  17.  *  by functions in rmstats.cpp.
  18.  *
  19.  *  Individual samples are executed through two functions, BuildScene and
  20.  *  OverrideDefaults, as described in rmdemo.h.  Samples can also read
  21.  *  mouse input via ReadMouse.
  22.  */
  24. #include "rmfull.h"
  25. #include <stdarg.h>
  27. /*
  28.  * GLOBAL VARIABLES
  29.  */
  30. D3DAppInfo* d3dapp;     /* Pointer to read only collection of DD and D3D
  31.        objects maintained by D3DApp */
  32. rmfullglobals myglobs;     /* collection of global variables */
  33. LPDIRECT3DRM lpD3DRM; /* Direct3DRM object */
  35. /*
  36.  *  INTERNAL FUNCTION PROTOTYPES
  37.  */
  38. static BOOL AppInit(HINSTANCE hInstance, LPSTR lpCmdLine);
  39. static BOOL CreateD3DApp(LPSTR lpCmdLine);
  40. static BOOL BeforeDeviceDestroyed(LPVOID lpContext);
  41. static BOOL AfterDeviceCreated(int w, int h, LPDIRECT3DVIEWPORT* lpViewport,
  42.        LPVOID lpContext);
  43. void CleanUpAndPostQuit(void);
  44. static void InitGlobals(void);
  45. static BOOL AppPause(BOOL f);
  46. void ReportD3DAppError(void);
  47. static BOOL RenderLoop(void);
  48. static BOOL RestoreSurfaces();
  49. long FAR PASCAL WindowProc(HWND hWnd, UINT message, WPARAM wParam,
  50.    LPARAM lParam );
  51. extern "C" void ReadMouse(int*, int*, int*);
  52. extern "C" char* D3DRMErrorToString(HRESULT error);
  53. BOOL CreateD3DRM(HWND win);
  54. BOOL SetRenderState(void);
  56. /****************************************************************************/
  57. /*                            WinMain                                       */
  58. /****************************************************************************/
  59. /*
  60.  * Initializes the application then enters a message loop which calls sample's
  61.  * RenderScene until a quit message is received.
  62.  */
  63. int PASCAL
  64. WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
  65. int nCmdShow)
  66. {
  67.     int failcount = 0; /* number of times RenderLoop has failed */
  68.     MSG msg;
  69.     HACCEL hAccelApp;
  71.     hPrevInstance;
  72.     /*
  73.      * Create the window and initialize all objects needed to begin rendering
  74.      */
  75.     if(!AppInit(hInstance, lpCmdLine))
  76.      return FALSE;
  77.     hAccelApp = LoadAccelerators(hInstance, "AppAccel");
  79.     while (!myglobs.bQuit) {
  80. /* 
  81.  * Monitor the message queue until there are no pressing
  82.  * messages
  83.  */
  84.         if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
  85.             if (msg.message == WM_QUIT) {
  86. CleanUpAndPostQuit();
  87.                 break;
  88.     }
  89.             if (!myglobs.hWndMain || !TranslateAccelerator(myglobs.hWndMain,
  90.    hAccelApp, &msg)) {
  91.                 TranslateMessage(&msg); 
  92.                 DispatchMessage(&msg);
  93.             }
  94. /* 
  95.  * If the app is not minimized, not about to quit, not paused, either the
  96.  * active fullscreen app or in a window and D3D has been initialized,
  97.  * we can render
  98.  */
  99.         } else if (d3dapp->bRenderingIsOK && !d3dapp->bMinimized
  100.    && !d3dapp->bPaused && !myglobs.bQuit 
  101.    && (d3dapp->bAppActive || !d3dapp->bFullscreen)) {
  102.     /*
  103.      * If were are not in single step mode or if we are and the
  104.      * bDrawAFrame flag is set, render one frame
  105.      */
  106.             if (!(myglobs.bSingleStepMode && !myglobs.bDrawAFrame)) {
  107. /* 
  108.  * Attempt to render a frame, if it fails, take a note.  If
  109.  * rendering fails more than twice, abort execution.
  110.  */
  111. if (!RenderLoop()) {
  112.     ++failcount;
  113.     if (failcount == 3) {
  114. Msg("Rendering has failed too many times.  Aborting execution.n");
  115. CleanUpAndPostQuit();
  116. break;
  117.     }
  118. }
  119.     }
  120.     /*
  121.      * Reset the bDrawAFrame flag if we are in single step mode
  122.      */
  123.             if (myglobs.bSingleStepMode)
  124.                 myglobs.bDrawAFrame = FALSE;
  125.         } else {
  126.     WaitMessage();
  127. }
  128.     }
  129.     DestroyWindow(myglobs.hWndMain);
  130.     return msg.wParam;
  131. }
  133. /****************************************************************************/
  134. /*             D3DApp Initialization and callback functions                 */
  135. /****************************************************************************/
  136. /*
  137.  * AppInit
  138.  * Creates the window and initializes all objects necessary to begin rendering
  139.  */
  140. static BOOL
  141. AppInit(HINSTANCE hInstance, LPSTR lpCmdLine)
  142. {
  143.     WNDCLASS wc;
  144.     HMENU hmenu;
  145.     DWORD flags;
  146.     int i;
  147.     Defaults defaults;
  149.     /*
  150.      * Register the window class
  151.      */
  152.     wc.style = CS_HREDRAW | CS_VREDRAW;
  153.     wc.lpfnWndProc = WindowProc;
  154.     wc.cbClsExtra = 0;
  155.     wc.cbWndExtra = 0;
  156.     wc.hInstance = hInstance;
  157.     wc.hIcon = LoadIcon( hInstance, "AppIcon");
  158.     wc.hCursor = LoadCursor( NULL, IDC_ARROW );
  159.     wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
  160.     wc.lpszMenuName = "AppMenu";
  161.     wc.lpszClassName = "Example";
  162.     if (!RegisterClass(&wc))
  163.         return FALSE;
  164.     /*
  165.      * Initialize the global variables and allow the sample code to override
  166.      * some of these default settings.
  167.      */
  168.     InitGlobals();
  169.     myglobs.hInstApp = hInstance;
  170.     defaults.bNoTextures = myglobs.bNoTextures;
  171.     defaults.bConstRenderQuality = myglobs.bConstRenderQuality;
  172.     defaults.bResizingDisabled = FALSE;
  173.     lstrcpy(defaults.Name, "D3DRM Example");
  174.     OverrideDefaults(&defaults);
  175.     myglobs.bNoTextures = defaults.bNoTextures;
  176.     myglobs.bConstRenderQuality = defaults.bConstRenderQuality;
  177.     myglobs.lpCmdLine = lpCmdLine;
  179.     /*
  180.      * Enumerate the DD drivers
  181.      */
  182.     if (!D3DAppEnumerateDDDevices(&myglobs.NumDDDrivers, &myglobs.DDDriver[0])) {
  183. ReportD3DAppError();
  184. return FALSE;
  185.     }
  186.     /*
  187.      * Choose the last device enumerated which will probably be secondary 3d hardware.
  188.      */
  189.     myglobs.CurrDDDriver = myglobs.NumDDDrivers - 1;
  191.     /*
  192.      * Create the window
  193.      */
  194.     if (defaults.bResizingDisabled)
  195. flags =  WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU |
  196.  WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
  197.     else
  198. flags = WS_OVERLAPPEDWINDOW;
  199.     /*
  200.      * Create a window with some default settings that may change
  201.      */
  202.     myglobs.hWndMain = CreateWindowEx(
  203.           WS_EX_APPWINDOW,
  204.  "Example",
  205.  defaults.Name,
  206.  flags,
  207.          CW_USEDEFAULT, CW_USEDEFAULT,
  208.  START_WIN_SIZE, START_WIN_SIZE,
  209.          NULL,     /* parent window */
  210.  NULL,     /* menu handle */
  211.  hInstance,     /* program handle */
  212.  NULL);     /* create parms */
  213.     if (!myglobs.hWndMain){
  214.      Msg("CreateWindowEx failed");
  215.      return FALSE;
  216.     }
  217.     /*
  218.      * Display the window
  219.      */
  220.     ShowWindow(myglobs.hWndMain, SW_SHOWNORMAL);
  221.     UpdateWindow(myglobs.hWndMain);
  222.     /*
  223.      * Add the list of DD drivers D3DApp found to the file menu
  224.      */
  225.     hmenu = GetSubMenu(GetMenu(myglobs.hWndMain), 0);
  226.     for (i = 0; i < myglobs.NumDDDrivers; i++) {
  227.         InsertMenu(hmenu,  6 + i, MF_BYPOSITION | MF_STRING,
  228.    MENU_FIRST_DDDRIVER + i, myglobs.DDDriver[i].Name);
  229.     }
  230.     /* 
  231.      * Create the D3DRM object which are initialized only when the program
  232.      * starts
  233.      */
  234.     if (!CreateD3DRM(myglobs.hWndMain))
  235.         return FALSE;
  236.     /*
  237.      * Call D3DApp to initialize all DD and D3D objects necessary to render.
  238.      * D3DApp will call the device creation callback which will initialize the
  239.      * viewport and the sample's execute buffers.
  240.      */
  241.     if (!CreateD3DApp(lpCmdLine))
  242. return FALSE;
  243.     /*
  244.      * Create the scene to be rendered by calling this sample's BuildScene
  245.      */
  246.     if (!BuildScene(myglobs.dev, myglobs.view, myglobs.scene, myglobs.camera))
  247. return FALSE;
  249.     return TRUE;
  250. }
  252. /*
  253.  * CreateD3DRM
  254.  * Create main D3DRM objects which are only initialized once.
  255.  */
  256. BOOL
  257. CreateD3DRM(HWND win)
  258. {
  259.     HRESULT rval;
  261.     /*
  262.      * Create the D3DRM object
  263.      */
  264.     rval = Direct3DRMCreate(&lpD3DRM);
  265.     if (rval != D3DRM_OK) {
  266. Msg("Failed to create Direct3DRM.n%s", D3DAppErrorToString(rval));
  267. return FALSE;
  268.     }
  269.     /*
  270.      * Create the master scene frame and camera frame
  271.      */
  272.     rval = lpD3DRM->CreateFrame(NULL, &myglobs.scene);
  273.     if (rval != D3DRM_OK) {
  274. Msg("Failed to create the master scene frame.n%s", D3DAppErrorToString(rval));
  275. return FALSE;
  276.     }
  277.     rval = lpD3DRM->CreateFrame(myglobs.scene, &myglobs.camera);
  278.     if (rval != D3DRM_OK) {
  279. Msg("Failed to create the camera's frame.n%s", D3DAppErrorToString(rval));
  280. return FALSE;
  281.     }
  282.     rval = myglobs.camera->SetPosition(myglobs.scene, D3DVAL(0.0), D3DVAL(0.0), D3DVAL(0.0));
  283.     if (rval != D3DRM_OK) {
  284. Msg("Failed to position the camera in the frame.n%s", D3DAppErrorToString(rval));
  285. return FALSE;
  286.     }
  287.     return TRUE;
  288. }
  290. /*
  291.  * CreateD3DApp
  292.  * Create all DirectDraw and Direct3D objects necessary to begin rendering.
  293.  * Add the list of D3D drivers to the file menu.
  294.  */
  295. static BOOL
  296. CreateD3DApp(LPSTR lpCmdLine)
  297. {
  298.     HMENU hmenu;
  299.     int i;
  300.     LPSTR option;
  301.     BOOL bOnlySystemMemory, bOnlyEmulation;
  302.     DWORD flags;
  304.     /*
  305.      * Parse the command line in seach of one of the following options:
  306.      *     systemmemory  All surfaces should be created in system memory.
  307.      *                   Hardware DD and D3D devices are disabled, but
  308.      *                   debugging during the Win16 lock becomes possible.
  309.      *     emulation     Do not use hardware DD or D3D devices.
  310.      */
  311.     bOnlySystemMemory = FALSE;
  312.     bOnlyEmulation = FALSE;
  313.     option = strtok(lpCmdLine, " -");
  314.     while(option != NULL )   {
  315.         if (!lstrcmp(option, "systemmemory")) {
  316.             bOnlySystemMemory = TRUE;
  317.         } else if (!lstrcmp(option, "emulation")) {
  318.     bOnlyEmulation = TRUE;
  319. } else {
  320.             Msg("Invalid command line options given.nLegal options: -systemmemory, -emulationn");
  321.             return FALSE;
  322.         }
  323.         option = strtok(NULL, " -");
  324.     }
  325.     /*
  326.      * Set the flags to pass to the D3DApp creation based on command line
  327.      */
  328.     flags = ((bOnlySystemMemory) ? D3DAPP_ONLYSYSTEMMEMORY : 0) | 
  329.     ((bOnlyEmulation) ? (D3DAPP_ONLYD3DEMULATION |
  330.  D3DAPP_ONLYDDEMULATION) : 0);
  331.     /*
  332.      * Create all the DirectDraw and D3D objects neccesary to render.  The
  333.      * AfterDeviceCreated callback function is called by D3DApp to create the
  334.      * viewport and the example's execute buffers.
  335.      */
  336.     if (!D3DAppCreateFromHWND(flags, myglobs.hWndMain, 
  337.       myglobs.DDDriver[myglobs.CurrDDDriver].bIsPrimary ? NULL : &myglobs.DDDriver[myglobs.CurrDDDriver].Guid,
  338.       AfterDeviceCreated, NULL, BeforeDeviceDestroyed, NULL, &d3dapp)) {
  339. ReportD3DAppError();
  340. return FALSE;
  341.     }
  342.     /*
  343.      * Add the the list of display modes D3DApp found to the mode menu
  344.      */
  345.     hmenu = GetSubMenu(GetMenu(myglobs.hWndMain), 2);
  346.     for (i = 0; i < d3dapp->NumModes; i++) {
  347.         char ach[80];
  348.         wsprintf(ach,"%dx%dx%d", d3dapp->Mode[i].w, d3dapp->Mode[i].h,
  349.  d3dapp->Mode[i].bpp);
  350.         AppendMenu(hmenu, MF_STRING, MENU_FIRST_MODE+i, ach);
  351.     }
  352.     /*
  353.      * Add the list of D3D drivers D3DApp foudn to the file menu
  354.      */
  355.     hmenu = GetSubMenu(GetMenu(myglobs.hWndMain), 0);
  356.     for (i = 0; i < d3dapp->NumDrivers; i++) {
  357.         InsertMenu(hmenu, 7 + myglobs.NumDDDrivers + i, MF_BYPOSITION | MF_STRING,
  358.    MENU_FIRST_DRIVER + i, d3dapp->Driver[i].Name);
  359.     }
  361.     return TRUE;
  362. }
  364. /*
  365.  * DestroyD3DApp
  366.  *
  367.  * Destroy D3DApp and changes to menu
  368.  */
  369. static void
  370. DestroyD3DApp(void)
  371. {
  372.     HMENU hmenu;
  373.     int i;
  375.     /*
  376.      * Remove the list of display modes
  377.      */
  378.     hmenu = GetSubMenu(GetMenu(myglobs.hWndMain), 4);
  379.     for (i = 0; i < d3dapp->NumModes; i++) {
  380.         DeleteMenu(hmenu, MENU_FIRST_MODE + i, MF_BYCOMMAND);
  381.     }
  382.     /*
  383.      * Remove the list of D3D drivers
  384.      */
  385.     hmenu = GetSubMenu(GetMenu(myglobs.hWndMain), 0);
  386.     for (i = 0; i < d3dapp->NumDrivers; i++) {
  387.         DeleteMenu(hmenu, MENU_FIRST_DRIVER + i, MF_BYCOMMAND);
  388.     }
  389.     RELEASE(myglobs.lpInfoBuffer);
  390.     RELEASE(myglobs.lpFrameRateBuffer);
  391.     D3DAppDestroy();
  392. }
  394. /*
  395.  * AfterDeviceCreated
  396.  * D3DApp will call this function immediately after the D3D device has been
  397.  * created (or re-created).  D3DApp expects the D3D viewport to be created and
  398.  * returned.  In this case, we will return NULL because we only have a D3DRM
  399.  * viewport.  This is fine as long as we don't use any of the D3D viewport
  400.  * functionality of D3DApp.
  401.  */
  402. static BOOL
  403. AfterDeviceCreated(int w, int h, LPDIRECT3DVIEWPORT* lplpViewport, LPVOID lpContext)
  404. {
  405.     HRESULT rval;
  407.     rval = lpD3DRM->CreateDeviceFromD3D(d3dapp->lpD3D, d3dapp->lpD3DDevice,
  408. &myglobs.dev);
  409.     if (rval != D3DRM_OK) {
  410.         Msg("Creation of D3DRM device failed.n%s", D3DAppErrorToString(rval));
  411.         return FALSE;
  412.     }
  413.     /*
  414.      * Create the D3DRM viewport using the camera frame.  Set the background
  415.      * depth to a large number.  The width and height may be slightly
  416.      * adjusted, so get them from the device to be sure.
  417.      */
  418.     w = myglobs.dev->GetWidth();
  419.     h = myglobs.dev->GetHeight();
  420.     rval = lpD3DRM->CreateViewport(myglobs.dev, myglobs.camera, 0, 0, w,
  421.    h, &myglobs.view);
  422.     if (rval != D3DRM_OK) {
  423. Msg("Failed to create the D3DRM viewport.n%s",
  424.     D3DAppErrorToString(rval));
  425. RELEASE(myglobs.dev);
  426. return FALSE;
  427.     }
  428.     rval = myglobs.view->SetBack(D3DVAL(5000.0));
  429.     if (rval != D3DRM_OK) {
  430. Msg("Failed to set the background depth of the D3DRM viewport.n%s",
  431.     D3DAppErrorToString(rval));
  432. RELEASE(myglobs.dev);
  433. RELEASE(myglobs.view);
  434. return FALSE;
  435.     }
  436.     /*
  437.      * Set the render quality, fill mode, lighting state and color shade info
  438.      */
  439.     if (!SetRenderState())
  440. return FALSE;
  442.     /*
  443.      * Return NULL for the viewport
  444.      */
  445.     *lplpViewport = NULL;
  446.     /*
  447.      * Create and initialize the surfaces containing the frame rate and
  448.      * window information
  449.      */
  450.     InitFontAndTextBuffers();
  452.     return TRUE;
  453. }
  455. /*
  456.  * BeforeDeviceDestroyed
  457.  * D3DApp will call this function before the current D3D device is destroyed
  458.  * to give the app the opportunity to destroy objects it has created with the
  459.  * DD or D3D objects.
  460.  */
  461. static BOOL
  462. BeforeDeviceDestroyed(LPVOID lpContext)
  463. {
  464.     RELEASE(myglobs.view);
  465.     RELEASE(myglobs.dev);
  466.     return TRUE;
  467. }
  469. /****************************************************************************/
  470. /*                            Rendering loop                                */
  471. /****************************************************************************/
  472. /*
  473.  * RenderLoop
  474.  * Render the next frame and update the window
  475.  */
  476. static BOOL
  477. RenderLoop()
  478. {
  479.     D3DRECT extents[D3DAPP_MAXCLEARRECTS];
  480.     int count;
  481.     HRESULT rval;
  482.     static BOOL b = FALSE; // Clear the second buffer on also
  484.     /*
  485.      * If all the DD and D3D objects have been initialized we can render
  486.      */
  487.     if (d3dapp->bRenderingIsOK) {
  488. /*
  489.  * Restore any lost surfaces
  490.  */
  491.         if (!RestoreSurfaces()) {
  492.     /*
  493.      * Restoring surfaces sometimes fails because the surfaces cannot
  494.      * yet be restored.  If this is the case, the error will show up
  495.      * somewhere else and we should return success here to prevent
  496.      * unnecessary error's being reported.
  497.      */
  498.     return TRUE;
  499. }
  500. /*
  501.  * Force an update of the entire client window if the resized flag is set
  502.  */
  503. if (myglobs.bResized || b)
  504.     myglobs.view->ForceUpdate(0, 0, d3dapp->szClient.cx, d3dapp->szClient.cy);
  505. /*
  506.  * Use b to makesure the second buffer is cleared also
  507.  */
  508. if (b)
  509.     b = FALSE;
  510. if (myglobs.bResized)
  511.     b = TRUE;
  513. /*
  514.  * Calculate the frame rate
  515.  */
  516.         if (!CalculateFrameRate())
  517.     return FALSE;
  519. /*
  520.  * Tick the scene
  521.  */
  522. rval = myglobs.scene->Move(D3DVAL(1.0));
  523. if (rval != D3DRM_OK) {
  524.     Msg("Moving scene failed.n%s", D3DAppErrorToString(rval));
  525.     return FALSE;
  526. }
  527. /* 
  528.  * Clear the viewport
  529.  */
  530. rval = myglobs.view->Clear();
  531. if (rval != D3DRM_OK) {
  532.     Msg("Clearing viewport failed.n%s", D3DAppErrorToString(rval));
  533.     return FALSE;
  534. }
  535. /*
  536.  * Render the scene to the viewport
  537.  */
  538. rval = myglobs.view->Render(myglobs.scene);
  539. if (rval != D3DRM_OK) {
  540.     Msg("Rendering scene failed.n%s", D3DAppErrorToString(rval));
  541.     return FALSE;
  542. }
  543. /*
  544.  * Blt the frame rate and window stat text to the back buffer
  545.  */
  546. count = 0;
  547.         if (!DisplayFrameRate(&count, &extents[0]))
  548.     return FALSE;
  549. for (;count;--count)
  550.     myglobs.view->ForceUpdate(extents[count-1].x1, extents[count-1].y1,
  551.       extents[count-1].x2, extents[count-1].y2);
  552. /*
  553.  * Update the window
  554.  */
  555. rval = myglobs.dev->Update();
  556. if (rval != D3DRM_OK) {
  557.     Msg("Updating device failed.n%s", D3DAppErrorToString(rval));
  558.     return FALSE;
  559. }
  560. /*
  561.  * Blt or flip the back buffer to the front buffer.  If this fails,
  562.  * don't report an error.
  563.  */
  564. D3DAppShowBackBuffer(myglobs.bResized ? D3DAPP_SHOWALL : NULL);
  566. /*
  567.  * Reset the resize flag
  568.  */
  569.         myglobs.bResized = FALSE;
  570.     }
  571.     return TRUE;
  572. }
  574. /*
  575.  * AppPause
  576.  * Pause and unpause the application
  577.  */
  578. static BOOL
  579. AppPause(BOOL f)
  580. {
  581.     /*
  582.      * Flip to the GDI surface and halt rendering
  583.      */
  584.     if (!D3DAppPause(f))
  585. return FALSE;
  586.     /*
  587.      * When returning from a pause, reset the frame rate count
  588.      */
  589.     if (!f) {
  590.         ResetFrameRate();
  591. myglobs.bResized = TRUE;
  592.     }
  593.     return TRUE;
  594. }
  596. /*
  597.  * RestoreSurfaces
  598.  * Restores any lost surfaces.  Returns TRUE if all surfaces are not lost and
  599.  * FALSE if one or more surfaces is lost and can not be restored at the
  600.  * moment.
  601.  */
  602. static BOOL
  603. RestoreSurfaces()
  604. {
  605.     HRESULT d3drval;
  607.     /*
  608.      * Have D3DApp check all the surfaces it's in charge of
  609.      */
  610.     if (!D3DAppCheckForLostSurfaces()) {
  611.             return FALSE;
  612.     }
  613.     /*
  614.      * Check frame rate and info surfaces and re-write them if they
  615.      * were lost.
  616.      */
  617.     if (myglobs.lpFrameRateBuffer->IsLost() == DDERR_SURFACELOST) {
  618.         d3drval = myglobs.lpFrameRateBuffer->Restore();
  619.         if (d3drval != DD_OK) {
  620.             return FALSE;
  621.         }
  622. if (!WriteFrameRateBuffer(0.0f, 0))
  623.     return FALSE;
  624.     }
  625.     if (myglobs.lpInfoBuffer->IsLost() == DDERR_SURFACELOST) {
  626.         d3drval = myglobs.lpInfoBuffer->Restore();
  627.         if (d3drval != DD_OK) {
  628.             return FALSE;
  629.         }
  630. if (!WriteInfoBuffer())
  631.     return FALSE;
  632.     }
  633.     return TRUE;
  634. }
  637. /*************************************************************************
  638.   Windows message handlers
  639.  *************************************************************************/
  640. /*
  641.  * AppAbout
  642.  * About box message handler
  643.  */
  644. BOOL
  645. FAR PASCAL AppAbout(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  646. {
  647.   switch (msg)
  648.   {
  649.     case WM_COMMAND:
  650.       if (LOWORD(wParam) == IDOK)
  651.         EndDialog(hwnd, TRUE);
  652.       break;
  654.     case WM_INITDIALOG:
  655.       return TRUE;
  656.   }
  657.   return FALSE;
  658. }
  660. /*
  661.  * WindowProc
  662.  * Main window message handler.
  663.  */
  664. long
  665. FAR PASCAL WindowProc(HWND hWnd, UINT message, WPARAM wParam,
  666.    LPARAM lParam )
  667. {
  668.     int i;
  669.     BOOL bStop;
  670.     LRESULT lresult;
  672.     /*
  673.      * Give D3DApp an opportunity to process any messages it MUST see in order
  674.      * to perform it's function.
  675.      */
  676.     if (!D3DAppWindowProc(&bStop, &lresult, hWnd, message, wParam, lParam)) {
  677. ReportD3DAppError();
  678. CleanUpAndPostQuit();
  679. return 0;
  680.     }
  681.     /* 
  682.      * If bStop is set by D3DApp, the app should not process the message but
  683.      * return lresult.
  684.      */
  685.     if (bStop)
  686. return lresult;
  688.     if (!d3dapp || !d3dapp->bRenderingIsOK) {
  689. return DefWindowProc(hWnd, message, wParam, lParam);
  690.     }
  692.     switch( message ) {
  693. case WM_LBUTTONDOWN:
  694. case WM_LBUTTONUP:
  695. case WM_RBUTTONDOWN:
  696. case WM_RBUTTONUP:
  697. case WM_MOUSEMOVE:
  698.     /*
  699.      * Record the mouse state for ReadMouse
  700.      */
  701.     myglobs.mouse_buttons = wParam;
  702.     myglobs.mouse_x = LOWORD(lParam);
  703.     myglobs.mouse_y = HIWORD(lParam);
  704.     break;
  705.         case WM_ENTERMENULOOP:
  706.             AppPause(TRUE);
  707.             break;
  708.         case WM_EXITMENULOOP:
  709.             AppPause(FALSE);
  710.             break;
  711.      case WM_DESTROY:
  712.             myglobs.hWndMain = NULL;
  713.             CleanUpAndPostQuit();
  714.             break;
  715.         case WM_INITMENUPOPUP:
  716.     /*
  717.              * Check and enable the appropriate menu items
  718.      */
  719.             CheckMenuItem((HMENU)wParam, MENU_STEP, (myglobs.bSingleStepMode) ? MF_CHECKED : MF_UNCHECKED);
  720.             EnableMenuItem((HMENU)wParam, MENU_GO, (myglobs.bSingleStepMode) ? MF_ENABLED : MF_GRAYED);
  721.     EnableMenuItem((HMENU)wParam, MENU_PHONG, MF_GRAYED);
  722.     if (!myglobs.bConstRenderQuality) {
  723. CheckMenuItem((HMENU)wParam, MENU_LIGHTING, (myglobs.RenderQuality & D3DRMLIGHT_MASK) == D3DRMLIGHT_ON ? MF_CHECKED : MF_GRAYED);
  724. CheckMenuItem((HMENU)wParam, MENU_FLAT, (myglobs.RenderQuality & D3DRMSHADE_MASK) == D3DRMSHADE_FLAT ? MF_CHECKED : MF_UNCHECKED);
  725. CheckMenuItem((HMENU)wParam, MENU_GOURAUD, (myglobs.RenderQuality & D3DRMSHADE_MASK) == D3DRMSHADE_GOURAUD ? MF_CHECKED : MF_UNCHECKED);
  726. CheckMenuItem((HMENU)wParam, MENU_PHONG, (myglobs.RenderQuality & D3DRMSHADE_MASK) == D3DRMSHADE_PHONG ? MF_CHECKED : MF_UNCHECKED);
  727. EnableMenuItem((HMENU)wParam, MENU_PHONG, MF_GRAYED);
  728. CheckMenuItem((HMENU)wParam, MENU_POINT, (myglobs.RenderQuality & D3DRMFILL_MASK) == D3DRMFILL_POINTS ? MF_CHECKED : MF_UNCHECKED);
  729. CheckMenuItem((HMENU)wParam, MENU_WIREFRAME, (myglobs.RenderQuality & D3DRMFILL_MASK) == D3DRMFILL_WIREFRAME ? MF_CHECKED : MF_UNCHECKED);
  730. CheckMenuItem((HMENU)wParam, MENU_SOLID, (myglobs.RenderQuality & D3DRMFILL_MASK) == D3DRMFILL_SOLID ? MF_CHECKED : MF_UNCHECKED);
  731.     } else {
  732. EnableMenuItem((HMENU)wParam, MENU_LIGHTING, MF_GRAYED);
  733. EnableMenuItem((HMENU)wParam, MENU_FLAT, MF_GRAYED);
  734. EnableMenuItem((HMENU)wParam, MENU_GOURAUD, MF_GRAYED);
  735. EnableMenuItem((HMENU)wParam, MENU_PHONG, MF_GRAYED);
  736. EnableMenuItem((HMENU)wParam, MENU_POINT, MF_GRAYED);
  737. EnableMenuItem((HMENU)wParam, MENU_WIREFRAME, MF_GRAYED);
  738. EnableMenuItem((HMENU)wParam, MENU_SOLID, MF_GRAYED);
  739.     }
  740.             if (!myglobs.bNoTextures && d3dapp->ThisDriver.bDoesTextures) {
  741. CheckMenuItem((HMENU)wParam, MENU_POINT_FILTER, (myglobs.TextureQuality == D3DRMTEXTURE_NEAREST) ? MF_CHECKED : MF_UNCHECKED);
  742. CheckMenuItem((HMENU)wParam, MENU_LINEAR_FILTER, (myglobs.TextureQuality == D3DRMTEXTURE_LINEAR) ? MF_CHECKED : MF_UNCHECKED);
  743.     } else {
  744. EnableMenuItem((HMENU)wParam, MENU_POINT_FILTER, MF_GRAYED);
  745. EnableMenuItem((HMENU)wParam, MENU_LINEAR_FILTER, MF_GRAYED);
  746.     }
  747.             CheckMenuItem((HMENU)wParam, MENU_DITHERING, (myglobs.bDithering) ? MF_CHECKED : MF_UNCHECKED);
  748.             CheckMenuItem((HMENU)wParam, MENU_ANTIALIAS, (myglobs.bAntialiasing) ? MF_CHECKED : MF_UNCHECKED);
  749.             EnableMenuItem((HMENU)wParam, MENU_ANTIALIAS, MF_GRAYED);
  750.     if (d3dapp->bIsPrimary) {
  751. CheckMenuItem((HMENU)wParam, MENU_FULLSCREEN, d3dapp->bFullscreen ? MF_CHECKED : MF_UNCHECKED);
  752. EnableMenuItem((HMENU)wParam, MENU_FULLSCREEN, d3dapp->bFullscreen && !d3dapp->ThisDriver.bCanDoWindow ? MF_GRAYED : MF_ENABLED);
  753. EnableMenuItem((HMENU)wParam, MENU_NEXT_MODE, (!d3dapp->bFullscreen) ? MF_GRAYED : MF_ENABLED);
  754. EnableMenuItem((HMENU)wParam, MENU_PREVIOUS_MODE, (!d3dapp->bFullscreen) ? MF_GRAYED : MF_ENABLED);
  755.     } else {
  756. EnableMenuItem((HMENU)wParam, MENU_FULLSCREEN, MF_GRAYED);
  757. EnableMenuItem((HMENU)wParam, MENU_NEXT_MODE, MF_GRAYED);
  758. EnableMenuItem((HMENU)wParam, MENU_PREVIOUS_MODE, MF_GRAYED);
  759.     }
  760.     for (i = 0; i < d3dapp->NumModes; i++) {
  761. CheckMenuItem((HMENU)wParam, MENU_FIRST_MODE + i, (i == d3dapp->CurrMode) ? MF_CHECKED : MF_UNCHECKED);
  762. EnableMenuItem((HMENU)wParam, MENU_FIRST_MODE + i, (d3dapp->Mode[i].bThisDriverCanDo) ? MF_ENABLED : MF_GRAYED);
  763.     }
  764.             for (i = 0; i < d3dapp->NumDrivers; i++) {
  765.                 CheckMenuItem((HMENU)wParam, MENU_FIRST_DRIVER + i, (i == d3dapp->CurrDriver) ? MF_CHECKED : MF_UNCHECKED);
  766.             }
  767.             break;
  768.         case WM_COMMAND:
  769.             switch(LOWORD(wParam)) {
  770.                 case MENU_ABOUT:
  771.                     AppPause(TRUE);
  772.                     DialogBox(myglobs.hInstApp, "AppAbout", myglobs.hWndMain, (DLGPROC)AppAbout);
  773.                     AppPause(FALSE);
  774.                     break;
  775.                 case MENU_EXIT:
  776.             CleanUpAndPostQuit();
  777.              break;
  778.                 case MENU_STEP:
  779.     /*
  780.      * Begin single step more or draw a frame if in single
  781.      * step mode
  782.      */
  783.                     if (!myglobs.bSingleStepMode) {
  784.                         myglobs.bSingleStepMode = TRUE;
  785.                         myglobs.bDrawAFrame = TRUE;
  786.                     } else if (!myglobs.bDrawAFrame) {
  787.                         myglobs.bDrawAFrame = TRUE;
  788.                     }
  789.                     break;
  790.                 case MENU_GO:
  791.     /*
  792.      * Exit single step mode
  793.      */
  794.                     if (myglobs.bSingleStepMode) {
  795.                         myglobs.bSingleStepMode = FALSE;
  796.                         ResetFrameRate();
  797.                     }
  798.                     break;
  799.                 case MENU_STATS:
  800.     /*
  801.      * Toggle output of frame rate and window info
  802.      */
  803.                     if ((myglobs.bShowFrameRate) && (myglobs.bShowInfo)) {
  804.                         myglobs.bShowFrameRate = FALSE;
  805.                         myglobs.bShowInfo = FALSE;
  806.                         break;
  807.                     }
  808.                     if ((!myglobs.bShowFrameRate) && (!myglobs.bShowInfo)) {
  809.                         myglobs.bShowFrameRate = TRUE;
  810.                         break;
  811.                     }
  812.                     myglobs.bShowInfo = TRUE;
  813.                     break;
  814.          case MENU_FULLSCREEN:
  815.     if (d3dapp->bFullscreen) {
  816. /*
  817.  * Return to a windowed mode.  Let D3DApp decide which
  818.  * D3D driver to use in case this one cannot render to
  819.  * the Windows display depth
  820.  */
  821. if (!D3DAppWindow(D3DAPP_YOUDECIDE, D3DAPP_YOUDECIDE)) {
  822.     ReportD3DAppError();
  823.     CleanUpAndPostQuit();
  824.     break;
  825. }
  826.     } else {
  827. /*
  828.  * Enter the current fullscreen mode.  D3DApp may
  829.  * resort to another mode if this driver cannot do
  830.  * the currently selected mode.
  831.  */
  832. if (!D3DAppFullscreen(d3dapp->CurrMode)) {
  833.     ReportD3DAppError();
  834.     CleanUpAndPostQuit();
  835.     break;
  836. }
  837.     }
  838.                  break;
  839. /*
  840.  * Lighting toggle
  841.  */
  842. case MENU_LIGHTING:
  843.     myglobs.RenderQuality ^= D3DRMLIGHT_ON;
  844.     SetRenderState();
  845.     break;
  846. /*
  847.  * Fill mode selection
  848.  */
  849. case MENU_POINT:
  850.     myglobs.RenderQuality = (myglobs.RenderQuality & ~D3DRMFILL_MASK) | D3DRMFILL_POINTS;
  851.     SetRenderState();
  852.     break;
  853. case MENU_WIREFRAME:
  854.     myglobs.RenderQuality = (myglobs.RenderQuality & ~D3DRMFILL_MASK) | D3DRMFILL_WIREFRAME;
  855.     SetRenderState();
  856.     break;
  857. case MENU_SOLID:
  858.     myglobs.RenderQuality = (myglobs.RenderQuality & ~D3DRMFILL_MASK) | D3DRMFILL_SOLID;
  859.     SetRenderState();
  860.     break;
  861. /*
  862.  * Shade mode selection
  863.  */
  864. case MENU_FLAT:
  865.     myglobs.RenderQuality = (myglobs.RenderQuality & ~D3DRMSHADE_MASK) | D3DRMSHADE_FLAT;
  866.     SetRenderState();
  867.     break;
  868. case MENU_GOURAUD:
  869.     myglobs.RenderQuality = (myglobs.RenderQuality & ~D3DRMSHADE_MASK) | D3DRMSHADE_GOURAUD;
  870.     SetRenderState();
  871.     break;
  872. case MENU_PHONG:
  873.     myglobs.RenderQuality = (myglobs.RenderQuality & ~D3DRMSHADE_MASK) | D3DRMSHADE_PHONG;
  874.     SetRenderState();
  875.     break;
  877. case MENU_DITHERING:
  878.     myglobs.bDithering = !myglobs.bDithering;
  879.     SetRenderState();
  880.     break;
  881. case MENU_ANTIALIAS:
  882.     myglobs.bAntialiasing = !myglobs.bAntialiasing;
  883.     SetRenderState();
  884.     break;
  885. /*
  886.  * Texture filter selection
  887.  */
  888. case MENU_POINT_FILTER:
  889.     if (myglobs.TextureQuality == D3DRMTEXTURE_NEAREST)
  890. break;
  891.     myglobs.TextureQuality = D3DRMTEXTURE_NEAREST;
  892.     SetRenderState();
  893.     break;
  894. case MENU_LINEAR_FILTER:
  895.     if (myglobs.TextureQuality == D3DRMTEXTURE_LINEAR)
  896. break;
  897.     myglobs.TextureQuality = D3DRMTEXTURE_LINEAR;
  898.     SetRenderState();
  899.     break;
  900. case MENU_NEXT_MODE:
  901.     /*
  902.      * Enter the next usable fullscreen mode
  903.      */
  904.     i = d3dapp->CurrMode;
  905.     do {
  906. ++i;
  907. if (i >= d3dapp->NumModes)
  908.     i = 0;
  909. if (!d3dapp->Mode[i].bThisDriverCanDo)
  910.     continue;
  911. else {
  912.     if (!D3DAppFullscreen(i)) {
  913. ReportD3DAppError();
  914. CleanUpAndPostQuit();
  915.     }
  916.     break;
  917. }
  918.     } while(i != d3dapp->CurrMode);
  919.     break;
  920. case MENU_PREVIOUS_MODE:
  921.     /*
  922.      * Enter the previous usable fullscreen mode
  923.      */
  924.     i = d3dapp->CurrMode;
  925.     do {
  926. --i;
  927. if (i < 0)
  928.     i = d3dapp->NumModes - 1;
  929. if (!d3dapp->Mode[i].bThisDriverCanDo)
  930.     continue;
  931. else {
  932.     if (!D3DAppFullscreen(i)) {
  933. ReportD3DAppError();
  934. CleanUpAndPostQuit();
  935.     }
  936.     break;
  937. }
  938.     } while(i != d3dapp->CurrMode);
  939.                     break;
  940.             }
  941.             if (   LOWORD(wParam) >= MENU_FIRST_DRIVER
  942. && LOWORD(wParam) < MENU_FIRST_DRIVER + D3DAPP_MAXD3DDRIVERS
  943. && d3dapp->CurrDriver != LOWORD(wParam) - MENU_FIRST_DRIVER) {
  944. /*
  945.  * Change the D3D driver
  946.  */
  947. if (!D3DAppChangeDriver(LOWORD(wParam) - MENU_FIRST_DRIVER,
  948. NULL)) {
  949.     ReportD3DAppError();
  950.     CleanUpAndPostQuit();
  951. }
  952.             }
  953.             if (   LOWORD(wParam) >= MENU_FIRST_MODE
  954. && LOWORD(wParam) < MENU_FIRST_MODE+100) {
  955. /*
  956.  * Switch to the selected fullscreen mode
  957.  */
  958. if (!D3DAppFullscreen(LOWORD(wParam) - MENU_FIRST_MODE)) {
  959.     ReportD3DAppError();
  960.     CleanUpAndPostQuit();
  961. }
  962.             }
  963.             if (   LOWORD(wParam) >= MENU_FIRST_DDDRIVER
  964. && LOWORD(wParam) < MENU_FIRST_DDDRIVER + D3DAPP_MAXDDDRIVERS
  965. && myglobs.CurrDDDriver != LOWORD(wParam) - MENU_FIRST_DDDRIVER) {
  966. /*
  967.  * Change the DD driver
  968.  */
  969. DestroyD3DApp();
  970. myglobs.CurrDDDriver = LOWORD(wParam) - MENU_FIRST_DDDRIVER;
  971. SetWindowPos(myglobs.hWndMain, HWND_NOTOPMOST, 0, 0, START_WIN_SIZE, START_WIN_SIZE, SWP_NOMOVE | SWP_SHOWWINDOW);
  972. if (!CreateD3DApp(myglobs.lpCmdLine))
  973.     return FALSE;
  974.             }
  975.     /*
  976.      * Whenever we receive a command in single step mode, draw a frame
  977.      */
  978.     if (myglobs.bSingleStepMode)
  979. myglobs.bDrawAFrame = TRUE;
  980.             return 0L;
  981.     }
  982.     return DefWindowProc(hWnd, message, wParam, lParam);
  983. }
  985. /****************************************************************************/
  986. /*                          Additional Functions                            */
  987. /****************************************************************************/
  988. /*
  989.  * ReadMouse
  990.  * Returns the mouse status for interaction with sample code
  991.  */
  992. void
  993. ReadMouse(int* b, int* x, int* y)
  994. {
  995.     *b = myglobs.mouse_buttons;
  996.     *x = myglobs.mouse_x;
  997.     *y = myglobs.mouse_y;
  998. }
  1000. /*
  1001.  * SetRenderState
  1002.  * Set the render quality, dither toggle and shade info if any of them has
  1003.  * changed
  1004.  */
  1005. BOOL
  1006. SetRenderState(void)
  1007. {
  1008.     HRESULT rval;
  1009.     /*
  1010.      * Set the number of buffers so D3DRM can keep track of extents properly
  1011.      */
  1012.     rval = myglobs.dev->SetBufferCount(d3dapp->bFullscreen &&
  1013.        d3dapp->bBackBufferInVideo ? 2 : 1);
  1014.     if (rval != D3DRM_OK) {
  1015. Msg("Setting the buffer count failed.n%s", D3DAppErrorToString(rval));
  1016. return FALSE;
  1017.     }
  1018.     /*
  1019.      * Set the render quality (light toggle, fill mode, shade mode)
  1020.      */
  1021.     if (myglobs.dev->GetQuality() != myglobs.RenderQuality) {
  1022. rval = myglobs.dev->SetQuality(myglobs.RenderQuality);
  1023. if (rval != D3DRM_OK) {
  1024.     Msg("Setting the render quality failed.n%s",
  1025. D3DAppErrorToString(rval));
  1026.     return FALSE;
  1027. }
  1028.     }
  1029.     /*
  1030.      * Set dithering toggle
  1031.      */
  1032.     if (myglobs.dev->GetDither() != myglobs.bDithering) {
  1033. rval = myglobs.dev->SetDither(myglobs.bDithering);
  1034. if (rval != D3DRM_OK) {
  1035.     Msg("Setting dither mode failed.n%s", D3DAppErrorToString(rval));
  1036.     return FALSE;
  1037. }
  1038.     }
  1039.     /*
  1040.      * Set the texture quality (point or linear filtering)
  1041.      */
  1042.     if (myglobs.dev->GetTextureQuality() != myglobs.TextureQuality) {
  1043. rval = myglobs.dev->SetTextureQuality(myglobs.TextureQuality);
  1044. if (rval != D3DRM_OK) {
  1045.     Msg("Setting texture quality failed.n%s",
  1046. D3DAppErrorToString(rval));
  1047.     return FALSE;
  1048. }
  1049.     }
  1050.     /*
  1051.      * Set shade info based on current bits per pixel
  1052.      */
  1053.     switch (d3dapp->ThisMode.bpp) {
  1054. case 1:
  1055.     if (FAILED(myglobs.dev->SetShades(4)))
  1056. goto shades_error;
  1057.     if (FAILED(lpD3DRM->SetDefaultTextureShades(4)))
  1058. goto shades_error;
  1059.     break;
  1060. case 16:
  1061.     if (FAILED(myglobs.dev->SetShades(32)))
  1062. goto shades_error;
  1063.     if (FAILED(lpD3DRM->SetDefaultTextureColors(64)))
  1064. goto shades_error;
  1065.     if (FAILED(lpD3DRM->SetDefaultTextureShades(32)))
  1066. goto shades_error;
  1067.     break;
  1068. case 24:
  1069. case 32:
  1070.     if (FAILED(myglobs.dev->SetShades(256)))
  1071. goto shades_error;
  1072.     if (FAILED(lpD3DRM->SetDefaultTextureColors(64)))
  1073. goto shades_error;
  1074.     if (FAILED(lpD3DRM->SetDefaultTextureShades(256)))
  1075. goto shades_error;
  1076.     break;
  1077.     }
  1078.     return TRUE;
  1079. shades_error:
  1080.     Msg("A failure occurred while setting color shade information.n");
  1081.     return FALSE;
  1082. }
  1084. /****************************************************************************/
  1085. /*          Initialization, error reporting and release functions.          */
  1086. /****************************************************************************/
  1087. /*
  1088.  * InitGlobals
  1089.  * Called once at program initialization to initialize global variables.
  1090.  */
  1091. static void
  1092. InitGlobals(void)
  1093. {
  1094.     d3dapp = NULL;
  1095.     memset(&myglobs, 0, sizeof(myglobs));
  1096.     myglobs.bShowFrameRate = TRUE;
  1097.     myglobs.bShowInfo = TRUE;
  1098.     myglobs.RenderQuality = D3DRMLIGHT_ON | D3DRMFILL_SOLID |
  1099.     D3DRMSHADE_GOURAUD;
  1100.     myglobs.TextureQuality = D3DRMTEXTURE_NEAREST;
  1101. }
  1103. /*
  1104.  * CleanUpAndPostQuit
  1105.  * Release all D3D objects, post a quit message and set the bQuit flag
  1106.  */
  1107. void
  1108. CleanUpAndPostQuit(void)
  1109. {
  1110.     if (myglobs.bQuit)
  1111. return;
  1112.     if (!D3DAppDestroy())
  1113. ReportD3DAppError();
  1114.     RELEASE(myglobs.scene);
  1115.     RELEASE(myglobs.camera);
  1116.     RELEASE(lpD3DRM);
  1117.     myglobs.bQuit = TRUE;
  1118.     PostQuitMessage( 0 );
  1119. }
  1121. /*
  1122.  * ReportD3DAppError
  1123.  * Reports an error during a d3d app call.
  1124.  */
  1125. void
  1126. ReportD3DAppError(void)
  1127. {
  1128.     Msg("%s", D3DAppLastErrorString());
  1129. }
  1131. /* Msg
  1132.  * Message output for error notification.
  1133.  */
  1134. void __cdecl
  1135. Msg( LPSTR fmt, ... )
  1136. {
  1137.     char buff[256];
  1138.     va_list args;
  1139.     
  1140.     va_start(args, fmt);
  1141.     wvsprintf(buff, fmt, args);
  1142.     va_end(args);
  1143.     
  1144.     lstrcat(buff, "rn");
  1145.     AppPause(TRUE);
  1146.     if (d3dapp && d3dapp->bFullscreen)
  1147. SetWindowPos(myglobs.hWndMain, HWND_NOTOPMOST, 0, 0, 0, 0,
  1148.      SWP_NOSIZE | SWP_NOMOVE);
  1149.     MessageBox( NULL, buff, "D3D Example Message", MB_OK );
  1150.     if (d3dapp && d3dapp->bFullscreen)
  1151. SetWindowPos(myglobs.hWndMain, HWND_TOPMOST, 0, 0, 0, 0,
  1152.      SWP_NOSIZE | SWP_NOMOVE);
  1153.     AppPause(FALSE);
  1154. }
  1156. /*
  1157.  * D3DRMErrorToString
  1158.  * Allows the samples to return error strings.
  1159.  */
  1160. char*
  1161. D3DRMErrorToString(HRESULT error)
  1162. {
  1163.     return D3DAppErrorToString(error);
  1164. }