Added classic Win32 PC samples

//--------------------------------------------------------------------------------------

// File: FindMedia.h

//

// Helper function to find the location of a media file for Windows desktop apps

// since they lack appx packaging support.

//

// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF

// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO

// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A

// PARTICULAR PURPOSE.

//

// Copyright (c) Microsoft Corporation. All rights reserved.

//-------------------------------------------------------------------------------------

#pragma once

#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP)

#error This header only works with Windows desktop apps

#endif

#include <exception>

#include <string.h>

namespace DX

{

    inline void FindMediaFile(_Out_writes_(cchDest) wchar_t* strDestPath, _In_ int cchDest, _In_z_ const wchar_t* strFilename)

    {

        bool bFound = false;

        if (!strFilename || strFilename[0] == 0 || !strDestPath || cchDest < 10)

            throw std::invalid_argument("FindMediaFile");

        // Get the exe name, and exe path

        wchar_t strExePath[MAX_PATH] = {};

        wchar_t strExeName[MAX_PATH] = {};

        wchar_t* strLastSlash = nullptr;

        GetModuleFileName(nullptr, strExePath, MAX_PATH);

        strExePath[MAX_PATH - 1] = 0;

        strLastSlash = wcsrchr(strExePath, TEXT('\\'));

        if (strLastSlash)

        {

            wcscpy_s(strExeName, MAX_PATH, &strLastSlash[1]);

            // Chop the exe name from the exe path

            *strLastSlash = 0;

            // Chop the .exe from the exe name

            strLastSlash = wcsrchr(strExeName, TEXT('.'));

            if (strLastSlash)

                *strLastSlash = 0;

        }

        wcscpy_s(strDestPath, cchDest, strFilename);

        if (GetFileAttributes(strDestPath) != 0xFFFFFFFF)

            return;

        // Search all parent directories starting at .\ and using strFilename as the leaf name

        wchar_t strLeafName[MAX_PATH] = {};

        wcscpy_s(strLeafName, MAX_PATH, strFilename);

        wchar_t strFullPath[MAX_PATH] = {};

        wchar_t strFullFileName[MAX_PATH] = {};

        wchar_t strSearch[MAX_PATH] = {};

        wchar_t* strFilePart = nullptr;

        GetFullPathName(strExePath, MAX_PATH, strFullPath, &strFilePart);

        if (!strFilePart)

            throw std::exception("FindMediaFile");

        while (strFilePart && *strFilePart != '\0')

        {

            swprintf_s(strFullFileName, MAX_PATH, L"%ls\\%ls", strFullPath, strLeafName);

            if (GetFileAttributes(strFullFileName) != 0xFFFFFFFF)

            {

                wcscpy_s(strDestPath, cchDest, strFullFileName);

                bFound = true;

                break;

            }

            swprintf_s(strFullFileName, MAX_PATH, L"%ls\\%ls\\%ls", strFullPath, strExeName, strLeafName);

            if (GetFileAttributes(strFullFileName) != 0xFFFFFFFF)

            {

                wcscpy_s(strDestPath, cchDest, strFullFileName);

                bFound = true;

                break;

            }

            swprintf_s(strSearch, MAX_PATH, L"%ls\\..", strFullPath);

            GetFullPathName(strSearch, MAX_PATH, strFullPath, &strFilePart);

        }

        if (bFound)

            return;

        // On failure, return the file as the path but also return an error code

        wcscpy_s(strDestPath, cchDest, strFilename);

        throw std::exception("File not found");

    }

}

 No newline at end of file

//

// DeviceResources.cpp - A wrapper for the Direct3D 11 device and swapchain

//                       (requires DirectX 11.1 Runtime)

//

#include "pch.h"

#include "DeviceResources.h"

using namespace DirectX;

using namespace DX;

using Microsoft::WRL::ComPtr;

namespace

{

#if defined(_DEBUG)

    // Check for SDK Layer support.

    inline bool SdkLayersAvailable()

