feat: use DirectComposition to render the QCefView

tishion · tishion · commit c8b04da719f5 · 2025-02-24T22:16:01.000+08:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -122,7 +122,11 @@ elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
   # Disable the sandbox on Windows, because the sandbox.lib is MT which is conflict with Qt
   set(USE_SANDBOX OFF CACHE BOOL "Disable sandbox on Windows" FORCE)
   add_definitions(-DOS_WINDOWS=1)
-  add_compile_options("/M$<IF:$<BOOL:${STATIC_CRT}>,T,D>$<$<CONFIG:Debug>:d>")
+  add_compile_options(
+    /W3
+    /WX
+    /M$<IF:$<BOOL:${STATIC_CRT}>,T,D>$<$<CONFIG:Debug>:d>
+  )
   add_link_options(/DEBUG)
 endif()
 
diff --git a/example/QCefViewTest/MainWindow.cpp b/example/QCefViewTest/MainWindow.cpp
@@ -105,6 +105,12 @@ MainWindow::createRightCefView()
   // m_pRightCefViewWidget = new QCefView(RIGHT_INDEX_URL, &setting, this);
   m_pRightCefViewWidget = new QCefView("https://www.testufo.com/", &setting, this);
 
+  auto vl = new QVBoxLayout(m_pRightCefViewWidget);
+  auto btn = new QPushButton("TEST BUTTON OVERLAY", m_pRightCefViewWidget);
+  vl->setAlignment(Qt::AlignTop);
+  vl->addWidget(btn);
+  m_pRightCefViewWidget->setLayout(vl);
+
   // all the following values will disable the context menu for both NCW and OSR mode
   // m_pRightCefViewWidget->setContextMenuPolicy(Qt::NoContextMenu);
   // m_pRightCefViewWidget->setContextMenuPolicy(Qt::ActionsContextMenu);
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -75,6 +75,7 @@ if(OS_WINDOWS)
     PRIVATE
     d3d11
     d3dcompiler
