Minor code style cleanup (#140)

solidpixel · web-flow · commit 562b02d80ece · 2025-08-12T15:02:23.000+01:00
diff --git a/.gitignore b/.gitignore
@@ -7,7 +7,7 @@ __pycache__
 pve
 
 # CMake build directories
-build*
+**/build*
 
 # Data files and build outputs
 *.log
diff --git a/generator/vk_layer/source/device.hpp b/generator/vk_layer/source/device.hpp
@@ -115,14 +115,14 @@ class Device
         VkCommandBuffer handle);
 
     /**
-     * \brief Drop a device from the global store of dispatchable devices.
+     * @brief Drop a device from the global store of dispatchable devices.
      *
      * This must be called before the driver VkDevice has been destroyed, as
      * we deference the native device handle to get the dispatch key.
      *
-     * \param handle   The dispatchable device handle to use as an indirect lookup.
+     * @param handle   The dispatchable device handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Device object to the caller.
+     * @return Returns the ownership of the Device object to the caller.
      */
     static std::unique_ptr<Device> destroy(
         VkDevice handle);
diff --git a/generator/vk_layer/source/instance.hpp b/generator/vk_layer/source/instance.hpp
@@ -99,14 +99,14 @@ class Instance
         VkPhysicalDevice handle);
 
     /**
-     * \brief Drop an instance from the global store of dispatchable instances.
+     * @brief Drop an instance from the global store of dispatchable instances.
      *
      * This must be called before the driver VkInstance has been destroyed, as
      * we deference the native instance handle to get the dispatch key.
      *
-     * \param handle   The dispatchable instance handle to use as an indirect lookup.
+     * @param handle   The dispatchable instance handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Instance object to the caller.
+     * @return Returns the ownership of the Instance object to the caller.
      */
     static std::unique_ptr<Instance> destroy(
         VkInstance handle);
diff --git a/layer_example/source/device.hpp b/layer_example/source/device.hpp
@@ -110,14 +110,14 @@ class Device
     static Device* retrieve(VkCommandBuffer handle);
 
     /**
-     * \brief Drop a device from the global store of dispatchable devices.
+     * @brief Drop a device from the global store of dispatchable devices.
      *
      * This must be called before the driver VkDevice has been destroyed, as
      * we deference the native device handle to get the dispatch key.
      *
-     * \param handle   The dispatchable device handle to use as an indirect lookup.
+     * @param handle   The dispatchable device handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Device object to the caller.
+     * @return Returns the ownership of the Device object to the caller.
      */
     static std::unique_ptr<Device> destroy(
         VkDevice handle);
diff --git a/layer_example/source/instance.hpp b/layer_example/source/instance.hpp
@@ -95,14 +95,14 @@ class Instance
     static Instance* retrieve(VkPhysicalDevice handle);
 
     /**
-     * \brief Drop an instance from the global store of dispatchable instances.
+     * @brief Drop an instance from the global store of dispatchable instances.
      *
      * This must be called before the driver VkInstance has been destroyed, as
      * we deference the native instance handle to get the dispatch key.
      *
-     * \param handle   The dispatchable instance handle to use as an indirect lookup.
+     * @param handle   The dispatchable instance handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Instance object to the caller.
+     * @return Returns the ownership of the Instance object to the caller.
      */
     static std::unique_ptr<Instance> destroy(
         VkInstance handle);
diff --git a/layer_gpu_profile/source/device.hpp b/layer_gpu_profile/source/device.hpp
@@ -118,14 +118,14 @@ class Device
     static Device* retrieve(VkCommandBuffer handle);
 
     /**
-     * \brief Drop a device from the global store of dispatchable devices.
+     * @brief Drop a device from the global store of dispatchable devices.
      *
      * This must be called before the driver VkDevice has been destroyed, as
      * we deference the native device handle to get the dispatch key.
      *
-     * \param handle   The dispatchable device handle to use as an indirect lookup.
+     * @param handle   The dispatchable device handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Device object to the caller.
+     * @return Returns the ownership of the Device object to the caller.
      */
     static std::unique_ptr<Device> destroy(
         VkDevice handle);