    {

        HRESULT hr = D3D11CreateDevice(

            nullptr,

            D3D_DRIVER_TYPE_NULL,       // There is no need to create a real hardware device.

            0,

            D3D11_CREATE_DEVICE_DEBUG,  // Check for the SDK layers.

            nullptr,                    // Any feature level will do.

            0,

            D3D11_SDK_VERSION,

            nullptr,                    // No need to keep the D3D device reference.

            nullptr,                    // No need to know the feature level.

            nullptr                     // No need to keep the D3D device context reference.

            );

        return SUCCEEDED(hr);

    }

#endif

};

// Constructor for DeviceResources.

DeviceResources::DeviceResources(DXGI_FORMAT backBufferFormat, DXGI_FORMAT depthBufferFormat, UINT backBufferCount, D3D_FEATURE_LEVEL minFeatureLevel) :

    m_screenViewport{},

    m_backBufferFormat(backBufferFormat),

    m_depthBufferFormat(depthBufferFormat),

    m_backBufferCount(backBufferCount),

    m_d3dMinFeatureLevel(minFeatureLevel),

    m_window(nullptr),

    m_d3dFeatureLevel(D3D_FEATURE_LEVEL_9_1),

    m_outputSize{0, 0, 1, 1},

    m_deviceNotify(nullptr)

{

}

// Configures the Direct3D device, and stores handles to it and the device context.

void DeviceResources::CreateDeviceResources() 

{

    UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;

#if defined(_DEBUG)

    if (SdkLayersAvailable())

    {

        // If the project is in a debug build, enable debugging via SDK Layers with this flag.

        creationFlags |= D3D11_CREATE_DEVICE_DEBUG;

    }

    else

    {

        OutputDebugStringA("WARNING: Direct3D Debug Device is not available\n");

    }

#endif

    // Determine DirectX hardware feature levels this app will support.

    static const D3D_FEATURE_LEVEL s_featureLevels[] =

    {

        D3D_FEATURE_LEVEL_11_1,

        D3D_FEATURE_LEVEL_11_0,

        D3D_FEATURE_LEVEL_10_1,

        D3D_FEATURE_LEVEL_10_0,

        D3D_FEATURE_LEVEL_9_3,

        D3D_FEATURE_LEVEL_9_2,

        D3D_FEATURE_LEVEL_9_1,

    };

    UINT featLevelCount = 0;

    for (; featLevelCount < _countof(s_featureLevels); ++featLevelCount)

    {

        if (s_featureLevels[featLevelCount] < m_d3dMinFeatureLevel)

            break;

    }

    if (!featLevelCount)

    {

        throw std::out_of_range("minFeatureLevel too high");

    }

    ComPtr<IDXGIAdapter1> adapter;

    GetHardwareAdapter(adapter.GetAddressOf());

    // Create the Direct3D 11 API device object and a corresponding context.

    ComPtr<ID3D11Device> device;

    ComPtr<ID3D11DeviceContext> context;

    HRESULT hr = E_FAIL;

    if (adapter)

    {

        hr = D3D11CreateDevice(

            adapter.Get(),

            D3D_DRIVER_TYPE_UNKNOWN,

            0,

            creationFlags,

            s_featureLevels,

            featLevelCount,

            D3D11_SDK_VERSION,

            device.GetAddressOf(),      // Returns the Direct3D device created.

            &m_d3dFeatureLevel,         // Returns feature level of device created.

            context.GetAddressOf()      // Returns the device immediate context.

            );

    }

#if defined(NDEBUG)

    else

    {

        throw std::exception("No Direct3D hardware device found");

    }

#else

    if (FAILED(hr))

    {

        // If the initialization fails, fall back to the WARP device.

        // For more information on WARP, see: 

        // http://go.microsoft.com/fwlink/?LinkId=286690

        hr = D3D11CreateDevice(

            nullptr,

            D3D_DRIVER_TYPE_WARP, // Create a WARP device instead of a hardware device.

            0,

            creationFlags,

            s_featureLevels,

            featLevelCount,

            D3D11_SDK_VERSION,

            device.GetAddressOf(),

            &m_d3dFeatureLevel,

            context.GetAddressOf()

            );

        if (SUCCEEDED(hr))

        {

            OutputDebugStringA("Direct3D Adapter - WARP\n");

        }

    }

#endif

    ThrowIfFailed(hr);

#ifndef NDEBUG

    ComPtr<ID3D11Debug> d3dDebug;

    if (SUCCEEDED(device.As(&d3dDebug)))

    {

        ComPtr<ID3D11InfoQueue> d3dInfoQueue;

        if (SUCCEEDED(d3dDebug.As(&d3dInfoQueue)))

        {

#ifdef _DEBUG

            d3dInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);

            d3dInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);

#endif

            D3D11_MESSAGE_ID hide [] =

            {

                D3D11_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS,

            };

            D3D11_INFO_QUEUE_FILTER filter = {};

            filter.DenyList.NumIDs = _countof(hide);

            filter.DenyList.pIDList = hide;

            d3dInfoQueue->AddStorageFilterEntries(&filter);

        }

    }