+    dcomp
   )
 
   add_custom_command(TARGET QCefView
diff --git a/src/win/details/render/hardware/DX11RenderBackend.cpp b/src/win/details/render/hardware/DX11RenderBackend.cpp
@@ -3,6 +3,11 @@
 #include <DirectXMath.h>
 #include <d3dcompiler.h>
 
+#define HR_CHECK(exp)                                                                                                  \
+  if (!(exp)) {                                                                                                        \
+    return false;                                                                                                      \
+  }
+
 using namespace DirectX;
 using namespace Microsoft::WRL;
 
@@ -56,36 +61,83 @@ float4 main(VS_OUTPUT input) : SV_Target
 bool
 DX11RenderBackend::CreateDeviceAndSwapchain()
 {
-  // create device and swapchain
-  DXGI_SWAP_CHAIN_DESC sd = {};
-  sd.BufferCount = 1;
-  sd.BufferDesc.Width = m_width;
-  sd.BufferDesc.Height = m_height;
-  sd.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
-  sd.BufferDesc.RefreshRate.Numerator = 60;
-  sd.BufferDesc.RefreshRate.Denominator = 1;
+  // we don't render directly to the window, but we
+  // use the DirectComposition to render the CefView
+
+  // Create D3D11 device and context
+  ComPtr<ID3D11Device> pD3dDevice;
+  ComPtr<ID3D11DeviceContext> pD3dContext;
+  HR_CHECK(S_OK == ::D3D11CreateDevice(nullptr,
+                                       D3D_DRIVER_TYPE_HARDWARE,
+                                       nullptr,
+                                       0,
+                                       nullptr,
+                                       0,
+                                       D3D11_SDK_VERSION,
+                                       pD3dDevice.ReleaseAndGetAddressOf(),
+                                       nullptr,
+                                       pD3dContext.ReleaseAndGetAddressOf()));
+
+  // Get DXGI device
+  ComPtr<IDXGIDevice1> pDxgiDevice;
+  HR_CHECK(S_OK == pD3dDevice.As(&pDxgiDevice));
+
+  // Get DXGI adapter
+  ComPtr<IDXGIAdapter> pDxgiAdapter;
+  HR_CHECK(S_OK == pDxgiDevice->GetAdapter(pDxgiAdapter.GetAddressOf()));
+
+  // Get DXGI factory
+  ComPtr<IDXGIFactory2> pDxgiFactory2;
+  HR_CHECK(S_OK == pDxgiAdapter->GetParent(IID_PPV_ARGS(pDxgiFactory2.ReleaseAndGetAddressOf())));
+
+  // Create swapchain description
+  DXGI_SWAP_CHAIN_DESC1 sd;
+  ZeroMemory(&sd, sizeof(sd));
+  sd.BufferCount = 2;
+  sd.Width = (UINT)m_width;
+  sd.Height = (UINT)m_height;
+  sd.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
   sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
-  sd.OutputWindow = m_hWnd;
   sd.SampleDesc.Count = 1;
   sd.SampleDesc.Quality = 0;
-  sd.Windowed = TRUE;
-
-  HRESULT hr = ::D3D11CreateDeviceAndSwapChain(nullptr,
-                                               D3D_DRIVER_TYPE_HARDWARE,
-                                               nullptr,
-                                               0,
-                                               nullptr,
-                                               0,
-                                               D3D11_SDK_VERSION,
-                                               &sd,
-                                               m_swapChain.ReleaseAndGetAddressOf(),
-                                               m_d3dDevice.ReleaseAndGetAddressOf(),
-                                               nullptr,
-                                               m_d3dContext.ReleaseAndGetAddressOf());
-  if (FAILED(hr)) {
-    return false;
-  }
-
+  sd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
+  sd.AlphaMode = DXGI_ALPHA_MODE_PREMULTIPLIED;
+  sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+  // Create swapchain
+  ComPtr<IDXGISwapChain1> pSwapChain;
+  HR_CHECK(S_OK == pDxgiFactory2->CreateSwapChainForComposition(
+                     pD3dDevice.Get(), &sd, nullptr, pSwapChain.ReleaseAndGetAddressOf()));
+
+  // Create DComposition device
+  ComPtr<IDCompositionDevice> pDecompositionDevice;
+  HR_CHECK(S_OK ==
+           ::DCompositionCreateDevice(pDxgiDevice.Get(), IID_PPV_ARGS(pDecompositionDevice.ReleaseAndGetAddressOf())));
+
+  // Create DComposition visual
+  ComPtr<IDCompositionVisual> pDCompositionVisual;
+  HR_CHECK(S_OK == pDecompositionDevice->CreateVisual(pDCompositionVisual.ReleaseAndGetAddressOf()));
+
+  // Set swapchain to visual
+  HR_CHECK(S_OK == pDCompositionVisual->SetContent(pSwapChain.Get()));
+
+  // Create DComposition target
+  ComPtr<IDCompositionTarget> pDCompositionTarget;
+  HR_CHECK(S_OK ==
+           pDecompositionDevice->CreateTargetForHwnd(m_hWnd, FALSE, pDCompositionTarget.ReleaseAndGetAddressOf()));
+
+  // Set root to target
+  HR_CHECK(S_OK == pDCompositionTarget->SetRoot(pDCompositionVisual.Get()));
+
+  // Commit
+  HR_CHECK(S_OK == pDecompositionDevice->Commit());
+
+  // Save
+  m_dcompositionTarget = pDCompositionTarget;
+  m_dcompositionDevice = pDecompositionDevice;
+  m_swapChain = pSwapChain;
+  m_d3dContext = pD3dContext;
+  m_d3dDevice = pD3dDevice;
   return true;
 }
 
@@ -123,8 +175,9 @@ DX11RenderBackend::CreateShaderResource()
     { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
     { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
   };
+  ComPtr<ID3D11InputLayout> pInputLayout;
   hr = m_d3dDevice->CreateInputLayout(
-    id, ARRAYSIZE(id), vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), m_inputLayout.ReleaseAndGetAddressOf());
+    id, ARRAYSIZE(id), vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), pInputLayout.ReleaseAndGetAddressOf());
   if (FAILED(hr)) {
     return false;
   }
