void Renderer::forward_rendering_pipeline()
{
//set states
{
SetViewPortToDefault();
if (use_postfx)
{
SetRenderViews(screen_texture->get_rt(), GetDefaultDepthStencilView(), 0);
}
else
{
SetRenderViews(GetDefaultRenderTargetView(), GetDefaultDepthStencilView(), 0);
}
clearScreen(D3DXVECTOR4(0, 0, 0, 0));
SetDepthState(depth_state_enable_test_enable_write);
default_render_shader->set_shaders();
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}
const vector<Mesh*> &meshes_to_render = scene_to_render->get_meshes();
for (int i = 0; i < meshes_to_render.size(); i++)
{
Mesh *mesh_to_render = meshes_to_render[i];
mesh_to_render->get_material()->set_textures();
set_mesh_constant_values(mesh_to_render);
//set buffers
SetVertexBuffer(mesh_to_render->get_vertex_buffer(), sizeof(Mesh::Vertex));
SetIndexBuffer(mesh_to_render->get_index_buffer());
SetSamplerState();
if (mesh_to_render->is_wireframe())
{
SetRasterState(raster_state_wireframe_mode);
}
else
{
SetRasterState(raster_state_fill_mode);
}
//render
int tri_to_render = mesh_to_render->get_index_count();
RenderIndexed(tri_to_render);
}
}
void Renderer::gbuffer_render()
{
invalidate_srv(shaderType::shader_type_pixel);
gbuffer_albedo_texture->set_as_render_target(0);
gbuffer_normal_texture->set_as_render_target(1);
gbuffer_specular_texture->set_as_render_target(2);
clearScreen(D3DXVECTOR4(0, 0, 0, 0));
ClearRenderView(D3DXVECTOR4(0, 0, 0, 0), 1);
ClearRenderView(D3DXVECTOR4(0, 0, 0, 0),2);
SetDepthState(depth_state_enable_test_enable_write);
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
const vector<Mesh*> &meshes_to_render = scene_to_render->get_meshes();
for (int i = 0; i < meshes_to_render.size(); i++)
{
Mesh *mesh_to_render = meshes_to_render[i];
if (mesh_to_render->get_material())
{
mesh_to_render->get_material()->set_textures();
}
set_mesh_constant_values(mesh_to_render);
Shader *shader_to_set = mesh_to_render->get_material() ? mesh_to_render->get_material()->get_enforced_gbuffer_shader() : nullptr;
if (shader_to_set == nullptr)
{
shader_to_set = gbuffer_shader;
}
shader_to_set->set_shaders();
//set buffers
SetVertexBuffer(mesh_to_render->get_vertex_buffer(), sizeof(Mesh::Vertex));
SetIndexBuffer(mesh_to_render->get_index_buffer());
set_mesh_primitive_topology(mesh_to_render);
if (mesh_to_render->is_wireframe())
{
SetRasterState(raster_state_wireframe_mode);
}
else
{
SetRasterState(raster_state_fill_mode);
}
SetSamplerState();
//render
int tri_to_render = mesh_to_render->get_index_count();
RenderIndexed(tri_to_render);
}
SetRenderTargetView(nullptr, 0);
SetRenderTargetView(nullptr, 1);
SetRenderTargetView(nullptr, 2);
for (int i = 0; i < render_components.size(); i++)
{
render_components[i]->post_gbuffer_render();
}
}
int ContextD3D11::CreateWindowSizeDependentResources(uint32_t width, uint32_t height) {
ID3D11RenderTargetView* nullViews[] = {nullptr};
device_context_->OMSetRenderTargets(ARRAYSIZE(nullViews), nullViews, nullptr);
SafeRelease(&render_target_view_);
SafeRelease(&depth_stencil_view_);
device_context_->Flush();
//RECT rc;
//GetClientRect( window_handle_, &rc );
width_ = width;//rc.right - rc.left;
height_ = height;//rc.bottom - rc.top;
if(swap_chain_ != nullptr)
{
swap_chain_->ResizeBuffers(2, static_cast<UINT>(width_),static_cast<UINT>(height_), DXGI_FORMAT_B8G8R8A8_UNORM, 0);
}
else
{
// Otherwise, create a new one using the same adapter as the existing Direct3D device.
DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
swapChainDesc.Width = static_cast<UINT>(width_); // Match the size of the window.
swapChainDesc.Height = static_cast<UINT>(height_);
swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM; // This is the most common swap chain 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 minimize latency.
swapChainDesc.Scaling = DXGI_SCALING_NONE;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // All Windows Store apps must use this SwapEffect.
swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
IDXGIDevice1* dxgiDevice;
device_->QueryInterface(__uuidof(dxgiDevice),(void**)&dxgiDevice);
//IDXGIAdapter* dxgiAdapter;
//dxgiDevice->GetAdapter(&dxgiAdapter);
IDXGIFactory2* dxgiFactory;
adaptor_->GetParent(__uuidof(IDXGIFactory2), (void**)&dxgiFactory );
DXGI_SWAP_CHAIN_FULLSCREEN_DESC fullscreen_desc;
memset(&fullscreen_desc,0,sizeof(fullscreen_desc));
fullscreen_desc.Windowed = true;
dxgiFactory->CreateSwapChainForHwnd(device_,window_handle_, &swapChainDesc, &fullscreen_desc,nullptr, &swap_chain_);
dxgiDevice->SetMaximumFrameLatency(1);
SafeRelease(&dxgiFactory);
//SafeRelease(&dxgiAdapter);
SafeRelease(&dxgiDevice);
}
ID3D11Texture2D* backBuffer;
swap_chain_->GetBuffer(0,__uuidof(ID3D11Texture2D),(void**)&backBuffer);
device_->CreateRenderTargetView(backBuffer,nullptr,&render_target_view_);
SafeRelease(&backBuffer);
// Create a depth stencil view.
CD3D11_TEXTURE2D_DESC depthStencilTextureDesc(
DXGI_FORMAT_D24_UNORM_S8_UINT,
static_cast<UINT>(width_),
static_cast<UINT>(height_),
1,
0,
D3D11_BIND_DEPTH_STENCIL
);
ID3D11Texture2D* depth_stencil_tex;
device_->CreateTexture2D(&depthStencilTextureDesc,nullptr,&depth_stencil_tex);
CD3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
device_->CreateDepthStencilView(depth_stencil_tex,&depthStencilViewDesc,&depth_stencil_view_);
SafeRelease(&depth_stencil_tex);
SafeRelease(&default_depth_state);
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
// Initialize the description of the stencil state.
ZeroMemory(&depthStencilDesc, sizeof(depthStencilDesc));
depthStencilDesc.DepthEnable = true;
depthStencilDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
depthStencilDesc.DepthFunc = D3D11_COMPARISON_LESS;
depthStencilDesc.StencilEnable = true;
depthStencilDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
depthStencilDesc.StencilWriteMask = 0xFF;
// Stencil operations if pixel is front-facing.
depthStencilDesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
depthStencilDesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
// Stencil operations if pixel is back-facing.
depthStencilDesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
device_->CreateDepthStencilState(&depthStencilDesc, &default_depth_state);
SetDepthState(null,0);
// Set the rendering viewport to target the entire window.
CD3D11_VIEWPORT viewport(0.0f,0.0f,width_,height_);
device_context_->RSSetViewports(1, &viewport);
device_context_->OMSetRenderTargets( 1, &render_target_view_, depth_stencil_view_ );
return S_OK;
}
//----------------------------------------------------------------------------------------
bool Renderer::Init( uint32 wndWidth, uint32 wndHeight, HWND hwnd )
{
m_wndWidth = wndWidth;
m_wndHeight = wndHeight;
#if USE_OPENGL
m_pRenderSys = new GLRenderSystem;
_AST(((GLRenderSystem*)m_pRenderSys)->Init(wndWidth, wndHeight, hwnd));
#else
m_pRenderSys = new D3D11RenderSystem;
_AST(((D3D11RenderSystem*)m_pRenderSys)->Init(wndWidth, wndHeight, hwnd));
#endif
// Init rasterize state
SStateRaster rasterState;
rasterState.Desc.AntialiasedLineEnable = false;
rasterState.Desc.CullMode = eCull_BACK;
rasterState.Desc.DepthBias = 0;
rasterState.Desc.DepthBiasClamp = 0.0f;
rasterState.Desc.DepthClipEnable = true;
rasterState.Desc.FillMode = eFill_Solid;
rasterState.Desc.FrontCounterClockwise = false;
rasterState.Desc.MultisampleEnable = false;
rasterState.Desc.ScissorEnable = false;
rasterState.Desc.SlopeScaledDepthBias = 0.0f;
SetRasterState(&rasterState);
// Init depth stencil state
SStateDepth depthState;
depthState.Desc.DepthFunc = eCompareFunc_LESS_EQUAL;
SetDepthState(&depthState);
// Init blend state
SStateBlend blendState;
blendState.Desc.AlphaToCoverageEnable = false;
blendState.Desc.IndependentBlendEnable = false;
blendState.Desc.RenderTarget[0].BlendEnable = false;
blendState.Desc.RenderTarget[0].SrcBlend = eBlend_ONE;
blendState.Desc.RenderTarget[0].DestBlend = eBlend_ZERO;
blendState.Desc.RenderTarget[0].BlendOp = eBlendOp_ADD;
blendState.Desc.RenderTarget[0].SrcBlendAlpha = eBlend_ONE;
blendState.Desc.RenderTarget[0].DestBlendAlpha = eBlend_ZERO;
blendState.Desc.RenderTarget[0].BlendOpAlpha = eBlendOp_ADD;
blendState.Desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
SetBlendState(&blendState);
// Setup the viewport
m_viewport.Width = (float)wndWidth;
m_viewport.Height = (float)wndHeight;
m_viewport.MinDepth = 0.0f;
m_viewport.MaxDepth = 1.0f;
m_viewport.TopLeftX = 0;
m_viewport.TopLeftY = 0;
SetViewport(&m_viewport);
// Create constant buffers
m_pGlobalCBuf = m_pRenderSys->CreateConstantBuffer(sizeof(cBufferGlobal), 1);
m_pMaterialCB = m_pRenderSys->CreateConstantBuffer(sizeof(cBufferMaterial), 2);
m_pSkinCB = m_pRenderSys->CreateConstantBuffer(sizeof(cBufferSkin), 3);
m_pFont = new Font;
return true;
}
