vk_memory_layout.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "gpu_shader_create_info.hh"
 
#include "BLI_math_base.h"
#include "BLI_math_vector_types.hh"
 
namespace blender::gpu {

struct Std140 {
  static uint32_t component_mem_size(const shader::Type type);
  static uint32_t element_alignment(const shader::Type type, bool is_array);
  static uint32_t element_components_len(const shader::Type type);
  static uint32_t array_components_len(const shader::Type type);
  static uint32_t inner_row_padding(const shader::Type type);
};

struct Std430 {
  static uint32_t component_mem_size(const shader::Type type);
  static uint32_t element_alignment(const shader::Type type, bool is_array);
  static uint32_t element_components_len(const shader::Type type);
  static uint32_t array_components_len(const shader::Type type);
  static uint32_t inner_row_padding(const shader::Type type);
};
 
template<typename LayoutT> static uint32_t element_stride(const shader::Type type)
{
  return LayoutT::element_components_len(type) * LayoutT::component_mem_size(type);
}
 
template<typename LayoutT> static uint32_t array_stride(const shader::Type type)
{
  return LayoutT::array_components_len(type) * LayoutT::component_mem_size(type);
}

template<typename LayoutT>
static void align(const shader::Type &type, const int32_t array_size, uint32_t *r_offset)
{
  uint32_t alignment = LayoutT::element_alignment(type, array_size != 0);
  uint32_t alignment_mask = alignment - 1;
  uint32_t offset = *r_offset;
  if ((offset & alignment_mask) != 0) {
    offset &= ~alignment_mask;
    offset += alignment;
    *r_offset = offset;
  }
}

template<typename LayoutT>
static void reserve(const shader::Type type, int32_t array_size, uint32_t *r_offset)
{
  uint32_t size = array_size == 0 ? element_stride<LayoutT>(type) :
                                    array_stride<LayoutT>(type) * array_size;
  *r_offset += size;
}

template<typename LayoutT> static void align_end_of_struct(uint32_t *r_offset)
{
  align<LayoutT>(shader::Type::float4_t, 0, r_offset);
}

struct TransferRegion {
  int3 offset;
  int3 extent;
  IndexRange layers;
 
  int64_t sample_count() const
  {
    return int64_t(extent.x) * int64_t(extent.y) * int64_t(extent.z) * layers.size();
  }
 
  int64_t result_offset(int3 sub_offset, int layer) const
  {
    int64_t diff_x = sub_offset.x - offset.x;
    int64_t diff_y = sub_offset.y - offset.y;
    int64_t diff_z = sub_offset.z - offset.z;
    int64_t diff_l = layer - layers.start();
 
    return (diff_l * extent.x * extent.y * extent.z) + (diff_z * extent.x * extent.y) +
           (diff_y * extent.x) + diff_x;
  }
};
 
}  // namespace blender::gpu