命名規則を変更

Author: yknishidate

include/reactive/App.hpp

@@ -78,7 +78,7 @@ class App {
     virtual void onRender(const CommandBufferHandle& commandBuffer) {}
     virtual void onShutdown() {}
 
-    void terminate() { running = false; }
+    void terminate() { m_running = false; }
 
     // Getter
     auto getCurrentColorImage() const -> ImageHandle;
@@ -103,9 +103,9 @@ class App {
 
     void listSurfaceFormats();
 
-    Context context;
-    vk::UniqueSurfaceKHR surface;
-    std::unique_ptr<Swapchain> swapchain;
-    bool running = true;
+    Context m_context;
+    vk::UniqueSurfaceKHR m_surface;
+    std::unique_ptr<Swapchain> m_swapchain;
+    bool m_running = true;
 };
 }  // namespace rv

include/reactive/Compiler/Compiler.hpp

@@ -39,12 +39,12 @@ class SlangCompiler
 public:
     SlangCompiler();
 
-    std::vector<Slang::ComPtr<slang::IBlob>> CompileShaders(
+    std::vector<Slang::ComPtr<slang::IBlob>> compileShaders(
         const std::filesystem::path& shaderPath,
         const std::vector<std::string>& entryPointNames);
 
 private:
-    Slang::ComPtr<slang::IGlobalSession> slangGlobalSession;
+    Slang::ComPtr<slang::IGlobalSession> m_globalSession;
 };
 
 }  // namespace rv

include/reactive/Graphics/Accel.hpp

@@ -59,51 +59,51 @@ class BottomAccel {
     friend class CommandBuffer;
 
 public:
-    BottomAccel(const Context& _context, const BottomAccelCreateInfo& createInfo);
+    BottomAccel(const Context& context, const BottomAccelCreateInfo& createInfo);
 
-    auto getBufferAddress() const -> uint64_t { return buffer->getAddress(); }
+    auto getBufferAddress() const -> uint64_t { return m_buffer->getAddress(); }
 
 private:
-    const Context* context;
+    const Context* m_context;
 
-    vk::UniqueAccelerationStructureKHR accel;
+    vk::UniqueAccelerationStructureKHR m_accel;
 
-    BufferHandle buffer;
-    BufferHandle scratchBuffer;
+    BufferHandle m_buffer;
+    BufferHandle m_scratchBuffer;
 
-    vk::AccelerationStructureGeometryTrianglesDataKHR trianglesData;
-    vk::GeometryFlagsKHR geometryFlags;
-    vk::BuildAccelerationStructureFlagsKHR buildFlags;
-    vk::AccelerationStructureBuildTypeKHR buildType;
+    vk::AccelerationStructureGeometryTrianglesDataKHR m_trianglesData;
+    vk::GeometryFlagsKHR m_geometryFlags;
+    vk::BuildAccelerationStructureFlagsKHR m_buildFlags;
+    vk::AccelerationStructureBuildTypeKHR m_buildType;
 
-    uint32_t maxPrimitiveCount;
+    uint32_t m_maxPrimitiveCount;
 };
 
 class TopAccel {
     friend class CommandBuffer;
 
 public:
-    TopAccel(const Context& _context, const TopAccelCreateInfo& createInfo);
+    TopAccel(const Context& context, const TopAccelCreateInfo& createInfo);
 
-    auto getAccel() const -> vk::AccelerationStructureKHR { return *accel; }
+    auto getAccel() const -> vk::AccelerationStructureKHR { return *m_accel; }
 
-    auto getInfo() const -> vk::WriteDescriptorSetAccelerationStructureKHR { return {*accel}; }
+    auto getInfo() const -> vk::WriteDescriptorSetAccelerationStructureKHR { return {*m_accel}; }
 
     void updateInstances(ArrayProxy<AccelInstance> accelInstances) const;
 
 private:
-    const Context* context;
+    const Context* m_context;
 
-    vk::UniqueAccelerationStructureKHR accel;
+    vk::UniqueAccelerationStructureKHR m_accel;
 
-    BufferHandle buffer;
-    BufferHandle instanceBuffer;
-    BufferHandle scratchBuffer;
+    BufferHandle m_buffer;
+    BufferHandle m_instanceBuffer;
+    BufferHandle m_scratchBuffer;
 
-    uint32_t primitiveCount;
-    vk::AccelerationStructureGeometryInstancesDataKHR instancesData;
-    vk::GeometryFlagsKHR geometryFlags;
-    vk::BuildAccelerationStructureFlagsKHR buildFlags;
-    vk::AccelerationStructureBuildTypeKHR buildType;
+    uint32_t m_primitiveCount;
+    vk::AccelerationStructureGeometryInstancesDataKHR m_instancesData;
+    vk::GeometryFlagsKHR m_geometryFlags;
+    vk::BuildAccelerationStructureFlagsKHR m_buildFlags;
+    vk::AccelerationStructureBuildTypeKHR m_buildType;
 };
 }  // namespace rv