@@ -146,12 +199,15 @@ DX11RenderBackend::CreateShaderResource()
     return false;
   }
 
+  ComPtr<ID3D11PixelShader> pPixelShader;
   hr = m_d3dDevice->CreatePixelShader(
-    psBlob->GetBufferPointer(), psBlob->GetBufferSize(), nullptr, m_pixelShader.ReleaseAndGetAddressOf());
+    psBlob->GetBufferPointer(), psBlob->GetBufferSize(), nullptr, pPixelShader.ReleaseAndGetAddressOf());
   if (FAILED(hr)) {
     return false;
   }
 
+  m_inputLayout = pInputLayout;
+  m_pixelShader = pPixelShader;
   return true;
 }
 
@@ -225,18 +281,26 @@ DX11RenderBackend::CreateRenderTarget()
   vdesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
   vdesc.Texture2D.MipSlice = 0;
   vdesc.Format = desc.BufferDesc.Format;
-  hr = m_d3dDevice->CreateRenderTargetView(pBackBuffer.Get(), &vdesc, m_renderTargetView.ReleaseAndGetAddressOf());
+  ComPtr<ID3D11RenderTargetView> pRenderTargetView;
+  hr = m_d3dDevice->CreateRenderTargetView(pBackBuffer.Get(), nullptr, pRenderTargetView.ReleaseAndGetAddressOf());
   if (FAILED(hr)) {
     return false;
   }
 
   // create vertex buffer
-  return CreateQuadVertexBuffer(0.0f,                                       //
-                                0.0f,                                       //
-                                m_width,                                    //
-                                m_height,                                   //
-                                m_viewVertexBuffer.ReleaseAndGetAddressOf() //
-  );
+  ComPtr<ID3D11Buffer> pViewVertexBuffer;
+  if (!CreateQuadVertexBuffer(0.0f,                                      //
+                              0.0f,                                      //
+                              static_cast<float>(m_width),               //
+                              static_cast<float>(m_height),              //
+                              pViewVertexBuffer.ReleaseAndGetAddressOf() //
+                              )) {
+    return false;
+  }
+
+  m_renderTargetView = pRenderTargetView;
+  m_viewVertexBuffer = pViewVertexBuffer;
+  return true;
 }
 
 void
@@ -393,6 +457,13 @@ DX11RenderBackend::UpdateTextureResource(Microsoft::WRL::ComPtr<ID3D11Texture2D>
   targetTextureDesc = sharedTextureDesc;
 }
 
