windows-xp/Source/XPSP1/NT/shell/osshell/control/scrnsave/dolphin/d3dframe.cpp

#include "StdAfx.h"





#if 0
//-----------------------------------------------------------------------------
// File: D3DFrame.cpp
//
// Desc: Class functions to implement a Direct3D app framework.
//
// Copyright (c) 1995-1999 by Microsoft, all rights reserved
//-----------------------------------------------------------------------------
//#define STRICT
//#include <windows.h>
//#include <tchar.h>
#include "D3DFrame.h"
#include "D3DUtil.h"




//-----------------------------------------------------------------------------
// Name: CD3DFramework7()
// Desc: The constructor. Clears static variables
//-----------------------------------------------------------------------------
CD3DFramework7::CD3DFramework7()
{
     m_hWnd           = NULL;
     m_bIsFullscreen  = FALSE;
     m_bIsStereo      = FALSE;
     m_dwRenderWidth  = 0L;
     m_dwRenderHeight = 0L;
     
     m_pddsFrontBuffer    = NULL;
     m_pddsBackBuffer     = NULL;
     m_pddsBackBufferLeft = NULL;
     
     m_pddsZBuffer     = NULL;
     m_pd3dDevice      = NULL;
     m_pDD             = NULL;
     m_pD3D            = NULL;
     m_dwDeviceMemType = NULL;
}




//-----------------------------------------------------------------------------
// Name: ~CD3DFramework7()
// Desc: The destructor. Deletes all objects
//-----------------------------------------------------------------------------
CD3DFramework7::~CD3DFramework7()
{
    DestroyObjects();
}




//-----------------------------------------------------------------------------
// Name: DestroyObjects()
// Desc: Cleans everything up upon deletion. This code returns an error
//       if any of the objects have remaining reference counts.
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::DestroyObjects()
{
    LONG nDD  = 0L; // Number of outstanding DDraw references
    LONG nD3D = 0L; // Number of outstanding D3DDevice references

    if (m_pDD)
    {
        m_pDD->SetCooperativeLevel(m_hWnd, DDSCL_NORMAL);
    }

    // Do a safe check for releasing the D3DDEVICE. RefCount must be zero.
    if (m_pd3dDevice)
        if (0 < (nD3D = m_pd3dDevice->Release()))
            DEBUG_MSG(_T("Error: D3DDevice object is still referenced!"));
    m_pd3dDevice = NULL;

    SAFE_RELEASE(m_pddsBackBuffer);
    SAFE_RELEASE(m_pddsBackBufferLeft);
    SAFE_RELEASE(m_pddsZBuffer);
    SAFE_RELEASE(m_pddsFrontBuffer);
    SAFE_RELEASE(m_pD3D);

    if (m_pDD)
    {
        // Do a safe check for releasing DDRAW. RefCount must be zero.
        if (0 < (nDD = m_pDD->Release()))
            DEBUG_MSG(_T("Error: DDraw object is still referenced!"));
    }
    m_pDD = NULL;

    // Return successful, unless there are outstanding DD or D3DDevice refs.
    return (nDD==0 && nD3D==0) ? S_OK : D3DFWERR_NONZEROREFCOUNT;
}