#endif

    ThrowIfFailed(device.As(&m_d3dDevice));

    ThrowIfFailed(context.As(&m_d3dContext));

    ThrowIfFailed(context.As(&m_d3dAnnotation));

}

// These resources need to be recreated every time the window size is changed.

void DeviceResources::CreateWindowSizeDependentResources() 

{

    if (!m_window)

    {

        throw std::exception("Call SetWindow with a valid Win32 window handle");

    }

    // Clear the previous window size specific context.

    ID3D11RenderTargetView* nullViews[] = {nullptr};

    m_d3dContext->OMSetRenderTargets(_countof(nullViews), nullViews, nullptr);

    m_d3dRenderTargetView.Reset();

    m_d3dDepthStencilView.Reset();

    m_renderTarget.Reset();

    m_depthStencil.Reset();

    m_d3dContext->Flush();

    // Determine the render target size in pixels.

    UINT backBufferWidth = std::max<UINT>(m_outputSize.right - m_outputSize.left, 1);

    UINT backBufferHeight = std::max<UINT>(m_outputSize.bottom - m_outputSize.top, 1);

    if (m_swapChain)

    {

        // If the swap chain already exists, resize it.

        HRESULT hr = m_swapChain->ResizeBuffers(

            m_backBufferCount,

            backBufferWidth,

            backBufferHeight,

            m_backBufferFormat,

            0

            );

        if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)

        {

#ifdef _DEBUG

            char buff[64] = {};

            sprintf_s(buff, "Device Lost on ResizeBuffers: Reason code 0x%08X\n", (hr == DXGI_ERROR_DEVICE_REMOVED) ? m_d3dDevice->GetDeviceRemovedReason() : hr);

            OutputDebugStringA(buff);

#endif

            // If the device was removed for any reason, a new device and swap chain will need to be created.

            HandleDeviceLost();

            // Everything is set up now. Do not continue execution of this method. HandleDeviceLost will reenter this method 

            // and correctly set up the new device.

            return;

        }

        else

        {

            ThrowIfFailed(hr);

        }

    }

    else

    {

        // Otherwise, create a new one using the same adapter as the existing Direct3D device.

        // This sequence obtains the DXGI factory that was used to create the Direct3D device above.

        ComPtr<IDXGIDevice1> dxgiDevice;

        ThrowIfFailed(m_d3dDevice.As(&dxgiDevice));

        ComPtr<IDXGIAdapter> dxgiAdapter;

        ThrowIfFailed(dxgiDevice->GetAdapter(dxgiAdapter.GetAddressOf()));

        ComPtr<IDXGIFactory2> dxgiFactory;

        ThrowIfFailed(dxgiAdapter->GetParent(IID_PPV_ARGS(dxgiFactory.GetAddressOf())));

        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};

        swapChainDesc.Width = backBufferWidth;

        swapChainDesc.Height = backBufferHeight;

        swapChainDesc.Format = m_backBufferFormat;

        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

        swapChainDesc.BufferCount = m_backBufferCount;

        swapChainDesc.SampleDesc.Count = 1;

        swapChainDesc.SampleDesc.Quality = 0;

        swapChainDesc.Scaling = DXGI_SCALING_STRETCH;

        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

        swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;

        DXGI_SWAP_CHAIN_FULLSCREEN_DESC fsSwapChainDesc = { 0 };

        fsSwapChainDesc.Windowed = TRUE;

        // Create a SwapChain from a Win32 window.

        ThrowIfFailed(dxgiFactory->CreateSwapChainForHwnd(

            m_d3dDevice.Get(),

            m_window,

            &swapChainDesc,

            &fsSwapChainDesc,

            nullptr, m_swapChain.ReleaseAndGetAddressOf()

            ));

        // This class does not support exclusive full-screen mode and prevents DXGI from responding to the ALT+ENTER shortcut

        ThrowIfFailed(dxgiFactory->MakeWindowAssociation(m_window, DXGI_MWA_NO_ALT_ENTER));

    }

    // Create a render target view of the swap chain back buffer.

    ThrowIfFailed(m_swapChain->GetBuffer(0, IID_PPV_ARGS(m_renderTarget.ReleaseAndGetAddressOf())));

    ThrowIfFailed(m_d3dDevice->CreateRenderTargetView(

        m_renderTarget.Get(),

        nullptr,

        m_d3dRenderTargetView.ReleaseAndGetAddressOf()

        ));

    if (m_depthBufferFormat != DXGI_FORMAT_UNKNOWN)

    {

        // Create a depth stencil view for use with 3D rendering if needed.

        CD3D11_TEXTURE2D_DESC depthStencilDesc(

            m_depthBufferFormat,

            backBufferWidth,

            backBufferHeight,

            1, // This depth stencil view has only one texture.

            1, // Use a single mipmap level.

            D3D11_BIND_DEPTH_STENCIL

            );

        ThrowIfFailed(m_d3dDevice->CreateTexture2D(

            &depthStencilDesc,

            nullptr,

            m_depthStencil.ReleaseAndGetAddressOf()

            ));

        CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);

        ThrowIfFailed(m_d3dDevice->CreateDepthStencilView(

            m_depthStencil.Get(),

            &depthStencilViewDesc,

            m_d3dDepthStencilView.ReleaseAndGetAddressOf()

            ));

    }

    // Set the 3D rendering viewport to target the entire window.

    m_screenViewport = CD3D11_VIEWPORT(

        0.0f,

        0.0f,

        static_cast<float>(backBufferWidth),

        static_cast<float>(backBufferHeight)

        );

}

