Fix minimal uniform buffer offset alignment

Author: floppyhammer

pathfinder/core/d3d9/renderer.cpp

@@ -88,9 +88,10 @@ void RendererD3D9::update_tile_batch_storage(uint32_t new_tile_batch_count) {
     }
 
     // Create a new uniform buffer.
-    tile_ub_id = allocator->allocate_buffer(new_tile_batch_count * sizeof(TileUniformD3d9),
-                                            BufferType::Uniform,
-                                            "tile uniform buffer");
+    tile_ub_id =
+        allocator->allocate_buffer(new_tile_batch_count * device->get_aligned_uniform_size(sizeof(TileUniformD3d9)),
+                                   BufferType::Uniform,
+                                   "tile uniform buffer");
 
     for (int i = tile_batch_storage_count; i < new_tile_batch_count; i++) {
         // Set descriptor set.
@@ -488,7 +489,7 @@ void RendererD3D9::upload_and_draw_tiles(const std::vector<DrawTileBatchD3D9> &t
                    z_buffer_texture_id,
                    encoder,
                    tile_descriptor_sets[tile_batch_idx],
-                   tile_batch_idx * sizeof(TileUniformD3d9));
+                   tile_batch_idx * device->get_aligned_uniform_size(sizeof(TileUniformD3d9)));
 
         tile_batch_idx++;
     }

pathfinder/gpu/device.h

@@ -65,6 +65,8 @@ class Device : public std::enable_shared_from_this<Device> {
 
     virtual std::shared_ptr<Fence> create_fence(const std::string &label) = 0;
 
+    virtual size_t get_aligned_uniform_size(size_t original_size) = 0;
+
     BackendType get_backend_type() const {
         return backend_type;
     }

pathfinder/gpu/gl/device.cpp

@@ -13,6 +13,8 @@ namespace Pathfinder {
 
 DeviceGl::DeviceGl() {
     backend_type = BackendType::Opengl;
+
+    glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &min_uniform_alignment_);
 }
 
 std::shared_ptr<Framebuffer> DeviceGl::create_framebuffer(const std::shared_ptr<RenderPass> &render_pass,
@@ -106,4 +108,9 @@ std::shared_ptr<Fence> DeviceGl::create_fence(const std::string &label) {
     return fence_gl;
 }
 
+size_t DeviceGl::get_aligned_uniform_size(size_t original_size) {
+    GLint aligned_size = (original_size + min_uniform_alignment_ - 1) & ~(min_uniform_alignment_ - 1);
+    return aligned_size;
+}
+
 } // namespace Pathfinder

pathfinder/gpu/gl/device.h

@@ -55,6 +55,11 @@ class DeviceGl : public Device {
                                                              const std::string &label) override;
 
     std::shared_ptr<Fence> create_fence(const std::string &label) override;
+
+    size_t get_aligned_uniform_size(size_t original_size) override;
+
+private:
+    GLint min_uniform_alignment_{};
 };
 
 } // namespace Pathfinder

pathfinder/gpu/vk/device.cpp

@@ -26,6 +26,10 @@ DeviceVk::DeviceVk(VkDevice vk_device,
     : vk_physical_device_(vk_physical_device), vk_device_(vk_device), vk_graphics_queue_(vk_graphics_queue),
       vk_present_queue_(vk_present_queue), vk_command_pool_(vk_command_pool) {
     backend_type = BackendType::Vulkan;
+
+    VkPhysicalDeviceProperties props;
+    vkGetPhysicalDeviceProperties(vk_physical_device, &props);
+    min_uniform_alignment_ = props.limits.minUniformBufferOffsetAlignment;
 }
 
 VkDevice DeviceVk::get_device() const {
@@ -761,4 +765,9 @@ void DeviceVk::copy_data_from_mappable_memory(void *dst, VkDeviceMemory buffer_m
     vkUnmapMemory(vk_device_, buffer_memory);
 }
 
+size_t DeviceVk::get_aligned_uniform_size(size_t original_size) {
+    VkDeviceSize aligned_size = (original_size + min_uniform_alignment_ - 1) & ~(min_uniform_alignment_ - 1);
+    return aligned_size;
+}
+
 } // namespace Pathfinder

pathfinder/gpu/vk/device.h

@@ -88,6 +88,8 @@ class DeviceVk : public Device {
                         VkDeviceSize src_offset = 0,
                         VkDeviceSize dst_offset = 0) const;
 
+    size_t get_aligned_uniform_size(size_t original_size) override;
+
 private:
     /// The graphics card that we'll end up selecting will be stored in a VkPhysicalDevice handle.
     VkPhysicalDevice vk_physical_device_{};
@@ -100,6 +102,8 @@ class DeviceVk : public Device {
 
     VkCommandPool vk_command_pool_{};
 
+    VkDeviceSize min_uniform_alignment_{};
+
     VkShaderModule create_shader_module(const std::vector<char> &code);
 
     void create_vk_image(uint32_t width,