void OpenGLEngine::Draw (int x, int y, glm::vec4 const& color, std::string const& message)
{
if (message.length () > 0)
{
int vx, vy, vw, vh;
GetViewport (vx, vy, vw, vh);
m_ActiveFont->SetStringData (vw, vh, x, y, color, message);
Update (m_ActiveFont->GetTextEffect () ->GetTranslate ());
Update (m_ActiveFont->GetTextEffect () ->GetColor ());
Update (m_ActiveFont->GetVertexBuffer ());
std::shared_ptr<BlendState> blendState = GetBlendState ();
std::shared_ptr<DepthStencilState> depthState = GetDepthStencilState ();
std::shared_ptr<RasterizerState> rasterizerState = GetRasterizerState ();
SetDefaultBlendState ();
SetDefaultDepthStencilState ();
SetDefaultRasterizerState ();
Draw (m_ActiveFont->GetVertexBuffer (), m_ActiveFont->GetIndexBuffer (), m_ActiveFont->GetTextEffect ());
SetBlendState (blendState);
SetDepthStencilState (depthState);
SetRasterizerState (rasterizerState);
}
}
void RenderingDevice::SetMaterial(const Material &material) {
SetRasterizerState(material.GetRasterizerState());
SetBlendState(material.GetBlendState());
SetDepthStencilState(material.GetDepthStencilState());
for (size_t i = 0; i < material.GetSamplers().size(); ++i) {
auto& sampler = material.GetSamplers()[i];
if (sampler.GetTexture()) {
D3DLOG(mDevice->SetTexture(i, sampler.GetTexture()->GetDeviceTexture()));
} else {
D3DLOG(mDevice->SetTexture(i, nullptr));
}
SetSamplerState(i, sampler.GetState());
}
// Free up the texture bindings of the samplers currently being used
for (size_t i = material.GetSamplers().size(); i < mUsedSamplers; ++i) {
D3DLOG(mDevice->SetTexture(i, nullptr));
}
mUsedSamplers = material.GetSamplers().size();
material.GetVertexShader()->Bind();
material.GetPixelShader()->Bind();
}
void D3D11GraphicsDeviceStateManager::SetDefaultFrontFaceRendering()
{
if( locked )
return;
SetRasterizerState( default_rasterizer_state );
SetDepthStencilState( default_depth_stencil_state );
}
void D3D11GraphicsDeviceStateManager::SetSpriteRendering( const BlendType::GRAPHICS_DEVICE_STATE_MANAGER_BLEND_TYPE blend_type )
{
if( locked )
return;
SetRasterizerState( sprite_rasterizer_state );
SetDepthStencilState( sprite_depth_stencil_state );
SetBlendType( blend_type );
}
void D3D11GraphicsDeviceStateManager::SetParticleRendering()
{
if( locked )
return;
SetRasterizerState( sprite_rasterizer_state );
SetDepthStencilState( particle_depth_stencil_state );
EnableAdditiveBlending();
}
void SkyBox::Render(const Ptr<RenderTargetView> & target, const Ptr<DepthStencilView> & dsv, const Ptr<RenderView> & view)
{
if (!_tex)
return;
auto rc = Global::GetRenderEngine()->GetRenderContext();
auto translationMat = translation(view->GetCamera()->GetPos());
auto transformMat = mul(translationMat, view->GetCamera()->GetViewProjMatrix());
auto vs = Shader::FindOrCreate<SkyBoxVS>();
auto ps = Shader::FindOrCreate<SkyBoxPS>();
vs->SetScalar("transform", transformMat);
ps->SetSRV("skyBoxTex", _tex->GetShaderResourceView(0, 0, 0, 0, true));
ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
vs->Flush();
ps->Flush();
rc->SetViewport(GetTextureQuadViewport(target->GetResource()->Cast<Texture>()));
rc->SetRenderTargets({ target });
rc->SetDepthStencil(dsv);
rc->SetRasterizerState(RasterizerStateTemplate<FILL_SOLID, CULL_NONE>::Get());
rc->SetDepthStencilState(DepthStencilStateTemplate<true, DEPTH_WRITE_ZERO, COMPARISON_LESS_EQUAL>::Get());
rc->SetVertexBuffer(_sphereMesh->GetRenderData()->GetMeshElements()[0]->GetVertexBuffer());
rc->SetIndexBuffer(_sphereMesh->GetRenderData()->GetMeshElements()[0]->GetIndexBuffer());
rc->SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLELIST);
rc->DrawIndexed(0, 0);
rc->SetRasterizerState(nullptr);
rc->SetDepthStencilState(nullptr);
}
void RenderContext::Init(pWindow inWindow)
{
CleanUp();
HWND hWnd = inWindow->mHWnd;
D3D_DRIVER_TYPE driver_type = D3D_DRIVER_TYPE_NULL;
D3D_FEATURE_LEVEL feature_level = D3D_FEATURE_LEVEL_11_0;
HRESULT hr = S_OK;
RECT rc;
GetClientRect(hWnd, &rc);
mWidth = rc.right - rc.left;
mHeight = rc.bottom - rc.top;
UINT createDeviceFlags = 0;
#ifdef _DEBUG
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
createDeviceFlags |= D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT;
#endif
D3D_DRIVER_TYPE driverTypes[] =
{
D3D_DRIVER_TYPE_HARDWARE,
D3D_DRIVER_TYPE_WARP,
D3D_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = ARRAYSIZE(driverTypes);
D3D_FEATURE_LEVEL featureLevels[] =
{
D3D_FEATURE_LEVEL_11_1,
D3D_FEATURE_LEVEL_11_0,
D3D_FEATURE_LEVEL_10_1,
D3D_FEATURE_LEVEL_10_0,
};
UINT numFeatureLevels = ARRAYSIZE(featureLevels);
for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
{
driver_type = driverTypes[driverTypeIndex];
hr = D3D11CreateDevice(nullptr, driver_type, nullptr, createDeviceFlags, featureLevels, numFeatureLevels,
D3D11_SDK_VERSION, &mD3DDevice, &feature_level, &mImmediateContext);
if (hr == E_INVALIDARG)
{
hr = D3D11CreateDevice(nullptr, driver_type, nullptr, createDeviceFlags, &featureLevels[1], numFeatureLevels - 1,
D3D11_SDK_VERSION, &mD3DDevice, &feature_level, &mImmediateContext);
}
if (SUCCEEDED(hr))
break;
}
if (FAILED(hr))
{
exit(hr);
}
// Obtain DXGI factory from device (since we used nullptr for pAdapter above)
IDXGIFactory1* dxgiFactory = nullptr;
{
IDXGIDevice* dxgiDevice = nullptr;
hr = mD3DDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice));
if (SUCCEEDED(hr))
{
IDXGIAdapter* adapter = nullptr;
hr = dxgiDevice->GetAdapter(&adapter);
if (SUCCEEDED(hr))
{
hr = adapter->GetParent(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&dxgiFactory));
adapter->Release();
}
dxgiDevice->Release();
}
}
if (FAILED(hr))
{
exit(hr);
}
// Create swap chain
IDXGIFactory2* dxgiFactory2 = nullptr;
hr = dxgiFactory->QueryInterface(__uuidof(IDXGIFactory2), reinterpret_cast<void**>(&dxgiFactory2));
if (dxgiFactory2)
{
// DirectX 11.1 or later
hr = mD3DDevice->QueryInterface(__uuidof(ID3D11Device1), reinterpret_cast<void**>(&mD3DDevice1));
if (SUCCEEDED(hr))
{
(void)mImmediateContext->QueryInterface(__uuidof(ID3D11DeviceContext1), reinterpret_cast<void**>(&mImmediateContext1));
}
DXGI_SWAP_CHAIN_DESC1 sd;
ZeroMemory(&sd, sizeof(sd));
sd.Width = mWidth;
sd.Height = mHeight;
sd.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_UNORDERED_ACCESS;
sd.BufferCount = 1;
hr = dxgiFactory2->CreateSwapChainForHwnd(mD3DDevice, hWnd, &sd, nullptr, nullptr, &mSwapChain1);
if (SUCCEEDED(hr))
{
hr = mSwapChain1->QueryInterface(__uuidof(IDXGISwapChain), reinterpret_cast<void**>(&mSwapChain));
}
dxgiFactory2->Release();
}
else
{
// DirectX 11.0 systems
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 1;
sd.BufferDesc.Width = mWidth;
sd.BufferDesc.Height = mHeight;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_UNORDERED_ACCESS;
sd.OutputWindow = hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
hr = dxgiFactory->CreateSwapChain(mD3DDevice, &sd, &mSwapChain);
}
// Note this tutorial doesn't handle full-screen swapchains so we block the ALT+ENTER shortcut
dxgiFactory->MakeWindowAssociation(hWnd, DXGI_MWA_NO_ALT_ENTER);
dxgiFactory->Release();
if (FAILED(hr))
{
exit(hr);
}
// Create a render target view
ID3D11Texture2D* pBackBuffer = nullptr;
hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&pBackBuffer));
if (FAILED(hr))
{
exit(hr);
}
mBackBuffer = MAKE_NEW(Texture);
mBackBuffer->Init(pBackBuffer);
mOutputRenderTarget = MAKE_NEW(RenderTarget);
mOutputRenderTarget->Init(mBackBuffer);
// setup rasterizer
SetRasterizerState(FILL_SOLID, CULL_BACK, true, 0, 0.0f, 0.0f, true, false, false, false);
D3D11_DEPTH_STENCIL_DESC dsDesc;
dsDesc.DepthEnable = true;
dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
dsDesc.DepthFunc = D3D11_COMPARISON_LESS;
dsDesc.StencilEnable = false;
dsDesc.StencilReadMask = 0xFF;
dsDesc.StencilWriteMask = 0xFF;
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;
mD3DDevice->CreateDepthStencilState(&dsDesc, &pDSState);
mImmediateContext->OMSetDepthStencilState(pDSState, 1);
// Setup the viewport
SetViewport(int2(mWidth, mHeight), 0.0f, 1.0f, int2(0, 0));
hr = mImmediateContext->QueryInterface(__uuidof(mAnnotation), reinterpret_cast<void**>(&mAnnotation));
if (FAILED(hr))
{
exit(hr);
}
mInitialized = true;
}
