void TextureFragmentShader::unsetParameters( ID3D11DeviceContext& deviceContext )
{
ID3D11ShaderResourceView* nullResource = nullptr;
ID3D11SamplerState* nullSampler = nullptr;
deviceContext.PSSetShaderResources( 0, 1, &nullResource );
deviceContext.PSSetSamplers( 0, 1, &nullSampler );
}
void SkeletonModelFragmentShader::unsetParameters( ID3D11DeviceContext& deviceContext )
{
ID3D11ShaderResourceView* nullResources[] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
ID3D11SamplerState* nullSampler = nullptr;
deviceContext.PSSetShaderResources( 0, 7, nullResources );
deviceContext.PSSetSamplers( 0, 1, &nullSampler );
}
void ShadowMappingShader::RenderShader(int indexCount)
{
ID3D11DeviceContext* deviceContext = GraphicsDX::GetDeviceContext();
// Set the vertex input layout.
deviceContext->IASetInputLayout(m_layout);
// Set the vertex and pixel shaders that will be used to render this triangle.
deviceContext->VSSetShader(m_vertexShader, NULL, 0);
deviceContext->PSSetShader(m_pixelShader, NULL, 0);
// Set the sampler states in the pixel shader.
deviceContext->PSSetSamplers(0, 1, &m_sampleStateClamp);
deviceContext->PSSetSamplers(1, 1, &m_sampleStateWrap);
// Render the triangle.
deviceContext->DrawIndexed(indexCount, 0, 0);
}
void DeferredPipeline::Lighting::set_layout_spot_light_shaders_samplers(ID3D11DeviceContext& device_context)
{
device_context.IASetInputLayout(_vertex_input_layout);
device_context.VSSetShader(_vertex_shader, nullptr, 0);
device_context.PSSetShader(_spot_light_pixel_shader, nullptr, 0);
device_context.PSSetSamplers(0, 1, &_sampler_state);
}
//-----------------------------------------------------------------------------
void CPUTRenderStateBlockDX11::SetRenderStates( CPUTRenderParameters &renderParams )
{
ID3D11DeviceContext *pContext = ((CPUTRenderParametersDX*)&renderParams)->mpContext;
pContext->OMSetBlendState( mpBlendState, mStateDesc.BlendFactor, mStateDesc.SampleMask );
pContext->OMSetDepthStencilState( mpDepthStencilState, 0 ); // TODO: read stecil ref from config file
pContext->RSSetState( mpRasterizerState );
pContext->PSSetSamplers( 0, mNumSamplers, mpSamplerState );
pContext->VSSetSamplers( 0, mNumSamplers, mpSamplerState );
pContext->GSSetSamplers( 0, mNumSamplers, mpSamplerState );
} // CPUTRenderStateBlockDX11::SetRenderState()
~CDX11StateGuard()
{
ID3D11Device* pDevice = static_cast<ID3D11Device*>( gD3DDevice );
ID3D11DeviceContext* pContext = NULL;
pDevice->GetImmediateContext( &pContext );
// Apply saved state
pContext->OMSetBlendState( m_pBlendState, m_BlendFactor, m_SampleMask );
pContext->RSSetState( m_pRasterizerState );
pContext->IASetPrimitiveTopology( m_PrimitiveTopology );
pContext->IASetIndexBuffer( m_pIndexBuffer, m_IndexBufferFormat, m_IndexBufferOffset );
pContext->IASetInputLayout( m_pInputLayout );
pContext->IASetVertexBuffers( 0, D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT, m_pVertexBuffers, m_pVertexBufferStrides, m_pVertexBufferOffsets );
pContext->VSSetShader( m_pVertexShader, m_ppVertexShaderClassInstances, m_VertexShaderClassInstancesCount );
pContext->PSSetShader( m_pPixelShader, m_ppPixelShaderClassInstances, m_PixelShaderClassInstancesCount );
pContext->PSSetSamplers( 0, D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT, m_ppPixelShaderSamplers );
pContext->PSSetShaderResources( 0, D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT, m_ppPixelShaderResources );
// Release references
SAFE_RELEASE( m_pBlendState );
SAFE_RELEASE( m_pRasterizerState );
SAFE_RELEASE( m_pIndexBuffer );
SAFE_RELEASE( m_pInputLayout );
for ( UINT i = 0; i < D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; ++i )
{
SAFE_RELEASE( m_pVertexBuffers[i] );
}
SAFE_RELEASE( m_pVertexShader );
for ( UINT i = 0; i < m_VertexShaderClassInstancesCount; ++i )
{
SAFE_RELEASE( m_ppVertexShaderClassInstances[i] );
}
SAFE_RELEASE( m_pPixelShader );
for ( UINT i = 0; i < m_PixelShaderClassInstancesCount; ++i )
{
SAFE_RELEASE( m_ppPixelShaderClassInstances[i] );
}
for ( UINT i = 0; i < D3D11_COMMONSHADER_SAMPLER_SLOT_COUNT; ++i )
{
SAFE_RELEASE( m_ppPixelShaderSamplers[i] );
}
for ( UINT i = 0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; ++i )
{
SAFE_RELEASE( m_ppPixelShaderResources[i] );
}
}
void MSAAFilter::RenderAA()
{
PIXEvent pixEvent(L"MSAA Resolve + Temporal AA");
ProfileBlock profileBlock(L"MSAA Resolve + Temporal AA");
ID3D11DeviceContext* context = deviceManager.ImmediateContext();
ID3D11RenderTargetView* rtvs[1] = { resolveTarget.RTView };
context->OMSetRenderTargets(1, rtvs, nullptr);
if(AppSettings::UseStandardResolve)
{
if(AppSettings::MSAAMode == 0)
context->CopyResource(resolveTarget.Texture, colorTarget.Texture);
else
context->ResolveSubresource(resolveTarget.Texture, 0, colorTarget.Texture, 0, colorTarget.Format);
return;
}
const uint32 SampleRadius = static_cast<uint32>((AppSettings::ResolveFilterDiameter / 2.0f) + 0.499f);
ID3D11PixelShader* pixelShader = resolvePS[AppSettings::MSAAMode];
context->PSSetShader(pixelShader, nullptr, 0);
context->VSSetShader(resolveVS, nullptr, 0);
resolveConstants.Data.TextureSize = Float2(static_cast<float>(colorTarget.Width), static_cast<float>(colorTarget.Height));
resolveConstants.Data.SampleRadius = SampleRadius;;
resolveConstants.ApplyChanges(context);
resolveConstants.SetPS(context, 0);
ID3D11ShaderResourceView* srvs[] = { colorTarget.SRView, velocityTarget.SRView, depthBuffer.SRView, prevFrameTarget.SRView};
context->PSSetShaderResources(0, ArraySize_(srvs), srvs);
ID3D11SamplerState* samplers[] = { samplerStates.LinearClamp(), samplerStates.Point() };
context->PSSetSamplers(0, ArraySize_(samplers), samplers);
ID3D11Buffer* vbs[1] = { nullptr };
UINT strides[1] = { 0 };
UINT offsets[1] = { 0 };
context->IASetVertexBuffers(0, 1, vbs, strides, offsets);
context->IASetInputLayout(nullptr);
context->IASetIndexBuffer(nullptr, DXGI_FORMAT_R16_UINT, 0);
context->Draw(3, 0);
rtvs[0] = nullptr;
context->OMSetRenderTargets(1, rtvs, nullptr);
srvs[0] = srvs[1] = srvs[2] = nullptr;
context->PSSetShaderResources(0, 3, srvs);
context->CopyResource(prevFrameTarget.Texture, resolveTarget.Texture);
}
void MultiTextureShader::RenderShader(Graphics* graphics)
{
ID3D11DeviceContext* deviceContext = graphics->GetImmediateContex();
deviceContext->IASetInputLayout(m_layout);
// set the vertex and pixel shaders that will be used to render
deviceContext->VSSetShader(m_vertexShader,NULL,0);
deviceContext->PSSetShader(m_pixelShader,NULL,0);
// set the sampler state
deviceContext->PSSetSamplers(0,1,&m_sampleState);
}
/*
Renders entity
*/
void CEntity::Render(unsigned int &prevMeshID) const
{
if (mRenderEntity)
{
CRenderManager* rm = CRenderManager::GetInstance();
ID3D11DeviceContext* deviceContext = rm->GetDeviceContext();
geom::CMesh* mesh = mTemplate->mMesh;
if (mesh != NULL)
{
if (mesh->GetUID() != prevMeshID)
{
/* Sets the buffers */
ID3D11Buffer* vertexBuffer = mesh->GetVertexBuffer();
ID3D11Buffer* indexBuffer = mesh->GetIndexBuffer();
UINT stride = mesh->GetVertexSize();
UINT offset = 0;
deviceContext->IASetVertexBuffers( 0, 1, &vertexBuffer, &stride, &offset );
deviceContext->IASetIndexBuffer( indexBuffer, DXGI_FORMAT_R16_UINT, 0 );
deviceContext->IASetPrimitiveTopology( mesh->GetTopology() );
/* Sets texture */
ID3D11ShaderResourceView* texture = mesh->GetTexture();
if (texture != NULL)
{
ID3D11SamplerState* sample = mesh->GetSample();
int startSlot = mesh->GetStartSlot();
deviceContext->PSSetShaderResources( startSlot, 1, &texture );
deviceContext->PSSetSamplers( startSlot, 1, &sample );
deviceContext->RSSetState( mTemplate->mRasterState );
}
}
deviceContext->DrawIndexed( mesh->GetNumberOfIndices(), 0, 0 );
prevMeshID = mesh->GetUID();
}
}
}
virtual void Apply(uint32 iStage, bool bVS, bool bGS, bool bTessellation)
{
ID3D11DeviceContext* pDC = g_pRenderSys->GetDeviceContext();
pDC->PSSetSamplers(iStage, 1, &m_pSamp);
if (bVS)
{
pDC->VSSetSamplers(iStage, 1, &m_pSamp);
}
if (bGS)
{
pDC->GSSetSamplers(iStage, 1, &m_pSamp);
}
if (bTessellation)
{
pDC->HSSetSamplers(iStage, 1, &m_pSamp);
pDC->DSSetSamplers(iStage, 1, &m_pSamp);
}
}
void CGUIShaderDX::ApplyStateBlock(void)
{
if (!m_bCreated)
return;
ID3D11DeviceContext* pContext = g_Windowing.Get3D11Context();
m_vertexShader.BindShader();
pContext->VSSetConstantBuffers(0, 1, &m_pWVPBuffer);
m_pixelShader[m_currentShader].BindShader();
pContext->PSSetConstantBuffers(0, 1, &m_pWVPBuffer);
pContext->PSSetConstantBuffers(1, 1, &m_pVPBuffer);
ID3D11SamplerState* samplers[] = { m_pSampLinear, m_pSampPoint };
pContext->PSSetSamplers(0, ARRAYSIZE(samplers), samplers);
RestoreBuffers();
}
void FontShader::renderShader(int i_indexCount)
{
ID3D11DeviceContext* deviceContext = GraphicsDX::GetDeviceContext();
// Set the vertex input layout.
deviceContext->IASetInputLayout(_layout);
// Set the vertex and pixel shaders that will be used to render the triangles.
deviceContext->VSSetShader(_vertexShader, NULL, 0);
deviceContext->HSSetShader(nullptr, NULL, 0);
deviceContext->DSSetShader(nullptr, NULL, 0);
deviceContext->GSSetShader(nullptr, NULL, 0);
deviceContext->PSSetShader(_pixelShader, NULL, 0);
// Set the sampler state in the pixel shader.
deviceContext->PSSetSamplers(0, 1, &_sampleState);
// Render the triangles.
deviceContext->DrawIndexed(i_indexCount, 0, 0);
}
void SkeletonModelFragmentShader::setParameters( ID3D11DeviceContext& deviceContext,
const Texture2DSpecBind< TexBind::ShaderResource, unsigned char >& alphaTexture,
const Texture2DSpecBind< TexBind::ShaderResource, uchar4 >& emissiveTexture,
const Texture2DSpecBind< TexBind::ShaderResource, uchar4 >& albedoTexture,
const Texture2DSpecBind< TexBind::ShaderResource, uchar4 >& normalTexture,
const Texture2DSpecBind< TexBind::ShaderResource, unsigned char >& metalnessTexture,
const Texture2DSpecBind< TexBind::ShaderResource, unsigned char >& roughnessTexture,
const Texture2DSpecBind< TexBind::ShaderResource, unsigned char >& indexOfRefractionTexture,
const float4& extraEmissive )
{
const int resourceCount = 7;
ID3D11ShaderResourceView* textureResource[ resourceCount ] =
{
alphaTexture.getShaderResourceView(),
emissiveTexture.getShaderResourceView(),
albedoTexture.getShaderResourceView(),
normalTexture.getShaderResourceView(),
metalnessTexture.getShaderResourceView(),
roughnessTexture.getShaderResourceView(),
indexOfRefractionTexture.getShaderResourceView()
};
deviceContext.PSSetShaderResources( 0, resourceCount, textureResource );
deviceContext.PSSetSamplers( 0, 1, m_samplerState.GetAddressOf() );
D3D11_MAPPED_SUBRESOURCE mappedResource;
ConstantBuffer* dataPtr;
HRESULT result = deviceContext.Map( m_constantInputBuffer.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource );
if ( result < 0 ) throw std::exception( "BlockModelVertexShader::setParameters - mapping constant buffer to CPU memory failed" );
dataPtr = (ConstantBuffer*)mappedResource.pData;
dataPtr->extraEmissive = extraEmissive;
deviceContext.Unmap( m_constantInputBuffer.Get(), 0 );
deviceContext.PSSetConstantBuffers( 0, 1, m_constantInputBuffer.GetAddressOf() );
}
void Model::Paint(const XMMATRIX &world, Camera *camera, XMFLOAT3 lightPos)
{
unsigned int stride = mSizeOfVertexDesc;
unsigned int offset = 0;
XMMATRIX view = camera->GetViewMatrix();
XMMATRIX proj = camera->GetProjectionMatrix();
MatrixBuffer buffer;
buffer.world = XMMatrixTranspose(world);
buffer.view = XMMatrixTranspose(view);
buffer.proj = XMMatrixTranspose(proj);
buffer.wvp = XMMatrixTranspose(world * view * proj);
buffer.cameraPos = camera->GetPosition();
ID3D11DeviceContext *dc = GameEngine::GetInstance()->GetGraphicsManager()->GetGraphicsDeviceContext();
dc->IASetVertexBuffers(0, 1, &mVertexBuffer, &stride, &offset);
dc->IASetInputLayout(mInputLayout);
dc->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
dc->VSSetShader(mVertexShader, 0, 0);
dc->PSSetShader(mFragmentShader, 0, 0);
dc->PSSetShaderResources(0, 1, &mTextureView);
dc->PSSetSamplers(0, 1, &mTextureSamplerState);
dc->UpdateSubresource(mMatrixBuffer, 0, 0, &buffer, 0, 0);
dc->VSSetConstantBuffers(0, 1, &mMatrixBuffer);
dc->UpdateSubresource(mLightBuffer, 0, 0, &lightPos, 0, 0);
dc->VSSetConstantBuffers(1, 1, &mLightBuffer);
if (mAnimation)
{
mAnimation->SetAnimationProperties(dc);
}
dc->Draw(mNumberOfVertices, 0);
}
void SpriteShader::SetParameters()
{
D3D11_MAPPED_SUBRESOURCE ms0, ms1;
ID3D11DeviceContext* devcon = (ID3D11DeviceContext*)EngineCore::GetGraphicsAPI()->GetDeviceContext();
// Set buffer 0
devcon->Map(
gpu_vs_buffer0,
0,
D3D11_MAP_WRITE_DISCARD,
0,
&ms0
);
memcpy(ms0.pData, &cpu_vs_buffer0, sizeof(cpu_vs_buffer0));
devcon->Unmap(gpu_vs_buffer0, 0);
devcon->VSSetConstantBuffers(0, 1, &gpu_vs_buffer0);
// Set buffer 1
devcon->Map(
gpu_vs_buffer1,
0,
D3D11_MAP_WRITE_DISCARD,
0,
&ms1
);
memcpy(ms1.pData, &cpu_vs_buffer1, sizeof(cpu_vs_buffer1));
devcon->Unmap(gpu_vs_buffer1, 0);
devcon->VSSetConstantBuffers(1, 1, &gpu_vs_buffer1);
PNG_Texture* png_tex = (PNG_Texture*)texture;
ID3D11ShaderResourceView* srv = png_tex->GetShaderResourceView();
devcon->PSSetShaderResources(0, 1, &srv);
devcon->PSSetSamplers(0, 1, &samplerState);
}
// Render function
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
{
// Avoid rendering when minimized
if (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f)
return;
ID3D11DeviceContext* ctx = g_pd3dDeviceContext;
// Create and grow vertex/index buffers if needed
if (!g_pVB || g_VertexBufferSize < draw_data->TotalVtxCount)
{
if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
g_VertexBufferSize = draw_data->TotalVtxCount + 5000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = g_VertexBufferSize * sizeof(ImDrawVert);
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
if (g_pd3dDevice->CreateBuffer(&desc, NULL, &g_pVB) < 0)
return;
}
if (!g_pIB || g_IndexBufferSize < draw_data->TotalIdxCount)
{
if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
g_IndexBufferSize = draw_data->TotalIdxCount + 10000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = g_IndexBufferSize * sizeof(ImDrawIdx);
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
if (g_pd3dDevice->CreateBuffer(&desc, NULL, &g_pIB) < 0)
return;
}
// Upload vertex/index data into a single contiguous GPU buffer
D3D11_MAPPED_SUBRESOURCE vtx_resource, idx_resource;
if (ctx->Map(g_pVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &vtx_resource) != S_OK)
return;
if (ctx->Map(g_pIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &idx_resource) != S_OK)
return;
ImDrawVert* vtx_dst = (ImDrawVert*)vtx_resource.pData;
ImDrawIdx* idx_dst = (ImDrawIdx*)idx_resource.pData;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
memcpy(vtx_dst, cmd_list->VtxBuffer.Data, cmd_list->VtxBuffer.Size * sizeof(ImDrawVert));
memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx));
vtx_dst += cmd_list->VtxBuffer.Size;
idx_dst += cmd_list->IdxBuffer.Size;
}
ctx->Unmap(g_pVB, 0);
ctx->Unmap(g_pIB, 0);
// Setup orthographic projection matrix into our constant buffer
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right).
{
D3D11_MAPPED_SUBRESOURCE mapped_resource;
if (ctx->Map(g_pVertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_resource) != S_OK)
return;
VERTEX_CONSTANT_BUFFER* constant_buffer = (VERTEX_CONSTANT_BUFFER*)mapped_resource.pData;
float L = draw_data->DisplayPos.x;
float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
float T = draw_data->DisplayPos.y;
float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
float mvp[4][4] =
{
{ 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.5f, 0.0f },
{ (R+L)/(L-R), (T+B)/(B-T), 0.5f, 1.0f },
};
memcpy(&constant_buffer->mvp, mvp, sizeof(mvp));
ctx->Unmap(g_pVertexConstantBuffer, 0);
}
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
struct BACKUP_DX11_STATE
{
UINT ScissorRectsCount, ViewportsCount;
D3D11_RECT ScissorRects[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
D3D11_VIEWPORT Viewports[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
ID3D11RasterizerState* RS;
ID3D11BlendState* BlendState;
FLOAT BlendFactor[4];
UINT SampleMask;
UINT StencilRef;
ID3D11DepthStencilState* DepthStencilState;
ID3D11ShaderResourceView* PSShaderResource;
ID3D11SamplerState* PSSampler;
ID3D11PixelShader* PS;
ID3D11VertexShader* VS;
UINT PSInstancesCount, VSInstancesCount;
ID3D11ClassInstance* PSInstances[256], *VSInstances[256]; // 256 is max according to PSSetShader documentation
D3D11_PRIMITIVE_TOPOLOGY PrimitiveTopology;
ID3D11Buffer* IndexBuffer, *VertexBuffer, *VSConstantBuffer;
UINT IndexBufferOffset, VertexBufferStride, VertexBufferOffset;
DXGI_FORMAT IndexBufferFormat;
ID3D11InputLayout* InputLayout;
};
BACKUP_DX11_STATE old;
old.ScissorRectsCount = old.ViewportsCount = D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
ctx->RSGetScissorRects(&old.ScissorRectsCount, old.ScissorRects);
ctx->RSGetViewports(&old.ViewportsCount, old.Viewports);
ctx->RSGetState(&old.RS);
ctx->OMGetBlendState(&old.BlendState, old.BlendFactor, &old.SampleMask);
ctx->OMGetDepthStencilState(&old.DepthStencilState, &old.StencilRef);
ctx->PSGetShaderResources(0, 1, &old.PSShaderResource);
ctx->PSGetSamplers(0, 1, &old.PSSampler);
old.PSInstancesCount = old.VSInstancesCount = 256;
ctx->PSGetShader(&old.PS, old.PSInstances, &old.PSInstancesCount);
ctx->VSGetShader(&old.VS, old.VSInstances, &old.VSInstancesCount);
ctx->VSGetConstantBuffers(0, 1, &old.VSConstantBuffer);
ctx->IAGetPrimitiveTopology(&old.PrimitiveTopology);
ctx->IAGetIndexBuffer(&old.IndexBuffer, &old.IndexBufferFormat, &old.IndexBufferOffset);
ctx->IAGetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset);
ctx->IAGetInputLayout(&old.InputLayout);
// Setup desired DX state
ImGui_ImplDX11_SetupRenderState(draw_data, ctx);
// Render command lists
// (Because we merged all buffers into a single one, we maintain our own offset into them)
int global_idx_offset = 0;
int global_vtx_offset = 0;
ImVec2 clip_off = draw_data->DisplayPos;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback != NULL)
{
// User callback, registered via ImDrawList::AddCallback()
// (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.)
if (pcmd->UserCallback == ImDrawCallback_ResetRenderState)
ImGui_ImplDX11_SetupRenderState(draw_data, ctx);
else
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
// Apply scissor/clipping rectangle
const D3D11_RECT r = { (LONG)(pcmd->ClipRect.x - clip_off.x), (LONG)(pcmd->ClipRect.y - clip_off.y), (LONG)(pcmd->ClipRect.z - clip_off.x), (LONG)(pcmd->ClipRect.w - clip_off.y) };
ctx->RSSetScissorRects(1, &r);
// Bind texture, Draw
ID3D11ShaderResourceView* texture_srv = (ID3D11ShaderResourceView*)pcmd->TextureId;
ctx->PSSetShaderResources(0, 1, &texture_srv);
ctx->DrawIndexed(pcmd->ElemCount, pcmd->IdxOffset + global_idx_offset, pcmd->VtxOffset + global_vtx_offset);
}
}
global_idx_offset += cmd_list->IdxBuffer.Size;
global_vtx_offset += cmd_list->VtxBuffer.Size;
}
// Restore modified DX state
ctx->RSSetScissorRects(old.ScissorRectsCount, old.ScissorRects);
ctx->RSSetViewports(old.ViewportsCount, old.Viewports);
ctx->RSSetState(old.RS); if (old.RS) old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask); if (old.BlendState) old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef); if (old.DepthStencilState) old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource); if (old.PSShaderResource) old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler); if (old.PSSampler) old.PSSampler->Release();
ctx->PSSetShader(old.PS, old.PSInstances, old.PSInstancesCount); if (old.PS) old.PS->Release();
for (UINT i = 0; i < old.PSInstancesCount; i++) if (old.PSInstances[i]) old.PSInstances[i]->Release();
ctx->VSSetShader(old.VS, old.VSInstances, old.VSInstancesCount); if (old.VS) old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer); if (old.VSConstantBuffer) old.VSConstantBuffer->Release();
for (UINT i = 0; i < old.VSInstancesCount; i++) if (old.VSInstances[i]) old.VSInstances[i]->Release();
ctx->IASetPrimitiveTopology(old.PrimitiveTopology);
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset); if (old.IndexBuffer) old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset); if (old.VertexBuffer) old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout); if (old.InputLayout) old.InputLayout->Release();
}
/// Called by D3D11 device to active this state block.
/// @param oldState The current state, used to make sure we don't set redundant states on the device. Pass NULL to reset all states.
void GFXD3D11StateBlock::activate(GFXD3D11StateBlock* oldState)
{
PROFILE_SCOPE( GFXD3D11StateBlock_Activate );
ID3D11DeviceContext* pDevCxt = D3D11DEVICECONTEXT;
mBlendDesc.AlphaToCoverageEnable = false;
mBlendDesc.IndependentBlendEnable = mDesc.separateAlphaBlendEnable;
mBlendDesc.RenderTarget[0].BlendEnable = mDesc.blendEnable;
mBlendDesc.RenderTarget[0].BlendOp = GFXD3D11BlendOp[mDesc.blendOp];
mBlendDesc.RenderTarget[0].BlendOpAlpha = GFXD3D11BlendOp[mDesc.separateAlphaBlendOp];
mBlendDesc.RenderTarget[0].DestBlend = GFXD3D11Blend[mDesc.blendDest];
mBlendDesc.RenderTarget[0].DestBlendAlpha = GFXD3D11Blend[mDesc.separateAlphaBlendDest];
mBlendDesc.RenderTarget[0].SrcBlend = GFXD3D11Blend[mDesc.blendSrc];
mBlendDesc.RenderTarget[0].SrcBlendAlpha = GFXD3D11Blend[mDesc.separateAlphaBlendSrc];
mBlendDesc.RenderTarget[0].RenderTargetWriteMask = mColorMask;
float blendFactor[] = { 1.0f, 1.0f, 1.0f, 1.0f };
pDevCxt->OMSetBlendState(mBlendState, blendFactor, 0xFFFFFFFF);
mDepthStencilDesc.DepthWriteMask = mDesc.zWriteEnable ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO;
mDepthStencilDesc.DepthEnable = mDesc.zEnable;
mDepthStencilDesc.DepthFunc = GFXD3D11CmpFunc[mDesc.zFunc];
mDepthStencilDesc.StencilWriteMask = mDesc.stencilWriteMask;
mDepthStencilDesc.StencilReadMask = mDesc.stencilMask;
mDepthStencilDesc.StencilEnable = mDesc.stencilEnable;
mDepthStencilDesc.FrontFace.StencilFunc = GFXD3D11CmpFunc[mDesc.stencilFunc];
mDepthStencilDesc.FrontFace.StencilFailOp = GFXD3D11StencilOp[mDesc.stencilFailOp];
mDepthStencilDesc.FrontFace.StencilDepthFailOp = GFXD3D11StencilOp[mDesc.stencilZFailOp];
mDepthStencilDesc.FrontFace.StencilPassOp = GFXD3D11StencilOp[mDesc.stencilPassOp];
if (mDesc.stencilEnable)
mDepthStencilDesc.BackFace = mDepthStencilDesc.FrontFace;
else
{
mDepthStencilDesc.BackFace.StencilFunc = GFXD3D11CmpFunc[GFXCmpAlways];
mDepthStencilDesc.BackFace.StencilFailOp = GFXD3D11StencilOp[GFXStencilOpKeep];
mDepthStencilDesc.BackFace.StencilDepthFailOp = GFXD3D11StencilOp[GFXStencilOpKeep];
mDepthStencilDesc.BackFace.StencilPassOp = GFXD3D11StencilOp[GFXStencilOpKeep];
}
pDevCxt->OMSetDepthStencilState(mDepthStencilState, mDesc.stencilRef);
mRasterizerDesc.CullMode = GFXD3D11CullMode[mDesc.cullMode];
mRasterizerDesc.FillMode = GFXD3D11FillMode[mDesc.fillMode];
mRasterizerDesc.DepthBias = mDesc.zBias;
mRasterizerDesc.SlopeScaledDepthBias = mDesc.zSlopeBias;
mRasterizerDesc.AntialiasedLineEnable = FALSE;
mRasterizerDesc.MultisampleEnable = FALSE;
mRasterizerDesc.ScissorEnable = FALSE;
if (mDesc.zEnable)
mRasterizerDesc.DepthClipEnable = true;
else
mRasterizerDesc.DepthClipEnable = false;
mRasterizerDesc.FrontCounterClockwise = FALSE;
mRasterizerDesc.DepthBiasClamp = 0.0f;
pDevCxt->RSSetState(mRasterizerState);
U32 numSamplers = GFX->getNumSamplers();
for (U32 i = 0; i < numSamplers; i++)
{
mSamplerDesc[i].AddressU = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeU];
mSamplerDesc[i].AddressV = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeV];
mSamplerDesc[i].AddressW = GFXD3D11TextureAddress[mDesc.samplers[i].addressModeW];
mSamplerDesc[i].MaxAnisotropy = mDesc.samplers[i].maxAnisotropy;
mSamplerDesc[i].MipLODBias = mDesc.samplers[i].mipLODBias;
mSamplerDesc[i].MinLOD = 0;
mSamplerDesc[i].MaxLOD = FLT_MAX;
if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_POINT_MIP_LINEAR;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterPoint && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_POINT_MAG_MIP_LINEAR;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_LINEAR_MAG_MIP_POINT;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterPoint && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterPoint)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT;
else if(mDesc.samplers[i].magFilter == GFXTextureFilterLinear && mDesc.samplers[i].minFilter == GFXTextureFilterLinear && mDesc.samplers[i].mipFilter == GFXTextureFilterLinear)
mSamplerDesc[i].Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
else
mSamplerDesc[i].Filter = D3D11_FILTER_ANISOTROPIC;
mSamplerDesc[i].BorderColor[0] = 0.0f;
mSamplerDesc[i].BorderColor[1] = 0.0f;
mSamplerDesc[i].BorderColor[2] = 0.0f;
mSamplerDesc[i].BorderColor[3] = 0.0f;
mSamplerDesc[i].ComparisonFunc = D3D11_COMPARISON_NEVER;
}
//TODO samplers for vertex shader
// Set all the samplers with one call
//pDevCxt->VSSetSamplers(0, numSamplers, &mSamplerStates[0]);
pDevCxt->PSSetSamplers(0, numSamplers, &mSamplerStates[0]);
}
// parameters should be validated/clamped by caller
EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
{
if (!mSwapChain)
{
return EGL_SUCCESS;
}
if (mRenderToBackBuffer)
{
// When rendering directly to the backbuffer, we must swap the whole buffer.
if (!(x == 0 && y == 0 && width == mWidth && height == mHeight))
{
ERR("When rendering directly to the backbuffer, swapRect can only be called on the entire backbuffer.");
ASSERT(false);
return EGL_FALSE;
}
}
HRESULT result = S_OK;
ID3D11Device *device = mRenderer->getDevice();
if (!mRenderToBackBuffer)
{
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
// Set vertices
D3D11_MAPPED_SUBRESOURCE mappedResource;
result = deviceContext->Map(mQuadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
return EGL_BAD_ACCESS;
}
d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);
// Create a quad in homogeneous coordinates
float x1 = (x / float(mWidth)) * 2.0f - 1.0f;
float y1 = (y / float(mHeight)) * 2.0f - 1.0f;
float x2 = ((x + width) / float(mWidth)) * 2.0f - 1.0f;
float y2 = ((y + height) / float(mHeight)) * 2.0f - 1.0f;
float u1 = x / float(mWidth);
float v1 = y / float(mHeight);
float u2 = (x + width) / float(mWidth);
float v2 = (y + height) / float(mHeight);
d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, u1, v1);
d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, u1, v2);
d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1);
d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2);
deviceContext->Unmap(mQuadVB, 0);
static UINT stride = sizeof(d3d11::PositionTexCoordVertex);
static UINT startIdx = 0;
deviceContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &startIdx);
// Apply state
deviceContext->OMSetDepthStencilState(NULL, 0xFFFFFFFF);
static const float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
deviceContext->OMSetBlendState(NULL, blendFactor, 0xFFFFFFF);
deviceContext->RSSetState(NULL);
// Apply shaders
deviceContext->IASetInputLayout(mPassThroughIL);
deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
deviceContext->VSSetShader(mPassThroughVS, NULL, 0);
deviceContext->PSSetShader(mPassThroughPS, NULL, 0);
deviceContext->GSSetShader(NULL, NULL, 0);
// Apply render targets
mRenderer->setOneTimeRenderTarget(mBackBufferRTView);
// Set the viewport
D3D11_VIEWPORT viewport;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = static_cast<FLOAT>(mWidth);
viewport.Height = static_cast<FLOAT>(mHeight);
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
deviceContext->RSSetViewports(1, &viewport);
// Apply textures
mRenderer->setShaderResource(gl::SAMPLER_PIXEL, 0, mOffscreenSRView);
deviceContext->PSSetSamplers(0, 1, &mPassThroughSampler);
// Draw
deviceContext->Draw(4, 0);
}
#if ANGLE_VSYNC == ANGLE_DISABLED
result = mSwapChain->Present(0, 0);
#else
// Use IDXGISwapChain1::Present1 with a dirty rect if DXGI 1.2 is available.
if (mSwapChain1 != nullptr)
{
RECT rect =
{
static_cast<LONG>(x), static_cast<LONG>(mHeight - y - height),
static_cast<LONG>(x + width), static_cast<LONG>(mHeight - y)
};
DXGI_PRESENT_PARAMETERS params = { 1, &rect, nullptr, nullptr };
result = mSwapChain1->Present1(mSwapInterval, 0, ¶ms);
}
else
{
result = mSwapChain->Present(mSwapInterval, 0);
}
#endif
if (result == DXGI_ERROR_DEVICE_REMOVED)
{
HRESULT removedReason = device->GetDeviceRemovedReason();
UNUSED_TRACE_VARIABLE(removedReason);
ERR("Present failed: the D3D11 device was removed: 0x%08X", removedReason);
return EGL_CONTEXT_LOST;
}
else if (result == DXGI_ERROR_DEVICE_RESET)
{
ERR("Present failed: the D3D11 device was reset from a bad command.");
return EGL_CONTEXT_LOST;
}
else if (FAILED(result))
{
ERR("Present failed with error code 0x%08X", result);
}
// Unbind
mRenderer->setShaderResource(gl::SAMPLER_PIXEL, 0, NULL);
mRenderer->unapplyRenderTargets();
mRenderer->markAllStateDirty();
return EGL_SUCCESS;
}
void BaseShader::PreRender(void)
{
ID3D11DeviceContext* deviceContext = Application::GetInstance().GetGraphicsDevice()->GetDXSystem()->GetDeviceContext();
HRESULT result;
D3D11_MAPPED_SUBRESOURCE mappedResource;
D3DXMATRIX world;
D3DXMATRIX proj;
D3DXMATRIX view;
unsigned int pixelBufferNum = 0;
unsigned int vertexBufferNum = 0;
Application::GetInstance().GetGraphicsDevice()->GetDXSystem()->GetWorldMatrix(world);
Application::GetInstance().GetGraphicsDevice()->GetDXSystem()->GetProjectionMatrix(proj);
Application::GetInstance().GetGraphicsDevice()->m_debugCamera->GetViewMatrix(view);
D3DXMatrixTranspose(&world, &world);
D3DXMatrixTranspose(&view, &view);
D3DXMatrixTranspose(&proj, &proj);
for (auto it = m_buffers.begin(); it != m_buffers.end(); it++)
{
eBufferType buffType = (*it).first;
if (buffType > eBufferType_Vertex && buffType < eBufferType_Pixel)
{
result = deviceContext->Map((*it).second, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LogManager::GetInstance().Error("Shader::Render-> could not lock a buffer");
return;
}
//Specific
switch (buffType)
{
case eBufferType_Vertex_Matrix:
{
MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
dataPtr->world = world;
dataPtr->projection = proj;
dataPtr->view = view;
}
break;
case eBufferType_Vertex_Camera:
{
CameraBufferType* dataPtr = (CameraBufferType*)mappedResource.pData;
dataPtr->cameraPosition = Application::GetInstance().GetGraphicsDevice()->m_debugCamera->GetPosition();
dataPtr->padding = 0.0f;
}
break;
case eBufferType_Vertex_Light:
{
LightBufferType* dataPtr = (LightBufferType*)mappedResource.pData;
dataPtr->ambientColour = D3DXVECTOR4(0.15f, 0.15f, 0.15f, 1.0f);
dataPtr->diffuseColour = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
dataPtr->specularColour = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
dataPtr->direction = D3DXVECTOR3(0.0f, -1.0f, 0.0f);
dataPtr->specularPower = 1024.0f;
}
break;
default:
assert(false && "It's pretty impossible to get here, re-evaluate your life");
break;
}
deviceContext->Unmap((*it).second, 0);
deviceContext->VSSetConstantBuffers(vertexBufferNum, 1, &(*it).second);
vertexBufferNum++;
}
else if (buffType > eBufferType_Pixel)
{
result = deviceContext->Map((*it).second, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LogManager::GetInstance().Error("Shader::Render-> could not lock a buffer");
return;
}
//Specific
switch (buffType)
{
case eBufferType_Pixel_Matrix:
{
MatrixBufferType* dataPtr = (MatrixBufferType*)mappedResource.pData;
dataPtr->world = world;
dataPtr->projection = proj;
dataPtr->view = view;
}
break;
case eBufferType_Pixel_Camera:
{
CameraBufferType* dataPtr = (CameraBufferType*)mappedResource.pData;
dataPtr->cameraPosition = Application::GetInstance().GetGraphicsDevice()->m_debugCamera->GetPosition();
dataPtr->padding = 0.0f;
}
break;
case eBufferType_Pixel_Light:
{
LightBufferType* dataPtr = (LightBufferType*)mappedResource.pData;
dataPtr->ambientColour = D3DXVECTOR4(0.15f, 0.15f, 0.15f, 1.0f);
dataPtr->diffuseColour = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
dataPtr->specularColour = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
dataPtr->direction = D3DXVECTOR3(0.0f, -1.0f, 0.0f);
dataPtr->specularPower = 1024.0f;
}
break;
default:
assert(false && "It's pretty impossible to get here, re-evaluate your life");
break;
}
deviceContext->Unmap((*it).second, 0);
deviceContext->PSSetConstantBuffers(pixelBufferNum, 1, &(*it).second);
pixelBufferNum++;
}
else
{
assert(false && "You dun goofed");
}
}
std::vector<ID3D11ShaderResourceView> texturesToSend;
for (auto it = m_textures.begin(); it != m_textures.end(); it++)
{
if (m_supportedTextures.count((*it).first) > 0)
{
ID3D11ShaderResourceView* temp = (*it).second->GetTexture();
deviceContext->PSSetShaderResources((*it).first, 1, &temp);
}
}
deviceContext->IASetInputLayout(m_layout);
deviceContext->VSSetShader(m_vertexShader, nullptr, 0);
deviceContext->PSSetShader(m_pixelShader, nullptr, 0);
deviceContext->PSSetSamplers(0, 1, &m_sampleState);
}
void D3D11CanvasWindowGraphics::Render()
{
RECT clientRc;
GetClientRect(m_hWnd, &clientRc);
RectF clientRcf((float)clientRc.left, (float)clientRc.top,
(float)clientRc.right, (float)clientRc.bottom);
D2D1_RECT_F clientRectf = D2D1::RectF((FLOAT)clientRc.left, (FLOAT)clientRc.top,
(FLOAT)clientRc.right, (FLOAT)clientRc.bottom);
ID3D11DeviceContext* pContext = m_driver->GetD3D11Context();
// Clear to black
static const float BG_COLOR[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
pContext->ClearRenderTargetView(m_backBufferRTV, BG_COLOR);
// TODO: CLEAN UP THIS MESS!!!
if (m_image)
{
// Set up rasterizer
RECT clientRc;
GetClientRect(m_hWnd, &clientRc);
RectF clientRcf((float)clientRc.left, (float)clientRc.top,
(float)clientRc.right, (float)clientRc.bottom);
D3D11_VIEWPORT vp = CD3D11_VIEWPORT(
clientRcf.left,
clientRcf.top,
clientRcf.right - clientRcf.left,
clientRcf.bottom - clientRcf.top);
pContext->RSSetViewports(1, &vp);
// Set up output merger
ID3D11RenderTargetView* rtv = m_backBufferRTV;
pContext->OMSetRenderTargets(1, &rtv, NULL);
pContext->OMSetBlendState(m_driver->GetOverBlend(), NULL, 0xFFFFFFFF);
D3D11ImagePtr d3d11Image = std::static_pointer_cast<D3D11Image, DriverImage>(
m_image->GetDriverImage());
ID3D11ShaderResourceView* srv = d3d11Image->GetSRV();
ID3D11SamplerState* ss = m_driver->GetBilinearSampler();
// Set up pixel shader
pContext->PSSetShader(m_driver->GetTexturedPixelShader(), NULL, 0);
pContext->PSSetShaderResources(0, 1, &srv);
pContext->PSSetSamplers(0, 1, &ss);
m_driver->RenderQuad(m_camera->GetCanvasToClip(clientRcf),
m_image->GetCanvasRect());
srv = NULL;
pContext->PSSetShaderResources(0, 1, &srv);
}
// Render something into Direct2D target
ComPtr<ID2D1RenderTarget> pD2DTarget = m_d2dTarget->AcquireTarget();
pD2DTarget->BeginDraw();
// Clear to transparent black
pD2DTarget->Clear(D2D1::ColorF(D2D1::ColorF::Black, 0.0f));
// Create brush for drawing stuff
ID2D1SolidColorBrush* brush;
pD2DTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Blue), &brush);
Matrix3x2f canvasToViewport = m_camera->GetCanvasToViewport(clientRcf);
// Draw the extensible image's tile structure
const ExtensibleImage::TileMap& tiles = m_extensibleImage->GetTileMap();
for (ExtensibleImage::TileMap::const_iterator it = tiles.begin();
it != tiles.end(); ++it)
{
const RectF& canvasRect = it->second->GetCanvasRect();
ID2D1Factory* d2dFactory;
pD2DTarget->GetFactory(&d2dFactory);
ID2D1RectangleGeometry* rectGeom;
d2dFactory->CreateRectangleGeometry(
D2D1::RectF(canvasRect.left, canvasRect.top, canvasRect.right, canvasRect.bottom),
&rectGeom);
ID2D1TransformedGeometry* transGeom;
d2dFactory->CreateTransformedGeometry(rectGeom,
D2D1::Matrix3x2F(canvasToViewport.m11, canvasToViewport.m12,
canvasToViewport.m21, canvasToViewport.m22,
canvasToViewport.m31, canvasToViewport.m32),
&transGeom);
rectGeom->Release();
pD2DTarget->DrawGeometry(transGeom, brush);
transGeom->Release();
d2dFactory->Release();
}
// Draw some text
RenderPrintf(pD2DTarget, m_textFormat, clientRectf, brush,
L"Welcome to Paint Sandbox!");
brush->Release();
pD2DTarget->EndDraw();
m_d2dTarget->ReleaseTarget();
// Transfer Direct2D target to display
//m_driver->RenderD2DTarget(m_d2dTarget);
// Set up rasterizer
D3D11_VIEWPORT vp = CD3D11_VIEWPORT(
clientRcf.left,
clientRcf.top,
clientRcf.right - clientRcf.left,
clientRcf.bottom - clientRcf.top);
pContext->RSSetViewports(1, &vp);
// Set up output merger
ID3D11RenderTargetView* rtv = m_backBufferRTV;
pContext->OMSetRenderTargets(1, &rtv, NULL);
pContext->OMSetBlendState(m_driver->GetOverBlend(), NULL, 0xFFFFFFFF);
ID3D11ShaderResourceView* srv = m_d2dTarget->AcquireSRV();
ID3D11SamplerState* ss = m_driver->GetBilinearSampler();
// Set up pixel shader
pContext->PSSetShader(m_driver->GetTexturedPixelShader(), NULL, 0);
pContext->PSSetShaderResources(0, 1, &srv);
pContext->PSSetSamplers(0, 1, &ss);
m_driver->RenderQuad(Matrix3x2f::IDENTITY, RectF(-1.0f, 1.0f, 1.0f, -1.0f));
srv = NULL;
pContext->PSSetShaderResources(0, 1, &srv);
m_d2dTarget->ReleaseSRV();
}
// Render function
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
{
ID3D11DeviceContext* ctx = g_pd3dDeviceContext;
// Create and grow vertex/index buffers if needed
if (!g_pVB || g_VertexBufferSize < draw_data->TotalVtxCount)
{
if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
g_VertexBufferSize = draw_data->TotalVtxCount + 5000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = g_VertexBufferSize * sizeof(ImDrawVert);
desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.MiscFlags = 0;
if (g_pd3dDevice->CreateBuffer(&desc, NULL, &g_pVB) < 0)
return;
}
if (!g_pIB || g_IndexBufferSize < draw_data->TotalIdxCount)
{
if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
g_IndexBufferSize = draw_data->TotalIdxCount + 10000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
desc.Usage = D3D11_USAGE_DYNAMIC;
desc.ByteWidth = g_IndexBufferSize * sizeof(ImDrawIdx);
desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
if (g_pd3dDevice->CreateBuffer(&desc, NULL, &g_pIB) < 0)
return;
}
// Copy and convert all vertices into a single contiguous buffer
D3D11_MAPPED_SUBRESOURCE vtx_resource, idx_resource;
if (ctx->Map(g_pVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &vtx_resource) != S_OK)
return;
if (ctx->Map(g_pIB, 0, D3D11_MAP_WRITE_DISCARD, 0, &idx_resource) != S_OK)
return;
ImDrawVert* vtx_dst = (ImDrawVert*)vtx_resource.pData;
ImDrawIdx* idx_dst = (ImDrawIdx*)idx_resource.pData;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
memcpy(vtx_dst, cmd_list->VtxBuffer.Data, cmd_list->VtxBuffer.Size * sizeof(ImDrawVert));
memcpy(idx_dst, cmd_list->IdxBuffer.Data, cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx));
vtx_dst += cmd_list->VtxBuffer.Size;
idx_dst += cmd_list->IdxBuffer.Size;
}
ctx->Unmap(g_pVB, 0);
ctx->Unmap(g_pIB, 0);
// Setup orthographic projection matrix into our constant buffer
{
D3D11_MAPPED_SUBRESOURCE mapped_resource;
if (ctx->Map(g_pVertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_resource) != S_OK)
return;
VERTEX_CONSTANT_BUFFER* constant_buffer = (VERTEX_CONSTANT_BUFFER*)mapped_resource.pData;
float L = 0.0f;
float R = ImGui::GetIO().DisplaySize.x;
float B = ImGui::GetIO().DisplaySize.y;
float T = 0.0f;
float mvp[4][4] =
{
{ 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.5f, 0.0f },
{ (R+L)/(L-R), (T+B)/(B-T), 0.5f, 1.0f },
};
memcpy(&constant_buffer->mvp, mvp, sizeof(mvp));
ctx->Unmap(g_pVertexConstantBuffer, 0);
}
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
struct BACKUP_DX11_STATE
{
UINT ScissorRectsCount, ViewportsCount;
D3D11_RECT ScissorRects[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
D3D11_VIEWPORT Viewports[D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
ID3D11RasterizerState* RS;
ID3D11BlendState* BlendState;
FLOAT BlendFactor[4];
UINT SampleMask;
UINT StencilRef;
ID3D11DepthStencilState* DepthStencilState;
ID3D11ShaderResourceView* PSShaderResource;
ID3D11SamplerState* PSSampler;
ID3D11PixelShader* PS;
ID3D11VertexShader* VS;
UINT PSInstancesCount, VSInstancesCount;
ID3D11ClassInstance* PSInstances[256], *VSInstances[256]; // 256 is max according to PSSetShader documentation
D3D11_PRIMITIVE_TOPOLOGY PrimitiveTopology;
ID3D11Buffer* IndexBuffer, *VertexBuffer, *VSConstantBuffer;
UINT IndexBufferOffset, VertexBufferStride, VertexBufferOffset;
DXGI_FORMAT IndexBufferFormat;
ID3D11InputLayout* InputLayout;
};
BACKUP_DX11_STATE old;
old.ScissorRectsCount = old.ViewportsCount = D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE;
ctx->RSGetScissorRects(&old.ScissorRectsCount, old.ScissorRects);
ctx->RSGetViewports(&old.ViewportsCount, old.Viewports);
ctx->RSGetState(&old.RS);
ctx->OMGetBlendState(&old.BlendState, old.BlendFactor, &old.SampleMask);
ctx->OMGetDepthStencilState(&old.DepthStencilState, &old.StencilRef);
ctx->PSGetShaderResources(0, 1, &old.PSShaderResource);
ctx->PSGetSamplers(0, 1, &old.PSSampler);
old.PSInstancesCount = old.VSInstancesCount = 256;
ctx->PSGetShader(&old.PS, old.PSInstances, &old.PSInstancesCount);
ctx->VSGetShader(&old.VS, old.VSInstances, &old.VSInstancesCount);
ctx->VSGetConstantBuffers(0, 1, &old.VSConstantBuffer);
ctx->IAGetPrimitiveTopology(&old.PrimitiveTopology);
ctx->IAGetIndexBuffer(&old.IndexBuffer, &old.IndexBufferFormat, &old.IndexBufferOffset);
ctx->IAGetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset);
ctx->IAGetInputLayout(&old.InputLayout);
// Setup viewport
D3D11_VIEWPORT vp;
memset(&vp, 0, sizeof(D3D11_VIEWPORT));
vp.Width = ImGui::GetIO().DisplaySize.x;
vp.Height = ImGui::GetIO().DisplaySize.y;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = vp.TopLeftY = 0.0f;
ctx->RSSetViewports(1, &vp);
// Bind shader and vertex buffers
unsigned int stride = sizeof(ImDrawVert);
unsigned int offset = 0;
ctx->IASetInputLayout(g_pInputLayout);
ctx->IASetVertexBuffers(0, 1, &g_pVB, &stride, &offset);
ctx->IASetIndexBuffer(g_pIB, sizeof(ImDrawIdx) == 2 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT, 0);
ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ctx->VSSetShader(g_pVertexShader, NULL, 0);
ctx->VSSetConstantBuffers(0, 1, &g_pVertexConstantBuffer);
ctx->PSSetShader(g_pPixelShader, NULL, 0);
ctx->PSSetSamplers(0, 1, &g_pFontSampler);
// Setup render state
const float blend_factor[4] = { 0.f, 0.f, 0.f, 0.f };
ctx->OMSetBlendState(g_pBlendState, blend_factor, 0xffffffff);
ctx->OMSetDepthStencilState(g_pDepthStencilState, 0);
ctx->RSSetState(g_pRasterizerState);
// Render command lists
int vtx_offset = 0;
int idx_offset = 0;
for (int n = 0; n < draw_data->CmdListsCount; n++)
{
const ImDrawList* cmd_list = draw_data->CmdLists[n];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
const ImDrawCmd* pcmd = &cmd_list->CmdBuffer[cmd_i];
if (pcmd->UserCallback)
{
pcmd->UserCallback(cmd_list, pcmd);
}
else
{
const D3D11_RECT r = { (LONG)pcmd->ClipRect.x, (LONG)pcmd->ClipRect.y, (LONG)pcmd->ClipRect.z, (LONG)pcmd->ClipRect.w };
ctx->PSSetShaderResources(0, 1, (ID3D11ShaderResourceView**)&pcmd->TextureId);
ctx->RSSetScissorRects(1, &r);
ctx->DrawIndexed(pcmd->ElemCount, idx_offset, vtx_offset);
}
idx_offset += pcmd->ElemCount;
}
vtx_offset += cmd_list->VtxBuffer.Size;
}
// Restore modified DX state
ctx->RSSetScissorRects(old.ScissorRectsCount, old.ScissorRects);
ctx->RSSetViewports(old.ViewportsCount, old.Viewports);
ctx->RSSetState(old.RS); if (old.RS) old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask); if (old.BlendState) old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef); if (old.DepthStencilState) old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource); if (old.PSShaderResource) old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler); if (old.PSSampler) old.PSSampler->Release();
ctx->PSSetShader(old.PS, old.PSInstances, old.PSInstancesCount); if (old.PS) old.PS->Release();
for (UINT i = 0; i < old.PSInstancesCount; i++) if (old.PSInstances[i]) old.PSInstances[i]->Release();
ctx->VSSetShader(old.VS, old.VSInstances, old.VSInstancesCount); if (old.VS) old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer); if (old.VSConstantBuffer) old.VSConstantBuffer->Release();
for (UINT i = 0; i < old.VSInstancesCount; i++) if (old.VSInstances[i]) old.VSInstances[i]->Release();
ctx->IASetPrimitiveTopology(old.PrimitiveTopology);
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset); if (old.IndexBuffer) old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset); if (old.VertexBuffer) old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout); if (old.InputLayout) old.InputLayout->Release();
}
void BillboardTrees::Render()
{
if (!m_loadingComplete)
return;
auto renderStateMgr = RenderStateMgr::Instance();
ID3D11DeviceContext* context = m_deviceResources->GetD3DDeviceContext();
// Set IA stage
UINT stride = sizeof(PointSize);
UINT offset = 0;
if (ShaderChangement::PrimitiveType != D3D11_PRIMITIVE_TOPOLOGY_POINTLIST)
{
context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
ShaderChangement::PrimitiveType = D3D11_PRIMITIVE_TOPOLOGY_POINTLIST;
}
if (ShaderChangement::InputLayout != m_treeInputLayout.Get())
{
context->IASetInputLayout(m_treeInputLayout.Get());
ShaderChangement::InputLayout = m_treeInputLayout.Get();
}
context->IASetVertexBuffers(0, 1, m_treeSpriteVB.GetAddressOf(), &stride, &offset);
ID3D11Buffer* cbuffers[2] = { m_perFrameCB->GetBuffer(), m_treeSettingsCB.GetBuffer() };
ID3D11SamplerState* samplers[1] = { renderStateMgr->LinearSam() };
// Bind shaders, constant buffers, srvs and samplers
context->VSSetShader(m_treeVS.Get(), 0, 0);
ShaderChangement::VS = m_treeVS.Get();
context->GSSetShader(m_treeGS.Get(), 0, 0);
context->GSSetConstantBuffers(0, 1, cbuffers);
switch (m_renderOptions)
{
case BillTreeRenderOption::Light3: // Light
context->PSSetShader(m_treeLight3PS.Get(), 0, 0);
ShaderChangement::PS = m_treeLight3PS.Get();
break;
case BillTreeRenderOption::Light3TexClip: // LightTexClip
context->PSSetShader(m_treeLight3TexClipPS.Get(), 0, 0);
ShaderChangement::PS = m_treeLight3TexClipPS.Get();
break;
case BillTreeRenderOption::Light3TexClipFog: // LightTexClipFog
context->PSSetShader(m_treeLight3TexClipFogPS.Get(), 0, 0);
ShaderChangement::PS = m_treeLight3TexClipFogPS.Get();
break;
default:
throw ref new Platform::InvalidArgumentException("No such render option");
}
context->PSSetConstantBuffers(0, 2, cbuffers);
context->PSSetSamplers(0, 1, samplers);
context->PSSetShaderResources(0, 1, m_treeTextureMapArraySRV.GetAddressOf());
float blendFactor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
if (m_alphaToCoverage)
context->OMSetBlendState(renderStateMgr->AlphaToCoverBS(), blendFactor, 0xffffffff);
context->Draw(m_treeCount, 0);
// Recover render state
if (m_alphaToCoverage)
context->OMSetBlendState(nullptr, blendFactor, 0xffffffff);
// Remove gs
context->GSSetShader(nullptr, 0, 0);
ShaderChangement::GS = nullptr;
}
/** Binds a pipeline-state */
void D3D11GraphicsEngineQueued::BindPipelineState(const PipelineState* state)
{
D3D11PipelineState* s = (D3D11PipelineState*)state;
D3D11PipelineState* b = (D3D11PipelineState*)BoundPipelineStateByThread[GetCurrentThreadId()];
ID3D11DeviceContext* context = GetDeferredContextByThread();
if(!b) b = (D3D11PipelineState*)&DefaultPipelineState;
// Bind state
if(b->BlendState != s->BlendState)
SC_DBG(context->OMSetBlendState(s->BlendState, (float *)&D3DXVECTOR4(0, 0, 0, 0), 0xFFFFFFFF), GothicRendererInfo::SC_BS);
if(b->SamplerState != s->SamplerState)
SC_DBG(context->PSSetSamplers(0, 1, &s->SamplerState), GothicRendererInfo::SC_SMPL);
if(b->DepthStencilState != s->DepthStencilState)
SC_DBG(context->OMSetDepthStencilState(s->DepthStencilState, 0), GothicRendererInfo::SC_DSS);
if(b->RasterizerState != s->RasterizerState)
SC_DBG(context->RSSetState(s->RasterizerState), GothicRendererInfo::SC_RS);
// Bind constantbuffers (They are likely to change for every object)
if(!s->ConstantBuffersVS.empty() && s->ConstantBuffersVS != b->ConstantBuffersVS)SC_DBG(context->VSSetConstantBuffers(0, s->ConstantBuffersVS.size(), &s->ConstantBuffersVS[0]),GothicRendererInfo::SC_CB);
if(!s->ConstantBuffersPS.empty() && s->ConstantBuffersPS != b->ConstantBuffersPS)SC_DBG(context->PSSetConstantBuffers(0, s->ConstantBuffersPS.size(), &s->ConstantBuffersPS[0]),GothicRendererInfo::SC_CB);
if(!s->ConstantBuffersHDS.empty() && s->ConstantBuffersHDS != b->ConstantBuffersHDS)SC_DBG(context->HSSetConstantBuffers(0, s->ConstantBuffersHDS.size(), &s->ConstantBuffersHDS[0]),GothicRendererInfo::SC_CB);
if(!s->ConstantBuffersHDS.empty() && s->ConstantBuffersHDS != b->ConstantBuffersHDS)SC_DBG(context->DSSetConstantBuffers(0, s->ConstantBuffersHDS.size(), &s->ConstantBuffersHDS[0]),GothicRendererInfo::SC_CB);
if(!s->ConstantBuffersGS.empty() && s->ConstantBuffersGS != b->ConstantBuffersGS)SC_DBG(context->GSSetConstantBuffers(0, s->ConstantBuffersGS.size(), &s->ConstantBuffersGS[0]),GothicRendererInfo::SC_CB);
// Vertexbuffers
UINT off[] = {0,0};
if(memcmp(s->BaseState.VertexBuffers, b->BaseState.VertexBuffers, sizeof(b->BaseState.VertexBuffers)) != 0)
SC_DBG(context->IASetVertexBuffers(0, s->VertexBuffers.size(), &s->VertexBuffers[0], s->BaseState.VertexStride, off), GothicRendererInfo::SC_VB);
if(!s->StructuredBuffersVS.empty() && memcmp(s->BaseState.StructuredBuffersVS, b->BaseState.StructuredBuffersVS, sizeof(b->BaseState.StructuredBuffersVS)) != 0)
SC_DBG(context->VSSetShaderResources(0, 1, &s->StructuredBuffersVS[0]), GothicRendererInfo::SC_VB);
if(s->IndexBuffer != b->IndexBuffer)
SC_DBG(context->IASetIndexBuffer(s->IndexBuffer, s->BaseState.IndexStride == 4 ? DXGI_FORMAT_R32_UINT : DXGI_FORMAT_R16_UINT, 0), GothicRendererInfo::SC_IB);
// Shaders
if(s->VertexShader != b->VertexShader)
SC_DBG(context->VSSetShader(s->VertexShader, NULL, NULL), GothicRendererInfo::SC_VS);
if(s->InputLayout != b->InputLayout)
SC_DBG(context->IASetInputLayout(s->InputLayout), GothicRendererInfo::SC_IL);
if(s->PixelShader != b->PixelShader)
SC_DBG(context->PSSetShader(s->PixelShader, NULL, NULL), GothicRendererInfo::SC_PS);
if(s->HullShader != b->HullShader)
SC_DBG(context->HSSetShader(s->HullShader, NULL, NULL), GothicRendererInfo::SC_HS);
if(s->DomainShader != b->DomainShader)
SC_DBG(context->DSSetShader(s->DomainShader, NULL, NULL), GothicRendererInfo::SC_DS);
if(s->GeometryShader != b->GeometryShader)
SC_DBG(context->GSSetShader(s->GeometryShader, NULL, NULL), GothicRendererInfo::SC_GS);
// Rendertargets
if(memcmp(s->RenderTargetViews, b->RenderTargetViews, sizeof(void*) * s->NumRenderTargetViews) != 0 ||
s->DepthStencilView != b->DepthStencilView)
SC_DBG(context->OMSetRenderTargets(s->NumRenderTargetViews, s->RenderTargetViews, s->DepthStencilView), GothicRendererInfo::SC_RTVDSV);
// Textures
if(memcmp(s->Textures, b->Textures, sizeof(void*) * s->BaseState.NumTextures) != 0)
SC_DBG(context->PSSetShaderResources(0, s->BaseState.NumTextures, s->Textures), GothicRendererInfo::SC_TX);
// Primitive topology
//Context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Replace old state
// FIXME: Might not threadsave
BoundPipelineStateByThread[GetCurrentThreadId()] = s;
}
void TTexture::PostTexture()
{
ID3D11DeviceContext* DeviceContext = Device->GetDeviceContext();
DeviceContext->PSSetSamplers(0,1,&Sampler);
DeviceContext->PSSetShaderResources(0,1,&TextureView);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
/// CelShadeApp::CelShadeD3D
///
/// @brief
/// Render a cel-shading demo using Direct3D
/// @return
/// N/A
///////////////////////////////////////////////////////////////////////////////////////////////////
void CelShadeApp::CelShadeD3D()
{
ID3D11DeviceContext* pContext = m_pDxData->pD3D11Context;
ID3D11Device* pDevice = m_pDxData->pD3D11Device;
D3DX11_IMAGE_LOAD_INFO imageLoadInfo;
memset( &imageLoadInfo, 0, sizeof(D3DX11_IMAGE_LOAD_INFO) );
imageLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;
imageLoadInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
DxTextureCreateInfo shadeTexInfo;
memset(&shadeTexInfo, 0, sizeof(DxTextureCreateInfo));
shadeTexInfo.flags.RenderTarget = TRUE;
shadeTexInfo.flags.ShaderInput = TRUE;
shadeTexInfo.format = DXGI_FORMAT_R8G8B8A8_UNORM;
shadeTexInfo.width = m_screenWidth;
shadeTexInfo.height = m_screenHeight;
DxTexture* pShadeTex = DxTexture::Create(pDevice, &shadeTexInfo);
DxTextureCreateInfo edgeTexInfo;
memset(&edgeTexInfo, 0, sizeof(DxTextureCreateInfo));
edgeTexInfo.flags.RenderTarget = TRUE;
edgeTexInfo.flags.ShaderInput = TRUE;
edgeTexInfo.format = DXGI_FORMAT_R8G8B8A8_UNORM;
edgeTexInfo.width = m_screenWidth;
edgeTexInfo.height = m_screenHeight;
DxTexture* pEdgeTex = DxTexture::Create(pDevice, &edgeTexInfo);
// Samplers /////////////////////////////////////////////////////////////////////////////
// SamplerState PointSampler : register(s0);
D3D11_SAMPLER_DESC pointSamplerDesc;
memset(&pointSamplerDesc, 0, sizeof(D3D11_SAMPLER_DESC));
pointSamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
pointSamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
pointSamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
pointSamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
pointSamplerDesc.MinLOD = -FLT_MAX;
pointSamplerDesc.MaxLOD = FLT_MAX;
pointSamplerDesc.MipLODBias = 0.0f;
pointSamplerDesc.MaxAnisotropy = 16;
ID3D11SamplerState* pPointSampler = NULL;
pDevice->CreateSamplerState(&pointSamplerDesc, &pPointSampler);
//
UINT numVertices = 0, numIndices = 0;
VertexPTN* pVB = NULL;
UINT* pIB = NULL;
ImportPly("Content/dragon_vrip_res3.ply", numVertices, &pVB, numIndices, &pIB);
//ImportPly("Content/bun_zipper_res4.ply", numVertices, &pVB, numIndices, &pIB);
DxMeshCreateInfo meshCreateInfo = {0};
meshCreateInfo.indexCount = numIndices;
meshCreateInfo.pIndexArray = pIB;
meshCreateInfo.indexFormat = DXGI_FORMAT_R32_UINT;
meshCreateInfo.pVertexArray = pVB;
meshCreateInfo.vertexCount = numVertices;
meshCreateInfo.vertexElementSize = sizeof(VertexPTN);
DxMesh* pMesh = DxMesh::Create(pDevice, &meshCreateInfo);
Plane p;
DxMeshCreateInfo planeMeshInfo;
memset(&planeMeshInfo, 0, sizeof(planeMeshInfo));
planeMeshInfo.pVertexArray = p.GetVB();
planeMeshInfo.vertexCount = p.NumVertices();
planeMeshInfo.vertexElementSize = sizeof(VertexPTN);
DxMesh* pPlaneMesh = DxMesh::Create(pDevice, &planeMeshInfo);
Cube c;
DxMeshCreateInfo cubeMeshInfo;
memset(&cubeMeshInfo, 0, sizeof(cubeMeshInfo));
cubeMeshInfo.pVertexArray = c.GetVB();
cubeMeshInfo.vertexCount = c.NumVertices();
cubeMeshInfo.vertexElementSize = sizeof(VertexPT);
DxMesh* pCubeMesh = DxMesh::Create(pDevice, &cubeMeshInfo);
D3D11_SUBRESOURCE_DATA cbInitData;
memset(&cbInitData, 0, sizeof(D3D11_SUBRESOURCE_DATA));
// Camera Buffer
CameraBufferData cameraData;
memset(&cameraData, 0, sizeof(CameraBufferData));
DxBufferCreateInfo cameraBufferCreateInfo = {0};
cameraBufferCreateInfo.flags.cpuWriteable = TRUE;
cameraBufferCreateInfo.elemSizeBytes = sizeof(CameraBufferData);
cameraBufferCreateInfo.pInitialData = &cameraData;
DxBuffer* pCameraBuffer = DxBuffer::Create(pDevice, &cameraBufferCreateInfo);
// Shaders ////////////////////////////////////////////////////////////////////////////////////
m_pPosTexTriVS = DxShader::CreateFromFile(pDevice, "PosTexTri", "Content/shaders/CelShade.hlsl", PosTexVertexDesc, PosTexElements);
m_pPosTexNormVS = DxShader::CreateFromFile(pDevice, "PosTexNorm", "Content/shaders/CelShade.hlsl", PosTexNormVertexDesc, PosTexNormElements);
m_pCelShadePS = DxShader::CreateFromFile(pDevice, "CelShade", "Content/shaders/CelShade.hlsl");
DxShader* pDetectEdges = DxShader::CreateFromFile(pDevice, "DetectEdges", "Content/shaders/CelShade.hlsl");
DxShader* pApplyTexPS = DxShader::CreateFromFile(pDevice, "ApplyTex", "Content/shaders/CelShade.hlsl");
DxShader* pCubeVS = DxShader::CreateFromFile(pDevice, "PosTex", "Content/shaders/CelShade.hlsl", PosTexVertexDesc, PosTexElements);
DxShader* pCubePS = DxShader::CreateFromFile(pDevice, "CubePS", "Content/shaders/CelShade.hlsl");
////////////////////////////////////////////////////////////////////////////////////////
pContext->ClearState();
// SET RENDER STATE
FLOAT clearColor[4];
clearColor[0] = 0.2f;
clearColor[1] = 0.2f;
clearColor[2] = 0.2f;
clearColor[3] = 1.0f;
D3D11_RASTERIZER_DESC shadeDesc;
shadeDesc.FillMode = D3D11_FILL_SOLID;
shadeDesc.CullMode = D3D11_CULL_BACK;
shadeDesc.FrontCounterClockwise = FALSE;
shadeDesc.DepthBias = 0;
shadeDesc.DepthBiasClamp = 0.0f;
shadeDesc.SlopeScaledDepthBias = 0;
shadeDesc.DepthClipEnable = false;
shadeDesc.ScissorEnable = false;
shadeDesc.MultisampleEnable = false;
shadeDesc.AntialiasedLineEnable = false;
ID3D11RasterizerState* pShadeRS = NULL;
pDevice->CreateRasterizerState(&shadeDesc, &pShadeRS);
pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
m_pWindow->Show();
BOOL quit = false;
FLOAT yRotationAngle = 0.0f;
while (!quit)
{
ProcessUpdates();
BeginFrame();
CameraBufferData* pCameraData = NULL;
// new frame, clear state
pContext->ClearState();
pContext->RSSetViewports(1, &m_pDxData->viewport);
pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
pContext->RSSetState(pShadeRS);
pContext->PSSetSamplers(0, 1, &pPointSampler);
pContext->OMSetRenderTargets(1,
&m_pDxData->pAppRenderTargetView,
m_pDxData->pAppDepthStencilTex->GetDepthStencilView());
pContext->ClearRenderTargetView(m_pDxData->pAppRenderTargetView, clearColor);
pContext->ClearDepthStencilView(m_pDxData->pAppDepthStencilTex->GetDepthStencilView(),
D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL,
1.0,
0);
///// Draw Mesh ///////////////////////////////////////////////////////////////////////////
FLOAT viewRotationY = (GetMousePos().x - (m_screenWidth / 2.0f)) /(m_screenWidth / 2.0f);
viewRotationY *= (3.14159f / 4.0f);
FLOAT viewRotationZ = (GetMousePos().y - (m_screenHeight / 2.0f)) /(m_screenHeight / 2.0f);
viewRotationZ *= (3.14159f / 4.0f);
pCameraData = reinterpret_cast<CameraBufferData*>(pCameraBuffer->Map(pContext));
pCameraData->worldMatrix = XMMatrixScaling(25, 25, 25) * XMMatrixRotationY(yRotationAngle) *
XMMatrixTranslation(m_pCamera->Position().x,
m_pCamera->Position().y,
m_pCamera->Position().z) ;
// translate world +6 in Z to position camera -9 from world origin
pCameraData->viewMatrix = m_pCamera->W2C();
pCameraData->projectionMatrix = m_pCamera->C2S();
pCameraBuffer->Unmap(pContext);
pCameraBuffer->BindVS(pContext, 0);
pMesh->Bind(pContext);
m_pPosTexNormVS->Bind(pContext);
m_pCelShadePS->Bind(pContext);
pMesh->Draw(pContext);
///// Detect Edges ///////////////////////////////////////////////////////////////////////////
///// Draw Light Position ////////////////////////////////////////////////////////////////////
//yRotationAngle = 0;
pCameraData = reinterpret_cast<CameraBufferData*>(pCameraBuffer->Map(pContext));
pCameraData->worldMatrix = XMMatrixScaling(1, 1, 1);
// XMMatrixRotationY(yRotationAngle);
// XMMatrixTranslation(-10, 10, 10);
// translate world +6 in Z to position camera -9 from world origin
pCameraData->viewMatrix = XMMatrixTranslation(0, 0, 10) * m_pCamera->W2C();
pCameraData->projectionMatrix = m_pCamera->C2S();
pCameraBuffer->Unmap(pContext);
pCameraBuffer->BindVS(pContext, 0);
pCubeVS->Bind(pContext);
pCubePS->Bind(pContext);
pCubeMesh->Bind(pContext);
pCubeMesh->Draw(pContext);
///// Draw UI ////////////////////////////////////////////////////////////////////////////////
///@todo Consider moving the following UI drawing to Draw2D()
m_pUI->Begin();
// Draw UI stuff
m_pUI->RenderRect();
m_pUI->RenderText();
m_pUI->End();
/// Blend UI onto final image
DrawUI();
m_pDxData->pDXGISwapChain->Present(0,0);
EndFrame();
Sleep(50);
yRotationAngle += 3.14159f / 60.0f;
}
// Shader Resource Views
pCameraBuffer->Destroy();
// Shaders
m_pCelShadePS->Destroy();
m_pCelShadePS = NULL;
m_pPosTexTriVS->Destroy();
m_pPosTexTriVS = NULL;
m_pPosTexNormVS->Destroy();
m_pPosTexNormVS = NULL;
pApplyTexPS->Destroy();
pApplyTexPS = NULL;
pPlaneMesh->Destroy();
pPlaneMesh = NULL;
// Samplers
pPointSampler->Release();
// Rasterizer State
pShadeRS->Release();
m_pDxData->pD3D11Context->ClearState();
m_pDxData->pD3D11Context->Flush();
}
// parameters should be validated/clamped by caller
EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
{
if (!mSwapChain)
{
return EGL_SUCCESS;
}
ID3D11Device *device = mRenderer->getDevice();
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
// Set vertices
D3D11_MAPPED_SUBRESOURCE mappedResource;
HRESULT result = deviceContext->Map(mQuadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
return EGL_BAD_ACCESS;
}
d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);
// Create a quad in homogeneous coordinates
float x1 = (x / float(mWidth)) * 2.0f - 1.0f;
float y1 = (y / float(mHeight)) * 2.0f - 1.0f;
float x2 = ((x + width) / float(mWidth)) * 2.0f - 1.0f;
float y2 = ((y + height) / float(mHeight)) * 2.0f - 1.0f;
float u1 = x / float(mWidth);
float v1 = y / float(mHeight);
float u2 = (x + width) / float(mWidth);
float v2 = (y + height) / float(mHeight);
d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, u1, v1);
d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, u1, v2);
d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1);
d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2);
deviceContext->Unmap(mQuadVB, 0);
static UINT stride = sizeof(d3d11::PositionTexCoordVertex);
static UINT startIdx = 0;
deviceContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &startIdx);
// Apply state
deviceContext->OMSetDepthStencilState(NULL, 0xFFFFFFFF);
static const float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
deviceContext->OMSetBlendState(NULL, blendFactor, 0xFFFFFFF);
deviceContext->RSSetState(NULL);
// Apply shaders
deviceContext->IASetInputLayout(mPassThroughIL);
deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
deviceContext->VSSetShader(mPassThroughVS, NULL, 0);
deviceContext->PSSetShader(mPassThroughPS, NULL, 0);
deviceContext->GSSetShader(NULL, NULL, 0);
// Apply render targets
mRenderer->setOneTimeRenderTarget(mBackBufferRTView);
// Set the viewport
D3D11_VIEWPORT viewport;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = mWidth;
viewport.Height = mHeight;
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
deviceContext->RSSetViewports(1, &viewport);
// Apply textures
deviceContext->PSSetShaderResources(0, 1, &mOffscreenSRView);
deviceContext->PSSetSamplers(0, 1, &mPassThroughSampler);
// Draw
deviceContext->Draw(4, 0);
result = mSwapChain->Present(mSwapInterval, 0);
if (result == DXGI_ERROR_DEVICE_REMOVED)
{
HRESULT removedReason = device->GetDeviceRemovedReason();
ERR("Present failed: the D3D11 device was removed: 0x%08X", removedReason);
return EGL_CONTEXT_LOST;
}
else if (result == DXGI_ERROR_DEVICE_RESET)
{
ERR("Present failed: the D3D11 device was reset from a bad command.");
return EGL_CONTEXT_LOST;
}
else if (FAILED(result))
{
ERR("Present failed with error code 0x%08X", result);
}
// Unbind
static ID3D11ShaderResourceView *const nullSRV = NULL;
deviceContext->PSSetShaderResources(0, 1, &nullSRV);
mRenderer->unapplyRenderTargets();
mRenderer->markAllStateDirty();
return EGL_SUCCESS;
}
EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width, EGLint height)
{
if (!mSwapChain)
{
return EGL_SUCCESS;
}
initPassThroughResources();
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
// Set vertices
D3D11_MAPPED_SUBRESOURCE mappedResource;
HRESULT result = deviceContext->Map(mQuadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
return EGL_BAD_ACCESS;
}
d3d11::PositionTexCoordVertex *vertices = static_cast<d3d11::PositionTexCoordVertex*>(mappedResource.pData);
// Create a quad in homogeneous coordinates
float x1 = (x / float(mWidth)) * 2.0f - 1.0f;
float y1 = (y / float(mHeight)) * 2.0f - 1.0f;
float x2 = ((x + width) / float(mWidth)) * 2.0f - 1.0f;
float y2 = ((y + height) / float(mHeight)) * 2.0f - 1.0f;
float u1 = x / float(mWidth);
float v1 = y / float(mHeight);
float u2 = (x + width) / float(mWidth);
float v2 = (y + height) / float(mHeight);
// Invert the quad vertices depending on the surface orientation.
if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_X_ANGLE) != 0)
{
std::swap(x1, x2);
}
if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE) != 0)
{
std::swap(y1, y2);
}
d3d11::SetPositionTexCoordVertex(&vertices[0], x1, y1, u1, v1);
d3d11::SetPositionTexCoordVertex(&vertices[1], x1, y2, u1, v2);
d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1);
d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2);
deviceContext->Unmap(mQuadVB, 0);
static UINT stride = sizeof(d3d11::PositionTexCoordVertex);
static UINT startIdx = 0;
deviceContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &startIdx);
// Apply state
deviceContext->OMSetDepthStencilState(NULL, 0xFFFFFFFF);
static const float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
deviceContext->OMSetBlendState(NULL, blendFactor, 0xFFFFFFF);
deviceContext->RSSetState(mPassThroughRS);
// Apply shaders
deviceContext->IASetInputLayout(mPassThroughIL);
deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
deviceContext->VSSetShader(mPassThroughVS, NULL, 0);
deviceContext->PSSetShader(mPassThroughPS, NULL, 0);
deviceContext->GSSetShader(NULL, NULL, 0);
auto stateManager = mRenderer->getStateManager();
// Apply render targets
stateManager->setOneTimeRenderTarget(mBackBufferRTView, nullptr);
// Set the viewport
D3D11_VIEWPORT viewport;
viewport.TopLeftX = 0;
viewport.TopLeftY = 0;
viewport.Width = static_cast<FLOAT>(mWidth);
viewport.Height = static_cast<FLOAT>(mHeight);
viewport.MinDepth = 0.0f;
viewport.MaxDepth = 1.0f;
deviceContext->RSSetViewports(1, &viewport);
// Apply textures
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, mOffscreenSRView);
deviceContext->PSSetSamplers(0, 1, &mPassThroughSampler);
// Draw
deviceContext->Draw(4, 0);
// Rendering to the swapchain is now complete. Now we can call Present().
// Before that, we perform any cleanup on the D3D device. We do this before Present() to make sure the
// cleanup is caught under the current eglSwapBuffers() PIX/Graphics Diagnostics call rather than the next one.
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, NULL);
mRenderer->markAllStateDirty();
return EGL_SUCCESS;
}
