Блог

Я новичок в UWP и WinRT, я уже знал DirectX11 и Win32, и мне очень интересно изучать UWP и WinRT.

DXMainResources — это класс для использования Diret3D и Direct2D, и самое главное при создании ресурсов — это окно (CoreWindow), однако при передаче окна в качестве параметра функции появляется много ошибок, таких как:

Ошибка C2065 ‘bEnableDepthStencilBuffer’: ошибка необъявленного идентификатора C2065 ‘window’: ошибка необъявленного идентификатора C2065 ‘window_’: необъявленный идентификатор

Столкнувшись с этими ошибками, удалите параметр окна CoreWindow, и программа компилируется, но окно в качестве параметра необходимо, поскольку мне нужны его высота и ширина для создания цепочки подкачки и текстуры для просмотра трафарета глубины.

Есть ли способ передать окно в качестве параметра?

Я использую интерфейсы DirectX 11.3, а версия WinRT, которую я использую, — 2.0.201026.4

 #pragma once

#include "pch.h"

#include <d3d11_3.h>
#include <d2d1_3.h>
#include <dxgi1_4.h>
#include <dwrite_3.h>

#include <array>

using namespace D2D1;

template<class Interface> void TSafeRelease(Interface** ppInterface)
{
    if (*ppInterface)
    {
        (*ppInterface)->Release();
        (*ppInterface) = nullptr;
    }
}

class DXMainResources
{
public:
    DXMainResources()
    {
        d3dDev = nullptr;
        d3dDevContext = nullptr;
        d3dRTView = nullptr;
        d3dDSView = nullptr;
        d2dDev = nullptr;
        d2dDevContext = nullptr;
        d2dTargetBitmap = nullptr;
        dxgiFactory = nullptr;
        dxgiDev = nullptr;
        dxgiDefaultAdapter = nullptr;
        dxgiSwapChain = nullptr;
        dwriteFactory = nullptr;
        dwriteTextFmt = nullptr;

        featureLevel = static_cast<D3D_FEATURE_LEVEL>(0);
        dxgiSwapChainFmt = DXGI_FORMAT_UNKNOWN;
        dxgiDepthStencilFmt = DXGI_FORMAT_UNKNOWN;
        viewPort = D3D11_VIEWPORT();
    }

    ~DXMainResources()
    {

    }

