[idd] project: organize driver sources by responsibility

Group the IDD sources and Visual Studio filters by subsystem.

Split the device and swap-chain implementations into focused units,
rename the context classes, and reduce header coupling.

idd/LGIdd/d3d/CInteropResource.cpp

@@ -0,0 +1,182 @@
+/**
+ * Looking Glass
+ * Copyright © 2017-2026 The Looking Glass Authors
+ * https://looking-glass.io
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include "d3d/CInteropResource.h"
+#include "CDebug.h"
+
+bool CInteropResource::Init(
+  std::shared_ptr<CD3D11Device> dx11Device,
+  std::shared_ptr<CD3D12Device> dx12Device,
+  ComPtr<ID3D11Texture2D> srcTex)
+{
+  HRESULT hr;
+
+  D3D11_TEXTURE2D_DESC srcDesc;
+  srcTex->GetDesc(&srcDesc);
+
+  ComPtr<IDXGIResource1> rSrcTex;
+  hr = srcTex.As(&rSrcTex);
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to obtain the IDXGIResource1 interface");
+    return false;
+  }
+
+  HANDLE h;
+  Wrappers::HandleT<Wrappers::HandleTraits::HANDLENullTraits> sharedHandle;
+  hr = rSrcTex->CreateSharedHandle(NULL, DXGI_SHARED_RESOURCE_READ, NULL, &h);
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to create the shared handle");
+    return false;
+  }
+  sharedHandle.Attach(h);
+
+  ComPtr<ID3D12Resource> dst;
+  hr = dx12Device->GetDevice()->OpenSharedHandle(sharedHandle.Get(), IID_PPV_ARGS(&dst));
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to open the D3D12Resource from the handle");
+    return false;
+  }
+
+  sharedHandle.Close();
+
+  ComPtr<ID3D11Fence> d11Fence;
+  hr = dx11Device->GetDevice()->CreateFence(0, D3D11_FENCE_FLAG_SHARED, IID_PPV_ARGS(&d11Fence));
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to create the d3d11 fence");
+    return false;
+  }
+
+  hr = d11Fence->CreateSharedHandle(NULL, GENERIC_ALL, NULL, &h);
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to create the d3d11 fence shared handle");
+    return false;
+  }
+  sharedHandle.Attach(h);
+
+  ComPtr<ID3D12Fence> d12Fence;
+  hr = dx12Device->GetDevice()->OpenSharedHandle(sharedHandle.Get(), IID_PPV_ARGS(&d12Fence));
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to open the D3D12Fence from the handle");
+    return false;
+  }
+
+  sharedHandle.Close();
+
+  m_dx11Device = dx11Device;
+  m_dx12Device = dx12Device;
+
+  memcpy(&m_format, &srcDesc, sizeof(m_format));
+  m_srcTex       = srcTex.Get();
+  m_d12Res       = dst;
+  m_d11Fence     = d11Fence;
+  m_d12Fence     = d12Fence;
+  m_fenceValue   = 0;
+  m_nbDirtyRects = 0;
+  m_ready        = true;
+
+  return true;
+}
+
+void CInteropResource::Reset()
+{
+  m_ready         = false;
+  m_fenceValue    = 0;
+  m_d12Fence.Reset();
+  m_d11Fence.Reset();
+  m_d12Res  .Reset();
+  m_srcTex       = NULL;
+  m_nbDirtyRects = 0;
+  memset(&m_format, 0, sizeof(m_format));
+
+  m_dx12Device.reset();
+  m_dx11Device.reset();
+}
+
+bool CInteropResource::Compare(
+  const ComPtr<ID3D11Texture2D>& srcTex) const
+{
+  if (srcTex.Get() != m_srcTex)
+    return false;
+
+  D3D11_TEXTURE2D_DESC format;
+  srcTex->GetDesc(&format);
+
+  return
+    m_format.Width  == format.Width  &&
+    m_format.Height == format.Height &&
+    m_format.Format == format.Format;
+}
+
+bool CInteropResource::Signal()
+{
+  const UINT64 fenceValue = m_fenceValue + 1;
+  const HRESULT hr =
+    m_dx11Device->GetContext()->Signal(m_d11Fence.Get(), fenceValue);
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_HR(hr, "Failed to signal the D3D11 source fence");
+    return false;
+  }
+
+  m_fenceValue = fenceValue;
+  return true;
+}
+
+bool CInteropResource::Sync(CD3D12CommandSlot& slot)
+{
+  if (m_d11Fence->GetCompletedValue() >= m_fenceValue)
+    return true;
+
+  if (!slot.WaitFor(m_d12Fence.Get(), m_fenceValue))
+  {
+    DEBUG_ERROR("Failed to queue a wait for the D3D11 source fence");
+    return false;
+  }
+
+  return true;
+}
+
+void CInteropResource::SetFullDamage()
+{
+  m_dirtyRects[0].left   = 0;
+  m_dirtyRects[0].top    = 0;
+  m_dirtyRects[0].right  = m_format.Width;
+  m_dirtyRects[0].bottom = m_format.Height;
+  m_nbDirtyRects = 1;
+}
+
+void CInteropResource::SetDirtyRects(const RECT * dirtyRects, unsigned nbDirtyRects)
+{
+  if (nbDirtyRects > LG_MAX_DIRTY_RECTS)
+  {
+    SetFullDamage();
+    return;
+  }
+
+  if (nbDirtyRects)
+    memcpy(m_dirtyRects, dirtyRects, nbDirtyRects * sizeof(*m_dirtyRects));
+  m_nbDirtyRects = nbDirtyRects;
+}