void Sample::Internal(ID3D11ShaderResourceView * src,ID3D11RenderTargetView * dst) { ID3D11DeviceContext * context; device->GetImmediateContext(&context); ps.Get()->Bind(); context->OMSetRenderTargets(1,&dst,nullptr); Color c = Color::White(); context->ClearRenderTargetView(dst,(float*)&c); context->PSSetShaderResources(0,1,&src); FullScreenQuad::BindVS(); FullScreenQuad::Draw(); FullScreenQuad::UnbindVS(); ID3D11RenderTargetView * rtvNull = nullptr; ID3D11ShaderResourceView * srvNull = nullptr; context->OMSetRenderTargets(1,&rtvNull,nullptr); context->PSSetShaderResources(0,1,&srvNull); }
static void DoRendering (const float* worldMatrix, const float* identityMatrix, float* projectionMatrix, const MyVertex* verts) { // Does actual rendering of a simple triangle #if SUPPORT_D3D11 // D3D11 case if (s_DeviceType == kUnityGfxRendererD3D11 && EnsureD3D11ResourcesAreCreated()) { ID3D11DeviceContext* ctx = NULL; g_D3D11Device->GetImmediateContext (&ctx); ID3D11RenderTargetView* pCurrentRenderTarget; ID3D11DepthStencilView* pCurrentDepthStencil; // Get the current render targets ctx->OMGetRenderTargets(1, &pCurrentRenderTarget, &pCurrentDepthStencil); ctx->OMSetRenderTargets(1, &g_pD3D11RenderTargetView, nullptr); /* // update native texture from code D3D11_TEXTURE2D_DESC desc; g_TexturePointer->GetDesc(&desc); unsigned char* data = new unsigned char[desc.Width*desc.Height * 4]; FillTextureFromCode(desc.Width, desc.Height, desc.Width * 4, data); ctx->UpdateSubresource(g_TexturePointer, 0, NULL, data, desc.Width * 4, 0); delete[] data; */ const float CLEAR_CLR[4] = { 1, 1, 0, 1 }; // Yellow ctx->ClearRenderTargetView(g_pD3D11RenderTargetView, CLEAR_CLR); // Restore the original render target ctx->OMSetRenderTargets(1, &pCurrentRenderTarget, pCurrentDepthStencil); // update constant buffer - just the world matrix in our case ctx->UpdateSubresource (g_D3D11CB, 0, NULL, worldMatrix, 64, 0); // set shaders ctx->VSSetConstantBuffers (0, 1, &g_D3D11CB); ctx->VSSetShader (g_D3D11VertexShader, NULL, 0); ctx->PSSetShader (g_D3D11PixelShader, NULL, 0); // update vertex buffer ctx->UpdateSubresource (g_D3D11VB, 0, NULL, verts, sizeof(verts[0])*3, 0); // set input assembler data and draw ctx->IASetInputLayout (g_D3D11InputLayout); ctx->IASetPrimitiveTopology (D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); UINT stride = sizeof(MyVertex); UINT offset = 0; ctx->IASetVertexBuffers (0, 1, &g_D3D11VB, &stride, &offset); ctx->Draw (3, 0); ctx->Release(); } #endif }
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 SwapChain::Present(ID3D11DeviceContext& deviceContext) { ID3D11RenderTargetView* tmpRenderTargetView = backBuffer_.get(); deviceContext.OMSetRenderTargets(1, &tmpRenderTargetView, depthStencilView_.get()); e_throw_com_ret_error(dxgiSwapChain_->Present(0, 0), "IDXGISwapChain::Present"); }
void App::RenderTerrain2( bool bReset, float fTime, float fElapsedTime ) { g_ResetTerrain = bReset; if (g_ResetTerrain) { g_ResetTerrain = false; DeformInitTerrain(context); } renderer->changeToMainFramebuffer(); ID3D11DeviceContext* pContext = GetApp()->GetContext(); ID3D11RenderTargetView* pBackBufferRTV; ID3D11DepthStencilView* pBackBufferDSV; pContext->OMGetRenderTargets(1, &pBackBufferRTV, &pBackBufferDSV); // Clear render target and the depth stencil float ClearColor[4] = { 1.0f, 0.0f, 1.0f, 1.0f }; // Purple to better spot terrain cracks (disable sky cube). //float ClearColor[4] = { 0.465f, 0.725f, 0.0f, 1.0f }; // NV green for colour-consistent illustrations. pContext->ClearRenderTargetView(pBackBufferRTV, ClearColor); pContext->ClearDepthStencilView(pBackBufferDSV, D3D11_CLEAR_DEPTH, 1.0, 0); // ¸®»çÀÌ¡½Ã Error! pContext->OMSetRenderTargets(1, &pBackBufferRTV, pBackBufferDSV); RenderToBackBuffer(renderer, fTime, fElapsedTime, NULL); }
void App::RenderText(const std::wstring& text, Float2 pos) { ID3D11DeviceContext* context = deviceManager.ImmediateContext(); // Set the backbuffer and viewport ID3D11RenderTargetView* rtvs[1] = { deviceManager.BackBuffer() }; context->OMSetRenderTargets(1, rtvs, NULL); float clearColor[4] = { 0.0f, 0.0f, 0.0f, 0.0f }; context->ClearRenderTargetView(rtvs[0], clearColor); SetViewport(context, deviceManager.BackBufferWidth(), deviceManager.BackBufferHeight()); // Draw the text Float4x4 transform; transform.SetTranslation(Float3(pos.x, pos.y,0.0f)); spriteRenderer.Begin(context, SpriteRenderer::Point); spriteRenderer.RenderText(font, text.c_str(), transform.ToSIMD()); spriteRenderer.End(); // Present deviceManager.SwapChain()->Present(0, 0); // Pump the message loop window.MessageLoop(); }
void RenderTargetPingPong::Apply(ID3D11Device* device, ID3DX11EffectTechnique* technique) { ID3D11DeviceContext* context; device->GetImmediateContext(&context); ID3D11Buffer* zero = 0; UINT nought = 0; context->IASetVertexBuffers(0,1,&zero,&nought,&nought); context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); context->IASetInputLayout(0); { ID3D11RenderTargetView* view[] = { m_target->RenderTargetView() }; context->OMSetRenderTargets(1, const_cast<ID3D11RenderTargetView**> (view), m_depth_stencil_view); } m_shader_resource_variable->SetResource(m_source->ShaderResourceView()); for(UINT n = 0; n < Effect::NumPasses(technique); ++n) { technique->GetPassByIndex(n)->Apply(0,context); context->Draw(4,0); } m_shader_resource_variable->SetResource(0); m_last_target = m_target; std::swap(m_source,m_target); }
void FForwardPlusRenderer::DoDepthNormalPrePass(const FCamera& Camera, class IScene* Scene) { // Clear depth buffer ID3D11DeviceContext* DeviceContext = GraphicsContext->GetImmediateContext(); const FLOAT NormalsClearColour[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; const FLOAT DepthClearColour[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; ID3D11RenderTargetView* Targets[2] = { NormalTarget->GetRenderTarget(), DepthTarget->GetRenderTarget() }; DeviceContext->ClearDepthStencilView(GraphicsContext->GetDepthStencil(), D3D11_CLEAR_STENCIL | D3D11_CLEAR_DEPTH, 1.0f, 0); DeviceContext->ClearRenderTargetView(NormalTarget->GetRenderTarget(), NormalsClearColour); DeviceContext->ClearRenderTargetView(DepthTarget->GetRenderTarget(), DepthClearColour); DeviceContext->OMSetRenderTargets(2, Targets, GraphicsContext->GetDepthStencil()); FViewport Fullscreen(0, 0, GraphicsContext->GetWidth(), GraphicsContext->GetHeight()); D3D11_VIEWPORT Viewport = Fullscreen.CreateRenderViewport(); DeviceContext->RSSetViewports(1, &Viewport); InstanceBuffer->SetWorld(glm::mat4(1.0)); FDrawCall Params(DeviceContext, InstanceBuffer.Get()); Params.OverrideMaterial = std::bind(&FForwardPlusRenderer::OverrideMaterialDepthNormalPass, this, std::placeholders::_1); Scene->Draw(Params); }
void FForwardPlusRenderer::DoScenePass(const FCamera& Camera, class IScene* Scene) { // Clear depth buffer ID3D11DeviceContext* DeviceContext = GraphicsContext->GetImmediateContext(); const FLOAT ClearColour[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; ID3D11RenderTargetView* BackBuffer = HighDynamicRangeMSAATarget->GetRenderTarget(); DeviceContext->ClearDepthStencilView(HighDynamicRangeMSAATarget->GetDepthStencil(), D3D11_CLEAR_STENCIL | D3D11_CLEAR_DEPTH, 1.0f, 0); DeviceContext->ClearRenderTargetView(BackBuffer, ClearColour); DeviceContext->OMSetRenderTargets(1, &BackBuffer, HighDynamicRangeMSAATarget->GetDepthStencil()); FViewport Fullscreen(0, 0, GraphicsContext->GetWidth(), GraphicsContext->GetHeight()); D3D11_VIEWPORT Viewport = Fullscreen.CreateRenderViewport(); DeviceContext->RSSetViewports(1, &Viewport); InstanceBuffer->SetWorld(glm::mat4(1.0)); ID3D11RasterizerState* PreviousState = nullptr; if (ForceWireframe.AsBoolean()) { DeviceContext->RSGetState(&PreviousState); DeviceContext->RSSetState(GraphicsContext->GetRenderStates()->WireframeRasterizer); } FDrawCall Params(DeviceContext, InstanceBuffer.Get()); Scene->Draw(Params); if (PreviousState != nullptr) { DeviceContext->RSSetState(PreviousState); } }
void RDX11RenderTargetMgr::ClearAndSetMaineFrame() { ID3D11DeviceContext* pContext = GLOBAL::D3DContext(); pContext->OMSetRenderTargets( 1, &pMainFrameRTV, pDSV ); pContext->ClearRenderTargetView( pMainFrameRTV, clearColor); pContext->ClearDepthStencilView( pDSV, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0, 0 ); }
void ParticleSystemEffectBinder::UnbindOM() { ID3D11DeviceContext * context = GetContext(); ID3D11RenderTargetView * rtvs[2] = {nullptr,nullptr}; context->OMSetRenderTargets(2,rtvs,nullptr); }
void graphics_extensions::BindRenderTargets(Texture** buffersBegin, Texture** buffersEnd, Texture* depthStencilBuffer) { ID3D11DeviceContext* context = GraphicsManager::Get()->GetImmidiateContext(); ID3D11RenderTargetView* rtViews[4] = { nullptr, nullptr, nullptr, nullptr }; I32 buffersCount = buffersEnd - buffersBegin; _ASSERT(buffersCount > 0 && buffersCount < _countof(rtViews)); U32 i = 0; for(Texture** it = buffersBegin; it < buffersEnd; ++it) { rtViews[i++] = (*it)->GetRTView(); } if (depthStencilBuffer) { context->OMSetRenderTargets(buffersCount, rtViews, depthStencilBuffer->GetDSView()); } else { context->OMSetRenderTargets(buffersCount, rtViews, nullptr); } }
//----------------------------------------------- void CPUTRenderTargetColor::SetRenderTarget( CPUTRenderParameters &renderParams, CPUTRenderTargetDepth *pDepthBuffer, DWORD renderTargetIndex, const float *pClearColor, bool clear, float zClearVal ) { // **************************** // Save the current render target "state" so we can restore it later. // **************************** mSavedWidth = CPUTRenderTargetColor::sCurrentWidth; mSavedHeight = CPUTRenderTargetColor::sCurrentHeight; // Save the render target view so we can restore it later. mpSavedColorRenderTargetView = CPUTRenderTargetColor::GetActiveRenderTargetView(); mpSavedDepthStencilView = CPUTRenderTargetDepth::GetActiveDepthStencilView(); CPUTRenderTargetColor::SetActiveWidthHeight( mWidth, mHeight ); CPUTRenderTargetDepth::SetActiveWidthHeight( mWidth, mHeight ); // TODO: support multiple render target views (i.e., MRT) ID3D11DeviceContext *pContext = CPUT_DX11::GetContext(); // Clear the shader resources to avoid a hazard warning ID3D11ShaderResourceView *pNullResources[16] = {0}; pContext->PSSetShaderResources(0, 16, pNullResources ); pContext->VSSetShaderResources(0, 16, pNullResources ); // **************************** // Set the new render target states // **************************** ID3D11DepthStencilView *pDepthStencilView = pDepthBuffer ? pDepthBuffer->GetDepthBufferView() : NULL; pContext->OMSetRenderTargets( 1, &mpColorRenderTargetView, pDepthStencilView ); CPUTRenderTargetColor::SetActiveRenderTargetView(mpColorRenderTargetView); CPUTRenderTargetDepth::SetActiveDepthStencilView(pDepthStencilView); if( clear ) { pContext->ClearRenderTargetView( mpColorRenderTargetView, pClearColor ); if( pDepthStencilView ) { pContext->ClearDepthStencilView( pDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, zClearVal, 0 ); } } D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (float)mWidth, (float)mHeight, 0.0f, 1.0f }; pContext->RSSetViewports(1, &viewport); mRenderTargetSet = true; mSoftwareTextureDirty = true; } // CPUTRenderTargetColor::SetRenderTarget()
void graphics_extensions::UnbindAll() { ID3D11DeviceContext* context = GraphicsManager::Get()->GetImmidiateContext(); ID3D11RenderTargetView* rtViews[4]; memset(rtViews, 0, sizeof(ID3D11RenderTargetView*) * _countof(rtViews)); context->OMSetRenderTargets(_countof(rtViews), rtViews, nullptr); ID3D11ShaderResourceView* srViews[6]; memset(srViews, 0, sizeof(ID3D11ShaderResourceView*) * _countof(srViews)); context->PSSetShaderResources(0, _countof(srViews), srViews); }
//--------------------------------------------------------------------------- void ShadowMapGen::End() { ID3D11DeviceContext* dc = m_rc->Context(); // Restore the render targets ID3D11RenderTargetView* rt = m_pSurface->GetRenderTargetView(); ID3D11DepthStencilView* dsv = m_pSurface->GetDepthStencilView(); dc->OMSetRenderTargets(1, &rt, dsv); dc->RSSetViewports( 1, &m_pSurface->GetViewPort() ); m_rc = NULL; }
// |----------------------------------------------------------------------------| // | SetAsRenderTarget | // |----------------------------------------------------------------------------| void Texture::SetAsRenderTarget() { ID3D11DeviceContext* deviceContext = D3DManager::GetRef()->GetDeviceContext(); ID3D11DepthStencilView* depthStencilView = D3DManager::GetRef()->GetDepthStencilView(); // Bind the render target view and depth stencil buffer to the output render pipeline. deviceContext->OMSetRenderTargets(1, &m_renderTargetView, depthStencilView); // Set the viewport. deviceContext->RSSetViewports(1, &m_viewport); return; }
void ParticleSystemEffectBinder::BindOM() { ID3D11DeviceContext * context = GetContext(); ID3D11RenderTargetView * rtvs[2] = {rtvColor,rtvLinearDepth.Get()->GetRenderTargetPtr()}; float color[4] = {0.0f,0.0f,0.0f,0.0f}; context->ClearRenderTargetView(rtvColor,color); float depth[4] = {1.0f,0.0f,0.0f,0.0f}; context->ClearRenderTargetView(rtvLinearDepth.Get()->GetRenderTargetPtr(),depth); context->OMSetRenderTargets(2,rtvs,nullptr); }
void ToneMapper::IntRun(ID3D11ShaderResourceView * src,ID3D11RenderTargetView * dst) { ID3D11DeviceContext * context; device->GetImmediateContext(&context); ID3D11ShaderResourceView * srvNull[2] = {nullptr,nullptr}; ID3D11RenderTargetView * rtvNull = nullptr; shader.Get()->Bind(); FullScreenQuad::BindVS(); ID3D11ShaderResourceView * srcSrv[2] = {src,bloomTexture.Get()->GetShaderResourcePointer()}; context->PSSetShaderResources(0,2,srcSrv); context->OMSetRenderTargets(1,&dst,nullptr); FullScreenQuad::Draw(); context->PSSetShaderResources(0,2,srvNull); context->OMSetRenderTargets(1,&rtvNull,nullptr); }
//----------------------------------------------- void CPUTRenderTargetDepth::SetRenderTarget( CPUTRenderParameters &renderParams, DWORD renderTargetIndex, float zClearVal, bool clear ) { // **************************** // Save the current render target "state" so we can restore it later. // **************************** mSavedWidth = CPUTRenderTargetDepth::GetActiveWidth(); mSavedHeight = CPUTRenderTargetDepth::GetActiveHeight(); CPUTRenderTargetColor::SetActiveWidthHeight( mWidth, mHeight ); CPUTRenderTargetDepth::SetActiveWidthHeight( mWidth, mHeight ); // TODO: support multiple render target views (i.e., MRT) ID3D11DeviceContext *pContext = CPUT_DX11::GetContext(); // Make sure this render target isn't currently bound as a texture. static ID3D11ShaderResourceView *pSRV[16] = {0}; pContext->PSSetShaderResources( 0, 16, pSRV ); // Save the color and depth views so we can restore them later. mpSavedColorRenderTargetView = CPUTRenderTargetColor::GetActiveRenderTargetView(); mpSavedDepthStencilView = CPUTRenderTargetDepth::GetActiveDepthStencilView(); // Clear the shader resources to avoid a hazard warning ID3D11ShaderResourceView *pNullResources[16] = {0}; pContext->PSSetShaderResources(0, 16, pNullResources ); pContext->VSSetShaderResources(0, 16, pNullResources ); // **************************** // Set the new render target states // **************************** ID3D11RenderTargetView *pView[1] = {NULL}; pContext->OMSetRenderTargets( 1, pView, mpDepthStencilView ); CPUTRenderTargetColor::SetActiveRenderTargetView( NULL ); CPUTRenderTargetDepth::SetActiveDepthStencilView( mpDepthStencilView ); if( clear ) { pContext->ClearDepthStencilView( mpDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, zClearVal, 0 ); } D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (float)mWidth, (float)mHeight, 0.0f, 1.0f }; pContext->RSSetViewports( 1, &viewport ); mRenderTargetSet = true; } // CPUTRenderTargetDepth::SetRenderTarget()
bool ClearRenderingRoutine::Render(float deltaTime) { ID3D11DeviceContext* context = m_Renderer->GetImmediateContext(); // Set rt to back buffer ID3D11RenderTargetView* bbufferRTV = m_Renderer->GetBackBufferView(); context->OMSetRenderTargets(1, &bbufferRTV, m_Renderer->GetBackDepthStencilView()); // Clear the back buffer float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; context->ClearRenderTargetView(m_Renderer->GetBackBufferView(), ClearColor); context->ClearDepthStencilView(m_Renderer->GetBackDepthStencilView(), D3D11_CLEAR_DEPTH, 1.0f, 0); return true; }
/////////////////////////////////////////////////////////////////////////////////////////////////// /// IvyApp::DrawUI /// /// @brief /// /// @return /// N/A /////////////////////////////////////////////////////////////////////////////////////////////////// void IvyApp::DrawUI() { ID3D11DeviceContext* pContext = m_pDxData->pD3D11Context; ID3D11Device* pDevice = m_pDxData->pD3D11Device; UINT acquireKey = 1; UINT releaseKey = 0; UINT timeout = 5; HRESULT hr = m_pUIData->pUserInterfaceMutexD3D->AcquireSync(acquireKey, timeout); FLOAT blendFactors[4]; UINT sampleMask = 0xFFFFFFFF; ID3D11BlendState* pLastBlendState = NULL; pContext->OMGetBlendState(&pLastBlendState, blendFactors, &sampleMask); if (hr == WAIT_OBJECT_0) { pContext->OMSetRenderTargets(1, &m_pDxData->pAppRenderTargetView, NULL); CameraBufferData* pCameraData = reinterpret_cast<CameraBufferData*>(m_pUIData->pUserInterfaceCameraBuf->Map(m_pDxData->pD3D11Context)); pCameraData->worldMatrix = XMMatrixRotationX(-3.14f/2.0f) * XMMatrixScaling(2, 2, 1); pCameraData->viewMatrix = XMMatrixTranslation(0, 0, 2.0f) * m_pCamera->W2C(); pCameraData->projectionMatrix = m_pCamera->C2S(); m_pUIData->pUserInterfaceCameraBuf->Unmap(pContext); m_pUIData->pUserInterfaceVS->Bind(pContext); m_pUIData->pUserInterfaceCameraBuf->BindVS(pContext, 0); m_pDxData->pD3D11Context->PSSetShaderResources(0, 1, &m_pUIData->pUserInterfaceSRV); m_pUIData->pUserInterfacePS->Bind(pContext); m_pDxData->pD3D11Context->OMSetBlendState(m_pUIData->pUserInterfaceBlendState, blendFactors, sampleMask); m_pUIData->pUserInterfaceQuad->Bind(m_pDxData->pD3D11Context); m_pUIData->pUserInterfaceQuad->Draw(m_pDxData->pD3D11Context); } hr = m_pUIData->pUserInterfaceMutexD3D->ReleaseSync(releaseKey); m_pDxData->pD3D11Context->OMSetBlendState(pLastBlendState, blendFactors, sampleMask); }
HRESULT DxAssist::SetRenderTarget(DxRTDevice* RTDevice, uint w, uint h) { HRESULT hresult = E_FAIL; ID3D11Device* device = m_device; ID3D11DeviceContext* deviceContext = m_deviceContext; ID3D11RenderTargetView* poldRT = 0; ID3D11DepthStencilView* poldDS = 0; D3D11_VIEWPORT vp; const float clear[] = { 0, 0, 0, 90/255.0f}; //red,green,blue,alpha ASSERT(device); ASSERT(deviceContext); KGLOG_PROCESS_ERROR(RTDevice); KGLOG_PROCESS_ERROR(RTDevice->RTView); KGLOG_PROCESS_ERROR(RTDevice->RTDepthStencil); KGLOG_PROCESS_ERROR(RTDevice->RTDepthStencilBuf); deviceContext->OMGetRenderTargets(1, &poldRT, &poldDS ); deviceContext->OMSetRenderTargets(1, &RTDevice->RTView, RTDevice->RTDepthStencil); vp.TopLeftX = 0; vp.TopLeftY = 0; vp.Width = (float)w; vp.Height = (float)h; vp.MinDepth = 0.0f; vp.MaxDepth = 1.0f; deviceContext->RSSetViewports(1, &vp); deviceContext->ClearRenderTargetView(RTDevice->RTView, clear); deviceContext->ClearDepthStencilView(RTDevice->RTDepthStencil, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0); { RTSaveInfo info; info.RTView = poldRT; info.RTStencil = poldDS; s_RTSaveInfoStack.push(info); } hresult = S_OK; Exit0: return hresult; }
void Draw() { ID3D11DeviceContext* context = g_d3d.context_.get(); // Clear float clearColor[] = { 0.3f, 0.3f, 0.3f, 1.0f }; context->ClearRenderTargetView( g_d3d.backBufferRTV_.get(), clearColor ); auto* rtv = g_d3d.backBufferRTV_.get(); context->OMSetRenderTargets( 1, &rtv, nullptr ); // Draw body auto cbModelWVP = DirectX::XMMatrixIdentity(); auto matWorld = DirectX::XMMatrixIdentity(); matWorld = DirectX::XMMatrixRotationRollPitchYaw( g_d3d.jointRot_[ 0 ], g_d3d.jointRot_[ 1 ], g_d3d.jointRot_[ 2 ] ); auto matView = DirectX::XMMatrixLookAtLH( DirectX::XMVectorSet( 0, 0, -3, 0 ), DirectX::XMVectorSet( 0, 0, 5, 0 ), DirectX::XMVectorSet( 0, 1, 0, 0 ) ); auto matProj = DirectX::XMMatrixPerspectiveFovLH( DirectX::XMConvertToRadians( 50 ), (float)g_windowWidth / (float)g_windowHeight, 0.01f, 1000.0f ); cbModelWVP = matWorld * matView * matProj; cbModelWVP = DirectX::XMMatrixTranspose( cbModelWVP ); g_d3d.context_->UpdateSubresource( g_d3d.modelCB_.get(), 0, nullptr, &cbModelWVP, 0, 0 ); auto* vb = g_d3d.modelVB_.get(); unsigned int stride = sizeof( D3D::MeshFormat ); unsigned int offset = 0; auto* cb = g_d3d.modelCB_.get(); D3D11_VIEWPORT viewport = { 0, 0, g_windowWidth, g_windowHeight, 0, 1 }; context->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST ); context->IASetInputLayout( g_d3d.modelIL_.get() ); context->IASetVertexBuffers( 0, 1, &vb, &stride, &offset ); context->VSSetShader( g_d3d.modelVS_.get(), nullptr, 0 ); context->VSSetConstantBuffers( 0, 1, &cb ); context->RSSetState( g_d3d.rasterState_.get() ); context->PSSetShader( g_d3d.modelPS_.get(), nullptr, 0 ); context->RSSetViewports( 1, &viewport ); context->Draw( 18, 0 ); g_d3d.swapChain_->Present( 1, 0 ); }
//----------------------------------------- // TODO: This function is exactly the same as the RestoreRenderTargetColor(). void CPUTRenderTargetDepth::RestoreRenderTarget( CPUTRenderParameters &renderParams ) { ASSERT( mRenderTargetSet, "Render target restored without calling SetRenderTarget()"); ID3D11DeviceContext *pContext = CPUT_DX11::GetContext(); pContext->OMSetRenderTargets( 1, &mpSavedColorRenderTargetView, mpSavedDepthStencilView ); CPUTRenderTargetColor::SetActiveWidthHeight( mSavedWidth, mSavedHeight ); CPUTRenderTargetDepth::SetActiveWidthHeight( mSavedWidth, mSavedHeight ); CPUTRenderTargetColor::SetActiveRenderTargetView( mpSavedColorRenderTargetView ); CPUTRenderTargetDepth::SetActiveDepthStencilView( mpSavedDepthStencilView ); // TODO: save/restore original VIEWPORT settings, not assume full-screen viewport. D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (float)mSavedWidth, (float)mSavedHeight, 0.0f, 1.0f }; pContext->RSSetViewports( 1, &viewport ); mRenderTargetSet = false; } // CPUTRenderTarget::RestoreRenderTarget()
void PipelineStateCache::setRenderTargets(uint32 numViews, ID3D11RenderTargetView* const * renderTargetViews, ID3D11DepthStencilView* depthStencilView) { bool hasChanges = false; for (uint32 i = 0; i < MAX_RENDER_TARGETS; ++i) { hasChanges |= renderTargetViews[i] != m_currentlyBoundRTV[i]; m_currentlyBoundRTV[i] = renderTargetViews[i]; } if (depthStencilView != m_currentlyBoundDSV) { hasChanges = true; m_currentlyBoundDSV = depthStencilView; } if (hasChanges) { m_deviceContext->OMSetRenderTargets(numViews, m_currentlyBoundRTV, m_currentlyBoundDSV); } }
HRESULT DxAssist::RestoreRenderTarget() { ASSERT(s_RTSaveInfoStack.size() > 0); HRESULT hr = E_FAIL; HRESULT hresult = E_FAIL; ID3D11DeviceContext* deviceContext = m_deviceContext; KGLOG_PROCESS_ERROR(deviceContext); { RTSaveInfo info = s_RTSaveInfoStack.top(); s_RTSaveInfoStack.pop(); deviceContext->OMSetRenderTargets(1, &info.RTView, info.RTStencil); SAFE_RELEASE(info.RTView); SAFE_RELEASE(info.RTStencil); } hresult = S_OK; Exit0: return hresult; }
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(); }
// WinMain int APIENTRY _tWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow ) { HRESULT hr; // ウィンドウクラスを登録 WNDCLASSEX wcex = { sizeof( WNDCLASSEX ), // cbSize CS_HREDRAW | CS_VREDRAW, // style WndProc, // lpfnWndProc 0, // cbClsExtra 0, // cbWndExtra hInstance, // hInstance NULL, // hIcon NULL, // hCursor ( HBRUSH )( COLOR_WINDOW + 1 ), // hbrBackGround NULL, // lpszMenuName g_className, // lpszClassName NULL // hIconSm }; if ( ! RegisterClassEx( &wcex ) ) { MessageBox( NULL, _T( "失敗: RegisterClassEx()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "RegisterClassEx: ok\n" ) ); // ウィンドウサイズを計算 RECT r = { 0, 0, 800, 450 }; // 800x450 (16:9) if ( ! AdjustWindowRect( &r, WS_OVERLAPPEDWINDOW, FALSE ) ) { MessageBox( NULL, _T( "失敗: AdjustWindowRect()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "AdjustWindowRect: ok (%d, %d)-(%d, %d)\n" ), r.left, r.top, r.right, r.bottom ); // ウィンドウ生成 HWND hWnd; hWnd = CreateWindow( g_className, g_windowName, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, r.right - r.left, r.bottom - r.top, NULL, NULL, hInstance, NULL ); if ( hWnd == NULL ) { MessageBox( NULL, _T( "失敗: CreateWindow()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "CreateWindow: ok\n" ) ); // ウィンドウ表示 ShowWindow(hWnd, nCmdShow); dtprintf( _T( "ShowWindow: ok\n" ) ); // スワップチェイン設定 DXGI_SWAP_CHAIN_DESC scDesc = { { 1280, // BufferDesc.Width 720, // BufferDesc.Height { 60, // BufferDesc.RefreshRate.Numerator 1 // BufferDesc.RefreshRate.Denominator }, DXGI_FORMAT_R16G16B16A16_FLOAT, // BufferDesc.Format DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED, // BufferDesc.ScanlineOrdering DXGI_MODE_SCALING_CENTERED // BufferDesc.Scaling }, { 1, // SampleDesc.Count 0 // SampleDesc.Quality }, DXGI_USAGE_RENDER_TARGET_OUTPUT, // BufferUsage 1, // BufferCount hWnd, // OutputWindow TRUE, // Windowed DXGI_SWAP_EFFECT_DISCARD, // SwapEffect DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH // Flags }; // Direct3D11 デバイス・デバイスコンテキスト・スワップチェーンを生成 ID3D11Device * pDevice = NULL; ID3D11DeviceContext * pDeviceContext = NULL; IDXGISwapChain * pSwapChain = NULL; D3D_FEATURE_LEVEL feature; hr = D3D11CreateDeviceAndSwapChain( NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, NULL, 0, D3D11_SDK_VERSION, &scDesc, &pSwapChain, &pDevice, &feature, &pDeviceContext ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: D3D11CreateDeviceAndSwapChain()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "D3D11CreateDeviceAndSwapChain: ok (pDevice: 0x%p, pDeviceContext: 0x%p, pSwapChain: 0x%p, feature: 0x%4x)\n" ), pDevice, pDeviceContext, pSwapChain, ( int ) feature ); // バックバッファテクスチャを取得 ID3D11Texture2D * pBackBuffer = NULL; hr = pSwapChain->GetBuffer( 0, __uuidof( pBackBuffer ), reinterpret_cast< void ** >( &pBackBuffer ) ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: IDXGISwapChain::GetBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "IDXGISwapChain::GetBuffer: ok (pBackBuffer: 0x%p)\n" ), pBackBuffer ); // レンダーターゲットビューを生成 ID3D11RenderTargetView * pRenderTargetView = NULL; hr = pDevice->CreateRenderTargetView( pBackBuffer, NULL, &pRenderTargetView ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRenderTargetView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateRenderTargetView: ok (pRenderTargetView: 0x%p)\n" ), pRenderTargetView ); // デプス・ステンシルバッファとなるテクスチャを生成 D3D11_TEXTURE2D_DESC depthStencilBufferDesc = { 1280, // Width 720, // Height 1, // MipLevels 1, // ArraySize DXGI_FORMAT_D32_FLOAT, // Format { 1, // SampleDesc.Count 0 // SampleDesc.Quality }, D3D11_USAGE_DEFAULT, // Usage D3D11_BIND_DEPTH_STENCIL, // BindFlags 0, // CPUAccessFlags 0 // MiscFlags }; ID3D11Texture2D * pDepthStencilBuffer = NULL; hr = pDevice->CreateTexture2D( &depthStencilBufferDesc, NULL, &pDepthStencilBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateTexture2D()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateTexture2D: ok (pDepthStencilBuffer: 0x%p)\n" ), pDepthStencilBuffer ); // デプス・ステンシルビューを生成 ID3D11DepthStencilView * pDepthStencilView = NULL; hr = pDevice->CreateDepthStencilView( pDepthStencilBuffer, NULL, &pDepthStencilView ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateDepthStencilView()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateDepthStencilView: ok (pDepthStencilView: 0x%p)\n" ), pDepthStencilView ); // レンダーターゲットビューとデプス・ステンシルビューをバインド ID3D11RenderTargetView * pRenderTargetViews[] = { pRenderTargetView }; pDeviceContext->OMSetRenderTargets( 1, pRenderTargetViews, pDepthStencilView ); dtprintf( _T( "ID3D11DeviceContext::OMSetRenderTargets: ok\n" ) ); // バックバッファはもうここでは使わない COM_SAFE_RELEASE( pBackBuffer ); // ビューポートをバインド D3D11_VIEWPORT viewport = { 0.0f, // TopLeftX 0.0f, // TopLeftY 1280.0f, // Width 720.0f, // Height 0.0f, // MinDepth 1.0f // MaxDepth }; pDeviceContext->RSSetViewports( 1, &viewport ); dtprintf( _T( "ID3D11DeviceContext::RSSetViewports: ok\n" ) ); // 頂点データ float vertices[ 8 ][ 7 ] = { // Xaxis Yaxis Zaxis 赤 緑 青 Alpha { -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f }, // 手前左上 { 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f }, // 手前右上 { 0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f }, // 手前右下 { -0.5f, -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f }, // 手前左下 { -0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f }, // 奥左上 { 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 1.0f, 1.0f }, // 奥右上 { 0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 0.0f, 1.0f }, // 奥右下 { -0.5f, -0.5f, -0.5f, 1.0f, 1.0f, 1.0f, 1.0f } // 奥左下 }; // 頂点バッファを生成 D3D11_BUFFER_DESC vertexBufferDesc = { sizeof( vertices ), // ByteWidth D3D11_USAGE_DEFAULT, // Usage D3D11_BIND_VERTEX_BUFFER, // BindFlags 0, // CPUAccessFlags 0, // MiscFlags 0 // StructureByteStride }; D3D11_SUBRESOURCE_DATA vertexResourceData = { vertices }; ID3D11Buffer * pVertexBuffer = NULL; hr = pDevice->CreateBuffer( &vertexBufferDesc, &vertexResourceData, &pVertexBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVertexBuffer: 0x%p)\n" ), pVertexBuffer ); // 頂点バッファをバインド UINT strides[] = { sizeof( float ) * 7 }; UINT offsets[] = { 0 }; pDeviceContext->IASetVertexBuffers( 0, 1, &pVertexBuffer, strides, offsets ); dtprintf( _T( "ID3D11DeviceContext::IASetVertexBuffers: ok\n" ) ); // インデックスデータ unsigned int indices[] = { 0, 1, 2, 0, 2, 3, // 手前 4, 0, 3, 4, 3, 7, // 左 1, 5, 6, 1, 6, 2, // 右 0, 4, 5, 0, 5, 1, // 上 2, 6, 7, 2, 7, 3, // 下 5, 4, 7, 5, 7, 6 }; // 裏 // インデックスバッファを生成 D3D11_BUFFER_DESC indexBufferDesc = { sizeof( indices ), // ByteWidth D3D11_USAGE_DEFAULT, // Usage D3D11_BIND_INDEX_BUFFER, // BindFlags 0, // CPUAccessFlags 0, // MiscFlags 0 // StructureByteStride }; D3D11_SUBRESOURCE_DATA indexResourceData = { indices }; ID3D11Buffer * pIndexBuffer = NULL; hr = pDevice->CreateBuffer( &indexBufferDesc, &indexResourceData, &pIndexBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pIndexBuffer: 0x%p)\n" ), pIndexBuffer ); // インデックスバッファをバインド pDeviceContext->IASetIndexBuffer( pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 ); dtprintf( _T( "ID3D11DeviceContext::IASetIndexBuffer: ok\n" ) ); // プリミティブタイプを設定 pDeviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST ); dtprintf( _T( "ID3D11DeviceContext::IASetPrimitiveTopology: ok\n" ) ); // 頂点シェーダ用の定数バッファを作成 D3D11_BUFFER_DESC VSConstantBufferDesc = { sizeof( D3DXMATRIX ) * 3, // ByteWidth D3D11_USAGE_DYNAMIC, // Usage D3D11_BIND_CONSTANT_BUFFER, // BindFlags D3D11_CPU_ACCESS_WRITE, // CPUAccessFlags 0, // MiscFlags 0 // StructureByteStride }; ID3D11Buffer * pVSConstantBuffer = NULL; hr = pDevice->CreateBuffer( &VSConstantBufferDesc, NULL, &pVSConstantBuffer ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateBuffer()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateBuffer: ok (pVSConstantBuffer: 0x%p)\n" ), pVSConstantBuffer ); // 定数バッファをバインド pDeviceContext->VSSetConstantBuffers( 0, 1, &pVSConstantBuffer ); dtprintf( _T( "ID3D11DeviceContext::VSSetConstantBuffers: ok\n" ) ); // 頂点シェーダを作成 ID3D11VertexShader * pVertexShader = NULL; hr = pDevice->CreateVertexShader( g_vs_perspective, sizeof( g_vs_perspective ), NULL, &pVertexShader ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateVertexShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateVertexShader: ok (pVertexShader: 0x%p)\n" ), pVertexShader ); // ピクセルシェーダを作成 ID3D11PixelShader * pPixelShader = NULL; hr = pDevice->CreatePixelShader( g_ps_constant, sizeof( g_ps_constant ), NULL, &pPixelShader ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreatePixelShader()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreatePixelShader: ok (pPixelShader: 0x%p)\n" ), pPixelShader ); // シェーダをバインド pDeviceContext->VSSetShader( pVertexShader, NULL, 0 ); dtprintf( _T( "ID3D11DeviceContext::VSSetShader: ok\n" ) ); pDeviceContext->PSSetShader( pPixelShader, NULL, 0 ); dtprintf( _T( "ID3D11DeviceContext::PSSetShader: ok\n" ) ); pDeviceContext->GSSetShader( NULL, NULL, 0 ); pDeviceContext->HSSetShader( NULL, NULL, 0 ); pDeviceContext->DSSetShader( NULL, NULL, 0 ); // 入力エレメント記述子 D3D11_INPUT_ELEMENT_DESC verticesDesc[] = { { "IN_POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "IN_COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, sizeof(float)*3, D3D11_INPUT_PER_VERTEX_DATA, 0 } }; // 入力レイアウトを生成 ID3D11InputLayout * pInputLayout = NULL; hr = pDevice->CreateInputLayout( verticesDesc, 2, g_vs_perspective, sizeof( g_vs_perspective ), &pInputLayout ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateInputLayout()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateInputLayout: ok (pInputLayout: 0x%p)\n" ), pInputLayout ); // 入力レイアウトをバインド pDeviceContext->IASetInputLayout( pInputLayout ); dtprintf( _T( "ID3D11DeviceContext::IASetInputLayout: ok\n" ) ); // ラスタライザステートを生成 D3D11_RASTERIZER_DESC rasterizerStateDesc = { D3D11_FILL_SOLID, // FillMode // D3D11_FILL_WIREFRAME, // FillMode (ワイヤーフレーム表示) D3D11_CULL_BACK, // CullMode // D3D11_CULL_NONE, // CullMode (カリングなし) FALSE, // FrontCounterClockwise 0, // DepthBias 0.0f, // DepthBiasClamp 0.0f, // SlopeScaledDepthBias TRUE, // DepthClipEnable FALSE, // ScissorEnable FALSE, // MultisampleEnable FALSE // AntialiasedLineEnable }; ID3D11RasterizerState * pRasterizerState = NULL; hr = pDevice->CreateRasterizerState( &rasterizerStateDesc, &pRasterizerState ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateRasterizerState()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateRasterizerState: ok (pRasterizerState: 0x%p)\n" ), pRasterizerState ); // ラスタライザステートをバインド pDeviceContext->RSSetState( pRasterizerState ); dtprintf( _T( "ID3D11DeviceContext::RSSetState: ok\n" ) ); // デプス・ステンシルステートを生成 D3D11_DEPTH_STENCIL_DESC depthStencilStateDesc = { TRUE, // DepthEnable D3D11_DEPTH_WRITE_MASK_ALL, // DepthWriteMask D3D11_COMPARISON_LESS, // DepthFunc FALSE, // StencilEnable D3D11_DEFAULT_STENCIL_READ_MASK, // StencilReadMask D3D11_DEFAULT_STENCIL_WRITE_MASK, // StencilWriteMask { D3D11_STENCIL_OP_KEEP, // FrontFace.StencilFailOp D3D11_STENCIL_OP_KEEP, // FrontFace.StencilDepthFailOp D3D11_STENCIL_OP_KEEP, // FrontFace.StencilPassOp D3D11_COMPARISON_ALWAYS // FrontFace.StencilFunc }, { D3D11_STENCIL_OP_KEEP, // BackFace.StencilFailOp D3D11_STENCIL_OP_KEEP, // BackFace.StencilDepthFailOp D3D11_STENCIL_OP_KEEP, // BackFace.StencilPassOp D3D11_COMPARISON_ALWAYS // BackFace.StencilFunc } }; ID3D11DepthStencilState * pDepthStencilState = NULL; hr = pDevice->CreateDepthStencilState( &depthStencilStateDesc, &pDepthStencilState ); if ( FAILED( hr ) ) { MessageBox( NULL, _T( "失敗: ID3D11Device::CreateDepthStencilState()" ), _T( "エラー" ), MB_OK | MB_ICONERROR ); return 0; } dtprintf( _T( "ID3D11Device::CreateDepthStencilState: ok (pDepthStencilState: 0x%p)\n" ), pDepthStencilState ); // デプス・ステンシルステートをバインド pDeviceContext->OMSetDepthStencilState( pDepthStencilState, 0 ); dtprintf( _T( "ID3D11DeviceContext::OMSetDepthStencilState: ok\n" ) ); MSG msg; while ( 1 ) { // メッセージを取得 if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) { if ( msg.message == WM_QUIT ) { dtprintf( _T( "PeekMessage: WM_QUIT\n" ) ); break; } // メッセージ処理 DispatchMessage( &msg ); } else { HRESULT hr; static unsigned int count = 0; float theta = ( count++ / 200.0f ) * ( 3.141593f / 2.0f ); // World-View-Projection 行列をそれぞれ生成 D3DXMATRIX world, view, projection; D3DXMatrixIdentity( &world ); const D3DXVECTOR3 eye( 1.8f * 1.414214f * -cosf( theta ), 1.8f, 1.8f * 1.414214f * sinf( theta ) ); const D3DXVECTOR3 at( 0.0f, 0.0f, 0.0f ); const D3DXVECTOR3 up( 0.0f, 1.0f, 0.0f ); D3DXMatrixLookAtRH( &view, &eye, &at, &up ); D3DXMatrixPerspectiveFovRH( &projection, 3.141593f / 4.0f, 1280.0f / 720.0f, 1.0f, 10000.0f ); // 頂点シェーダ用定数バッファへアクセス D3D11_MAPPED_SUBRESOURCE mapped; hr = pDeviceContext->Map( pVSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped ); if ( SUCCEEDED( hr ) ) { D3DXMATRIX * mapped_m = static_cast< D3DXMATRIX * >( mapped.pData ); mapped_m[0] = world; mapped_m[1] = view; mapped_m[2] = projection; // 後始末 pDeviceContext->Unmap( pVSConstantBuffer, 0 ); } // レンダーターゲットビューをクリア const float clear[ 4 ] = { 0.0f, 0.0f, 0.3f, 1.0f }; // RGBA pDeviceContext->ClearRenderTargetView( pRenderTargetView, clear ); // デプス・ステンシルビューをクリア pDeviceContext->ClearDepthStencilView( pDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0 ); // 描画 pDeviceContext->DrawIndexed( 36, 0, 0 ); pSwapChain->Present( 1, 0 ); // ちょっとだけ待つ Sleep( 5 ); } } // シェーダをアンバインド pDeviceContext->VSSetShader( NULL, NULL, 0 ); pDeviceContext->PSSetShader( NULL, NULL, 0 ); // デバイス・リソース解放 COM_SAFE_RELEASE( pDepthStencilState ); COM_SAFE_RELEASE( pRasterizerState ); COM_SAFE_RELEASE( pInputLayout ); COM_SAFE_RELEASE( pPixelShader ); COM_SAFE_RELEASE( pVertexShader ); COM_SAFE_RELEASE( pVSConstantBuffer ); COM_SAFE_RELEASE( pIndexBuffer ); COM_SAFE_RELEASE( pVertexBuffer ); COM_SAFE_RELEASE( pDepthStencilView ); COM_SAFE_RELEASE( pDepthStencilBuffer ); COM_SAFE_RELEASE( pRenderTargetView ); COM_SAFE_RELEASE( pSwapChain ); COM_SAFE_RELEASE( pDeviceContext ); COM_SAFE_RELEASE( pDevice ); return msg.wParam; }
void CRenderCaptureDX::BeginRender() { ID3D11DeviceContext* pContext = g_Windowing.Get3D11Context(); ID3D11Device* pDevice = g_Windowing.Get3D11Device(); CD3D11_QUERY_DESC queryDesc(D3D11_QUERY_EVENT); if (!m_asyncChecked) { m_asyncSupported = SUCCEEDED(pDevice->CreateQuery(&queryDesc, nullptr)); if (m_flags & CAPTUREFLAG_CONTINUOUS) { if (!m_asyncSupported) CLog::Log(LOGWARNING, "CRenderCaptureDX: D3D11_QUERY_OCCLUSION not supported, performance might suffer"); if (!UseOcclusionQuery()) CLog::Log(LOGWARNING, "CRenderCaptureDX: D3D11_QUERY_OCCLUSION disabled, performance might suffer"); } m_asyncChecked = true; } HRESULT result; if (m_surfaceWidth != m_width || m_surfaceHeight != m_height) { SAFE_RELEASE(m_renderSurface); SAFE_RELEASE(m_copySurface); CD3D11_TEXTURE2D_DESC texDesc(DXGI_FORMAT_B8G8R8A8_UNORM, m_width, m_height, 1, 1, D3D11_BIND_RENDER_TARGET); result = pDevice->CreateTexture2D(&texDesc, nullptr, &m_renderTexture); if (FAILED(result)) { CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateTexture2D (RENDER_TARGET) failed %s", g_Windowing.GetErrorDescription(result).c_str()); SetState(CAPTURESTATE_FAILED); return; } CD3D11_RENDER_TARGET_VIEW_DESC rtDesc(D3D11_RTV_DIMENSION_TEXTURE2D); result = pDevice->CreateRenderTargetView(m_renderTexture, &rtDesc, &m_renderSurface); if (FAILED(result)) { CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateRenderTargetView failed %s", g_Windowing.GetErrorDescription(result).c_str()); SetState(CAPTURESTATE_FAILED); return; } texDesc.BindFlags = 0; texDesc.Usage = D3D11_USAGE_STAGING; texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ; result = pDevice->CreateTexture2D(&texDesc, nullptr, &m_copySurface); if (FAILED(result)) { CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateTexture2D (USAGE_STAGING) failed %s", g_Windowing.GetErrorDescription(result).c_str()); SetState(CAPTURESTATE_FAILED); return; } m_surfaceWidth = m_width; m_surfaceHeight = m_height; } if (m_bufferSize != m_width * m_height * 4) { m_bufferSize = m_width * m_height * 4; av_freep(&m_pixels); m_pixels = (uint8_t*)av_malloc(m_bufferSize); } pContext->OMSetRenderTargets(1, &m_renderSurface, nullptr); if (m_asyncSupported && UseOcclusionQuery()) { //generate an occlusion query if we don't have one if (!m_query) { result = pDevice->CreateQuery(&queryDesc, &m_query); if (FAILED(result)) { CLog::Log(LOGERROR, "CRenderCaptureDX::BeginRender: CreateQuery failed %s", g_Windowing.GetErrorDescription(result).c_str()); m_asyncSupported = false; SAFE_RELEASE(m_query); } } } else { //don't use an occlusion query, clean up any old one SAFE_RELEASE(m_query); } }
void VRender() override { float color[4] = { 0.2f, 0.2f, 0.2f, 1.0f }; // Set up the input assembler mDeviceContext->IASetInputLayout(mInputLayout); mRenderer->VSetPrimitiveType(GPU_PRIMITIVE_TYPE_TRIANGLE); mDeviceContext->RSSetViewports(1, &mRenderer->GetViewport()); mDeviceContext->OMSetRenderTargets(1, mRenderer->GetRenderTargetView(), mRenderer->GetDepthStencilView()); mDeviceContext->ClearRenderTargetView(*mRenderer->GetRenderTargetView(), color); mDeviceContext->ClearDepthStencilView( mRenderer->GetDepthStencilView(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0); mDeviceContext->VSSetShader(mVertexShader, NULL, 0); mDeviceContext->PSSetShader(mPixelShader, NULL, 0); mDeviceContext->UpdateSubresource( mConstantBuffer, 0, NULL, &mMatrixBuffer, 0, 0); mDeviceContext->VSSetConstantBuffers( 0, 1, &mConstantBuffer); // Bezier mDeviceContext->UpdateSubresource(static_cast<DX11Mesh*>(mBezierMesh)->mVertexBuffer, 0, NULL, &mBezierVertices, 0, 0); mRenderer->VSetPrimitiveType(GPU_PRIMITIVE_TYPE_LINE); mRenderer->VBindMesh(mBezierMesh); mRenderer->VDrawIndexed(0, mBezierMesh->GetIndexCount()); // Handles mDeviceContext->UpdateSubresource(static_cast<DX11Mesh*>(mHandlesMesh)->mVertexBuffer, 0, NULL, &mHandlesVertices, 0, 0); mRenderer->VSetPrimitiveType(GPU_PRIMITIVE_TYPE_LINE); mRenderer->VBindMesh(mHandlesMesh); mRenderer->VDrawIndexed(0, mHandlesMesh->GetIndexCount()); // Circles mRenderer->VSetPrimitiveType(GPU_PRIMITIVE_TYPE_TRIANGLE); for (size_t i = 0; i < 4; i++) { mMatrixBuffer.mWorld = (mat4f::scale(mCircleScale) * mat4f::translate(mBezier.p[i])).transpose(); mDeviceContext->UpdateSubresource(mConstantBuffer, 0, NULL, &mMatrixBuffer, 0, 0); mRenderer->VBindMesh(mCircleMesh); mRenderer->VDrawIndexed(0, mCircleMesh->GetIndexCount()); } mRenderer->VSwapBuffers(); }