include/reactive/Graphics/Buffer.hpp

@@ -16,11 +16,11 @@ class Buffer {
     friend class CommandBuffer;
 
 public:
-    Buffer(const Context& _context, const BufferCreateInfo& createInfo);
+    Buffer(const Context& context, const BufferCreateInfo& createInfo);
 
-    auto getBuffer() const -> vk::Buffer { return *buffer; }
-    auto getSize() const -> vk::DeviceSize { return size; }
-    auto getInfo() const -> vk::DescriptorBufferInfo { return {*buffer, 0, size}; }
+    auto getBuffer() const -> vk::Buffer { return *m_buffer; }
+    auto getSize() const -> vk::DeviceSize { return m_size; }
+    auto getInfo() const -> vk::DescriptorBufferInfo { return {*m_buffer, 0, m_size}; }
     auto getAddress() const -> vk::DeviceAddress;
 
     auto map() -> void*;
@@ -30,17 +30,17 @@ class Buffer {
     void prepareStagingBuffer();
 
 private:
-    const Context* context = nullptr;
+    const Context* m_context = nullptr;
 
-    vk::UniqueBuffer buffer;
-    vk::UniqueDeviceMemory memory;
-    vk::DeviceSize size = 0u;
+    vk::UniqueBuffer m_buffer;
+    vk::UniqueDeviceMemory m_memory;
+    vk::DeviceSize m_size = 0u;
 
     // For host buffer
-    void* mapped = nullptr;
-    bool isHostVisible;
+    void* m_mapped = nullptr;
+    bool m_isHostVisible;
 
     // For device buffer
-    BufferHandle stagingBuffer;
+    BufferHandle m_stagingBuffer;
 };
 }  // namespace rv

include/reactive/Graphics/CommandBuffer.hpp

@@ -23,13 +23,13 @@ class CommandBuffer {
 public:
     CommandBuffer() = default;
 
-    CommandBuffer(const Context& _context,
+    CommandBuffer(const Context& context,
                   vk::CommandBuffer commandBuffer,
                   vk::CommandPool commandPool,
                   vk::QueueFlags queueFlags)
-        : context{&_context},
-          commandBuffer{commandBuffer, {context->getDevice(), commandPool}},
-          queueFlags{queueFlags} {}
+        : m_context{&context},
+          m_commandBuffer{commandBuffer, {m_context->getDevice(), commandPool}},
+          m_queueFlags{queueFlags} {}
 
     auto getQueueFlags() const -> vk::QueueFlags;
 
@@ -180,8 +180,8 @@ class CommandBuffer {
     void beginDebugLabel(const char* labelName) const;
     void endDebugLabel() const;
 
-    const Context* context = nullptr;
-    vk::UniqueCommandBuffer commandBuffer;
-    vk::QueueFlags queueFlags;
+    const Context* m_context = nullptr;
+    vk::UniqueCommandBuffer m_commandBuffer;
+    vk::QueueFlags m_queueFlags;
 };
 }  // namespace rv

include/reactive/Graphics/Context.hpp

@@ -191,19 +191,19 @@ class Context {
                     bool enableRayTracing);
 
     // Getter
-    auto getInstance() const -> vk::Instance { return *instance; }
+    auto getInstance() const -> vk::Instance { return *m_instance; }
 
-    auto getDevice() const -> vk::Device { return *device; }
+    auto getDevice() const -> vk::Device { return *m_device; }
 
-    auto getPhysicalDevice() const -> vk::PhysicalDevice { return physicalDevice; }
+    auto getPhysicalDevice() const -> vk::PhysicalDevice { return m_physicalDevice; }
 
     auto getQueue(vk::QueueFlags flag = QueueFlags::General) const -> vk::Queue;
 
     auto getQueueFamily(vk::QueueFlags flag = QueueFlags::General) const -> uint32_t;
 
     auto getCommandPool(vk::QueueFlags flag = QueueFlags::General) const -> vk::CommandPool;
 
-    auto getDescriptorPool() const -> vk::DescriptorPool { return *descriptorPool; }
+    auto getDescriptorPool() const -> vk::DescriptorPool { return *m_descriptorPool; }
 
     // Command buffer
     auto allocateCommandBuffer(vk::QueueFlags flag = QueueFlags::General) const
@@ -230,14 +230,14 @@ class Context {
         vk::PhysicalDeviceProperties2 props2;
         T props;
         props2.pNext = &props;
-        physicalDevice.getProperties2(&props2);
+        m_physicalDevice.getProperties2(&props2);
         return props;
     }
 
     auto getPhysicalDeviceLimits() const -> vk::PhysicalDeviceLimits;
 
     // Debug
-    auto debugEnabled() const -> bool { return debugMessenger.get(); }
+    auto debugEnabled() const -> bool { return m_debugMessenger.get(); }
 
     template <typename T, typename = std::enable_if_t<vk::isVulkanHandleType<T>::value>>
     void setDebugName(T object, const char* debugName) const {
@@ -302,14 +302,14 @@ class Context {
     };
     auto getThreadQueue(vk::QueueFlags flag) const -> const ThreadQueue&;
 
-    vk::UniqueInstance instance;
-    vk::UniqueDebugUtilsMessengerEXT debugMessenger;
-    vk::UniqueDevice device;
-    vk::PhysicalDevice physicalDevice;
+    vk::UniqueInstance m_instance;
+    vk::UniqueDebugUtilsMessengerEXT m_debugMessenger;
+    vk::UniqueDevice m_device;
+    vk::PhysicalDevice m_physicalDevice;
 
-    mutable std::mutex queueMutex;
-    mutable std::map<vk::QueueFlags, std::vector<ThreadQueue>> queues;
-    std::unordered_map<vk::QueueFlags, uint32_t> queueFamilies;
-    vk::UniqueDescriptorPool descriptorPool;
+    mutable std::mutex m_queueMutex;
+    mutable std::map<vk::QueueFlags, std::vector<ThreadQueue>> m_queues;
+    std::unordered_map<vk::QueueFlags, uint32_t> m_queueFamilies;
+    vk::UniqueDescriptorPool m_descriptorPool;
 };
 }  // namespace rv