// This method is called when the Win32 window is created (or re-created).

void DeviceResources::SetWindow(HWND window, int width, int height)

{

    m_window = window;

    m_outputSize.left = m_outputSize.top = 0;

    m_outputSize.right = width;

    m_outputSize.bottom = height;

}

// This method is called when the Win32 window changes size

bool DeviceResources::WindowSizeChanged(int width, int height)

{

    RECT newRc;

    newRc.left = newRc.top = 0;

    newRc.right = width;

    newRc.bottom = height;

    if (newRc == m_outputSize)

    {

        return false;

    }

    m_outputSize = newRc;

    CreateWindowSizeDependentResources();

    return true;

}

// Recreate all device resources and set them back to the current state.

void DeviceResources::HandleDeviceLost()

{

    if (m_deviceNotify)

    {

        m_deviceNotify->OnDeviceLost();

    }

    m_d3dDepthStencilView.Reset();

    m_d3dRenderTargetView.Reset();

    m_renderTarget.Reset();

    m_depthStencil.Reset();

    m_swapChain.Reset();

    m_d3dContext.Reset();

    m_d3dAnnotation.Reset();

#ifdef _DEBUG

    {

        ComPtr<ID3D11Debug> d3dDebug;

        if (SUCCEEDED(m_d3dDevice.As(&d3dDebug)))

        {

            d3dDebug->ReportLiveDeviceObjects(D3D11_RLDO_SUMMARY);

        }

    }

#endif

    m_d3dDevice.Reset();

    CreateDeviceResources();

    CreateWindowSizeDependentResources();

    if (m_deviceNotify)

    {

        m_deviceNotify->OnDeviceRestored();

    }

}

