draw_manager.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2022 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include "BLI_listbase.h"
#include "BLI_map.hh"
#include "BLI_sys_types.h"
 
#include "GPU_material.hh"
 
#include "draw_resource.hh"
#include "draw_view.hh"
 
#include <atomic>
 
namespace blender::draw {
 
/* Forward declarations. */
 
namespace detail {
template<typename T> class Pass;
}  // namespace detail
 
namespace command {
class DrawCommandBuf;
class DrawMultiBuf;
}  // namespace command
 
using PassSimple = detail::Pass<command::DrawCommandBuf>;
using PassMain = detail::Pass<command::DrawMultiBuf>;
class PassSortable;
 
class Manager {
  using ObjectMatricesBuf = StorageArrayBuffer<ObjectMatrices, 128>;
  using ObjectBoundsBuf = StorageArrayBuffer<ObjectBounds, 128>;
  using ObjectInfosBuf = StorageArrayBuffer<ObjectInfos, 128>;
  using ObjectAttributeBuf = StorageArrayBuffer<ObjectAttribute, 128>;
  using LayerAttributeBuf = UniformArrayBuffer<LayerAttribute, 512>;
  using ObjectAttributeLegacyBuf = UniformArrayBuffer<float4, 8 * 512>;
 
 public:
  struct SubmitDebugOutput {
    Span<uint32_t> visibility;
    Span<uint32_t> resource_id;
  };
 
  struct DataDebugOutput {
    Span<ObjectMatrices> matrices;
    Span<ObjectBounds> bounds;
    Span<ObjectInfos> infos;
  };

  SwapChain<ObjectMatricesBuf, 2> matrix_buf;
  SwapChain<ObjectBoundsBuf, 2> bounds_buf;
  SwapChain<ObjectInfosBuf, 2> infos_buf;

  ObjectAttributeBuf attributes_buf;

  Map<uint32_t, GPULayerAttr> layer_attributes;

  LayerAttributeBuf layer_attributes_buf;

  Vector<GPUTexture *> acquired_textures;
 
 private:
  static std::atomic<uint32_t> global_sync_counter_;
 
  /* Local sync counter. Used for fingerprint. Must never be null. */
  uint32_t sync_counter_ = 1;

  uint resource_len_ = 0;
  uint attribute_len_ = 0;
 
  Object *object_active = nullptr;
 
 public:
  Manager(){};
  ~Manager();

  ResourceHandleRange unique_handle(const ObjectRef &ref);
  /* WORKAROUND: Instead of breaking const correctness everywhere, we only break it for this. */
  ResourceHandleRange resource_handle(const ObjectRef &ref, float inflate_bounds = 0.0f);
  ResourceHandle resource_handle(const ObjectRef &ref,
                                 const float4x4 *model_matrix,
                                 const float3 *bounds_center,
                                 const float3 *bounds_half_extent);
  ResourceHandle resource_handle(const float4x4 &model_matrix);
  ResourceHandle resource_handle(const float4x4 &model_matrix,
                                 const float3 &bounds_center,
                                 const float3 &bounds_half_extent);
  ResourceHandle resource_handle_for_psys(const ObjectRef &ref, const float4x4 &model_matrix);
 
  ResourceHandleRange resource_handle_for_sculpt(const ObjectRef &ref);

  void update_handle_bounds(ResourceHandle handle,
                            const ObjectRef &ref,
                            float inflate_bounds = 0.0f);
  void update_handle_bounds(ResourceHandle handle,
                            const float3 &bounds_center,
                            const float3 &bounds_half_extent);

  void extract_object_attributes(ResourceHandle handle,
                                 const ObjectRef &ref,
                                 const GPUMaterial *material);
  void extract_object_attributes(ResourceHandle handle,
                                 const ObjectRef &ref,
                                 Span<GPUMaterial *> materials);

  void register_layer_attributes(GPUMaterial *material);


  void compute_visibility(View &view);
  void ensure_visibility(View &view);
  void generate_commands(PassMain &pass, View &view);
  void generate_commands(PassSortable &pass, View &view);
  void generate_commands(PassSimple &pass);