diff --git a/layer_gpu_profile/source/instance.hpp b/layer_gpu_profile/source/instance.hpp
@@ -96,14 +96,14 @@ class Instance
     static Instance* retrieve(VkPhysicalDevice handle);
 
     /**
-     * \brief Drop an instance from the global store of dispatchable instances.
+     * @brief Drop an instance from the global store of dispatchable instances.
      *
      * This must be called before the driver VkInstance has been destroyed, as
      * we deference the native instance handle to get the dispatch key.
      *
-     * \param handle   The dispatchable instance handle to use as an indirect lookup.
+     * @param handle   The dispatchable instance handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Instance object to the caller.
+     * @return Returns the ownership of the Instance object to the caller.
      */
     static std::unique_ptr<Instance> destroy(
         VkInstance handle);
diff --git a/layer_gpu_support/source/device.hpp b/layer_gpu_support/source/device.hpp
@@ -111,14 +111,14 @@ class Device
     static Device* retrieve(VkCommandBuffer handle);
 
     /**
-     * \brief Drop a device from the global store of dispatchable devices.
+     * @brief Drop a device from the global store of dispatchable devices.
      *
      * This must be called before the driver VkDevice has been destroyed, as
      * we deference the native device handle to get the dispatch key.
      *
-     * \param handle   The dispatchable device handle to use as an indirect lookup.
+     * @param handle   The dispatchable device handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Device object to the caller.
+     * @return Returns the ownership of the Device object to the caller.
      */
     static std::unique_ptr<Device> destroy(
         VkDevice handle);
diff --git a/layer_gpu_support/source/instance.hpp b/layer_gpu_support/source/instance.hpp
@@ -95,14 +95,14 @@ class Instance
     static Instance* retrieve(VkPhysicalDevice handle);
 
     /**
-     * \brief Drop an instance from the global store of dispatchable instances.
+     * @brief Drop an instance from the global store of dispatchable instances.
      *
      * This must be called before the driver VkInstance has been destroyed, as
      * we deference the native instance handle to get the dispatch key.
      *
-     * \param handle   The dispatchable instance handle to use as an indirect lookup.
+     * @param handle   The dispatchable instance handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Instance object to the caller.
+     * @return Returns the ownership of the Instance object to the caller.
      */
     static std::unique_ptr<Instance> destroy(
         VkInstance handle);
diff --git a/layer_gpu_timeline/source/device.hpp b/layer_gpu_timeline/source/device.hpp
@@ -113,14 +113,14 @@ class Device
     static Device* retrieve(VkCommandBuffer handle);
 
     /**
-     * \brief Drop a device from the global store of dispatchable devices.
+     * @brief Drop a device from the global store of dispatchable devices.
      *
      * This must be called before the driver VkDevice has been destroyed, as
      * we deference the native device handle to get the dispatch key.
      *
-     * \param handle   The dispatchable device handle to use as an indirect lookup.
+     * @param handle   The dispatchable device handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Device object to the caller.
+     * @return Returns the ownership of the Device object to the caller.
      */
     static std::unique_ptr<Device> destroy(
         VkDevice handle);
diff --git a/layer_gpu_timeline/source/instance.hpp b/layer_gpu_timeline/source/instance.hpp
@@ -95,14 +95,14 @@ class Instance
     static Instance* retrieve(VkPhysicalDevice handle);
 
     /**
-     * \brief Drop an instance from the global store of dispatchable instances.
+     * @brief Drop an instance from the global store of dispatchable instances.
      *
      * This must be called before the driver VkInstance has been destroyed, as
      * we deference the native instance handle to get the dispatch key.
      *
-     * \param handle   The dispatchable instance handle to use as an indirect lookup.
+     * @param handle   The dispatchable instance handle to use as an indirect lookup.
      *
-     * \return Returns the ownership of the Instance object to the caller.
+     * @return Returns the ownership of the Instance object to the caller.
      */
     static std::unique_ptr<Instance> destroy(
         VkInstance handle);
diff --git a/layer_gpu_timeline/source/timeline_protobuf_encoder.hpp b/layer_gpu_timeline/source/timeline_protobuf_encoder.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * Methods for transforming layer command stream workloads into metadata messages
  * for transmission to the host.
  *