// Present the contents of the swap chain to the screen.

void DeviceResources::Present() 

{

    // The first argument instructs DXGI to block until VSync, putting the application

    // to sleep until the next VSync. This ensures we don't waste any cycles rendering

    // frames that will never be displayed to the screen.

    HRESULT hr = m_swapChain->Present(1, 0);

    // Discard the contents of the render target.

    // This is a valid operation only when the existing contents will be entirely

    // overwritten. If dirty or scroll rects are used, this call should be removed.

    m_d3dContext->DiscardView(m_d3dRenderTargetView.Get());

    if (m_d3dDepthStencilView)

    {

        // Discard the contents of the depth stencil.

        m_d3dContext->DiscardView(m_d3dDepthStencilView.Get());

    }

    // If the device was removed either by a disconnection or a driver upgrade, we 

    // must recreate all device resources.

    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)

    {

#ifdef _DEBUG

        char buff[64] = {};

        sprintf_s(buff, "Device Lost on Present: Reason code 0x%08X\n", (hr == DXGI_ERROR_DEVICE_REMOVED) ? m_d3dDevice->GetDeviceRemovedReason() : hr);

        OutputDebugStringA(buff);

#endif

        HandleDeviceLost();

    }

    else

    {

        ThrowIfFailed(hr);

    }

}

// This method acquires the first available hardware adapter.

// If no such adapter can be found, *ppAdapter will be set to nullptr.

void DeviceResources::GetHardwareAdapter(IDXGIAdapter1** ppAdapter)

{

    *ppAdapter = nullptr;

    ComPtr<IDXGIFactory1> dxgiFactory;

    ThrowIfFailed(CreateDXGIFactory1(IID_PPV_ARGS(dxgiFactory.GetAddressOf())));

    ComPtr<IDXGIAdapter1> adapter;

    for (UINT adapterIndex = 0; DXGI_ERROR_NOT_FOUND != dxgiFactory->EnumAdapters1(adapterIndex, adapter.ReleaseAndGetAddressOf()); adapterIndex++)

    {

        DXGI_ADAPTER_DESC1 desc;

        adapter->GetDesc1(&desc);

        if (desc.Flags & DXGI_ADAPTER_FLAG_SOFTWARE)

        {

            // Don't select the Basic Render Driver adapter.

            continue;

        }

#ifdef _DEBUG

        wchar_t buff[256] = {};

        swprintf_s(buff, L"Direct3D Adapter (%u): VID:%04X, PID:%04X - %ls\n", adapterIndex, desc.VendorId, desc.DeviceId, desc.Description);

        OutputDebugStringW(buff);

#endif

        break;

    }

    *ppAdapter = adapter.Detach();

}

//

// DeviceResources.h - A wrapper for the Direct3D 11 device and swapchain

//

#pragma once

namespace DX

{

    // Provides an interface for an application that owns DeviceResources to be notified of the device being lost or created.

    interface IDeviceNotify

    {

        virtual void OnDeviceLost() = 0;

        virtual void OnDeviceRestored() = 0;

    };

    // Controls all the DirectX device resources.

    class DeviceResources

    {

    public:

        DeviceResources(DXGI_FORMAT backBufferFormat = DXGI_FORMAT_B8G8R8A8_UNORM,

                        DXGI_FORMAT depthBufferFormat = DXGI_FORMAT_D32_FLOAT,

                        UINT backBufferCount = 2,

                        D3D_FEATURE_LEVEL minFeatureLevel = D3D_FEATURE_LEVEL_10_0);

