Merge pull request #3 from nefarius/wil-modernization

Introduced Windows Implementation Library

Author: nefarius

CMakeLists.txt

@@ -5,6 +5,7 @@ set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(imgui CONFIG REQUIRED)
+find_package(WIL CONFIG REQUIRED)
 
 file(GLOB_RECURSE SOURCE_FILES src/*.cpp)
 file(GLOB_RECURSE HEADER_FILES src/*.h)
@@ -22,6 +23,7 @@ target_include_directories(MultiPadTester PRIVATE src res)
 
 target_link_libraries(MultiPadTester PRIVATE
     imgui::imgui
+    WIL::WIL
     d3d11.lib
     d3dcompiler.lib
     dxgi.lib

src/d3d_helpers.cpp

@@ -44,7 +44,7 @@ bool D3DContext::Create(const HWND hwnd, const int refreshRatePreferred)
 	if (D3D11CreateDeviceAndSwapChain(
 		nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
 		levels.data(), levels.size(), D3D11_SDK_VERSION,
-		&sd, &swapChain, &device, &obtained, &deviceCtx) != S_OK)
+		&sd, swapChain.put(), device.put(), &obtained, deviceCtx.put()) != S_OK)
 		return false;
 
 	CreateRTV();
@@ -53,39 +53,22 @@ bool D3DContext::Create(const HWND hwnd, const int refreshRatePreferred)
 
 void D3DContext::CreateRTV()
 {
-	ID3D11Texture2D* back = nullptr;
-	swapChain->GetBuffer(0, IID_PPV_ARGS(&back));
-	device->CreateRenderTargetView(back, nullptr, &rtv);
-	back->Release();
+	wil::com_ptr<ID3D11Texture2D> back;
+	swapChain->GetBuffer(0, IID_PPV_ARGS(back.put()));
+	device->CreateRenderTargetView(back.get(), nullptr, rtv.put());
 }
 
 void D3DContext::CleanupRTV()
 {
-	if (rtv)
-	{
-		rtv->Release();
-		rtv = nullptr;
-	}
+	rtv.reset();
 }
 
 void D3DContext::Cleanup()
 {
 	CleanupRTV();
-	if (swapChain)
-	{
-		swapChain->Release();
-		swapChain = nullptr;
-	}
-	if (deviceCtx)
-	{
-		deviceCtx->Release();
-		deviceCtx = nullptr;
-	}
-	if (device)
-	{
-		device->Release();
-		device = nullptr;
-	}
+	swapChain.reset();
+	deviceCtx.reset();
+	device.reset();
 }
 
 void D3DContext::Resize(LPARAM lParam)

src/d3d_helpers.h

@@ -1,13 +1,14 @@
 #pragma once
 #include <d3d11.h>
 #include <dxgi.h>
+#include <wil/com.h>
 
 struct D3DContext
 {
-	ID3D11Device* device = nullptr;
-	ID3D11DeviceContext* deviceCtx = nullptr;
-	IDXGISwapChain* swapChain = nullptr;
-	ID3D11RenderTargetView* rtv = nullptr;
+	wil::com_ptr<ID3D11Device> device;
+	wil::com_ptr<ID3D11DeviceContext> deviceCtx;
+	wil::com_ptr<IDXGISwapChain> swapChain;
+	wil::com_ptr<ID3D11RenderTargetView> rtv;
 
 	[[nodiscard]] bool Create(HWND hwnd, int refreshRatePreferred = 60);
 	void CreateRTV();

src/dinput_backend.cpp

@@ -10,11 +10,7 @@
 DInputBackend::~DInputBackend()
 {
 	ReleaseDevices();
-	if (di_)
-	{
-		di_->Release();
-		di_ = nullptr;
-	}
+	di_.reset();
 }
 
 void DInputBackend::Init(const HWND hwnd)
@@ -25,7 +21,7 @@ void DInputBackend::Init(const HWND hwnd)
 		GetWindowLongPtr(hwnd, GWLP_HINSTANCE));
 
 	if (FAILED(DirectInput8Create(hInst, DIRECTINPUT_VERSION,
-		IID_IDirectInput8W, reinterpret_cast<void**>(&di_), nullptr)))
+		IID_IDirectInput8W, reinterpret_cast<void**>(di_.put()), nullptr)))
 		return;
 
 	EnumerateDevices();
@@ -38,7 +34,7 @@ void DInputBackend::ReleaseDevices()
 		if (d.device)
 		{
 			d.device->Unacquire();
-			d.device->Release();
+			d.device.reset();
 		}
 		if (d.slot >= 0 && d.slot < kMaxDevices)
 			states_[d.slot] = GamepadState{};
@@ -197,7 +193,7 @@ void DInputBackend::EnumerateDevices()
 		if (d.device)
 		{
 			d.device->Unacquire();
-			d.device->Release();
+			d.device.reset();
 		}
 		return true;
 	});
@@ -211,21 +207,19 @@ bool DInputBackend::SetupDevice(
 	info.productId = static_cast<uint16_t>(HIWORD(inst.guidProduct.Data1));
 	info.productName = inst.tszProductName;
 
-	if (FAILED(di_->CreateDevice(inst.guidInstance, &info.device, nullptr)))
+	if (FAILED(di_->CreateDevice(inst.guidInstance, info.device.put(), nullptr)))
 		return false;
 
 	if (FAILED(info.device->SetDataFormat(&c_dfDIJoystick2)))
 	{
-		info.device->Release();
-		info.device = nullptr;
+		info.device.reset();
 		return false;
 	}
 
 	if (FAILED(info.device->SetCooperativeLevel(
 		hwnd_, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE)))
 	{
-		info.device->Release();
-		info.device = nullptr;
+		info.device.reset();
 		return false;
 	}
 
@@ -241,8 +235,7 @@ bool DInputBackend::SetupDevice(
 	int s = AllocateSlot();
 	if (s < 0)
 	{
-		info.device->Release();
-		info.device = nullptr;
+		info.device.reset();
 		return false;
 	}
 	info.slot = s;

src/dinput_backend.h

@@ -8,6 +8,7 @@
 #endif
 #include <dinput.h>
 #include <vector>
+#include <wil/com.h>
 
 class DInputBackend final : public IInputBackend
 {
@@ -49,11 +50,11 @@ class DInputBackend final : public IInputBackend
 	[[nodiscard]] const char* GetName() const override;
 	[[nodiscard]] const char* GetSlotDisplayName(int slot) const override;
 
-private:
+	private:
 	struct DeviceInfo
 	{
 		GUID instanceGuid{};
-		IDirectInputDevice8W* device = nullptr;
+		wil::com_ptr<IDirectInputDevice8W> device;
 		int slot = -1;
 		bool found = false;
 		uint16_t vendorId = 0;
@@ -62,7 +63,7 @@ class DInputBackend final : public IInputBackend
 	};
 
 	HWND hwnd_ = nullptr;
-	IDirectInput8W* di_ = nullptr;
+	wil::com_ptr<IDirectInput8W> di_;
 	std::vector<DeviceInfo> devices_;
 	GamepadState states_[kMaxDevices]{};
 	int pollCounter_ = 0;

src/hidapi_backend.cpp

@@ -20,24 +20,16 @@ HidApiBackend::~HidApiBackend()
 
 void HidApiBackend::CloseDevice(DeviceInfo& dev)
 {
-	if (dev.handle != INVALID_HANDLE_VALUE)
+	if (dev.handle.is_valid())
 	{
 		if (dev.readPending)
-			CancelIo(dev.handle);
-		CloseHandle(dev.handle);
-		dev.handle = INVALID_HANDLE_VALUE;
-	}
-	if (dev.overlapped.hEvent)
-	{
-		CloseHandle(dev.overlapped.hEvent);
-		dev.overlapped.hEvent = nullptr;
+			CancelIo(dev.handle.get());
+		dev.handle.reset();
 	}
+	dev.readEvent.reset();
+	dev.overlapped.hEvent = nullptr;
 	dev.readPending = false;
-	if (dev.preparsed)
-	{
-		HidD_FreePreparsedData(dev.preparsed);
-		dev.preparsed = nullptr;
-	}
+	dev.preparsed.reset();
 	dev.readBuf.clear();
 	if (dev.slot >= 0 && dev.slot < kMaxDevices)
 		states_[dev.slot] = GamepadState{};
@@ -62,7 +54,7 @@ void HidApiBackend::Poll()
 	for (auto it = devices_.begin(); it != devices_.end();)
 	{
 		auto& dev = **it;
-		if (dev.handle == INVALID_HANDLE_VALUE)
+		if (!dev.handle.is_valid())
 		{
 			++it;
 			continue;
@@ -76,7 +68,7 @@ void HidApiBackend::Poll()
 		}
 
 		DWORD bytesRead = 0;
-		BOOL ok = GetOverlappedResult(dev.handle, &dev.overlapped,
+		BOOL ok = GetOverlappedResult(dev.handle.get(), &dev.overlapped,
 		                              &bytesRead, FALSE);
 		if (ok)
 		{
@@ -228,40 +220,35 @@ bool HidApiBackend::OpenAndSetup(const wchar_t* path, DeviceInfo& info)
 	if (h == INVALID_HANDLE_VALUE)
 		return false;
 
-	info.handle = h;
+	info.handle.reset(h);
 
 	HIDD_ATTRIBUTES attrs{};
 	attrs.Size = sizeof(attrs);
-	if (HidD_GetAttributes(h, &attrs))
+	if (HidD_GetAttributes(info.handle.get(), &attrs))
 	{
 		info.vendorId = attrs.VendorID;
 		info.productId = attrs.ProductID;
 	}
 
 	PHIDP_PREPARSED_DATA pp = nullptr;
-	if (!HidD_GetPreparsedData(h, &pp))
+	if (!HidD_GetPreparsedData(info.handle.get(), &pp))
 	{
-		CloseHandle(h);
-		info.handle = INVALID_HANDLE_VALUE;
+		info.handle.reset();
 		return false;
 	}
-	info.preparsed = pp;
+	info.preparsed.reset(pp);
 
 	if (HidP_GetCaps(pp, &info.caps) != HIDP_STATUS_SUCCESS)
 	{
-		HidD_FreePreparsedData(pp);
-		info.preparsed = nullptr;
-		CloseHandle(h);
-		info.handle = INVALID_HANDLE_VALUE;
+		info.preparsed.reset();
+		info.handle.reset();
 		return false;
 	}
 
 	if (!IsGamepadOrJoystick(info.caps))
 	{
-		HidD_FreePreparsedData(pp);
-		info.preparsed = nullptr;
-		CloseHandle(h);
-		info.handle = INVALID_HANDLE_VALUE;
+		info.preparsed.reset();
+		info.handle.reset();
 		return false;
 	}
 
@@ -279,10 +266,8 @@ bool HidApiBackend::OpenAndSetup(const wchar_t* path, DeviceInfo& info)
 	int s = AllocateSlot();
 	if (s < 0)
 	{
-		HidD_FreePreparsedData(pp);
-		info.preparsed = nullptr;
-		CloseHandle(h);
-		info.handle = INVALID_HANDLE_VALUE;
+		info.preparsed.reset();
+		info.handle.reset();
 		return false;
 	}
 
@@ -293,7 +278,8 @@ bool HidApiBackend::OpenAndSetup(const wchar_t* path, DeviceInfo& info)
 	info.readBuf.resize(info.caps.InputReportByteLength);
 
 	info.overlapped = {};
-	info.overlapped.hEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
+	info.readEvent.reset(CreateEventW(nullptr, TRUE, FALSE, nullptr));
+	info.overlapped.hEvent = info.readEvent.get();
 
 	StartRead(info);
 	return true;
@@ -303,14 +289,14 @@ bool HidApiBackend::OpenAndSetup(const wchar_t* path, DeviceInfo& info)
 
 void HidApiBackend::StartRead(DeviceInfo& dev)
 {
-	if (dev.handle == INVALID_HANDLE_VALUE) return;
+	if (!dev.handle.is_valid()) return;
 
 	constexpr int kMaxSyncReads = 16;
 	for (int attempt = 0; attempt < kMaxSyncReads; ++attempt)
 	{
 		ResetEvent(dev.overlapped.hEvent);
 		DWORD bytesRead = 0;
-		BOOL ok = ReadFile(dev.handle, dev.readBuf.data(),
+		BOOL ok = ReadFile(dev.handle.get(), dev.readBuf.data(),
 		                   static_cast<DWORD>(dev.readBuf.size()),
 		                   &bytesRead, &dev.overlapped);
 		if (ok)
@@ -353,7 +339,7 @@ void HidApiBackend::ParseReport(DeviceInfo& dev, DWORD bytesRead)
 	if (bytesRead == 0) return;
 	if (dev.slot < 0 || dev.slot >= kMaxDevices) return;
 
-	PHIDP_PREPARSED_DATA pp = dev.preparsed;
+	PHIDP_PREPARSED_DATA pp = dev.preparsed.get();
 	if (!pp) return;
 
 	auto& gs = states_[dev.slot];

src/hidapi_backend.h

@@ -10,6 +10,7 @@
 #include <memory>
 #include <vector>
 #include <string>
+#include <wil/resource.h>
 
 class HidApiBackend final : public IInputBackend
 {
@@ -61,10 +62,22 @@ class HidApiBackend final : public IInputBackend
 	struct DeviceInfo
 	{
 		std::wstring path;
-		HANDLE handle = INVALID_HANDLE_VALUE;
+		wil::unique_hfile handle;
+		wil::unique_handle readEvent;
 		OVERLAPPED overlapped{};
 		std::vector<BYTE> readBuf;
-		PHIDP_PREPARSED_DATA preparsed = nullptr;
+		struct UniquePreparsed
+		{
+			PHIDP_PREPARSED_DATA p = nullptr;
+			UniquePreparsed() = default;
+			explicit UniquePreparsed(PHIDP_PREPARSED_DATA q) : p(q) {}
+			~UniquePreparsed() { reset(); }
+			UniquePreparsed(UniquePreparsed&& other) noexcept : p(other.p) { other.p = nullptr; }
+			UniquePreparsed& operator=(UniquePreparsed&& other) noexcept { reset(other.p); other.p = nullptr; return *this; }
+			void reset(PHIDP_PREPARSED_DATA q = nullptr) { if (p) HidD_FreePreparsedData(p); p = q; }
+			PHIDP_PREPARSED_DATA get() const { return p; }
+			explicit operator bool() const { return p != nullptr; }
+		} preparsed;
 		HIDP_CAPS caps{};
 		std::vector<HIDP_VALUE_CAPS> valueCaps;
 		int slot = -1;