    void CreateResources(CoreWindow constamp; window, bool bOnlyDirect2D = false, bool bEnableDepthStencilBuffer = true
        , DXGI_FORMAT dxgiSwapChainFmt_ = DXGI_FORMAT_B8G8R8A8_UNORM, DXGI_FORMAT dxgiDepthStencilFmt_ = DXGI_FORMAT_D24_UNORM_S8_UINT
        , DXGI_SWAP_EFFECT swapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL)
    {
        dxgiSwapChainFmt = dxgiSwapChainFmt_;
        dxgiDepthStencilFmt = dxgiDepthStencilFmt_;

        CoreWindow window_ = window;

        std::array<D3D_FEATURE_LEVEL, 9> featureLevels =
        {
            D3D_FEATURE_LEVEL_12_1,
            D3D_FEATURE_LEVEL_12_0,
            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 deviceFlags = D3D11_CREATE_DEVICE_DEBUG | D3D11_CREATE_DEVICE_BGRA_SUPPORT;

        HRESULT hr = D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, deviceFlags, featureLevels.data(), static_cast<UINT>(std::size(featureLevels))
            , D3D11_SDK_VERSION, reinterpret_cast<ID3D11Device**>(amp;d3dDev), amp;featureLevel, nullptr);

        hr = d3dDev->QueryInterface(__uuidof(IDXGIDevice3), reinterpret_cast<void**>(amp;dxgiDev));

        hr = dxgiDev->GetAdapter(reinterpret_cast<IDXGIAdapter**>(amp;dxgiDefaultAdapter));

        hr = dxgiDefaultAdapter->GetParent(__uuidof(IDXGIFactory4), reinterpret_cast<void**>(amp;dxgiFactory));

        DXGI_SWAP_CHAIN_DESC1 swapChainDesc;
        ZeroMemory(amp;swapChainDesc, sizeof(DXGI_SWAP_CHAIN_DESC1));
        
        swapChainDesc.BufferCount = 2;
        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
        swapChainDesc.Format = dxgiSwapChainFmt_;
        swapChainDesc.SampleDesc.Count = 1;
        swapChainDesc.SwapEffect = swapEffect;

        hr = dxgiFactory->CreateSwapChainForCoreWindow(d3dDev, reinterpret_cast<IUnknown*>(window_)
            , amp;swapChainDesc, nullptr, reinterpret_cast<IDXGISwapChain1**>(amp;dxgiSwapChain));
            
        if (bOnlyDirect2D)
        {
            IDXGISurface2* dxgiBackBufferSurface = nullptr;
            hr = dxgiSwapChain->GetBuffer(0, __uuidof(IDXGISurface2), reinterpret_cast<void**>(amp;dxgiBackBufferSurface));

            D2D1_CREATION_PROPERTIES creationProps = CreationProperties(D2D1_THREADING_MODE_SINGLE_THREADED, D2D1_DEBUG_LEVEL_INFORMATION, D2D1_DEVICE_CONTEXT_OPTIONS_NONE);
            D2D1_BITMAP_PROPERTIES1 bmpProps = BitmapProperties1(D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_TARGET
                , PixelFormat(dxgiSwapChainFmt_, D2D1_ALPHA_MODE_IGNORE));
            
            hr = D2D1CreateDevice(dxgiDev, creationProps, reinterpret_cast<ID2D1Device**>(amp;d2dDev));

            hr = d2dDev->CreateDeviceContext(creationProps.options, amp;d2dDevContext);

            hr = d2dDevContext->CreateBitmapFromDxgiSurface(dxgiBackBufferSurface, bmpProps, amp;d2dTargetBitmap);

            d2dDevContext->SetTarget(d2dTargetBitmap);

            TSafeRelease(amp;dxgiBackBufferSurface);
        }
        else
        {
            IDXGISurface2* dxgiBackBufferSurface = nullptr;
            hr = dxgiSwapChain->GetBuffer(0, __uuidof(IDXGISurface2), reinterpret_cast<void**>(amp;dxgiBackBufferSurface));

            D2D1_CREATION_PROPERTIES creationProps = CreationProperties(D2D1_THREADING_MODE_SINGLE_THREADED, D2D1_DEBUG_LEVEL_INFORMATION, D2D1_DEVICE_CONTEXT_OPTIONS_NONE);
            D2D1_BITMAP_PROPERTIES1 bmpProps = BitmapProperties1(D2D1_BITMAP_OPTIONS_CANNOT_DRAW | D2D1_BITMAP_OPTIONS_TARGET
                , PixelFormat(dxgiSwapChainFmt_, D2D1_ALPHA_MODE_IGNORE));

            hr = D2D1CreateDevice(dxgiDev, creationProps, reinterpret_cast<ID2D1Device**>(amp;d2dDev));

            hr = d2dDev->CreateDeviceContext(creationProps.options, amp;d2dDevContext);

            hr = d2dDevContext->CreateBitmapFromDxgiSurface(dxgiBackBufferSurface, bmpProps, amp;d2dTargetBitmap);
            d2dDevContext->SetTarget(d2dTargetBitmap);

            TSafeRelease(amp;dxgiBackBufferSurface);

            d3dDev->GetImmediateContext3(amp;d3dDevContext);

            ID3D11Texture2D1* d3dBackBufferTex = nullptr;
            hr = dxgiSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D1), reinterpret_cast<void**>(amp;d3dBackBufferTex));

            hr = d3dDev->CreateRenderTargetView1(d3dBackBufferTex, nullptr, amp;d3dRTView);

            TSafeRelease(amp;d3dBackBufferTex);

