Apply new formatting

include/core/Network.h

@@ -72,8 +72,8 @@ void stopServer(void);
 void tickServer(void);
 void sendServerPacketBroadcast(const OutPacket* p, PacketSendMode mode);
 void sendServerPacket(Client client, const OutPacket* p, PacketSendMode mode);
-void setServerTimeout(Client client, u32 timeout, u32 timeoutMin,
-                      u32 timeoutMax);
+void setServerTimeout(
+    Client client, u32 timeout, u32 timeoutMin, u32 timeoutMax);
 void disconnectServerClient(Client client);
 void setServerConnectHandler(OnClientConnect oc);
 void setServerDisconnectHandler(OnClientDisconnect od);

src/Network.c

@@ -57,7 +57,7 @@ bool readInPacketI16(InPacket* in, i16* i) {
     if(readInPacketU16(in, &u)) {
         return true;
     }
-    *i = (i16)((i32)u - (i32)32768);
+    *i = (i16)((i32)u - (i32)32'768);
     return false;
 }
 
@@ -66,10 +66,10 @@ bool readInPacketI32(InPacket* in, i32* i) {
     if(readInPacketU32(in, &u)) {
         return true;
     }
-    if(u < 2147483648) {
-        *i = (i32)((i32)u - (i32)2147483648);
+    if(u < 2'147'483'648) {
+        *i = (i32)((i32)u - (i32)2'147'483'648);
     } else {
-        *i = (i32)(u - (u32)2147483648);
+        *i = (i32)(u - (u32)2'147'483'648);
     }
     return false;
 }
@@ -145,14 +145,14 @@ void writeOutPacketI8(OutPacket* out, i8 i) {
 }
 
 void writeOutPacketI16(OutPacket* out, i16 i) {
-    writeOutPacketU16(out, (u16)((i32)i + (i32)32768));
+    writeOutPacketU16(out, (u16)((i32)i + (i32)32'768));
 }
 
 void writeOutPacketI32(OutPacket* out, i32 i) {
     if(i < 0) {
-        writeOutPacketU32(out, (u32)((i + (i32)2147483647) + (i32)1));
+        writeOutPacketU32(out, (u32)((i + (i32)2'147'483'647) + (i32)1));
     } else {
-        writeOutPacketU32(out, (u32)((u32)i + (u32)2147483648));
+        writeOutPacketU32(out, (u32)((u32)i + (u32)2'147'483'648));
     }
 }
 
@@ -167,7 +167,7 @@ void writeOutPacketString(OutPacket* out, const char* s) {
     size_t marker = out->data.size;
     writeOutPacketU16(out, 0);
     size_t end = 0;
-    while(end < 65534 && *s != '\0') {
+    while(end < 65'534 && *s != '\0') {
         writeOutPacketU8(out, (u8)(*(s++)));
         end++;
     }
@@ -243,8 +243,9 @@ bool startClient(void) {
 void stopClient(void) {
     if(client.connection != nullptr) {
         client.onDisconnect();
-        FAIL(enet_peer_disconnect_now(client.connection, 0),
-             enet_peer_reset(client.connection));
+        FAIL(
+            enet_peer_disconnect_now(client.connection, 0),
+            enet_peer_reset(client.connection));
         client.connection = nullptr;
     }
     if(client.client != nullptr) {
@@ -301,11 +302,12 @@ void sendClientPacket(const OutPacket* p, PacketSendMode mode) {
        client.connectTicks >= 0) {
         return;
     }
-    static const enet_uint32 flags[] = {ENET_PACKET_FLAG_RELIABLE, 0,
-                                        ENET_PACKET_FLAG_UNSEQUENCED};
+    static const enet_uint32 flags[] = {
+        ENET_PACKET_FLAG_RELIABLE, 0, ENET_PACKET_FLAG_UNSEQUENCED};
     enet_uint8 i = (enet_uint8)mode;
-    enet_peer_send(client.connection, i,
-                   enet_packet_create(p->data.buffer, p->data.size, flags[i]));
+    enet_peer_send(
+        client.connection, i,
+        enet_packet_create(p->data.buffer, p->data.size, flags[i]));
 }
 
 static void tickClientEvents(void) {
@@ -440,8 +442,8 @@ void stopServer(void) {
 }
 
 static void writeId(ENetPeer* peer, Client id) {
-    static_assert(sizeof(peer->data) >= sizeof(id),
-                  "private data not big enough for id");
+    static_assert(
+        sizeof(peer->data) >= sizeof(id), "private data not big enough for id");
     memcpy(&(peer->data), &id, sizeof(id));
 }
 
@@ -493,8 +495,8 @@ void tickServer(void) {
 }
 
 static ENetPacket* fromBuffer(const Buffer* buffer, enet_uint8 index) {
-    static const enet_uint32 flags[] = {ENET_PACKET_FLAG_RELIABLE, 0,
-                                        ENET_PACKET_FLAG_UNSEQUENCED};
+    static const enet_uint32 flags[] = {
+        ENET_PACKET_FLAG_RELIABLE, 0, ENET_PACKET_FLAG_UNSEQUENCED};
     return enet_packet_create(buffer->buffer, buffer->size, flags[index]);
 }
 
@@ -505,8 +507,8 @@ void sendServerPacketBroadcast(const OutPacket* p, PacketSendMode mode) {
     }
 }
 
-void sendServerPacket(Client clientId, const OutPacket* p,
-                      PacketSendMode mode) {
+void sendServerPacket(
+    Client clientId, const OutPacket* p, PacketSendMode mode) {
     if(server.server == nullptr) {
         return;
     }
@@ -517,8 +519,8 @@ void sendServerPacket(Client clientId, const OutPacket* p,
     }
 }
 
-void setServerTimeout(Client clientId, u32 timeout, u32 timeoutMin,
-                      u32 timeoutMax) {
+void setServerTimeout(
+    Client clientId, u32 timeout, u32 timeoutMin, u32 timeoutMax) {
     if(server.server == nullptr) {
         return;
     }

src/VulkanWrapper.c

@@ -35,9 +35,10 @@ typedef struct {
     u32 width;
     u32 height;
 } VulkanData;
+
 static VulkanData vk = {0};
 
-#define VK_ERROR_CASE(error)                                                   \
+#define VK_ERROR_CASE(error)  \
     case error: return #error
 
 static const char* getVulkanErrorString(VkResult r) {
@@ -52,15 +53,15 @@ static const char* getVulkanErrorString(VkResult r) {
     }
 }
 
-#define VK_ASSERT(a)                                                           \
-    do {                                                                       \
-        VkResult vkResult = (a);                                               \
-        if(vkResult != VK_SUCCESS) {                                           \
-            printf("Vulkan error at [%s:%d]: %s\n",                            \
-                   getShortFileName(__FILE__), __LINE__,                       \
-                   getVulkanErrorString(vkResult));                            \
-            return true;                                                       \
-        }                                                                      \
+#define VK_ASSERT(a)                                                         \
+    do {                                                                     \
+        VkResult vkResult = (a);                                             \
+        if(vkResult != VK_SUCCESS) {                                         \
+            printf(                                                          \
+                "Vulkan error at [%s:%d]: %s\n", getShortFileName(__FILE__), \
+                __LINE__, getVulkanErrorString(vkResult));                   \
+            return true;                                                     \
+        }                                                                    \
     } while(false)
 
 static PFN_vkVoidFunction getVulkanFunction(const char* name) {
@@ -69,13 +70,18 @@ static PFN_vkVoidFunction getVulkanFunction(const char* name) {
 
 #define GET_VULKAN_FUNCTION(name) ((PFN_##name)getVulkanFunction(#name))
 
+static int64_t someData[] = {10'000, 2,           3,   4,          5,
+                             6,      0xFFFF'FFFF, 'a', 0b1000'0001};
+
 static bool initInstance() {
-    VkApplicationInfo i = {.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-                           .pApplicationName = "Vulkan",
-                           .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
-                           .pEngineName = "Kajetan",
-                           .engineVersion = VK_MAKE_VERSION(0, 0, 1),
-                           .apiVersion = VK_API_VERSION_1_1};
+    (void)someData; //    gusi
+    VkApplicationInfo i = {
+        .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+        .pApplicationName = "Vulkan",
+        .applicationVersion = VK_MAKE_VERSION(1, 0, 0),
+        .pEngineName = "Kajetan",
+        .engineVersion = VK_MAKE_VERSION(0, 0, 1),
+        .apiVersion = VK_API_VERSION_1_1};
     VkInstanceCreateInfo ci = {
         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
         .pApplicationInfo = &i,
@@ -115,9 +121,9 @@ static bool initDebugMessenger() {
     return false;
 }
 
-static VKAPI_ATTR VkBool32 onVulkanDebugReport
-VKAPI_CALL(VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, uint64_t, size_t,
-           int32_t, const char* pLayerPrefix, const char* pMessage, void*) {
+static VKAPI_ATTR VkBool32 onVulkanDebugReport VKAPI_CALL(
+    VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, uint64_t, size_t,
+    int32_t, const char* pLayerPrefix, const char* pMessage, void*) {
     LOG_WARNING("Vulkan debug message '%s': %s", pLayerPrefix, pMessage);
     return false;
 }
@@ -238,8 +244,8 @@ static bool initDevice() {
         .ppEnabledExtensionNames =
             (const char*[]){VK_KHR_SWAPCHAIN_EXTENSION_NAME},
         .pEnabledFeatures = &deviceFeatures};
-    VK_ASSERT(vkCreateDevice(vk.physicalDevice, &deviceCreateInfo, nullptr,
-                             &vk.device));
+    VK_ASSERT(vkCreateDevice(
+        vk.physicalDevice, &deviceCreateInfo, nullptr, &vk.device));
     vkGetDeviceQueue(vk.device, vk.graphicsFamily, 0, &vk.graphicsQueue);
     if(vk.graphicsQueue == VK_NULL_HANDLE) {
         LOG_ERROR("Cannot get device graphics queue");
@@ -249,8 +255,8 @@ static bool initDevice() {
 }
 
 static bool initSurface() {
-    VK_ASSERT(glfwCreateWindowSurface(vk.instance, getWindow(), nullptr,
-                                      &vk.surface));
+    VK_ASSERT(glfwCreateWindowSurface(
+        vk.instance, getWindow(), nullptr, &vk.surface));
     return false;
 }
 
@@ -266,11 +272,11 @@ static u32 getSwapImageCount(const VkSurfaceCapabilitiesKHR* caps) {
 
 static bool getSurfaceFormat(VkSurfaceFormatKHR* sf) {
     u32 c = 0;
-    VK_ASSERT(vkGetPhysicalDeviceSurfaceFormatsKHR(vk.physicalDevice,
-                                                   vk.surface, &c, nullptr));
+    VK_ASSERT(vkGetPhysicalDeviceSurfaceFormatsKHR(
+        vk.physicalDevice, vk.surface, &c, nullptr));
     VkSurfaceFormatKHR* formats = coreAllocate(sizeof(VkSurfaceFormatKHR) * c);
-    VK_ASSERT(vkGetPhysicalDeviceSurfaceFormatsKHR(vk.physicalDevice,
-                                                   vk.surface, &c, formats));
+    VK_ASSERT(vkGetPhysicalDeviceSurfaceFormatsKHR(
+        vk.physicalDevice, vk.surface, &c, formats));
     for(u32 i = 0; i < c; i++) {
         if(formats[i].format == VK_FORMAT_B8G8R8A8_UNORM &&
            formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
@@ -289,8 +295,8 @@ static bool getPresentMode(VkPresentModeKHR* pm) {
     VK_ASSERT(vkGetPhysicalDeviceSurfacePresentModesKHR(
         vk.physicalDevice, vk.surface, &c, nullptr));
     VkPresentModeKHR* modes = coreAllocate(sizeof(VkPresentModeKHR) * c);
-    VK_ASSERT(vkGetPhysicalDeviceSurfacePresentModesKHR(vk.physicalDevice,
-                                                        vk.surface, &c, modes));
+    VK_ASSERT(vkGetPhysicalDeviceSurfacePresentModesKHR(
+        vk.physicalDevice, vk.surface, &c, modes));
     for(u32 i = 0; i < c; i++) {
         if(modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
             *pm = modes[i];
@@ -305,8 +311,8 @@ static bool getPresentMode(VkPresentModeKHR* pm) {
 
 static bool initSwapchain() {
     VkSurfaceCapabilitiesKHR caps = {0};
-    VK_ASSERT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk.physicalDevice,
-                                                        vk.surface, &caps));
+    VK_ASSERT(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
+        vk.physicalDevice, vk.surface, &caps));
     VkSurfaceFormatKHR sf = {0};
     if(getSurfaceFormat(&sf)) {
         return true;
@@ -345,11 +351,12 @@ static bool createImageView(VkImage image, VkImageView* view) {
         .image = image,
         .viewType = VK_IMAGE_VIEW_TYPE_2D,
         .format = VK_FORMAT_B8G8R8A8_UNORM,
-        .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                             .baseMipLevel = 0,
-                             .levelCount = 1,
-                             .baseArrayLayer = 0,
-                             .layerCount = 1}};
+        .subresourceRange = {
+            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .baseMipLevel = 0,
+            .levelCount = 1,
+            .baseArrayLayer = 0,
+            .layerCount = 1}};
     VK_ASSERT(vkCreateImageView(vk.device, &info, nullptr, view));
     return false;
 }
@@ -370,11 +377,11 @@ static bool initSwapchainImages() {
     vk.swapchain.amount = c;
     vk.swapchain.images = coreAllocate(sizeof(VkImage) * c);
     vk.swapchain.imageViews = coreZeroAllocate(sizeof(VkImageView) * c);
-    VK_ASSERT(vkGetSwapchainImagesKHR(vk.device, vk.swapchain.handle, &c,
-                                      vk.swapchain.images));
+    VK_ASSERT(vkGetSwapchainImagesKHR(
+        vk.device, vk.swapchain.handle, &c, vk.swapchain.images));
     for(u32 x = 0; x < c; x++) {
-        if(createImageView(vk.swapchain.images[x],
-                           vk.swapchain.imageViews + x)) {
+        if(createImageView(
+               vk.swapchain.images[x], vk.swapchain.imageViews + x)) {
             return true;
         }
     }
@@ -382,8 +389,8 @@ static bool initSwapchainImages() {
 }
 
 static bool initSemaphore(VkSemaphore* s) {
-    VkSemaphoreCreateInfo info = {.sType =
-                                      VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
+    VkSemaphoreCreateInfo info = {
+        .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
     VK_ASSERT(vkCreateSemaphore(vk.device, &info, nullptr, s));
     return false;
 }
@@ -407,8 +414,8 @@ static bool initCommandBuffers() {
     VkCommandPoolCreateInfo info = {
         .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
         .queueFamilyIndex = vk.graphicsFamily};
-    VK_ASSERT(vkCreateCommandPool(vk.device, &info, nullptr,
-                                  &vk.swapchain.commandPool));
+    VK_ASSERT(vkCreateCommandPool(
+        vk.device, &info, nullptr, &vk.swapchain.commandPool));
     vk.swapchain.commandsBuffers =
         coreAllocate(sizeof(VkCommandBuffer) * vk.swapchain.amount);
     VkCommandBufferAllocateInfo a = {
@@ -423,8 +430,9 @@ static bool initCommandBuffers() {
 
 static void destroyCommandBuffers() {
     if(vk.swapchain.commandPool != VK_NULL_HANDLE && vk.swapchain.amount > 0) {
-        vkFreeCommandBuffers(vk.device, vk.swapchain.commandPool,
-                             vk.swapchain.amount, vk.swapchain.commandsBuffers);
+        vkFreeCommandBuffers(
+            vk.device, vk.swapchain.commandPool, vk.swapchain.amount,
+            vk.swapchain.commandsBuffers);
     }
     coreFree(vk.swapchain.commandsBuffers);
     vkDestroyCommandPool(vk.device, vk.swapchain.commandPool, nullptr);
@@ -442,10 +450,10 @@ static bool initRenderPass() {
         .finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR};
     VkAttachmentReference ca = {
         .attachment = 0, .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
-    VkSubpassDescription subpass = {.pipelineBindPoint =
-                                        VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                    .colorAttachmentCount = 1,
-                                    .pColorAttachments = &ca};
+    VkSubpassDescription subpass = {
+        .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
+        .colorAttachmentCount = 1,
+        .pColorAttachments = &ca};
     VkRenderPassCreateInfo info = {
         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
         .attachmentCount = 1,
@@ -468,8 +476,8 @@ static bool initFramebuffers() {
             .width = vk.width,
             .height = vk.height,
             .layers = 1};
-        VK_ASSERT(vkCreateFramebuffer(vk.device, &info, nullptr,
-                                      vk.swapchain.framebuffers + i));
+        VK_ASSERT(vkCreateFramebuffer(
+            vk.device, &info, nullptr, vk.swapchain.framebuffers + i));
     }
     printf("%u\n", vk.swapchain.amount);
     return false;

src/WindowManager.c

@@ -31,12 +31,14 @@ static void* renderHandlerData = nullptr;
 static i64 nanosPerTick = 1;
 
 #define CLOCK_SIZE 16
+
 typedef struct {
     i64 last;
     i64 sum;
     i64 values[CLOCK_SIZE];
     size_t index;
 } Clock;
+
 static Clock fps = {0};
 static Clock tps = {0};
 
@@ -57,6 +59,7 @@ typedef struct {
     int controllerUp;
     int controllerDown;
 } ButtonData;
+
 #define BUTTONS 100
 static ButtonData buttons[BUTTONS] = {{.name = "unknown"}};
 static size_t buttonIndex = 1;
@@ -263,7 +266,7 @@ static i64 updateClock(Clock* c) {
     i64 nanos = getNanos();
     if(nanos < 0) {
         LOG_WARNING("Cannot get nanos, using default");
-        nanos = 10000000 + c->last;
+        nanos = 10'000'000 + c->last;
     }
     i64 diff = nanos - c->last;
     c->last = nanos;
@@ -451,13 +454,15 @@ Vector2 getMousePosition(void) {
 }
 
 Vector2 getLeftGamepadAxis(void) {
-    return (Vector2){{lastControllerState.axes[GLFW_GAMEPAD_AXIS_LEFT_X],
-                      lastControllerState.axes[GLFW_GAMEPAD_AXIS_LEFT_Y]}};
+    return (Vector2){
+        {lastControllerState.axes[GLFW_GAMEPAD_AXIS_LEFT_X],
+         lastControllerState.axes[GLFW_GAMEPAD_AXIS_LEFT_Y]}};
 }
 
 Vector2 getRightGamepadAxis(void) {
-    return (Vector2){{lastControllerState.axes[GLFW_GAMEPAD_AXIS_RIGHT_X],
-                      lastControllerState.axes[GLFW_GAMEPAD_AXIS_RIGHT_Y]}};
+    return (Vector2){
+        {lastControllerState.axes[GLFW_GAMEPAD_AXIS_RIGHT_X],
+         lastControllerState.axes[GLFW_GAMEPAD_AXIS_RIGHT_Y]}};
 }
 
 float getLeftGamepadTrigger(void) {

test/Main.c

@@ -8,7 +8,7 @@
 
 int main(int argAmount, char** args) {
     if(argAmount >= 2 && strcmp(args[1], "help") == 0) {
-        // puts("test");
+        puts("test");
         puts("window");
         return 0;
     }