//-----------------------------------------------------------------------------
// Name: Initialize()
// Desc: Creates the internal objects for the framework
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::Initialize(HWND hWnd, GUID* pDriverGUID,
                                    GUID* pDeviceGUID, DDSURFACEDESC2* pMode,
                                    DWORD dwFlags)
{
    HRESULT hr;

    // Check params. Note: A NULL mode is valid for windowed modes only.
    if ((NULL==hWnd) || (NULL==pDeviceGUID) || 
        (NULL==pMode && (dwFlags&D3DFW_FULLSCREEN)))
        return E_INVALIDARG;

    // Setup state for windowed/fullscreen mode
    m_hWnd          = hWnd;
    m_bIsStereo     = FALSE;
    m_bIsFullscreen = (dwFlags & D3DFW_FULLSCREEN) ? TRUE : FALSE;

    // Support stereoscopic viewing for fullscreen modes which support it
    if ((dwFlags & D3DFW_STEREO) && (dwFlags & D3DFW_FULLSCREEN))
        if (pMode->ddsCaps.dwCaps2 & DDSCAPS2_STEREOSURFACELEFT)
            m_bIsStereo = TRUE;

    // Create the D3D rendering environment (surfaces, device, viewport, etc.)
    if (FAILED(hr = CreateEnvironment(pDriverGUID, pDeviceGUID, pMode,
                                        dwFlags)))
    {
        DestroyObjects();
        return hr;
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: CreateEnvironment()
// Desc: Creates the internal objects for the framework
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::CreateEnvironment(GUID* pDriverGUID, GUID* pDeviceGUID,
                                           DDSURFACEDESC2* pMode, DWORD dwFlags)
{
    HRESULT hr;

    // Select the default memory type, for whether the device is HW or SW
    if (IsEqualIID(*pDeviceGUID, IID_IDirect3DHALDevice))
        m_dwDeviceMemType = DDSCAPS_VIDEOMEMORY;
    else if (IsEqualIID(*pDeviceGUID, IID_IDirect3DTnLHalDevice))
        m_dwDeviceMemType = DDSCAPS_VIDEOMEMORY;
    else
        m_dwDeviceMemType = DDSCAPS_SYSTEMMEMORY;

    // Create the DDraw object
    hr = CreateDirectDraw(pDriverGUID, dwFlags);
    if (FAILED(hr))
        return hr;

    // Create the front and back buffers, and attach a clipper
    if (dwFlags & D3DFW_FULLSCREEN)
        hr = CreateFullscreenBuffers(pMode);
    else
        hr = CreateWindowedBuffers();
    if (FAILED(hr))
        return hr;

    // Create the Direct3D object and the Direct3DDevice object
    hr = CreateDirect3D(pDeviceGUID);
    if (FAILED(hr))
        return hr;

    // Create and attach the zbuffer
    if (dwFlags & D3DFW_ZBUFFER)
        hr = CreateZBuffer(pDeviceGUID);
    if (FAILED(hr))
        return hr;

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: EnumZBufferFormatsCallback()
// Desc: Simply returns the first matching enumerated z-buffer format
//-----------------------------------------------------------------------------
static HRESULT WINAPI EnumZBufferFormatsCallback(DDPIXELFORMAT* pddpf,
                                                  VOID* pContext)
{
    DDPIXELFORMAT* pddpfOut = (DDPIXELFORMAT*)pContext;

    if (pddpfOut->dwRGBBitCount == pddpf->dwRGBBitCount)
    {
        (*pddpfOut) = (*pddpf);
        return D3DENUMRET_CANCEL;
    }

    return D3DENUMRET_OK;
}




//-----------------------------------------------------------------------------
// Name: CreateDirectDraw()
// Desc: Create the DirectDraw interface
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::CreateDirectDraw(GUID* pDriverGUID, DWORD dwFlags)
{
    // Create the DirectDraw interface, and query for the DD7 interface
    if (FAILED(DirectDrawCreateEx(pDriverGUID, (VOID**)&m_pDD,
                                    IID_IDirectDraw7, NULL)))
    {
        DEBUG_MSG(_T("Could not create DirectDraw"));
        return D3DFWERR_NODIRECTDRAW;
    }

    // Set the Windows cooperative level
    DWORD dwCoopFlags = DDSCL_NORMAL;
    if (m_bIsFullscreen)
        dwCoopFlags = DDSCL_ALLOWREBOOT|DDSCL_EXCLUSIVE|DDSCL_FULLSCREEN;

    // By defualt, set the flag to allow D3D to optimize floating point calcs
    if (0L == (dwFlags & D3DFW_NO_FPUSETUP))
        dwCoopFlags |= DDSCL_FPUSETUP;

    if (FAILED(m_pDD->SetCooperativeLevel(m_hWnd, dwCoopFlags)))
    {
        DEBUG_MSG(_T("Couldn't set coop level"));
        return D3DFWERR_COULDNTSETCOOPLEVEL;
    }

    // Check that we are NOT in a palettized display. That case will fail,
    // since the framework doesn't use palettes.
    DDSURFACEDESC2 ddsd;
    ddsd.dwSize = sizeof(ddsd);
    m_pDD->GetDisplayMode(&ddsd);
    if (ddsd.ddpfPixelFormat.dwRGBBitCount <= 8)
        return D3DFWERR_INVALIDMODE;

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: CreateFullscreenBuffers()
// Desc: Creates the primary and (optional) backbuffer for rendering.
//       Windowed mode and fullscreen mode are handled differently.
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::CreateFullscreenBuffers(DDSURFACEDESC2* pddsd)
{
    HRESULT hr;

    // Get the dimensions of the screen bounds
    // Store the rectangle which contains the renderer
    SetRect(&m_rcScreenRect, 0, 0, pddsd->dwWidth, pddsd->dwHeight);
    m_dwRenderWidth  = m_rcScreenRect.right  - m_rcScreenRect.left;
    m_dwRenderHeight = m_rcScreenRect.bottom - m_rcScreenRect.top;

    // Set the display mode to the requested dimensions. Check for
    // 320x200x8 modes, and set flag to avoid using ModeX
    DWORD dwModeFlags = 0;

    if ((320==m_dwRenderWidth) && (200==m_dwRenderHeight) &&
        (8==pddsd->ddpfPixelFormat.dwRGBBitCount))
        dwModeFlags |= DDSDM_STANDARDVGAMODE;

    if (FAILED(m_pDD->SetDisplayMode(m_dwRenderWidth, m_dwRenderHeight,
                                pddsd->ddpfPixelFormat.dwRGBBitCount,
                                pddsd->dwRefreshRate, dwModeFlags)))
    {
        DEBUG_MSG(_T("Can't set display mode"));
        return D3DFWERR_BADDISPLAYMODE;
    }

    // Setup to create the primary surface w/backbuffer
    DDSURFACEDESC2 ddsd;
    ZeroMemory(&ddsd, sizeof(ddsd));
    ddsd.dwSize            = sizeof(ddsd);
    ddsd.dwFlags           = DDSD_CAPS|DDSD_BACKBUFFERCOUNT;
    ddsd.ddsCaps.dwCaps    = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE |
                             DDSCAPS_FLIP | DDSCAPS_COMPLEX;
    ddsd.dwBackBufferCount = 1;

    // Support for stereoscopic viewing
    if (m_bIsStereo)
    {
        ddsd.ddsCaps.dwCaps  |= DDSCAPS_VIDEOMEMORY;
        ddsd.ddsCaps.dwCaps2 |= DDSCAPS2_STEREOSURFACELEFT;
    }

    // Create the primary surface
    if (FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrontBuffer, NULL)))
    {
        DEBUG_MSG(_T("Error: Can't create primary surface"));
        if (hr != DDERR_OUTOFVIDEOMEMORY)
            return D3DFWERR_NOPRIMARY;
        DEBUG_MSG(_T("Error: Out of video memory"));
        return DDERR_OUTOFVIDEOMEMORY;
    }

    // Get the backbuffer, which was created along with the primary.
    DDSCAPS2 ddscaps = { DDSCAPS_BACKBUFFER, 0, 0, 0 };
    if (FAILED(hr = m_pddsFrontBuffer->GetAttachedSurface(&ddscaps,
                                                &m_pddsBackBuffer)))
    {
        DEBUG_ERR(hr, _T("Error: Can't get the backbuffer"));
        return D3DFWERR_NOBACKBUFFER;
    }

    // Increment the backbuffer count (for consistency with windowed mode)
    m_pddsBackBuffer->AddRef();

    // Support for stereoscopic viewing
    if (m_bIsStereo)
    {
        // Get the left backbuffer, which was created along with the primary.
        DDSCAPS2 ddscaps = { 0, DDSCAPS2_STEREOSURFACELEFT, 0, 0 };
        if (FAILED(hr = m_pddsBackBuffer->GetAttachedSurface(&ddscaps,
                                                    &m_pddsBackBufferLeft)))
        {
            DEBUG_ERR(hr, _T("Error: Can't get the left backbuffer"));
            return D3DFWERR_NOBACKBUFFER;
        }
        m_pddsBackBufferLeft->AddRef();
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: CreateWindowedBuffers()
// Desc: Creates the primary and (optional) backbuffer for rendering.
//       Windowed mode and fullscreen mode are handled differently.
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::CreateWindowedBuffers()
{
    HRESULT hr;

    // Get the dimensions of the viewport and screen bounds
    GetClientRect(m_hWnd, &m_rcScreenRect);
    ClientToScreen(m_hWnd, (POINT*)&m_rcScreenRect.left);
    ClientToScreen(m_hWnd, (POINT*)&m_rcScreenRect.right);
    m_dwRenderWidth  = m_rcScreenRect.right  - m_rcScreenRect.left;
    m_dwRenderHeight = m_rcScreenRect.bottom - m_rcScreenRect.top;

    // Create the primary surface
    DDSURFACEDESC2 ddsd;
    ZeroMemory(&ddsd, sizeof(ddsd));
    ddsd.dwSize         = sizeof(ddsd);
    ddsd.dwFlags        = DDSD_CAPS;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

    if (FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsFrontBuffer, NULL)))
    {
        DEBUG_MSG(_T("Error: Can't create primary surface"));
        if (hr != DDERR_OUTOFVIDEOMEMORY)
            return D3DFWERR_NOPRIMARY;
        DEBUG_MSG(_T("Error: Out of video memory"));
        return DDERR_OUTOFVIDEOMEMORY;
    }

    // If in windowed-mode, create a clipper object
    LPDIRECTDRAWCLIPPER pcClipper;
    if (FAILED(hr = m_pDD->CreateClipper(0, &pcClipper, NULL)))
    {
        DEBUG_MSG(_T("Error: Couldn't create clipper"));
        return D3DFWERR_NOCLIPPER;
    }

    // Associate the clipper with the window
    pcClipper->SetHWnd(0, m_hWnd);
    m_pddsFrontBuffer->SetClipper(pcClipper);
    SAFE_RELEASE(pcClipper);

    // Create a backbuffer
    ddsd.dwFlags        = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS;
    ddsd.dwWidth        = m_dwRenderWidth;
    ddsd.dwHeight       = m_dwRenderHeight;
    ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;

    if (FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsBackBuffer, NULL)))
    {
        DEBUG_ERR(hr, _T("Error: Couldn't create the backbuffer"));
        if (hr != DDERR_OUTOFVIDEOMEMORY)
            return D3DFWERR_NOBACKBUFFER;
        DEBUG_MSG(_T("Error: Out of video memory"));
        return DDERR_OUTOFVIDEOMEMORY;
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: CreateDirect3D()
// Desc: Create the Direct3D interface
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::CreateDirect3D(GUID* pDeviceGUID)
{
    // Query DirectDraw for access to Direct3D
    if (FAILED(m_pDD->QueryInterface(IID_IDirect3D7, (VOID**)&m_pD3D)))
    {
        DEBUG_MSG(_T("Couldn't get the Direct3D interface"));
        return D3DFWERR_NODIRECT3D;
    }

    // Create the device
    if (FAILED(m_pD3D->CreateDevice(*pDeviceGUID, m_pddsBackBuffer,
                                      &m_pd3dDevice)))
    {
        DEBUG_MSG(_T("Couldn't create the D3DDevice"));
        return D3DFWERR_NO3DDEVICE;
    }

    // Finally, set the viewport for the newly created device
    D3DVIEWPORT7 vp = { 0, 0, m_dwRenderWidth, m_dwRenderHeight, 0.0f, 1.0f };

    if (FAILED(m_pd3dDevice->SetViewport(&vp)))
    {
        DEBUG_MSG(_T("Error: Couldn't set current viewport to device"));
        return D3DFWERR_NOVIEWPORT;
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: CreateZBuffer()
// Desc: Internal function called by Create() to make and attach a zbuffer
//       to the renderer
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::CreateZBuffer(GUID* pDeviceGUID)
{
    HRESULT hr;

    // Check if the device supports z-bufferless hidden surface removal. If so,
    // we don't really need a z-buffer
    D3DDEVICEDESC7 ddDesc;
    m_pd3dDevice->GetCaps(&ddDesc);
    if (ddDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_ZBUFFERLESSHSR)
        return S_OK;

    // Get z-buffer dimensions from the render target
    DDSURFACEDESC2 ddsd;
    ddsd.dwSize = sizeof(ddsd);
    m_pddsBackBuffer->GetSurfaceDesc(&ddsd);

    // Setup the surface desc for the z-buffer.
    ddsd.dwFlags        = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT;
    ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | m_dwDeviceMemType;
    ddsd.ddpfPixelFormat.dwSize = 0;  // Tag the pixel format as unitialized

    // Get an appropiate pixel format from enumeration of the formats. On the
    // first pass, we look for a zbuffer dpeth which is equal to the frame
    // buffer depth (as some cards unfornately require this).
    m_pD3D->EnumZBufferFormats(*pDeviceGUID, EnumZBufferFormatsCallback,
                                (VOID*)&ddsd.ddpfPixelFormat);
    if (0 == ddsd.ddpfPixelFormat.dwSize)
    {
        // Try again, just accepting any 16-bit zbuffer
        ddsd.ddpfPixelFormat.dwRGBBitCount = 16;
        m_pD3D->EnumZBufferFormats(*pDeviceGUID, EnumZBufferFormatsCallback,
                                    (VOID*)&ddsd.ddpfPixelFormat);
            
        if (0 == ddsd.ddpfPixelFormat.dwSize)
        {
            DEBUG_MSG(_T("Device doesn't support requested zbuffer format"));
            return D3DFWERR_NOZBUFFER;
        }
    }

    // Create and attach a z-buffer
    if (FAILED(hr = m_pDD->CreateSurface(&ddsd, &m_pddsZBuffer, NULL)))
    {
        DEBUG_MSG(_T("Error: Couldn't create a ZBuffer surface"));
        if (hr != DDERR_OUTOFVIDEOMEMORY)
            return D3DFWERR_NOZBUFFER;
        DEBUG_MSG(_T("Error: Out of video memory"));
        return DDERR_OUTOFVIDEOMEMORY;
    }

    if (FAILED(m_pddsBackBuffer->AddAttachedSurface(m_pddsZBuffer)))
    {
        DEBUG_MSG(_T("Error: Couldn't attach zbuffer to render surface"));
        return D3DFWERR_NOZBUFFER;
    }

    // For stereoscopic viewing, attach zbuffer to left surface as well
    if (m_bIsStereo)
    {
        if (FAILED(m_pddsBackBufferLeft->AddAttachedSurface(m_pddsZBuffer)))
        {
            DEBUG_MSG(_T("Error: Couldn't attach zbuffer to left render surface"));
            return D3DFWERR_NOZBUFFER;
        }
    }

    // Finally, this call rebuilds internal structures
    if (FAILED(m_pd3dDevice->SetRenderTarget(m_pddsBackBuffer, 0L)))
    {
        DEBUG_MSG(_T("Error: SetRenderTarget() failed after attaching zbuffer!"));
        return D3DFWERR_NOZBUFFER;
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: RestoreSurfaces()
// Desc: Checks for lost surfaces and restores them if lost. Note: Don't
//       restore render surface, since it's just a duplicate ptr.
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::RestoreSurfaces()
{
    // Restore all surfaces (including video memory vertex buffers)
    m_pDD->RestoreAllSurfaces();

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: Move()
// Desc: Moves the screen rect for windowed renderers
//-----------------------------------------------------------------------------
VOID CD3DFramework7::Move(INT x, INT y)
{
    if (TRUE == m_bIsFullscreen)
        return;

    SetRect(&m_rcScreenRect, x, y, x + m_dwRenderWidth, y + m_dwRenderHeight);
}




//-----------------------------------------------------------------------------
// Name: FlipToGDISurface()
// Desc: Puts the GDI surface in front of the primary, so that dialog
//       boxes and other windows drawing funcs may happen.
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::FlipToGDISurface(BOOL bDrawFrame)
{
    if (m_pDD && m_bIsFullscreen)
    {
        m_pDD->FlipToGDISurface();

        if (bDrawFrame)
        {
            DrawMenuBar(m_hWnd);
            RedrawWindow(m_hWnd, NULL, NULL, RDW_FRAME);
        }
    }

    return S_OK;
}




//-----------------------------------------------------------------------------
// Name: ShowFrame()
// Desc: Show the frame on the primary surface, via a blt or a flip.
//-----------------------------------------------------------------------------
HRESULT CD3DFramework7::ShowFrame()
{
    if (NULL == m_pddsFrontBuffer)
        return D3DFWERR_NOTINITIALIZED;

    if (m_bIsFullscreen)
    {
        // We are in fullscreen mode, so perform a flip.
        if (m_bIsStereo)
            return m_pddsFrontBuffer->Flip(NULL, DDFLIP_WAIT | DDFLIP_STEREO);
        else
            return m_pddsFrontBuffer->Flip(NULL, DDFLIP_WAIT);
    }
    else
    {
        // We are in windowed mode, so perform a blit.
        return m_pddsFrontBuffer->Blt(&m_rcScreenRect, m_pddsBackBuffer,
                                       NULL, DDBLT_WAIT, NULL);
    }
}



#endif