+void
+DX11RenderBackend::SetTargetView()
+{
+  ID3D11RenderTargetView* rtvList[] = { m_renderTargetView.Get() };
+  m_d3dContext->OMSetRenderTargets(ARRAYSIZE(rtvList), rtvList, nullptr);
+}
+
 void
 DX11RenderBackend::ClearTargetView()
 {
@@ -545,8 +616,8 @@ DX11RenderBackend::resize(int width, int height, float scale)
 
   // update size
   m_scale = scale;
-  m_width = width * scale;
-  m_height = height * scale;
+  m_width = static_cast<int>(width * scale);
+  m_height = static_cast<int>(height * scale);
 
   // remove current render target
   m_d3dContext->OMSetRenderTargets(0, nullptr, nullptr);
@@ -589,10 +660,11 @@ void
 DX11RenderBackend::updatePopupRect(const CefRect& rect)
 {
   CefRect newRect = rect;
-  newRect.x *= m_scale;
-  newRect.y *= m_scale;
-  newRect.width *= m_scale;
-  newRect.height *= m_scale;
+  newRect.x = static_cast<int>(newRect.x * m_scale);
+  newRect.y = static_cast<int>(newRect.y * m_scale);
+  newRect.width = static_cast<int>(newRect.width * m_scale);
+  newRect.height = static_cast<int>(newRect.height * m_scale);
+
   if (newRect == m_popupRect) {
     return;
   }
@@ -601,10 +673,10 @@ DX11RenderBackend::updatePopupRect(const CefRect& rect)
   m_popupRect = newRect;
 
   // create vertex buffer
-  CreateQuadVertexBuffer(m_popupRect.x,                               //
-                         m_popupRect.y,                               //
-                         m_popupRect.width,                           //
-                         m_popupRect.height,                          //
+  CreateQuadVertexBuffer(static_cast<float>(m_popupRect.x),           //
+                         static_cast<float>(m_popupRect.y),           //
+                         static_cast<float>(m_popupRect.width),       //
+                         static_cast<float>(m_popupRect.height),      //
                          m_popupVertexBuffer.ReleaseAndGetAddressOf() //
   );
 }
@@ -650,6 +722,8 @@ DX11RenderBackend::render(void* painter)
 {
   std::lock_guard<std::mutex> l(m_d3dContextLock);
 
+  SetTargetView();
+
   ClearTargetView();
 
   DrawCefView();
diff --git a/src/win/details/render/hardware/DX11RenderBackend.h b/src/win/details/render/hardware/DX11RenderBackend.h
@@ -6,6 +6,9 @@
 #include <d3d11.h>
 #include <d3d11_1.h>
 #include <d3d11_2.h>
+#include <dcomp.h>
+#include <dxgi.h>
+#include <dxgi1_2.h>
 #include <wrl.h>
 
 #include <mutex>
@@ -27,11 +30,15 @@ class DX11RenderBackend : public ICefViewRenderer
   int m_width = 800;
   int m_height = 600;
 
+  // lock
+  std::mutex m_d3dContextLock;
+
   // device/context/swapchain
   Microsoft::WRL::ComPtr<ID3D11Device> m_d3dDevice;
   Microsoft::WRL::ComPtr<ID3D11DeviceContext> m_d3dContext;
-  Microsoft::WRL::ComPtr<IDXGISwapChain> m_swapChain;
-  std::mutex m_d3dContextLock;
+  Microsoft::WRL::ComPtr<IDCompositionDevice> m_dcompositionDevice;
+  Microsoft::WRL::ComPtr<IDCompositionTarget> m_dcompositionTarget;
+  Microsoft::WRL::ComPtr<IDXGISwapChain1> m_swapChain;
 
   // IA stage
   Microsoft::WRL::ComPtr<ID3D11InputLayout> m_inputLayout;
@@ -82,6 +89,7 @@ class DX11RenderBackend : public ICefViewRenderer
                              Microsoft::WRL::ComPtr<ID3D11ShaderResourceView>& pTargetSRV,
                              D3D11_TEXTURE2D_DESC& targetTextureDesc);
 
+  void SetTargetView();
   void ClearTargetView();
   void DrawCefView();
   void DrawCefPopup();
diff --git a/thirdparty/CMakeLists.txt b/thirdparty/CMakeLists.txt
@@ -1,7 +1,7 @@
 include(FetchContent)
 
 if(NOT CEFVIEW_CORE_VERSION)
-    set(DEFAULT_CEFVIEW_CORE_VERSION "bb1cbae4bce755e88bb89fea3c5ab31e47b44b65")
+    set(DEFAULT_CEFVIEW_CORE_VERSION "ca9f2c009a6a248a13ff0a2e33bbf46e7a044581")
     set(CEFVIEW_CORE_VERSION ${DEFAULT_CEFVIEW_CORE_VERSION})
     message(STATUS "CEFVIEW_CORE_VERSION not set, use default value:${CEFVIEW_CORE_VERSION}")
 endif()

Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,7 @@ if(OS_WINDOWS)`
`75`	`75`	`PRIVATE`
`76`	`76`	`d3d11`
`77`	`77`	`d3dcompiler`
	`78`	`+ dcomp`
`78`	`79`	`)`
`79`	`80`
`80`	`81`	`add_custom_command(TARGET QCefView`