        void CreateDeviceResources();

        void CreateWindowSizeDependentResources();

        void SetWindow(HWND window, int width, int height);

        bool WindowSizeChanged(int width, int height);

        void HandleDeviceLost();

        void RegisterDeviceNotify(IDeviceNotify* deviceNotify) { m_deviceNotify = deviceNotify; }

        void Present();

        // Device Accessors.

        RECT GetOutputSize() const { return m_outputSize; }

        // Direct3D Accessors.

        ID3D11Device1*          GetD3DDevice() const                    { return m_d3dDevice.Get(); }

        ID3D11DeviceContext1*   GetD3DDeviceContext() const             { return m_d3dContext.Get(); }

        IDXGISwapChain1*        GetSwapChain() const                    { return m_swapChain.Get(); }

        D3D_FEATURE_LEVEL       GetDeviceFeatureLevel() const           { return m_d3dFeatureLevel; }

        ID3D11Texture2D*        GetRenderTarget() const                 { return m_renderTarget.Get(); }

        ID3D11Texture2D*        GetDepthStencil() const                 { return m_depthStencil.Get(); }

        ID3D11RenderTargetView*	GetRenderTargetView() const             { return m_d3dRenderTargetView.Get(); }

        ID3D11DepthStencilView* GetDepthStencilView() const             { return m_d3dDepthStencilView.Get(); }

        DXGI_FORMAT             GetBackBufferFormat() const             { return m_backBufferFormat; }

        DXGI_FORMAT             GetDepthBufferFormat() const            { return m_depthBufferFormat; }

        D3D11_VIEWPORT          GetScreenViewport() const               { return m_screenViewport; }

        UINT                    GetBackBufferCount() const              { return m_backBufferCount; }

        // Performance events

        void PIXBeginEvent(_In_z_ const wchar_t* name)

        {

            m_d3dAnnotation->BeginEvent(name);

        }

        void PIXEndEvent()

        {

            m_d3dAnnotation->EndEvent();

        }

        void PIXSetMarker(_In_z_ const wchar_t* name)

        {

            m_d3dAnnotation->SetMarker(name);

        }

    private:

        void GetHardwareAdapter(IDXGIAdapter1** ppAdapter);

        // Direct3D objects.

        Microsoft::WRL::ComPtr<ID3D11Device1>               m_d3dDevice;

        Microsoft::WRL::ComPtr<ID3D11DeviceContext1>        m_d3dContext;

        Microsoft::WRL::ComPtr<IDXGISwapChain1>             m_swapChain;

        Microsoft::WRL::ComPtr<ID3DUserDefinedAnnotation>   m_d3dAnnotation;

        // Direct3D rendering objects. Required for 3D.

        Microsoft::WRL::ComPtr<ID3D11Texture2D>         m_renderTarget;

        Microsoft::WRL::ComPtr<ID3D11Texture2D>         m_depthStencil;

        Microsoft::WRL::ComPtr<ID3D11RenderTargetView>  m_d3dRenderTargetView;

        Microsoft::WRL::ComPtr<ID3D11DepthStencilView>  m_d3dDepthStencilView;

        D3D11_VIEWPORT                                  m_screenViewport;

        // Direct3D properties.

        DXGI_FORMAT                                     m_backBufferFormat;

        DXGI_FORMAT                                     m_depthBufferFormat;

        UINT                                            m_backBufferCount;

        D3D_FEATURE_LEVEL                               m_d3dMinFeatureLevel;

        // Cached device properties.

        HWND                                            m_window;

        D3D_FEATURE_LEVEL                               m_d3dFeatureLevel;

        RECT                                            m_outputSize;

        // The IDeviceNotify can be held directly as it owns the DeviceResources.

        IDeviceNotify*                                  m_deviceNotify;

    };

}

 No newline at end of file