NOD_geometry_nodes_log.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <chrono>
 
#include "BLI_compute_context.hh"
#include "BLI_enumerable_thread_specific.hh"
#include "BLI_generic_pointer.hh"
#include "BLI_linear_allocator_chunked_list.hh"
#include "BLI_multi_value_map.hh"
 
#include "BKE_geometry_set.hh"
#include "BKE_node.hh"
#include "BKE_node_tree_zones.hh"
#include "BKE_viewer_path.hh"
#include "BKE_volume_grid.hh"
 
#include "FN_field.hh"
 
#include "DNA_node_types.h"
 
struct SpaceNode;
 
namespace blender::nodes::geo_eval_log {
 
using fn::GField;
 
enum class NodeWarningType {
  Error = 0,
  Warning = 1,
  Info = 2,
};
 
int node_warning_type_icon(NodeWarningType type);
int node_warning_type_severity(NodeWarningType type);
 
struct NodeWarning {
  NodeWarningType type;
  std::string message;
 
  uint64_t hash() const
  {
    return get_default_hash(this->type, this->message);
  }
 
  BLI_STRUCT_EQUALITY_OPERATORS_2(NodeWarning, type, message)
};
 
enum class NamedAttributeUsage {
  None = 0,
  Read = 1 << 0,
  Write = 1 << 1,
  Remove = 1 << 2,
};
ENUM_OPERATORS(NamedAttributeUsage, NamedAttributeUsage::Remove);
 
class ValueLog {
 public:
  virtual ~ValueLog() = default;
};
 
class GenericValueLog : public ValueLog {
 public:
  GMutablePointer value;
 
  GenericValueLog(const GMutablePointer value) : value(value) {}
 
  ~GenericValueLog();
};
 
class FieldInfoLog : public ValueLog {
 public:
  const CPPType &type;
  Vector<std::string> input_tooltips;
 
  FieldInfoLog(const GField &field);
};
 
struct GeometryAttributeInfo {
  std::string name;
  std::optional<bke::AttrDomain> domain;
  std::optional<eCustomDataType> data_type;
};
 
class GeometryInfoLog : public ValueLog {
 public:
  std::string name;
  Vector<GeometryAttributeInfo> attributes;
  Vector<bke::GeometryComponent::Type> component_types;
 
  struct MeshInfo {
    int verts_num, edges_num, faces_num;
  };
  struct CurveInfo {
    int points_num;
    int splines_num;
  };
  struct PointCloudInfo {
    int points_num;
  };
  struct GreasePencilInfo {
    int layers_num;
  };
  struct InstancesInfo {
    int instances_num;
  };
  struct EditDataInfo {
    bool has_deformed_positions = false;
    bool has_deform_matrices = false;
    int gizmo_transforms_num = 0;
  };
  struct VolumeInfo {
    int grids_num;
  };
  struct GridInfo {
    bool is_empty;
  };
 
  std::optional<MeshInfo> mesh_info;
  std::optional<CurveInfo> curve_info;
  std::optional<PointCloudInfo> pointcloud_info;
  std::optional<GreasePencilInfo> grease_pencil_info;
  std::optional<InstancesInfo> instances_info;
  std::optional<EditDataInfo> edit_data_info;
  std::optional<VolumeInfo> volume_info;
  std::optional<GridInfo> grid_info;
 
  GeometryInfoLog(const bke::GeometrySet &geometry_set);
  GeometryInfoLog(const bke::GVolumeGrid &grid);
};
 
class ViewerNodeLog {
 public:
  bke::GeometrySet geometry;
};
 
using Clock = std::chrono::steady_clock;
using TimePoint = Clock::time_point;
 
class GeoTreeLogger {
 public:
  std::optional<ComputeContextHash> parent_hash;
  std::optional<int32_t> parent_node_id;
  Vector<ComputeContextHash> children_hashes;
  std::chrono::nanoseconds execution_time{};
 
  LinearAllocator<> *allocator = nullptr;
 
  struct WarningWithNode {
    int32_t node_id;
    NodeWarning warning;
  };
  struct SocketValueLog {
    int32_t node_id;
    int socket_index;
    destruct_ptr<ValueLog> value;
  };
  struct NodeExecutionTime {
    int32_t node_id;
    TimePoint start;
    TimePoint end;
  };
  struct ViewerNodeLogWithNode {
    int32_t node_id;
    destruct_ptr<ViewerNodeLog> viewer_log;
  };
  struct AttributeUsageWithNode {
    int32_t node_id;
    StringRefNull attribute_name;
    NamedAttributeUsage usage;
  };
  struct DebugMessage {
    int32_t node_id;
    StringRefNull message;
  };
  struct EvaluatedGizmoNode {
    int32_t node_id;
  };
 