            if (bEnableDepthStencilBuffer)
            {
                ID3D11Texture2D1* d3dDepthStencilTex = nullptr;

                D3D11_TEXTURE2D_DESC1 depthStencilTexDesc;
                ZeroMemory(amp;depthStencilTexDesc, sizeof(D3D11_TEXTURE2D_DESC1));

                depthStencilTexDesc.ArraySize = 1;
                depthStencilTexDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
                depthStencilTexDesc.Format = dxgiDepthStencilFmt_;
                depthStencilTexDesc.Height = window_.Bounds().Height;
                depthStencilTexDesc.MipLevels = 1;
                depthStencilTexDesc.SampleDesc.Count = 1;
                depthStencilTexDesc.Width = window_.Bounds().Width;

                hr = d3dDev->CreateTexture2D1(amp;depthStencilTexDesc, nullptr, amp;d3dDepthStencilTex);
                hr = d3dDev->CreateDepthStencilView(d3dDepthStencilTex, nullptr, amp;d3dDSView);

                d3dDevContext->OMSetRenderTargets(1, reinterpret_cast<ID3D11RenderTargetView**>(amp;d3dRTView), d3dDSView);

                TSafeRelease(amp;d3dDepthStencilTex);
            }
            else
            {
                d3dDevContext->OMSetRenderTargets(1, reinterpret_cast<ID3D11RenderTargetView**>(amp;d3dRTView), nullptr);
            }

            viewPort.Height = window_.Bounds().Height;
            viewPort.MaxDepth = 1.0f;
            viewPort.Width = window_.Bounds().Width;

            d3dDevContext->RSSetViewports(1, amp;viewPort);
        }

        hr = DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory3), reinterpret_cast<IUnknown**>(amp;dwriteFactory));
        hr = dwriteFactory->CreateTextFormat(L"Segoe", nullptr, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL, DWRITE_FONT_STRETCH_NORMAL, 11.0f
            , L"en-US", reinterpret_cast<IDWriteTextFormat**>(amp;dwriteTextFmt));
    }

    ID3D11Device3* GetD3D11Device() const { return d3dDev; }
    ID3D11DeviceContext3* GetD3D11DeviceContext() const { return d3dDevContext; }
    ID3D11RenderTargetView1* GetD3D11RenderTargetView() const { return d3dRTView; }
    ID3D11DepthStencilView* GetD3D11DepthStencilView() const { return d3dDSView; }

    ID2D1Device2* GetD2DDevice() const { return d2dDev; }
    ID2D1DeviceContext2* GetD2DDeviceContext() const { return d2dDevContext; }
    ID2D1Bitmap1* GetD2DTargetBitmap() const { return d2dTargetBitmap; }

    IDXGIFactory4* GetDXGIFactory() const { return dxgiFactory; }
    IDXGIDevice3* GetDXGIDevice() const { return dxgiDev; }
    IDXGIAdapter3* GetDXGIDefaultAdapter() const { return dxgiDefaultAdapter; }
    IDXGISwapChain3* GetDXGISwapChain() const { return dxgiSwapChain; }

    IDWriteFactory* GetDWriteFactory() const { return dwriteFactory; }
    IDWriteTextFormat3* GetDWriteTextFormat() const { return dwriteTextFmt; }

    D3D_FEATURE_LEVEL GetD3DDeviceFeatureLevel() { return featureLevel; }
    DXGI_FORMAT GetDXGISwapChainFormat() { return dxgiSwapChainFmt; }
    DXGI_FORMAT GetDXGIDepthStencilFormat() { return dxgiDepthStencilFmt; }
    D3D11_VIEWPORT GetD3D11ViewPort() { return viewPort; }
private:
    ID3D11Device3* d3dDev;
    ID3D11DeviceContext3* d3dDevContext;
    ID3D11RenderTargetView1* d3dRTView;
    ID3D11DepthStencilView* d3dDSView;

    ID2D1Device2* d2dDev;
    ID2D1DeviceContext2* d2dDevContext;
    ID2D1Bitmap1* d2dTargetBitmap;

    IDXGIFactory4* dxgiFactory;
    IDXGIDevice3* dxgiDev;
    IDXGIAdapter3* dxgiDefaultAdapter;
    IDXGISwapChain3* dxgiSwapChain;

    IDWriteFactory* dwriteFactory;
    IDWriteTextFormat3* dwriteTextFmt;

    D3D_FEATURE_LEVEL featureLevel;
    DXGI_FORMAT dxgiSwapChainFmt;
    DXGI_FORMAT dxgiDepthStencilFmt;
    D3D11_VIEWPORT viewPort;
};


  

Обратитесь к Важному в документе, пожалуйста, добавьте следующий #include оператор и using инструкцию, затем попробуйте скомпилировать свой проект.

 #include <winrt/Windows.UI.Core.h>
using namespace winrt::Windows::UI::Core;