  void warm_shader_specialization(PassMain &pass);
  void warm_shader_specialization(PassSimple &pass);

  void submit_only(PassMain &pass, View &view);
  void submit(PassSimple &pass, View &view);
  void submit(PassMain &pass, View &view);
  void submit(PassSortable &pass, View &view);
  void submit(PassSimple &pass, bool inverted_view = false);

  SubmitDebugOutput submit_debug(PassSimple &pass, View &view);
  SubmitDebugOutput submit_debug(PassMain &pass, View &view);

  DataDebugOutput data_debug();

  void acquire_texture(GPUTexture *texture)
  {
    GPU_texture_ref(texture);
    acquired_textures.append(texture);
  }

  uint resource_handle_count() const
  {
    return resource_len_;
  }

  void begin_sync(Object *object_active = nullptr);
  void end_sync();
 
  void debug_bind();
  void resource_bind();
 
 private:
  void sync_layer_attributes();
 
  /* Fingerprint of the manager in a certain state. Assured to not be 0.
   * Not reliable enough for general update detection. Only to be used for debugging assertion. */
  uint64_t fingerprint_get();
};
 
inline ResourceHandleRange Manager::unique_handle(const ObjectRef &ref)
{
  if (ref.handle.handle_first.raw == 0) {
    /* WORKAROUND: Instead of breaking const correctness everywhere, we only break it for this. */
    const_cast<ObjectRef &>(ref).handle = resource_handle(ref);
  }
  return ref.handle;
}
 
inline ResourceHandleRange Manager::resource_handle(const ObjectRef &ref, float inflate_bounds)
{
  bool is_active_object = (ref.dupli_object ? ref.dupli_parent : ref.object) == object_active;
  bool is_edit_mode = object_active && DRW_object_is_in_edit_mode(object_active) &&
                      ref.object->mode == object_active->mode;
  matrix_buf.current().get_or_resize(resource_len_).sync(*ref.object);
  bounds_buf.current().get_or_resize(resource_len_).sync(*ref.object, inflate_bounds);
  infos_buf.current().get_or_resize(resource_len_).sync(ref, is_active_object, is_edit_mode);
  return ResourceHandle(resource_len_++, (ref.object->transflag & OB_NEG_SCALE) != 0);
}
 
inline ResourceHandle Manager::resource_handle(const ObjectRef &ref,
                                               const float4x4 *model_matrix,
                                               const float3 *bounds_center,
                                               const float3 *bounds_half_extent)
{
  bool is_active_object = (ref.dupli_object ? ref.dupli_parent : ref.object) == object_active;
  bool is_edit_mode = object_active && DRW_object_is_in_edit_mode(object_active) &&
                      ref.object->mode == object_active->mode;
  if (model_matrix) {
    matrix_buf.current().get_or_resize(resource_len_).sync(*model_matrix);
  }
  else {
    matrix_buf.current().get_or_resize(resource_len_).sync(*ref.object);
  }
  if (bounds_center && bounds_half_extent) {
    bounds_buf.current().get_or_resize(resource_len_).sync(*bounds_center, *bounds_half_extent);
  }
  else {
    bounds_buf.current().get_or_resize(resource_len_).sync(*ref.object);
  }
  infos_buf.current().get_or_resize(resource_len_).sync(ref, is_active_object, is_edit_mode);
  return ResourceHandle(resource_len_++, (ref.object->transflag & OB_NEG_SCALE) != 0);
}
 
inline ResourceHandle Manager::resource_handle(const float4x4 &model_matrix)
{
  matrix_buf.current().get_or_resize(resource_len_).sync(model_matrix);
  bounds_buf.current().get_or_resize(resource_len_).sync();
  infos_buf.current().get_or_resize(resource_len_).sync();
  return ResourceHandle(resource_len_++, false);
}
 
inline ResourceHandle Manager::resource_handle(const float4x4 &model_matrix,
                                               const float3 &bounds_center,
                                               const float3 &bounds_half_extent)
{
  matrix_buf.current().get_or_resize(resource_len_).sync(model_matrix);
  bounds_buf.current().get_or_resize(resource_len_).sync(bounds_center, bounds_half_extent);
  infos_buf.current().get_or_resize(resource_len_).sync();
  return ResourceHandle(resource_len_++, false);
}
 
inline ResourceHandle Manager::resource_handle_for_psys(const ObjectRef &ref,
                                                        const float4x4 &model_matrix)
{
  bool is_active_object = (ref.dupli_object ? ref.dupli_parent : ref.object) == object_active;
  bool matches_active_object_edit_mode = object_active &&
                                         object_active->mode == eObjectMode::OB_MODE_EDIT &&
                                         ref.object->mode == object_active->mode;
  matrix_buf.current().get_or_resize(resource_len_).sync(model_matrix);
  bounds_buf.current().get_or_resize(resource_len_).sync();
  infos_buf.current()
      .get_or_resize(resource_len_)
      .sync(ref, is_active_object, matches_active_object_edit_mode);
  return ResourceHandle(resource_len_++, (ref.object->transflag & OB_NEG_SCALE) != 0);
}
 
inline void Manager::update_handle_bounds(ResourceHandle handle,
                                          const ObjectRef &ref,
                                          float inflate_bounds)
{
  bounds_buf.current()[handle.resource_index()].sync(*ref.object, inflate_bounds);
}
 
inline void Manager::update_handle_bounds(ResourceHandle handle,
                                          const float3 &bounds_center,
                                          const float3 &bounds_half_extent)
{
  bounds_buf.current()[handle.resource_index()].sync(bounds_center, bounds_half_extent);
}
 
inline void Manager::extract_object_attributes(ResourceHandle handle,
                                               const ObjectRef &ref,
                                               const GPUMaterial *material)
{
  ObjectInfos &infos = infos_buf.current().get_or_resize(handle.resource_index());
  infos.object_attrs_offset = attribute_len_;
 
  const GPUUniformAttrList *attr_list = GPU_material_uniform_attributes(material);
  if (attr_list == nullptr) {
    return;
  }
 
  LISTBASE_FOREACH (const GPUUniformAttr *, attr, &attr_list->list) {
    if (attributes_buf.get_or_resize(attribute_len_).sync(ref, *attr)) {
      infos.object_attrs_len++;
      attribute_len_++;
    }
  }
}
 
inline void Manager::extract_object_attributes(ResourceHandle handle,
                                               const ObjectRef &ref,
                                               Span<GPUMaterial *> materials)
{
  ObjectInfos &infos = infos_buf.current().get_or_resize(handle.resource_index());
  infos.object_attrs_offset = attribute_len_;
 
  /* Simple cache solution to avoid duplicates. */
  Vector<uint32_t, 4> hash_cache;
 
  for (const GPUMaterial *mat : materials) {
    const GPUUniformAttrList *attr_list = GPU_material_uniform_attributes(mat);
    if (attr_list == nullptr) {
      continue;
    }
 
    LISTBASE_FOREACH (const GPUUniformAttr *, attr, &attr_list->list) {
      if ((mat != materials.first()) && (hash_cache.first_index_of_try(attr->hash_code) != -1)) {
        /* Attribute has already been added to the attribute buffer by another material. */
        continue;
      }
      hash_cache.append(attr->hash_code);
      if (attributes_buf.get_or_resize(attribute_len_).sync(ref, *attr)) {
        infos.object_attrs_len++;
        attribute_len_++;
      }
    }
  }
}
 
inline void Manager::register_layer_attributes(GPUMaterial *material)
{
  const ListBase *attr_list = GPU_material_layer_attributes(material);
 
  if (attr_list != nullptr) {
    LISTBASE_FOREACH (const GPULayerAttr *, attr, attr_list) {
      layer_attributes.add(attr->hash_code, *attr);
    }
  }
}
 
}  // namespace blender::draw
 
/* TODO(@fclem): This is for testing. The manager should be passed to the engine through the
 * callbacks. */
blender::draw::Manager *DRW_manager_get();