diff --git a/source_common/comms/comms_transmitter.cpp b/source_common/comms/comms_transmitter.cpp
@@ -61,7 +61,7 @@ Transmitter::~Transmitter()
 void Transmitter::runTransmitter()
 {
     // Keep looping until we are told to stop and message queue is empty
-    while (!stopRequested || !parent.messageQueue.is_empty())
+    while (!stopRequested || !parent.messageQueue.isEmpty())
     {
         auto message = parent.dequeueMessage();
 
diff --git a/source_common/trackers/command_buffer.hpp b/source_common/trackers/command_buffer.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * The declaration of Vulkan command pool and command buffer use trackers.
  *
  * Role summary
@@ -246,7 +246,7 @@ class CommandPool
      *
      * @param commandBuffer   The Vulkan handle of the allocated command buffer.
      *
-     * \return The layer wrapper object for the command buffer.
+     * @return The layer wrapper object for the command buffer.
      */
     CommandBuffer& allocateCommandBuffer(VkCommandBuffer commandBuffer);
 
diff --git a/source_common/trackers/device.hpp b/source_common/trackers/device.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * This module implements basic tracking of Vulkan devices.
  *
  * Role summary
diff --git a/source_common/trackers/layer_command_stream.hpp b/source_common/trackers/layer_command_stream.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * The declaration of a replayable layer command stream.
  *
  * Role summary
diff --git a/source_common/trackers/queue.hpp b/source_common/trackers/queue.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * The declaration of Vulkan queue use trackers.
  *
  * Role summary
diff --git a/source_common/trackers/render_pass.hpp b/source_common/trackers/render_pass.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * The declaration of Vulkan render pass use trackers.
  *
  * Role summary
diff --git a/source_common/trackers/stats.hpp b/source_common/trackers/stats.hpp
@@ -24,7 +24,7 @@
  */
 
 /**
- * \file
+ * @file
  * This module implements basic counter tracking of Vulkan workloads.
  */
 
diff --git a/source_common/utils/queue.hpp b/source_common/utils/queue.hpp
@@ -51,30 +51,30 @@ class Task
      */
     void wait()
     {
-        std::unique_lock<std::mutex> lock(condition_lock);
-        complete_condition.wait(lock, [this]{ return complete.load(); });
+        std::unique_lock<std::mutex> lock(conditionLock);
+        completeCondition.wait(lock, [this]{ return complete.load(); });
     }
 
     /**
      * @brief Notify that the task is complete.
      */
     void notify()
     {
-        std::unique_lock<std::mutex> lock(condition_lock);
+        std::unique_lock<std::mutex> lock(conditionLock);
         complete = true;
         lock.unlock();
-        complete_condition.notify_all();
+        completeCondition.notify_all();
     }
 
 private:
     /** @brief Task completion status. */
     std::atomic<bool> complete { false };
 
     /** @brief Condition variable for notifications. */
-    std::condition_variable complete_condition;
+    std::condition_variable completeCondition;
 
     /** @brief Lock for notifications. */
-    std::mutex condition_lock;
+    std::mutex conditionLock;
 };
 
 
@@ -86,7 +86,7 @@ class TaskQueue
 {
 private:
     /** @brief Lock for thread-safe access. */
-    std::mutex store_lock;
+    std::mutex storeLock;
 
     /** @brief Condition variable for notifications. */
     std::condition_variable condition;
@@ -103,7 +103,7 @@ class TaskQueue
     void put(
         T task
     ) {
-        std::lock_guard<std::mutex> lock(store_lock);
+        std::lock_guard<std::mutex> lock(storeLock);
         store.push_back(task);
         condition.notify_one();
     }
@@ -117,7 +117,7 @@ class TaskQueue
      */
     T get()
     {
-        std::unique_lock<std::mutex> lock(store_lock);
+        std::unique_lock<std::mutex> lock(storeLock);
 
         // Release lock until we have data, and then reacquire
         while(store.empty())
@@ -138,9 +138,9 @@ class TaskQueue
      *
      * @return @c true if the queue is empty, @c false otherwise.
      */
-    bool is_empty()
+    bool isEmpty()
     {
-        std::unique_lock<std::mutex> lock(store_lock);
+        std::lock_guard<std::mutex> lock(storeLock);
         return store.empty();
     }
 };

Original file line number	Diff line number	Diff line change
`@@ -115,14 +115,14 @@ class Device`
`115`	`115`	`VkCommandBuffer handle);`
`116`	`116`
`117`	`117`	`/**`
`118`		`- * \brief Drop a device from the global store of dispatchable devices.`
	`118`	`+ * @brief Drop a device from the global store of dispatchable devices.`
`119`	`119`	`*`
`120`	`120`	`* This must be called before the driver VkDevice has been destroyed, as`
`121`	`121`	`* we deference the native device handle to get the dispatch key.`
`122`	`122`	`*`
`123`		`- * \param handle The dispatchable device handle to use as an indirect lookup.`
	`123`	`+ * @param handle The dispatchable device handle to use as an indirect lookup.`
`124`	`124`	`*`
`125`		`- * \return Returns the ownership of the Device object to the caller.`
	`125`	`+ * @return Returns the ownership of the Device object to the caller.`
`126`	`126`	`*/`
`127`	`127`	`static std::unique_ptr<Device> destroy(`
`128`	`128`	`VkDevice handle);`
Original file line number	Diff line number	Diff line change
`@@ -99,14 +99,14 @@ class Instance`
`99`	`99`	`VkPhysicalDevice handle);`
`100`	`100`
`101`	`101`	`/**`
`102`		`- * \brief Drop an instance from the global store of dispatchable instances.`
	`102`	`+ * @brief Drop an instance from the global store of dispatchable instances.`
`103`	`103`	`*`
`104`	`104`	`* This must be called before the driver VkInstance has been destroyed, as`
`105`	`105`	`* we deference the native instance handle to get the dispatch key.`
`106`	`106`	`*`
`107`		`- * \param handle The dispatchable instance handle to use as an indirect lookup.`
	`107`	`+ * @param handle The dispatchable instance handle to use as an indirect lookup.`
`108`	`108`	`*`
`109`		`- * \return Returns the ownership of the Instance object to the caller.`
	`109`	`+ * @return Returns the ownership of the Instance object to the caller.`
`110`	`110`	`*/`
`111`	`111`	`static std::unique_ptr<Instance> destroy(`
`112`	`112`	`VkInstance handle);`
Original file line number	Diff line number	Diff line change
`@@ -110,14 +110,14 @@ class Device`
`110`	`110`	`static Device* retrieve(VkCommandBuffer handle);`
`111`	`111`
`112`	`112`	`/**`
`113`		`- * \brief Drop a device from the global store of dispatchable devices.`
	`113`	`+ * @brief Drop a device from the global store of dispatchable devices.`
`114`	`114`	`*`
`115`	`115`	`* This must be called before the driver VkDevice has been destroyed, as`
`116`	`116`	`* we deference the native device handle to get the dispatch key.`
`117`	`117`	`*`
`118`		`- * \param handle The dispatchable device handle to use as an indirect lookup.`
	`118`	`+ * @param handle The dispatchable device handle to use as an indirect lookup.`
`119`	`119`	`*`
`120`		`- * \return Returns the ownership of the Device object to the caller.`
	`120`	`+ * @return Returns the ownership of the Device object to the caller.`
`121`	`121`	`*/`
`122`	`122`	`static std::unique_ptr<Device> destroy(`
`123`	`123`	`VkDevice handle);`
Original file line number	Diff line number	Diff line change
`@@ -95,14 +95,14 @@ class Instance`
`95`	`95`	`static Instance* retrieve(VkPhysicalDevice handle);`
`96`	`96`
`97`	`97`	`/**`
`98`		`- * \brief Drop an instance from the global store of dispatchable instances.`
	`98`	`+ * @brief Drop an instance from the global store of dispatchable instances.`
`99`	`99`	`*`
`100`	`100`	`* This must be called before the driver VkInstance has been destroyed, as`
`101`	`101`	`* we deference the native instance handle to get the dispatch key.`
`102`	`102`	`*`
`103`		`- * \param handle The dispatchable instance handle to use as an indirect lookup.`
	`103`	`+ * @param handle The dispatchable instance handle to use as an indirect lookup.`
`104`	`104`	`*`
`105`		`- * \return Returns the ownership of the Instance object to the caller.`
	`105`	`+ * @return Returns the ownership of the Instance object to the caller.`
`106`	`106`	`*/`
`107`	`107`	`static std::unique_ptr<Instance> destroy(`
`108`	`108`	`VkInstance handle);`
Original file line number	Diff line number	Diff line change
`@@ -118,14 +118,14 @@ class Device`
`118`	`118`	`static Device* retrieve(VkCommandBuffer handle);`
`119`	`119`
`120`	`120`	`/**`
`121`		`- * \brief Drop a device from the global store of dispatchable devices.`
	`121`	`+ * @brief Drop a device from the global store of dispatchable devices.`
`122`	`122`	`*`
`123`	`123`	`* This must be called before the driver VkDevice has been destroyed, as`
`124`	`124`	`* we deference the native device handle to get the dispatch key.`
`125`	`125`	`*`
`126`		`- * \param handle The dispatchable device handle to use as an indirect lookup.`
	`126`	`+ * @param handle The dispatchable device handle to use as an indirect lookup.`
`127`	`127`	`*`
`128`		`- * \return Returns the ownership of the Device object to the caller.`
	`128`	`+ * @return Returns the ownership of the Device object to the caller.`
`129`	`129`	`*/`
`130`	`130`	`static std::unique_ptr<Device> destroy(`
`131`	`131`	`VkDevice handle);`
Original file line number	Diff line number	Diff line change
`@@ -96,14 +96,14 @@ class Instance`
`96`	`96`	`static Instance* retrieve(VkPhysicalDevice handle);`
`97`	`97`
`98`	`98`	`/**`
`99`		`- * \brief Drop an instance from the global store of dispatchable instances.`
	`99`	`+ * @brief Drop an instance from the global store of dispatchable instances.`
`100`	`100`	`*`
`101`	`101`	`* This must be called before the driver VkInstance has been destroyed, as`
`102`	`102`	`* we deference the native instance handle to get the dispatch key.`
`103`	`103`	`*`
`104`		`- * \param handle The dispatchable instance handle to use as an indirect lookup.`
	`104`	`+ * @param handle The dispatchable instance handle to use as an indirect lookup.`
`105`	`105`	`*`
`106`		`- * \return Returns the ownership of the Instance object to the caller.`
	`106`	`+ * @return Returns the ownership of the Instance object to the caller.`
`107`	`107`	`*/`
`108`	`108`	`static std::unique_ptr<Instance> destroy(`
`109`	`109`	`VkInstance handle);`
Original file line number	Diff line number	Diff line change
`@@ -111,14 +111,14 @@ class Device`
`111`	`111`	`static Device* retrieve(VkCommandBuffer handle);`
`112`	`112`
`113`	`113`	`/**`
`114`		`- * \brief Drop a device from the global store of dispatchable devices.`
	`114`	`+ * @brief Drop a device from the global store of dispatchable devices.`
`115`	`115`	`*`
`116`	`116`	`* This must be called before the driver VkDevice has been destroyed, as`
`117`	`117`	`* we deference the native device handle to get the dispatch key.`
`118`	`118`	`*`
`119`		`- * \param handle The dispatchable device handle to use as an indirect lookup.`
	`119`	`+ * @param handle The dispatchable device handle to use as an indirect lookup.`
`120`	`120`	`*`
`121`		`- * \return Returns the ownership of the Device object to the caller.`
	`121`	`+ * @return Returns the ownership of the Device object to the caller.`
`122`	`122`	`*/`
`123`	`123`	`static std::unique_ptr<Device> destroy(`
`124`	`124`	`VkDevice handle);`
Original file line number	Diff line number	Diff line change
`@@ -113,14 +113,14 @@ class Device`
`113`	`113`	`static Device* retrieve(VkCommandBuffer handle);`
`114`	`114`
`115`	`115`	`/**`
`116`		`- * \brief Drop a device from the global store of dispatchable devices.`
	`116`	`+ * @brief Drop a device from the global store of dispatchable devices.`
`117`	`117`	`*`
`118`	`118`	`* This must be called before the driver VkDevice has been destroyed, as`
`119`	`119`	`* we deference the native device handle to get the dispatch key.`
`120`	`120`	`*`
`121`		`- * \param handle The dispatchable device handle to use as an indirect lookup.`
	`121`	`+ * @param handle The dispatchable device handle to use as an indirect lookup.`
`122`	`122`	`*`
`123`		`- * \return Returns the ownership of the Device object to the caller.`
	`123`	`+ * @return Returns the ownership of the Device object to the caller.`
`124`	`124`	`*/`
`125`	`125`	`static std::unique_ptr<Device> destroy(`
`126`	`126`	`VkDevice handle);`