mirror of https://github.com/axmolengine/axmol.git
removed old WP8 files
This commit is contained in:
Dale Stammen
parent
dadbbc18d6
commit
05d33ac0c8
|
|
@ -1,470 +0,0 @@
|
|||
//-----------------------------------------------------------------------------------------------
|
||||
// Copyright (c) 2012 Andrew Garrison
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
||||
// and associated documentation files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or
|
||||
// substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
||||
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
|
||||
#include "platform/CCPlatformConfig.h"
|
||||
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
|
||||
|
||||
#include "DirectXBase.h"
|
||||
#include <windows.ui.xaml.media.dxinterop.h>
|
||||
#include <math.h>
|
||||
|
||||
using namespace Microsoft::WRL;
|
||||
using namespace Windows::UI::Core;
|
||||
using namespace Windows::UI::Xaml::Controls;
|
||||
using namespace Windows::Foundation;
|
||||
using namespace Windows::Graphics::Display;
|
||||
using namespace D2D1;
|
||||
|
||||
// Constructor.
|
||||
DirectXBase::DirectXBase() :
|
||||
m_dpi(-1.0f)
|
||||
{
|
||||
}
|
||||
|
||||
// Initialize the DirectX resources required to run.
|
||||
void DirectXBase::Initialize(CoreWindow^ window, SwapChainBackgroundPanel^ panel, float dpi)
|
||||
{
|
||||
m_window = window;
|
||||
m_panel = panel;
|
||||
|
||||
CreateDeviceIndependentResources();
|
||||
CreateDeviceResources();
|
||||
SetDpi(dpi);
|
||||
}
|
||||
|
||||
// These are the resources required independent of the device.
|
||||
void DirectXBase::CreateDeviceIndependentResources()
|
||||
{
|
||||
D2D1_FACTORY_OPTIONS options;
|
||||
ZeroMemory(&options, sizeof(D2D1_FACTORY_OPTIONS));
|
||||
|
||||
#if defined(_DEBUG)
|
||||
// If the project is in a debug build, enable Direct2D debugging via SDK Layers
|
||||
options.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION;
|
||||
#endif
|
||||
|
||||
DX::ThrowIfFailed(
|
||||
D2D1CreateFactory(
|
||||
D2D1_FACTORY_TYPE_SINGLE_THREADED,
|
||||
__uuidof(ID2D1Factory1),
|
||||
&options,
|
||||
&m_d2dFactory
|
||||
)
|
||||
);
|
||||
|
||||
DX::ThrowIfFailed(
|
||||
DWriteCreateFactory(
|
||||
DWRITE_FACTORY_TYPE_SHARED,
|
||||
__uuidof(IDWriteFactory),
|
||||
&m_dwriteFactory
|
||||
)
|
||||
);
|
||||
|
||||
DX::ThrowIfFailed(
|
||||
CoCreateInstance(
|
||||
CLSID_WICImagingFactory,
|
||||
nullptr,
|
||||
CLSCTX_INPROC_SERVER,
|
||||
IID_PPV_ARGS(&m_wicFactory)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// These are the resources that depend on the device.
|
||||
void DirectXBase::CreateDeviceResources()
|
||||
{
|
||||
// This flag adds support for surfaces with a different color channel ordering than the API default.
|
||||
// It is recommended usage, and is required for compatibility with Direct2D.
|
||||
UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
|
||||
ComPtr<IDXGIDevice> dxgiDevice;
|
||||
|
||||
#if defined(_DEBUG)
|
||||
// If the project is in a debug build, enable debugging via SDK Layers with this flag.
|
||||
creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
|
||||
#endif
|
||||
|
||||
// This array defines the set of DirectX hardware feature levels this app will support.
|
||||
// Note the ordering should be preserved.
|
||||
// Don't forget to declare your application's minimum required feature level in its
|
||||
// description. All applications are assumed to support 9.1 unless otherwise stated.
|
||||
D3D_FEATURE_LEVEL 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
|
||||
};
|
||||
|
||||
// Create the DX11 API device object, and get a corresponding context.
|
||||
ComPtr<ID3D11Device> device;
|
||||
ComPtr<ID3D11DeviceContext> context;
|
||||
DX::ThrowIfFailed(
|
||||
D3D11CreateDevice(
|
||||
nullptr, // specify null to use the default adapter
|
||||
D3D_DRIVER_TYPE_HARDWARE,
|
||||
0, // leave as 0 unless software device
|
||||
creationFlags, // optionally set debug and Direct2D compatibility flags
|
||||
featureLevels, // list of feature levels this app can support
|
||||
ARRAYSIZE(featureLevels), // number of entries in above list
|
||||
D3D11_SDK_VERSION, // always set this to D3D11_SDK_VERSION for Metro style apps
|
||||
&device, // returns the Direct3D device created
|
||||
&m_featureLevel, // returns feature level of device created
|
||||
&context // returns the device immediate context
|
||||
)
|
||||
);
|
||||
|
||||
// Get the DirectX11.1 device by QI off the DirectX11 one.
|
||||
DX::ThrowIfFailed(
|
||||
device.As(&m_d3dDevice)
|
||||
);
|
||||
|
||||
// And get the corresponding device context in the same way.
|
||||
DX::ThrowIfFailed(
|
||||
context.As(&m_d3dContext)
|
||||
);
|
||||
|
||||
// Obtain the underlying DXGI device of the Direct3D11.1 device.
|
||||
DX::ThrowIfFailed(
|
||||
m_d3dDevice.As(&dxgiDevice)
|
||||
);
|
||||
|
||||
// Obtain the Direct2D device for 2-D rendering.
|
||||
DX::ThrowIfFailed(
|
||||
m_d2dFactory->CreateDevice(dxgiDevice.Get(), &m_d2dDevice)
|
||||
);
|
||||
|
||||
// And get its corresponding device context object.
|
||||
DX::ThrowIfFailed(
|
||||
m_d2dDevice->CreateDeviceContext(
|
||||
D2D1_DEVICE_CONTEXT_OPTIONS_NONE,
|
||||
&m_d2dContext
|
||||
)
|
||||
);
|
||||
|
||||
// Release the swap chain (if it exists) as it will be incompatible with the new device.
|
||||
m_swapChain = nullptr;
|
||||
}
|
||||
|
||||
// Helps track the DPI in the helper class.
|
||||
// This is called in the dpiChanged event handler in the view class.
|
||||
void DirectXBase::SetDpi(float dpi)
|
||||
{
|
||||
if (dpi != m_dpi)
|
||||
{
|
||||
// Save the DPI of this display in our class.
|
||||
m_dpi = dpi;
|
||||
|
||||
// Update Direct2D's stored DPI.
|
||||
m_d2dContext->SetDpi(m_dpi, m_dpi);
|
||||
|
||||
// Often a DPI change implies a window size change. In some cases Windows will issues
|
||||
// both a size changed event and a DPI changed event. In this case, the resulting bounds
|
||||
// will not change, and the window resize code will only be executed once.
|
||||
UpdateForWindowSizeChange();
|
||||
}
|
||||
}
|
||||
|
||||
// This routine is called in the event handler for the view SizeChanged event.
|
||||
void DirectXBase::UpdateForWindowSizeChange()
|
||||
{
|
||||
// Only handle window size changed if there is no pending DPI change.
|
||||
if (m_dpi != DisplayProperties::LogicalDpi)
|
||||
return;
|
||||
|
||||
if (m_window->Bounds.Width != m_windowBounds.Width ||
|
||||
m_window->Bounds.Height != m_windowBounds.Height)
|
||||
{
|
||||
m_d2dContext->SetTarget(nullptr);
|
||||
m_d2dTargetBitmap = nullptr;
|
||||
m_renderTargetView = nullptr;
|
||||
m_depthStencilView = nullptr;
|
||||
CreateWindowSizeDependentResources();
|
||||
}
|
||||
}
|
||||
|
||||
// Allocate all memory resources that change on a window SizeChanged event.
|
||||
void DirectXBase::CreateWindowSizeDependentResources()
|
||||
{
|
||||
// Store the window bounds so the next time we get a SizeChanged event we can
|
||||
// avoid rebuilding everything if the size is identical.
|
||||
m_windowBounds = m_window->Bounds;
|
||||
|
||||
// Calculate the necessary swap chain and render target size in pixels.
|
||||
m_renderTargetSize.Width = ConvertDipsToPixels(m_windowBounds.Width);
|
||||
m_renderTargetSize.Height = ConvertDipsToPixels(m_windowBounds.Height);
|
||||
|
||||
// If the swap chain already exists, resize it.
|
||||
if (m_swapChain != nullptr)
|
||||
{
|
||||
DX::ThrowIfFailed(
|
||||
m_swapChain->ResizeBuffers(
|
||||
2,
|
||||
static_cast<UINT>(m_renderTargetSize.Width),
|
||||
static_cast<UINT>(m_renderTargetSize.Height),
|
||||
DXGI_FORMAT_B8G8R8A8_UNORM,
|
||||
0
|
||||
)
|
||||
);
|
||||
}
|
||||
// Otherwise, create a new one.
|
||||
else
|
||||
{
|
||||
// Allocate a descriptor.
|
||||
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
|
||||
swapChainDesc.Width = static_cast<UINT>(m_renderTargetSize.Width); // Match the size of the windowm.
|
||||
swapChainDesc.Height = static_cast<UINT>(m_renderTargetSize.Height);
|
||||
swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swapchain format.
|
||||
swapChainDesc.Stereo = false;
|
||||
swapChainDesc.SampleDesc.Count = 1; // Don't use multi-sampling.
|
||||
swapChainDesc.SampleDesc.Quality = 0;
|
||||
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
|
||||
swapChainDesc.BufferCount = 2; // Use double buffering to enable flip.
|
||||
swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
|
||||
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Metro style apps must use this SwapEffect.
|
||||
swapChainDesc.Flags = 0;
|
||||
|
||||
// Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device.
|
||||
|
||||
// First, retrieve the underlying DXGI Device from the D3D Device.
|
||||
ComPtr<IDXGIDevice1> dxgiDevice;
|
||||
DX::ThrowIfFailed(
|
||||
m_d3dDevice.As(&dxgiDevice)
|
||||
);
|
||||
|
||||
// Identify the physical adapter (GPU or card) this device is running on.
|
||||
ComPtr<IDXGIAdapter> dxgiAdapter;
|
||||
DX::ThrowIfFailed(
|
||||
dxgiDevice->GetAdapter(&dxgiAdapter)
|
||||
);
|
||||
|
||||
// And obtain the factory object that created it.
|
||||
ComPtr<IDXGIFactory2> dxgiFactory;
|
||||
DX::ThrowIfFailed(
|
||||
dxgiAdapter->GetParent(IID_PPV_ARGS(&dxgiFactory))
|
||||
);
|
||||
|
||||
// Create the swap chain and then associate it with the SwapChainBackgroundPanel.
|
||||
DX::ThrowIfFailed(
|
||||
dxgiFactory->CreateSwapChainForComposition(
|
||||
m_d3dDevice.Get(),
|
||||
&swapChainDesc,
|
||||
nullptr,
|
||||
&m_swapChain
|
||||
)
|
||||
);
|
||||
|
||||
ComPtr<ISwapChainBackgroundPanelNative> panelNative;
|
||||
DX::ThrowIfFailed(
|
||||
reinterpret_cast<IUnknown*>(m_panel)->QueryInterface(IID_PPV_ARGS(&panelNative))
|
||||
);
|
||||
|
||||
DX::ThrowIfFailed(
|
||||
panelNative->SetSwapChain(m_swapChain.Get())
|
||||
);
|
||||
|
||||
// Ensure that DXGI does not queue more than one frame at a time. This both reduces
|
||||
// latency and ensures that the application will only render after each VSync, minimizing
|
||||
// power consumption.
|
||||
DX::ThrowIfFailed(
|
||||
dxgiDevice->SetMaximumFrameLatency(1)
|
||||
);
|
||||
}
|
||||
|
||||
// Obtain the backbuffer for this window which will be the final 3D rendertarget.
|
||||
ComPtr<ID3D11Texture2D> backBuffer;
|
||||
DX::ThrowIfFailed(
|
||||
m_swapChain->GetBuffer(0, IID_PPV_ARGS(&backBuffer))
|
||||
);
|
||||
|
||||
// Create a view interface on the rendertarget to use on bind.
|
||||
DX::ThrowIfFailed(
|
||||
m_d3dDevice->CreateRenderTargetView(
|
||||
backBuffer.Get(),
|
||||
nullptr,
|
||||
&m_renderTargetView
|
||||
)
|
||||
);
|
||||
|
||||
// Create a descriptor for the depth/stencil buffer.
|
||||
CD3D11_TEXTURE2D_DESC depthStencilDesc(
|
||||
DXGI_FORMAT_D24_UNORM_S8_UINT,
|
||||
static_cast<UINT>(m_renderTargetSize.Width),
|
||||
static_cast<UINT>(m_renderTargetSize.Height),
|
||||
1,
|
||||
1,
|
||||
D3D11_BIND_DEPTH_STENCIL
|
||||
);
|
||||
|
||||
// Allocate a 2-D surface as the depth/stencil buffer.
|
||||
ComPtr<ID3D11Texture2D> depthStencil;
|
||||
DX::ThrowIfFailed(
|
||||
m_d3dDevice->CreateTexture2D(
|
||||
&depthStencilDesc,
|
||||
nullptr,
|
||||
&depthStencil
|
||||
)
|
||||
);
|
||||
|
||||
// Create a DepthStencil view on this surface to use on bind.
|
||||
CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
|
||||
DX::ThrowIfFailed(
|
||||
m_d3dDevice->CreateDepthStencilView(
|
||||
depthStencil.Get(),
|
||||
&depthStencilViewDesc,
|
||||
&m_depthStencilView
|
||||
)
|
||||
);
|
||||
|
||||
// Create a viewport descriptor of the full window size.
|
||||
CD3D11_VIEWPORT viewport(
|
||||
0.0f,
|
||||
0.0f,
|
||||
m_renderTargetSize.Width,
|
||||
m_renderTargetSize.Height
|
||||
);
|
||||
|
||||
// Set the current viewport using the descriptor.
|
||||
m_d3dContext->RSSetViewports(1, &viewport);
|
||||
|
||||
// Now we set up the Direct2D render target bitmap linked to the swapchain.
|
||||
// Whenever we render to this bitmap, it will be directly rendered to the
|
||||
// swapchain associated with the window.
|
||||
D2D1_BITMAP_PROPERTIES1 bitmapProperties =
|
||||
BitmapProperties1(
|
||||
D2D1_BITMAP_OPTIONS_TARGET | D2D1_BITMAP_OPTIONS_CANNOT_DRAW,
|
||||
PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),
|
||||
m_dpi,
|
||||
m_dpi
|
||||
);
|
||||
|
||||
// Direct2D needs the DXGI version of the backbuffer surface pointer.
|
||||
ComPtr<IDXGISurface> dxgiBackBuffer;
|
||||
DX::ThrowIfFailed(
|
||||
m_swapChain->GetBuffer(0, IID_PPV_ARGS(&dxgiBackBuffer))
|
||||
);
|
||||
|
||||
// Get a D2D surface from the DXGI back buffer to use as the D2D render target.
|
||||
DX::ThrowIfFailed(
|
||||
m_d2dContext->CreateBitmapFromDxgiSurface(
|
||||
dxgiBackBuffer.Get(),
|
||||
&bitmapProperties,
|
||||
&m_d2dTargetBitmap
|
||||
)
|
||||
);
|
||||
|
||||
// So now we can set the Direct2D render target.
|
||||
m_d2dContext->SetTarget(m_d2dTargetBitmap.Get());
|
||||
|
||||
// Set D2D text anti-alias mode to Grayscale to ensure proper rendering of text on intermediate surfaces.
|
||||
m_d2dContext->SetTextAntialiasMode(D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE);
|
||||
|
||||
// Set the blend function.
|
||||
ID3D11BlendState* g_pBlendState = NULL;
|
||||
D3D11_BLEND_DESC blendDesc;
|
||||
ZeroMemory(&blendDesc, sizeof(D3D11_BLEND_DESC));
|
||||
blendDesc.AlphaToCoverageEnable = false;
|
||||
blendDesc.IndependentBlendEnable = false;
|
||||
D3D11_RENDER_TARGET_BLEND_DESC rtBlendDesc;
|
||||
rtBlendDesc.BlendEnable = false;
|
||||
rtBlendDesc.SrcBlend = D3D11_BLEND_SRC_ALPHA;
|
||||
rtBlendDesc.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
|
||||
rtBlendDesc.BlendOp = D3D11_BLEND_OP_ADD;
|
||||
rtBlendDesc.SrcBlendAlpha = D3D11_BLEND_ZERO;
|
||||
rtBlendDesc.DestBlendAlpha = D3D11_BLEND_ZERO;
|
||||
rtBlendDesc.BlendOpAlpha = D3D11_BLEND_OP_ADD;
|
||||
rtBlendDesc.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
|
||||
blendDesc.RenderTarget[0] = rtBlendDesc;
|
||||
|
||||
auto hr1 = m_d3dDevice->CreateBlendState(&blendDesc, &g_pBlendState);
|
||||
m_d3dContext->OMSetBlendState(g_pBlendState, 0, 0xffffffff);
|
||||
|
||||
D3D11_DEPTH_STENCIL_DESC dsDesc;
|
||||
// Depth test parameters
|
||||
dsDesc.DepthEnable = false;
|
||||
dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
|
||||
dsDesc.DepthFunc = D3D11_COMPARISON_LESS;
|
||||
|
||||
// Stencil test parameters
|
||||
dsDesc.StencilEnable = true;
|
||||
dsDesc.StencilReadMask = 0xFF;
|
||||
dsDesc.StencilWriteMask = 0xFF;
|
||||
|
||||
// Stencil operations if pixel is front-facing
|
||||
dsDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
|
||||
dsDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
|
||||
dsDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
|
||||
dsDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
|
||||
|
||||
// Stencil operations if pixel is back-facing
|
||||
dsDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
|
||||
dsDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
|
||||
dsDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
|
||||
dsDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
|
||||
|
||||
// Create depth stencil state
|
||||
ID3D11DepthStencilState * pDSState;
|
||||
m_d3dDevice->CreateDepthStencilState(&dsDesc, &pDSState);
|
||||
m_d3dContext->OMSetDepthStencilState(pDSState, 1);
|
||||
m_d3dContext->OMSetRenderTargets(1, m_renderTargetView.GetAddressOf(), m_depthStencilView.Get());
|
||||
}
|
||||
|
||||
// Method to deliver the final image to the display.
|
||||
void DirectXBase::Present()
|
||||
{
|
||||
// The application may optionally specify "dirty" or "scroll" rects to improve efficiency
|
||||
// in certain scenarios.
|
||||
DXGI_PRESENT_PARAMETERS parameters = {0};
|
||||
parameters.DirtyRectsCount = 0;
|
||||
parameters.pDirtyRects = nullptr;
|
||||
parameters.pScrollRect = nullptr;
|
||||
parameters.pScrollOffset = nullptr;
|
||||
|
||||
|
||||
|
||||
// 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->Present1(1, 0, ¶meters);
|
||||
m_d3dContext->OMSetRenderTargets(1,m_renderTargetView.GetAddressOf(),m_depthStencilView.Get());
|
||||
|
||||
|
||||
|
||||
// If the device was removed either by a disconnect or a driver upgrade, we
|
||||
// must completely reinitialize the renderer.
|
||||
if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
|
||||
{
|
||||
Initialize(m_window.Get(), m_panel, m_dpi);
|
||||
}
|
||||
else
|
||||
{
|
||||
DX::ThrowIfFailed(hr);
|
||||
}
|
||||
}
|
||||
|
||||
// Method to convert a length in device-independent pixels (DIPs) to a length in physical pixels.
|
||||
float DirectXBase::ConvertDipsToPixels(float dips)
|
||||
{
|
||||
static const float dipsPerInch = 96.0f;
|
||||
return floor(dips * m_dpi / dipsPerInch + 0.5f); // Round to nearest integer.
|
||||
}
|
||||
|
||||
#endif // (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
//-----------------------------------------------------------------------------------------------
|
||||
// Copyright (c) 2012 Andrew Garrison
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
||||
// and associated documentation files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or
|
||||
// substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
||||
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
#pragma once
|
||||
|
||||
#include "platform/CCPlatformConfig.h"
|
||||
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
|
||||
|
||||
#include <wrl/client.h>
|
||||
#include <d3d11_1.h>
|
||||
#include <d2d1_1.h>
|
||||
#include <d2d1effects.h>
|
||||
#include <dwrite_1.h>
|
||||
#include <wincodec.h>
|
||||
#include <agile.h>
|
||||
#include <DirectXMath.h>
|
||||
#include "DirectXHelper.h"
|
||||
|
||||
#pragma warning (disable: 4449)
|
||||
using namespace Windows::UI::ViewManagement;
|
||||
|
||||
// Helper class that initializes DirectX APIs
|
||||
ref class DirectXBase abstract
|
||||
{
|
||||
internal:
|
||||
DirectXBase();
|
||||
|
||||
public:
|
||||
virtual void Initialize(Windows::UI::Core::CoreWindow^ window, Windows::UI::Xaml::Controls::SwapChainBackgroundPanel^ panel, float dpi);
|
||||
virtual void CreateDeviceIndependentResources();
|
||||
virtual void CreateDeviceResources();
|
||||
virtual void SetDpi(float dpi);
|
||||
virtual void CreateWindowSizeDependentResources();
|
||||
virtual void UpdateForWindowSizeChange();
|
||||
virtual void Present();
|
||||
virtual float ConvertDipsToPixels(float dips);
|
||||
|
||||
protected private:
|
||||
|
||||
Platform::Agile<Windows::UI::Core::CoreWindow> m_window;
|
||||
Windows::UI::Xaml::Controls::SwapChainBackgroundPanel^ m_panel;
|
||||
|
||||
// Direct2D Objects
|
||||
Microsoft::WRL::ComPtr<ID2D1Factory1> m_d2dFactory;
|
||||
Microsoft::WRL::ComPtr<ID2D1Device> m_d2dDevice;
|
||||
Microsoft::WRL::ComPtr<ID2D1DeviceContext> m_d2dContext;
|
||||
Microsoft::WRL::ComPtr<ID2D1Bitmap1> m_d2dTargetBitmap;
|
||||
|
||||
// DirectWrite & Windows Imaging Component Objects
|
||||
Microsoft::WRL::ComPtr<IDWriteFactory1> m_dwriteFactory;
|
||||
Microsoft::WRL::ComPtr<IWICImagingFactory2> m_wicFactory;
|
||||
|
||||
// Direct3D Objects
|
||||
Microsoft::WRL::ComPtr<ID3D11Device1> m_d3dDevice;
|
||||
Microsoft::WRL::ComPtr<ID3D11DeviceContext1> m_d3dContext;
|
||||
Microsoft::WRL::ComPtr<IDXGISwapChain1> m_swapChain;
|
||||
Microsoft::WRL::ComPtr<ID3D11RenderTargetView> m_renderTargetView;
|
||||
Microsoft::WRL::ComPtr<ID3D11DepthStencilView> m_depthStencilView;
|
||||
|
||||
D3D_FEATURE_LEVEL m_featureLevel;
|
||||
Windows::Foundation::Size m_renderTargetSize;
|
||||
Windows::Foundation::Rect m_windowBounds;
|
||||
float m_dpi;
|
||||
};
|
||||
|
||||
#pragma warning (default: 4449)
|
||||
|
||||
#endif // (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
//-----------------------------------------------------------------------------------------------
|
||||
// Copyright (c) 2012 Andrew Garrison
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
|
||||
// and associated documentation files (the "Software"), to deal in the Software without
|
||||
// restriction, including without limitation the rights to use, copy, modify, merge, publish,
|
||||
// distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
|
||||
// Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or
|
||||
// substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
|
||||
// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
//-----------------------------------------------------------------------------------------------
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "platform/CCPlatformConfig.h"
|
||||
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
|
||||
|
||||
// Helper utilities to make Win32 APIs work with exceptions.
|
||||
namespace DX
|
||||
{
|
||||
inline void ThrowIfFailed(HRESULT hr)
|
||||
{
|
||||
if (FAILED(hr))
|
||||
{
|
||||
// Set a breakpoint on this line to catch Win32 API errors.
|
||||
throw Platform::Exception::CreateException(hr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif // (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)
|
||||
Loading…
Reference in New Issue