  linear_allocator::ChunkedList<WarningWithNode> node_warnings;
  linear_allocator::ChunkedList<SocketValueLog, 16> input_socket_values;
  linear_allocator::ChunkedList<SocketValueLog, 16> output_socket_values;
  linear_allocator::ChunkedList<NodeExecutionTime, 16> node_execution_times;
  linear_allocator::ChunkedList<ViewerNodeLogWithNode> viewer_node_logs;
  linear_allocator::ChunkedList<AttributeUsageWithNode> used_named_attributes;
  linear_allocator::ChunkedList<DebugMessage> debug_messages;
  linear_allocator::ChunkedList<EvaluatedGizmoNode> evaluated_gizmo_nodes;
 
  GeoTreeLogger();
  ~GeoTreeLogger();
 
  void log_value(const bNode &node, const bNodeSocket &socket, GPointer value);
  void log_viewer_node(const bNode &viewer_node, bke::GeometrySet geometry);
};
 
class GeoNodeLog {
 public:
  VectorSet<NodeWarning> warnings;
  std::chrono::nanoseconds execution_time{0};
  Map<int, ValueLog *> input_values_;
  Map<int, ValueLog *> output_values_;
  Map<StringRefNull, NamedAttributeUsage> used_named_attributes;
  Vector<StringRefNull> debug_messages;
 
  GeoNodeLog();
  ~GeoNodeLog();
};
 
class GeoModifierLog;
 
class GeoTreeLog {
 private:
  GeoModifierLog *modifier_log_;
  Vector<GeoTreeLogger *> tree_loggers_;
  VectorSet<ComputeContextHash> children_hashes_;
  bool reduced_node_warnings_ = false;
  bool reduced_execution_times_ = false;
  bool reduced_socket_values_ = false;
  bool reduced_viewer_node_logs_ = false;
  bool reduced_existing_attributes_ = false;
  bool reduced_used_named_attributes_ = false;
  bool reduced_debug_messages_ = false;
  bool reduced_evaluated_gizmo_nodes_ = false;
 
 public:
  Map<int32_t, GeoNodeLog> nodes;
  Map<int32_t, ViewerNodeLog *, 0> viewer_node_logs;
  VectorSet<NodeWarning> all_warnings;
  std::chrono::nanoseconds execution_time{0};
  Vector<const GeometryAttributeInfo *> existing_attributes;
  Map<StringRefNull, NamedAttributeUsage> used_named_attributes;
  Set<int> evaluated_gizmo_nodes;
 
  GeoTreeLog(GeoModifierLog *modifier_log, Vector<GeoTreeLogger *> tree_loggers);
  ~GeoTreeLog();
 
  void ensure_node_warnings(const bNodeTree *tree);
  void ensure_execution_times();
  void ensure_socket_values();
  void ensure_viewer_node_logs();
  void ensure_existing_attributes();
  void ensure_used_named_attributes();
  void ensure_debug_messages();
  void ensure_evaluated_gizmo_nodes();
 
  ValueLog *find_socket_value_log(const bNodeSocket &query_socket);
  [[nodiscard]] bool try_convert_primitive_socket_value(const GenericValueLog &value_log,
                                                        const CPPType &dst_type,
                                                        void *dst);
 
  template<typename T>
  std::optional<T> find_primitive_socket_value(const bNodeSocket &query_socket)
  {
    if (auto *value_log = dynamic_cast<GenericValueLog *>(
            this->find_socket_value_log(query_socket)))
    {
      T value;
      if (this->try_convert_primitive_socket_value(*value_log, CPPType::get<T>(), &value)) {
        return value;
      }
    }
    return std::nullopt;
  }
};
 
class GeoModifierLog {
 private:
  struct LocalData {
    LinearAllocator<> allocator;
    Map<ComputeContextHash, destruct_ptr<GeoTreeLogger>> tree_logger_by_context;
  };
 
  threading::EnumerableThreadSpecific<LocalData> data_per_thread_;
  Map<ComputeContextHash, std::unique_ptr<GeoTreeLog>> tree_logs_;
 
 public:
  GeoModifierLog();
  ~GeoModifierLog();
 
  GeoTreeLogger &get_local_tree_logger(const ComputeContext &compute_context);
 
  GeoTreeLog &get_tree_log(const ComputeContextHash &compute_context_hash);
 
  static Map<const bke::bNodeTreeZone *, ComputeContextHash>
  get_context_hash_by_zone_for_node_editor(const SpaceNode &snode, StringRefNull modifier_name);
  static Map<const bke::bNodeTreeZone *, ComputeContextHash>
  get_context_hash_by_zone_for_node_editor(const SpaceNode &snode,
                                           ComputeContextBuilder &compute_context_builder);
 
  static Map<const bke::bNodeTreeZone *, GeoTreeLog *> get_tree_log_by_zone_for_node_editor(
      const SpaceNode &snode);
  static const ViewerNodeLog *find_viewer_node_log_for_path(const ViewerPath &viewer_path);
};
 
}  // namespace blender::nodes::geo_eval_log