BlackMark/CoopAllTheThings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Apply clang-format across the whole tree

Browse Source 
Run clang-format (the repo's .clang-format: LLVM base, 120 cols, tabs,
Allman functions) over every source file so the tree is formatter-clean.
Whitespace only -- no behavior change; full x64 + x86 suites pass.

Also set SortIncludes: false in .clang-format. Windows include order is
load-bearing (windows.h must precede tlhelp32.h / mmreg.h / xinput.h /
dinput.h; winsock2.h must precede windows.h), and the default
alphabetical sort reorders tlhelp32.h ahead of windows.h -- a build
break. Leaving order alone keeps the manual, correct grouping.
This commit is contained in:
BlackMark
2026-07-12 11:52:53 +02:00
parent c684a15fb9
commit 30eccf749d
155 changed files with 3333 additions and 6171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
tools/mock_game/render_vk.cpp
View File

@@ -10,19 +10,15 @@
#include <volk.h>
namespace coop::mock
{
namespace
{
class VkBackend : public RenderBackend
{
public:
namespace coop::mock {
namespace {
class VkBackend : public RenderBackend {
public:
bool init(HWND hwnd, std::uint32_t width, std::uint32_t height) override
{
width_ = width;
height_ = height;
if (volkInitialize() != VK_SUCCESS)
{
if (volkInitialize() != VK_SUCCESS) {
return false; // no Vulkan loader on this machine
}
@@ -34,8 +30,7 @@ public:
ici.pApplicationInfo = &app;
ici.enabledExtensionCount = 2;
ici.ppEnabledExtensionNames = inst_ext;
if (vkCreateInstance(&ici, nullptr, &instance_) != VK_SUCCESS)
{
if (vkCreateInstance(&ici, nullptr, &instance_) != VK_SUCCESS) {
return false;
}
volkLoadInstance(instance_);
@@ -43,13 +38,11 @@ public:
VkWin32SurfaceCreateInfoKHR sci{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR};
sci.hinstance = GetModuleHandleW(nullptr);
sci.hwnd = hwnd;
if (vkCreateWin32SurfaceKHR(instance_, &sci, nullptr, &surface_) != VK_SUCCESS)
{
if (vkCreateWin32SurfaceKHR(instance_, &sci, nullptr, &surface_) != VK_SUCCESS) {
return false;
}
if (!pick_device() || !create_device() || !create_swapchain() || !create_commands())
{
if (!pick_device() || !create_device() || !create_swapchain() || !create_commands()) {
return false;
}
return true;
@@ -57,20 +50,17 @@ public:
void render_and_present(std::uint32_t frame) override
{
if (device_ == VK_NULL_HANDLE || swapchain_ == VK_NULL_HANDLE)
{
if (device_ == VK_NULL_HANDLE || swapchain_ == VK_NULL_HANDLE) {
return;
}
vkWaitForFences(device_, 1, &in_flight_, VK_TRUE, UINT64_MAX);
std::uint32_t idx = 0;
VkResult acq = vkAcquireNextImageKHR(device_, swapchain_, UINT64_MAX, acquire_sem_, VK_NULL_HANDLE, &idx);
if (acq == VK_ERROR_OUT_OF_DATE_KHR || acq == VK_SUBOPTIMAL_KHR)
{
if (acq == VK_ERROR_OUT_OF_DATE_KHR || acq == VK_SUBOPTIMAL_KHR) {
return; // skip this frame (the mock window isn't resized in practice)
}
if (acq != VK_SUCCESS)
{
if (acq != VK_SUCCESS) {
return;
}
vkResetFences(device_, 1, &in_flight_);
@@ -118,15 +108,11 @@ public:
vkQueuePresentKHR(queue_, &pi);
}
[[nodiscard]] const char* name() const override
{
return "vk";
}
[[nodiscard]] const char* name() const override { return "vk"; }
~VkBackend() override
{
if (device_ != VK_NULL_HANDLE)
{
if (device_ != VK_NULL_HANDLE) {
vkDeviceWaitIdle(device_);
if (in_flight_ != VK_NULL_HANDLE)
vkDestroyFence(device_, in_flight_, nullptr);
@@ -146,25 +132,22 @@ public:
vkDestroyInstance(instance_, nullptr);
}
private:
private:
bool pick_device()
{
std::uint32_t n = 0;
vkEnumeratePhysicalDevices(instance_, &n, nullptr);
std::vector<VkPhysicalDevice> devs(n);
vkEnumeratePhysicalDevices(instance_, &n, devs.data());
for (VkPhysicalDevice pd : devs)
{
for (VkPhysicalDevice pd : devs) {
std::uint32_t qn = 0;
vkGetPhysicalDeviceQueueFamilyProperties(pd, &qn, nullptr);
std::vector<VkQueueFamilyProperties> qf(qn);
vkGetPhysicalDeviceQueueFamilyProperties(pd, &qn, qf.data());
for (std::uint32_t i = 0; i < qn; ++i)
{
for (std::uint32_t i = 0; i < qn; ++i) {
VkBool32 present = VK_FALSE;
vkGetPhysicalDeviceSurfaceSupportKHR(pd, i, surface_, &present);
if ((qf[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && present)
{
if ((qf[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && present) {
phys_ = pd;
qfam_ = i;
return true;
@@ -187,8 +170,7 @@ private:
dci.pQueueCreateInfos = &qci;
dci.enabledExtensionCount = 1;
dci.ppEnabledExtensionNames = dev_ext;
if (vkCreateDevice(phys_, &dci, nullptr, &device_) != VK_SUCCESS)
{
if (vkCreateDevice(phys_, &dci, nullptr, &device_) != VK_SUCCESS) {
return false;
}
volkLoadDevice(device_);
@@ -205,13 +187,11 @@ private:
vkGetPhysicalDeviceSurfaceFormatsKHR(phys_, surface_, &fn, nullptr);
std::vector<VkSurfaceFormatKHR> formats(fn);
vkGetPhysicalDeviceSurfaceFormatsKHR(phys_, surface_, &fn, formats.data());
VkSurfaceFormatKHR chosen = formats.empty() ? VkSurfaceFormatKHR{VK_FORMAT_B8G8R8A8_UNORM,
VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}
: formats[0];
for (const VkSurfaceFormatKHR& f : formats)
{
if (f.format == VK_FORMAT_B8G8R8A8_UNORM || f.format == VK_FORMAT_R8G8B8A8_UNORM)
{
VkSurfaceFormatKHR chosen =
formats.empty() ? VkSurfaceFormatKHR{VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}
: formats[0];
for (const VkSurfaceFormatKHR& f : formats) {
if (f.format == VK_FORMAT_B8G8R8A8_UNORM || f.format == VK_FORMAT_R8G8B8A8_UNORM) {
chosen = f;
break;
}
@@ -219,8 +199,7 @@ private:
format_ = chosen.format;
std::uint32_t want = caps.minImageCount + 1;
if (caps.maxImageCount > 0 && want > caps.maxImageCount)
{
if (caps.maxImageCount > 0 && want > caps.maxImageCount) {
want = caps.maxImageCount;
}
VkSwapchainCreateInfoKHR sc{VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR};
@@ -228,9 +207,7 @@ private:
sc.minImageCount = want;
sc.imageFormat = chosen.format;
sc.imageColorSpace = chosen.colorSpace;
sc.imageExtent = caps.currentExtent.width != 0xFFFFFFFFu
? caps.currentExtent
: VkExtent2D{width_, height_};
sc.imageExtent = caps.currentExtent.width != 0xFFFFFFFFu ? caps.currentExtent : VkExtent2D{width_, height_};
sc.imageArrayLayers = 1;
// TRANSFER_DST so we can clear it; TRANSFER_SRC so the capture hook can copy it out.
sc.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
@@ -249,12 +226,11 @@ private:
return true;
return false;
};
sc.presentMode = has_mode(VK_PRESENT_MODE_IMMEDIATE_KHR) ? VK_PRESENT_MODE_IMMEDIATE_KHR
sc.presentMode = has_mode(VK_PRESENT_MODE_IMMEDIATE_KHR) ? VK_PRESENT_MODE_IMMEDIATE_KHR
: has_mode(VK_PRESENT_MODE_MAILBOX_KHR) ? VK_PRESENT_MODE_MAILBOX_KHR
: VK_PRESENT_MODE_FIFO_KHR;
: VK_PRESENT_MODE_FIFO_KHR;
sc.clipped = VK_TRUE;
if (vkCreateSwapchainKHR(device_, &sc, nullptr, &swapchain_) != VK_SUCCESS)
{
if (vkCreateSwapchainKHR(device_, &sc, nullptr, &swapchain_) != VK_SUCCESS) {
return false;
}
std::uint32_t in = 0;
@@ -269,29 +245,26 @@ private:
VkCommandPoolCreateInfo pci{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
pci.queueFamilyIndex = qfam_;
if (vkCreateCommandPool(device_, &pci, nullptr, &pool_) != VK_SUCCESS)
{
if (vkCreateCommandPool(device_, &pci, nullptr, &pool_) != VK_SUCCESS) {
return false;
}
VkCommandBufferAllocateInfo ai{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
ai.commandPool = pool_;
ai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
ai.commandBufferCount = 1;
if (vkAllocateCommandBuffers(device_, &ai, &cmd_) != VK_SUCCESS)
{
if (vkAllocateCommandBuffers(device_, &ai, &cmd_) != VK_SUCCESS) {
return false;
}
VkSemaphoreCreateInfo si{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
VkFenceCreateInfo fi{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
fi.flags = VK_FENCE_CREATE_SIGNALED_BIT;
return vkCreateSemaphore(device_, &si, nullptr, &acquire_sem_) == VK_SUCCESS &&
vkCreateSemaphore(device_, &si, nullptr, &submit_sem_) == VK_SUCCESS &&
vkCreateFence(device_, &fi, nullptr, &in_flight_) == VK_SUCCESS;
return vkCreateSemaphore(device_, &si, nullptr, &acquire_sem_) == VK_SUCCESS
&& vkCreateSemaphore(device_, &si, nullptr, &submit_sem_) == VK_SUCCESS
&& vkCreateFence(device_, &fi, nullptr, &in_flight_) == VK_SUCCESS;
}
static void barrier(VkCommandBuffer cb, VkImage img, VkImageLayout from, VkImageLayout to,
VkAccessFlags src_access, VkAccessFlags dst_access, VkPipelineStageFlags src_stage,
VkPipelineStageFlags dst_stage)
static void barrier(VkCommandBuffer cb, VkImage img, VkImageLayout from, VkImageLayout to, VkAccessFlags src_access,
VkAccessFlags dst_access, VkPipelineStageFlags src_stage, VkPipelineStageFlags dst_stage)
{
VkImageMemoryBarrier b{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
b.srcAccessMask = src_access;