include/reactive/Graphics/DescriptorSet.hpp

@@ -17,24 +17,24 @@ struct DescriptorSetCreateInfo {
 
 class DescriptorSet {
 public:
-    DescriptorSet(const Context& _context, const DescriptorSetCreateInfo& createInfo);
+    DescriptorSet(const Context& context, const DescriptorSetCreateInfo& createInfo);
 
     void update();
 
     void set(const std::string& name, ArrayProxy<BufferHandle> buffers);
     void set(const std::string& name, ArrayProxy<ImageHandle> images);
     void set(const std::string& name, ArrayProxy<TopAccelHandle> accels);
 
-    vk::DescriptorSetLayout getLayout() const { return *descSetLayout; }
-    vk::DescriptorSet getDescriptorSet() const { return *descSet; }
+    vk::DescriptorSetLayout getLayout() const { return *m_descSetLayout; }
+    vk::DescriptorSet getDescriptorSet() const { return *m_descSet; }
 
 private:
     void addResources(ShaderHandle shader);
     void updateBindingMap(const SpvReflectDescriptorBinding* binding, vk::ShaderStageFlags stage);
 
-    const Context* context;
-    vk::UniqueDescriptorSet descSet;
-    vk::UniqueDescriptorSetLayout descSetLayout;
+    const Context* m_context;
+    vk::UniqueDescriptorSet m_descSet;
+    vk::UniqueDescriptorSetLayout m_descSetLayout;
 
     using BufferInfos = std::vector<vk::DescriptorBufferInfo>;
     using ImageInfos = std::vector<vk::DescriptorImageInfo>;
@@ -44,6 +44,6 @@ class DescriptorSet {
         std::variant<BufferInfos, ImageInfos, AccelInfos> infos;
     };
 
-    std::unordered_map<std::string, Descriptor> descriptors;
+    std::unordered_map<std::string, Descriptor> m_descriptors;
 };
 }  // namespace rv

include/reactive/Graphics/Fence.hpp

@@ -9,17 +9,17 @@ struct FenceCreateInfo {
 
 class Fence {
 public:
-    Fence(const Context& _context, const FenceCreateInfo& createInfo);
+    Fence(const Context& context, const FenceCreateInfo& createInfo);
 
-    auto getFence() const -> vk::Fence { return *fence; }
+    auto getFence() const -> vk::Fence { return *m_fence; }
 
     void wait() const;
     void reset() const;
     auto finished() const -> bool;
 
 private:
-    const Context* context = nullptr;
+    const Context* m_context = nullptr;
 
-    vk::UniqueFence fence;
+    vk::UniqueFence m_fence;
 };
 }  // namespace rv