void VideoBackend::InitBackendInfo()
{
HRESULT hr = DX11::D3D::LoadDXGI();
if (SUCCEEDED(hr))
hr = DX11::D3D::LoadD3D();
if (FAILED(hr))
{
DX11::D3D::UnloadDXGI();
return;
}
g_Config.backend_info.api_type = APIType::D3D;
g_Config.backend_info.MaxTextureSize = D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION;
g_Config.backend_info.bUsesLowerLeftOrigin = false;
g_Config.backend_info.bSupportsExclusiveFullscreen = true;
g_Config.backend_info.bSupportsDualSourceBlend = true;
g_Config.backend_info.bSupportsPrimitiveRestart = true;
g_Config.backend_info.bSupportsOversizedViewports = false;
g_Config.backend_info.bSupportsGeometryShaders = true;
g_Config.backend_info.bSupportsComputeShaders = false;
g_Config.backend_info.bSupports3DVision = true;
g_Config.backend_info.bSupportsPostProcessing = true;
g_Config.backend_info.bSupportsPaletteConversion = true;
g_Config.backend_info.bSupportsClipControl = true;
g_Config.backend_info.bSupportsDepthClamp = true;
g_Config.backend_info.bSupportsReversedDepthRange = false;
g_Config.backend_info.bSupportsLogicOp = true;
g_Config.backend_info.bSupportsMultithreading = false;
g_Config.backend_info.bSupportsGPUTextureDecoding = true;
g_Config.backend_info.bSupportsST3CTextures = false;
g_Config.backend_info.bSupportsCopyToVram = true;
g_Config.backend_info.bSupportsLargePoints = false;
g_Config.backend_info.bSupportsPartialDepthCopies = false;
g_Config.backend_info.bSupportsBitfield = false;
g_Config.backend_info.bSupportsDynamicSamplerIndexing = false;
g_Config.backend_info.bSupportsBPTCTextures = false;
g_Config.backend_info.bSupportsFramebufferFetch = false;
g_Config.backend_info.bSupportsBackgroundCompiling = true;
IDXGIFactory2* factory;
IDXGIAdapter* ad;
hr = DX11::PCreateDXGIFactory(__uuidof(IDXGIFactory2), (void**)&factory);
if (FAILED(hr))
PanicAlert("Failed to create IDXGIFactory object");
// adapters
g_Config.backend_info.Adapters.clear();
g_Config.backend_info.AAModes.clear();
while (factory->EnumAdapters((UINT)g_Config.backend_info.Adapters.size(), &ad) !=
DXGI_ERROR_NOT_FOUND)
{
const size_t adapter_index = g_Config.backend_info.Adapters.size();
DXGI_ADAPTER_DESC desc;
ad->GetDesc(&desc);
// TODO: These don't get updated on adapter change, yet
if (adapter_index == g_Config.iAdapter)
{
std::vector<DXGI_SAMPLE_DESC> modes = DX11::D3D::EnumAAModes(ad);
// First iteration will be 1. This equals no AA.
for (unsigned int i = 0; i < modes.size(); ++i)
{
g_Config.backend_info.AAModes.push_back(modes[i].Count);
}
D3D_FEATURE_LEVEL feature_level = D3D::GetFeatureLevel(ad);
bool shader_model_5_supported = feature_level >= D3D_FEATURE_LEVEL_11_0;
g_Config.backend_info.MaxTextureSize = D3D::GetMaxTextureSize(feature_level);
// Requires the earlydepthstencil attribute (only available in shader model 5)
g_Config.backend_info.bSupportsEarlyZ = shader_model_5_supported;
// Requires full UAV functionality (only available in shader model 5)
g_Config.backend_info.bSupportsBBox =
g_Config.backend_info.bSupportsFragmentStoresAndAtomics = shader_model_5_supported;
// Requires the instance attribute (only available in shader model 5)
g_Config.backend_info.bSupportsGSInstancing = shader_model_5_supported;
// Sample shading requires shader model 5
g_Config.backend_info.bSupportsSSAA = shader_model_5_supported;
}
g_Config.backend_info.Adapters.push_back(UTF16ToUTF8(desc.Description));
ad->Release();
}
factory->Release();
DX11::D3D::UnloadDXGI();
DX11::D3D::UnloadD3D();
}
// 建立渲染窗口
/////////////////////////////////////////////////////////////////////////////////
void D3D11RenderEngine::DoCreateRenderWindow(std::string const & name,
RenderSettings const & settings)
{
motion_frames_ = settings.motion_frames;
D3D11RenderWindowPtr win = MakeSharedPtr<D3D11RenderWindow>(gi_factory_, this->ActiveAdapter(),
name, settings);
switch (d3d_feature_level_)
{
#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/)
case D3D_FEATURE_LEVEL_11_1:
#endif
case D3D_FEATURE_LEVEL_11_0:
vs_profile_ = "vs_5_0";
ps_profile_ = "ps_5_0";
gs_profile_ = "gs_5_0";
cs_profile_ = "cs_5_0";
hs_profile_ = "hs_5_0";
ds_profile_ = "ds_5_0";
break;
case D3D_FEATURE_LEVEL_10_1:
vs_profile_ = "vs_4_1";
ps_profile_ = "ps_4_1";
gs_profile_ = "gs_4_1";
cs_profile_ = "cs_4_1";
hs_profile_ = "";
ds_profile_ = "";
break;
case D3D_FEATURE_LEVEL_10_0:
vs_profile_ = "vs_4_0";
ps_profile_ = "ps_4_0";
gs_profile_ = "gs_4_0";
cs_profile_ = "cs_4_0";
hs_profile_ = "";
ds_profile_ = "";
break;
case D3D_FEATURE_LEVEL_9_3:
vs_profile_ = "vs_4_0_level_9_3";
ps_profile_ = "ps_4_0_level_9_3";
gs_profile_ = "";
cs_profile_ = "";
hs_profile_ = "";
ds_profile_ = "";
break;
default:
vs_profile_ = "vs_4_0_level_9_1";
ps_profile_ = "ps_4_0_level_9_1";
gs_profile_ = "";
cs_profile_ = "";
hs_profile_ = "";
ds_profile_ = "";
break;
}
this->ResetRenderStates();
this->BindFrameBuffer(win);
if (STM_LCDShutter == settings.stereo_method)
{
stereo_method_ = SM_None;
#if (_WIN32_WINNT >= 0x0602 /*_WIN32_WINNT_WIN8*/)
IDXGIFactory2* factory;
gi_factory_->QueryInterface(IID_IDXGIFactory2, reinterpret_cast<void**>(&factory));
if (factory != nullptr)
{
if (factory->IsWindowedStereoEnabled())
{
stereo_method_ = SM_DXGI;
}
factory->Release();
}
#endif
if (SM_None == stereo_method_)
{
DXGI_ADAPTER_DESC1 adapter_desc;
win->Adapter().DXGIAdapter()->GetDesc1(&adapter_desc);
if (std::wstring(adapter_desc.Description).find(L"NVIDIA", 0) != std::wstring::npos)
{
stereo_method_ = SM_NV3DVision;
RenderFactory& rf = Context::Instance().RenderFactoryInstance();
uint32_t const w = win->Width();
uint32_t const h = win->Height();
stereo_nv_3d_vision_tex_ = rf.MakeTexture2D(w * 2, h + 1, 1, 1,
settings.color_fmt, 1, 0, EAH_GPU_Read | EAH_GPU_Write, nullptr);
stereo_nv_3d_vision_fb_ = rf.MakeFrameBuffer();
stereo_nv_3d_vision_fb_->Attach(FrameBuffer::ATT_Color0,
rf.Make2DRenderView(*stereo_nv_3d_vision_tex_, 0, 1, 0));
NVSTEREOIMAGEHEADER sih;
sih.dwSignature = NVSTEREO_IMAGE_SIGNATURE;
sih.dwBPP = NumFormatBits(settings.color_fmt);
sih.dwFlags = SIH_SWAP_EYES;
sih.dwWidth = w * 2;
sih.dwHeight = h;
ElementInitData init_data;
init_data.data = &sih;
init_data.row_pitch = sizeof(sih);
init_data.slice_pitch = init_data.row_pitch;
TexturePtr sih_tex = rf.MakeTexture2D(sizeof(sih) / NumFormatBytes(settings.color_fmt),
1, 1, 1, settings.color_fmt, 1, 0, EAH_GPU_Read, &init_data);
sih_tex->CopyToSubTexture2D(*stereo_nv_3d_vision_tex_,
0, 0, 0, h, sih_tex->Width(0), 1,
0, 0, 0, 0, sih_tex->Width(0), 1);
}
else if (std::wstring(adapter_desc.Description).find(L"AMD", 0) != std::wstring::npos)
{
stereo_method_ = SM_AMDQuadBuffer;
}
}
}
}
void BBWin8Game::CreateD3dDevice(){
CoreWindow ^window=CoreWindow::GetForCurrentThread();
int width=DipsToPixels( window->Bounds.Width );
int height=DipsToPixels( window->Bounds.Height );
#if WINDOWS_8
switch( DisplayProperties::CurrentOrientation ){
case DisplayOrientations::Portrait:
case DisplayOrientations::PortraitFlipped:
std::swap( width,height );
break;
}
#endif
UINT creationFlags=D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifdef _DEBUG
creationFlags|=D3D11_CREATE_DEVICE_DEBUG;
#endif
#if WINDOWS_8
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
};
#elif WINDOWS_PHONE_8
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
};
#endif
ID3D11Device *device;
ID3D11DeviceContext *context;
DXASS( D3D11CreateDevice(
0,
D3D_DRIVER_TYPE_HARDWARE,
0,
creationFlags,
featureLevels,
ARRAYSIZE(featureLevels),
D3D11_SDK_VERSION,
&device,
&_featureLevel,
&context ) );
DXASS( device->QueryInterface( __uuidof( ID3D11Device1 ),(void**)&_d3dDevice ) );
DXASS( context->QueryInterface( __uuidof( ID3D11DeviceContext1 ),(void**)&_d3dContext ) );
device->Release();
context->Release();
//create swap chain
if( _swapChain ){
DXASS( _swapChain->ResizeBuffers( 2,width,height,DXGI_FORMAT_B8G8R8A8_UNORM,0 ) );
}else{
#if WINDOWS_8
DXGI_SWAP_CHAIN_DESC1 swapChainDesc={0};
swapChainDesc.Width=width;
swapChainDesc.Height=height;
swapChainDesc.Format=DXGI_FORMAT_B8G8R8A8_UNORM;
swapChainDesc.Stereo=false;
swapChainDesc.SampleDesc.Count=1;
swapChainDesc.SampleDesc.Quality=0;
swapChainDesc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount=2;
swapChainDesc.Scaling=DXGI_SCALING_NONE;
swapChainDesc.SwapEffect=DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
swapChainDesc.Flags=0;
#elif WINDOWS_PHONE_8
DXGI_SWAP_CHAIN_DESC1 swapChainDesc={0};
swapChainDesc.Width=width;
swapChainDesc.Height=height;
swapChainDesc.Format=DXGI_FORMAT_B8G8R8A8_UNORM;
swapChainDesc.Stereo=false;
swapChainDesc.SampleDesc.Count=1;
swapChainDesc.SampleDesc.Quality=0;
swapChainDesc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount=1;
swapChainDesc.Scaling=DXGI_SCALING_STRETCH;
swapChainDesc.SwapEffect=DXGI_SWAP_EFFECT_DISCARD;
swapChainDesc.Flags=0;
#endif
IDXGIDevice1 *dxgiDevice;
DXASS( _d3dDevice->QueryInterface( __uuidof( IDXGIDevice1 ),(void**)&dxgiDevice ) );
IDXGIAdapter *dxgiAdapter;
DXASS( dxgiDevice->GetAdapter( &dxgiAdapter ) );
IDXGIFactory2 *dxgiFactory;
DXASS( dxgiAdapter->GetParent( __uuidof( IDXGIFactory2 ),(void**)&dxgiFactory ) );
DXASS( dxgiFactory->CreateSwapChainForCoreWindow( _d3dDevice,(IUnknown*)window,&swapChainDesc,0,&_swapChain ) );
DXASS( dxgiDevice->SetMaximumFrameLatency( 1 ) );
dxgiFactory->Release();
dxgiAdapter->Release();
dxgiDevice->Release();
}
// Create a render target view of the swap chain back buffer.
//
ID3D11Texture2D *backBuffer;
DXASS( _swapChain->GetBuffer( 0,__uuidof( ID3D11Texture2D ),(void**)&backBuffer ) );
DXASS( _d3dDevice->CreateRenderTargetView( backBuffer,0,&_renderTargetView ) );
backBuffer->Release();
/*
// Create a depth stencil view
//
D3D11_TEXTURE2D_DESC dsdesc;
ZEROMEM( dsdesc );
dsdesc.Width=width;
dsdesc.Height=height;
dsdesc.MipLevels=1;
dsdesc.ArraySize=1;
dsdesc.Format=DXGI_FORMAT_D24_UNORM_S8_UINT;
dsdesc.SampleDesc.Count=1;
dsdesc.SampleDesc.Quality=0;
dsdesc.Usage=D3D11_USAGE_DEFAULT;
dsdesc.BindFlags=D3D11_BIND_DEPTH_STENCIL;
dsdesc.CpuAccessFlags=0;
dsdesc.MiscFlags=0;
ID3D11Texture2D *depthStencil;
DXASS( _d3dDevice->CreateTexture2D( &dsdesc,0,&depthStencil ) );
DXASS( _d3dDevice->CreateDepthStencilView( depthStencil,0,&_depthStencilView ) );
depthStencil->Release();
*/
D3D11_VIEWPORT viewport={ 0,0,width,height,0,1 };
_d3dContext->RSSetViewports( 1,&viewport );
}
void Graphics4::init(int windowId, int depthBufferBits, int stencilBufferBits, bool vSync) {
#ifdef KORE_VR
vsync = false;
#else
vsync = vSync;
#endif
for (int i = 0; i < 1024 * 4; ++i) vertexConstants[i] = 0;
for (int i = 0; i < 1024 * 4; ++i) fragmentConstants[i] = 0;
#ifdef KORE_WINDOWS
HWND hwnd = Window::get(windowId)->_data.handle;
#endif
UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#ifdef _DEBUG
creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
D3D_FEATURE_LEVEL featureLevels[] = {
#ifdef KORE_WINDOWSAPP
D3D_FEATURE_LEVEL_11_1,
#endif
D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_10_0};
#ifdef KORE_WINDOWSAPP
IDXGIAdapter3* adapter = nullptr;
#ifdef KORE_HOLOLENS
adapter = holographicFrameController->getCompatibleDxgiAdapter().Get();
#endif
Kore_Microsoft_affirm(D3D11CreateDevice(adapter, D3D_DRIVER_TYPE_HARDWARE, nullptr, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION,
&device, &featureLevel, &context));
#elif KORE_OCULUS
IDXGIFactory* dxgiFactory = nullptr;
Windows::affirm(CreateDXGIFactory1(__uuidof(IDXGIFactory), (void**)(&dxgiFactory)));
Windows::affirm(D3D11CreateDevice(nullptr, D3D_DRIVER_TYPE_HARDWARE, 0, creationFlags, featureLevels, ARRAYSIZE(featureLevels), D3D11_SDK_VERSION, &device,
&featureLevel, &context));
#endif
// affirm(device0.As(&device));
// affirm(context0.As(&context));
// m_windowBounds = m_window->Bounds;
const int _DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL = 3;
const int _DXGI_SWAP_EFFECT_FLIP_DISCARD = 4;
if (swapChain != nullptr) {
Kore_Microsoft_affirm(swapChain->ResizeBuffers(2, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0));
}
else {
#ifdef KORE_WINDOWS
DXGI_SWAP_CHAIN_DESC swapChainDesc = {0};
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferDesc.RefreshRate.Denominator = 1; // 60Hz
swapChainDesc.BufferDesc.RefreshRate.Numerator = 60;
swapChainDesc.BufferDesc.Width = System::windowWidth(windowId); // use automatic sizing
swapChainDesc.BufferDesc.Height = System::windowHeight(windowId);
swapChainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // this is the most common swapchain format
// swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = antialiasingSamples() > 1 ? antialiasingSamples() : 1;
swapChainDesc.SampleDesc.Quality = antialiasingSamples() > 1 ? D3D11_STANDARD_MULTISAMPLE_PATTERN : 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // use two buffers to enable flip effect
swapChainDesc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
swapChainDesc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; // DXGI_SCALING_NONE;
if (isWindows10OrGreater()) {
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//(DXGI_SWAP_EFFECT) _DXGI_SWAP_EFFECT_FLIP_DISCARD;
}
else if (isWindows8OrGreater()) {
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
//(DXGI_SWAP_EFFECT) _DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
}
else {
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
}
swapChainDesc.Flags = 0;
swapChainDesc.OutputWindow = Window::get(windowId)->_data.handle;
swapChainDesc.Windowed = true;
#endif
#if defined(KORE_WINDOWSAPP)
#ifdef KORE_HOLOLENS
// The Windows::Graphics::Holographic::HolographicSpace owns its own swapchain so we don't need to create one here
#else
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = 0; // use automatic sizing
swapChainDesc.Height = 0;
swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // this is the most common swapchain format
swapChainDesc.Stereo = false;
swapChainDesc.SampleDesc.Count = antialiasingSamples() > 1 ? antialiasingSamples() : 1;
swapChainDesc.SampleDesc.Quality = antialiasingSamples() > 1 ? D3D11_STANDARD_MULTISAMPLE_PATTERN : 0;
swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
swapChainDesc.BufferCount = 2; // use two buffers to enable flip effect
swapChainDesc.Scaling = DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
swapChainDesc.Flags = 0;
IDXGIDevice1* dxgiDevice;
Kore_Microsoft_affirm(device->QueryInterface(IID_IDXGIDevice1, (void**)&dxgiDevice));
IDXGIAdapter* dxgiAdapter;
Kore_Microsoft_affirm(dxgiDevice->GetAdapter(&dxgiAdapter));
IDXGIFactory2* dxgiFactory;
Kore_Microsoft_affirm(dxgiAdapter->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory));
Kore_Microsoft_affirm(dxgiFactory->CreateSwapChainForCoreWindow(device, reinterpret_cast<IUnknown*>(CoreWindow::GetForCurrentThread()), &swapChainDesc,
nullptr, &swapChain));
Kore_Microsoft_affirm(dxgiDevice->SetMaximumFrameLatency(1));
#endif
#elif KORE_OCULUS
DXGI_SWAP_CHAIN_DESC scDesc = {0};
scDesc.BufferCount = 2;
scDesc.BufferDesc.Width = System::windowWidth(windowId);
scDesc.BufferDesc.Height = System::windowHeight(windowId);
scDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scDesc.BufferDesc.RefreshRate.Denominator = 1;
scDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scDesc.OutputWindow = (HWND)System::windowHandle(windowId);
;
scDesc.SampleDesc.Count = antialiasingSamples() > 1 ? antialiasingSamples() : 1;
scDesc.SampleDesc.Quality = antialiasingSamples() > 1 ? D3D11_STANDARD_MULTISAMPLE_PATTERN : 0;
scDesc.Windowed = true;
scDesc.SwapEffect = DXGI_SWAP_EFFECT_SEQUENTIAL;
Windows::affirm(dxgiFactory->CreateSwapChain(device, &scDesc, &swapChain));
dxgiFactory->Release();
IDXGIDevice1* dxgiDevice = nullptr;
Windows::affirm(device->QueryInterface(__uuidof(IDXGIDevice1), (void**)&dxgiDevice));
Windows::affirm(dxgiDevice->SetMaximumFrameLatency(1));
dxgiDevice->Release();
#else
UINT flags = 0;
#ifdef _DEBUG
flags = D3D11_CREATE_DEVICE_DEBUG;
#endif
HRESULT result = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, flags, featureLevels, 3, D3D11_SDK_VERSION, &swapChainDesc,
&swapChain, &device, nullptr, &context);
if (result != S_OK) {
Kore_Microsoft_affirm(D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_WARP, nullptr, flags, featureLevels, 3, D3D11_SDK_VERSION, &swapChainDesc,
&swapChain, &device, nullptr, &context));
}
#endif
}
#ifdef KORE_HOLOLENS
// holographicFrameController manages the targets and views for hololens.
// the views have to be created/deleted on the CameraAdded/Removed events
// at this point we don't know if this event has alread occured so we cannot
// simply set the renderTargetWidth, renderTargetHeight, currentRenderTargetViews and currentDepthStencilView.
// to bind the targets for hololens one has to use the VrInterface::beginRender(eye) instead of the methods in this class.
ComPtr<ID3D11Device> devicePtr = device;
ComPtr<ID3D11DeviceContext> contextPtr = context;
Microsoft::WRL::ComPtr<ID3D11Device4> device4Ptr;
Microsoft::WRL::ComPtr<ID3D11DeviceContext3> context3Ptr;
affirm(devicePtr.As(&device4Ptr));
affirm(contextPtr.As(&context3Ptr));
holographicFrameController->setDeviceAndContext(device4Ptr, context3Ptr);
#else
createBackbuffer(antialiasingSamples());
currentRenderTargetViews[0] = renderTargetView;
currentDepthStencilView = depthStencilView;
context->OMSetRenderTargets(1, &renderTargetView, depthStencilView);
CD3D11_VIEWPORT viewPort(0.0f, 0.0f, static_cast<float>(renderTargetWidth), static_cast<float>(renderTargetHeight));
context->RSSetViewports(1, &viewPort);
#endif
D3D11_SAMPLER_DESC samplerDesc;
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
for (int i = 0; i < 16; ++i) {
lastSamplers[i] = samplerDesc;
}
initSamplers();
D3D11_BLEND_DESC blendDesc;
ZeroMemory(&blendDesc, sizeof(blendDesc));
D3D11_RENDER_TARGET_BLEND_DESC rtbd;
ZeroMemory(&rtbd, sizeof(rtbd));
rtbd.BlendEnable = true;
rtbd.SrcBlend = D3D11_BLEND_SRC_ALPHA;
rtbd.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.BlendOp = D3D11_BLEND_OP_ADD;
rtbd.SrcBlendAlpha = D3D11_BLEND_ONE;
rtbd.DestBlendAlpha = D3D11_BLEND_ZERO;
rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
#ifdef KORE_WINDOWSAPP
rtbd.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
#else
rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
#endif
blendDesc.AlphaToCoverageEnable = false;
blendDesc.RenderTarget[0] = rtbd;
ID3D11BlendState* blending;
device->CreateBlendState(&blendDesc, &blending);
Kore_Microsoft_affirm(device->CreateBlendState(&blendDesc, &blending));
context->OMSetBlendState(blending, nullptr, 0xffffffff);
}
