BKE_grease_pencil.hh

Go to the documentation of this file.

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

 
#include <atomic>
 
#include "BLI_color.hh"
#include "BLI_implicit_sharing_ptr.hh"
#include "BLI_map.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_offset_indices.hh"
#include "BLI_shared_cache.hh"
#include "BLI_virtual_array_fwd.hh"
 
#include "DNA_grease_pencil_types.h"
 
struct Brush;
struct Main;
struct Depsgraph;
struct Scene;
struct Object;
struct Material;
 
namespace blender::bke::bake {
struct BakeMaterialsList;
}
 
namespace blender::bke {
struct AttributeAccessorFunctions;
 
namespace greasepencil {
 
/* Previously, Grease Pencil used a radius convention where 1 `px` = 0.001 units. This `px`
 * was the brush size which would be stored in the stroke thickness and then scaled by the
 * point pressure factor. Finally, the render engine would divide this thickness value by
 * 2000 (we're going from a thickness to a radius, hence the factor of two) to convert back
 * into blender units. With Grease Pencil 3, the radius is no longer stored in `px` space,
 * but in blender units (world space) directly. Also note that there is no longer a stroke
 * "thickness" attribute, the radii are directly stored on the points.
 * For compatibility, legacy thickness values have to be multiplied by this factor. */
constexpr float LEGACY_RADIUS_CONVERSION_FACTOR = 1.0f / 2000.0f;
 
class DrawingRuntime {
 public:
  mutable SharedCache<Vector<int>> triangle_offsets_cache;
  mutable SharedCache<Vector<int3>> triangles_cache;

  mutable SharedCache<Vector<float3>> curve_plane_normals_cache;
 
  /*
   * Matrices that transform from a 3D point in layer-space to a 2D point in texture-space. This is
   * stored per curve.
   */
  mutable SharedCache<Vector<float4x2>> curve_texture_matrices;

  mutable std::atomic<int> user_count = 1;
};
 
class Drawing : public ::GreasePencilDrawing {
 public:
  Drawing();
  Drawing(const Drawing &other);
  Drawing(Drawing &&other);
  Drawing &operator=(const Drawing &other);
  Drawing &operator=(Drawing &&other);
  ~Drawing();
 
  const bke::CurvesGeometry &strokes() const;
  bke::CurvesGeometry &strokes_for_write();
  Span<int3> triangles() const;
  Span<float3> curve_plane_normals() const;
 
  void tag_texture_matrices_changed();
 
  void tag_positions_changed();
  void tag_positions_changed(const IndexMask &changed_curves);
 
  void tag_topology_changed();
  void tag_topology_changed(const IndexMask &changed_curves);

  Span<float4x2> texture_matrices() const;
  void set_texture_matrices(Span<float4x2> matrices, const IndexMask &selection);

  VArray<float> radii() const;
  MutableSpan<float> radii_for_write();

  VArray<float> opacities() const;
  MutableSpan<float> opacities_for_write();

  VArray<ColorGeometry4f> vertex_colors() const;
  MutableSpan<ColorGeometry4f> vertex_colors_for_write();

  VArray<ColorGeometry4f> fill_colors() const;
  MutableSpan<ColorGeometry4f> fill_colors_for_write();

  void add_user() const;
  void remove_user() const;
  bool is_instanced() const;
  bool has_users() const;
  int user_count() const;
 
 private:
  OffsetIndices<int> triangle_offsets() const;
};
static_assert(sizeof(Drawing) == sizeof(::GreasePencilDrawing));
 
class DrawingReference : public ::GreasePencilDrawingReference {
 public:
  DrawingReference();
  DrawingReference(const DrawingReference &other);
  ~DrawingReference();
};
static_assert(sizeof(DrawingReference) == sizeof(::GreasePencilDrawingReference));

void copy_drawing_array(Span<const GreasePencilDrawingBase *> src_drawings,
                        MutableSpan<GreasePencilDrawingBase *> dst_drawings);
 
class LayerGroup;
class Layer;
 
/* Defines the common functions used by #TreeNode, #Layer, and #LayerGroup.
 * NOTE: Because we cannot mix C-style and C++ inheritance (all of these three classes wrap a
 * C-struct that already uses "inheritance"), we define and implement these methods on all these
 * classes individually. This just means that we can call `layer->name()` directly instead of
 * having to write `layer->as_node().name()`. For #Layer and #LayerGroup the calls are just
 * forwarded to #TreeNode. */
#define TREENODE_COMMON_METHODS \
  StringRefNull name() const; \
  void set_name(StringRef new_name); \
  bool is_visible() const; \
  void set_visible(bool visible); \
  bool is_locked() const; \
  void set_locked(bool locked); \
  bool is_editable() const; \
  bool is_selected() const; \
  void set_selected(bool selected); \
  bool use_onion_skinning() const; \
  bool use_masks() const; \
  bool ignore_locked_materials() const; \
  bool is_child_of(const LayerGroup &group) const;
 
/* Implements the forwarding of the methods defined by #TREENODE_COMMON_METHODS. */
#define TREENODE_COMMON_METHODS_FORWARD_IMPL(class_name) \
  inline StringRefNull class_name::name() const \
  { \
    return this->as_node().name(); \
  } \
  inline void class_name::set_name(const StringRef new_name) \
  { \
    return this->as_node().set_name(new_name); \
  } \
  inline bool class_name::is_visible() const \
  { \
    return this->as_node().is_visible(); \
  } \
  inline void class_name::set_visible(const bool visible) \
  { \
    this->as_node().set_visible(visible); \
  } \
  inline bool class_name::is_locked() const \
  { \
    return this->as_node().is_locked(); \
  } \
  inline void class_name::set_locked(const bool locked) \
  { \
    this->as_node().set_locked(locked); \
  } \
  inline bool class_name::is_editable() const \
  { \
    return this->as_node().is_editable(); \
  } \
  inline bool class_name::is_selected() const \
  { \
    return this->as_node().is_selected(); \
  } \
  inline void class_name::set_selected(const bool selected) \
  { \
    this->as_node().set_selected(selected); \
  } \
  inline bool class_name::use_onion_skinning() const \
  { \
    return this->as_node().use_onion_skinning(); \
  } \
  inline bool class_name::use_masks() const \
  { \
    return this->as_node().use_masks(); \
  } \
  inline bool class_name::ignore_locked_materials() const \
  { \
    return this->as_node().ignore_locked_materials(); \
  } \
  inline bool class_name::is_child_of(const LayerGroup &group) const \
  { \
    return this->as_node().is_child_of(group); \
  }

class TreeNode : public ::GreasePencilLayerTreeNode {
 public:
  TreeNode();
  explicit TreeNode(GreasePencilLayerTreeNodeType type);
  explicit TreeNode(GreasePencilLayerTreeNodeType type, StringRef name);
  TreeNode(const TreeNode &other);
  ~TreeNode();
 
 public:
  /* Define the common functions for #TreeNode. */
  TREENODE_COMMON_METHODS;
  bool is_group() const;
  bool is_layer() const;

  const Layer &as_layer() const;
  Layer &as_layer();

  const LayerGroup &as_group() const;
  LayerGroup &as_group();

  const LayerGroup *parent_group() const;
  LayerGroup *parent_group();
 
  const TreeNode *parent_node() const;
  TreeNode *parent_node();

  int64_t depth() const;
};
static_assert(sizeof(TreeNode) == sizeof(::GreasePencilLayerTreeNode));

class LayerMask : public ::GreasePencilLayerMask {
 public:
  LayerMask();
  explicit LayerMask(StringRef name);
  LayerMask(const LayerMask &other);
  ~LayerMask();
};
static_assert(sizeof(LayerMask) == sizeof(::GreasePencilLayerMask));

struct LayerTransformData {
  enum FrameTransformationStatus { TRANS_CLEAR, TRANS_INIT, TRANS_RUNNING };
 
  /* Map of frame keys describing the transformation of the frames. Keys of the map are the source
   * frame indices, and the values of the map are the destination frame indices. */
  Map<int, int> frames_destination;
 
  /* Copy of the layer frames, stored in two separate maps :
   * - frames_static contains the frames not affected by the transformation,
   * - frames_transformed contains the frames affected by the transformation.
   * This allows to display the transformation while running, without removing any drawing.
   */
  Map<int, GreasePencilFrame> frames_static;
  Map<int, GreasePencilFrame> frames_transformed;
 
  /* Map containing the duration (in frames) for each frame in the layer that has a fixed duration,
   * i.e. each frame that is not an implicit hold. */
  Map<int, int> frames_duration;
 
  /* Temporary copy of duplicated frames before we decide on a place to insert them.
   * Used in the move+duplicate operator. */
  Map<int, GreasePencilFrame> duplicated_frames_buffer;
 
  FrameTransformationStatus status{TRANS_CLEAR};
};
 
/*
 * The key type for a `GreasePencilFrame` in the frames map.
 *
 * This is either the start or end frame (scene time) of a `GreasePencilFrame`.
 *
 * If the key refers to a end frame, the value in the map for this key is
 * `GreasePencilFrame::end()`.
 * Note that end frame is exclusive with regards to the frame duration. E.g. if a frame starts at
 * 10 and the end frame is at 15, then the duration is 4.
 */
using FramesMapKeyT = int;
 
class LayerRuntime {
 public:
  Map<FramesMapKeyT, GreasePencilFrame> frames_;
  mutable SharedCache<Vector<FramesMapKeyT>> sorted_keys_cache_;
  Vector<LayerMask> masks_;

  LayerTransformData trans_data_;

  bool is_visibility_animated_;

  int orig_layer_index_ = -1;
 
 public:
  void clear();
};

class Layer : public ::GreasePencilLayer {
 public:
  using SortedKeysIterator = const int *;
 
  Layer();
  explicit Layer(StringRef name);
  Layer(const Layer &other);
  ~Layer();
 
  /* Define the common functions for #TreeNode. */
  TREENODE_COMMON_METHODS;
  const TreeNode &as_node() const;
  TreeNode &as_node();

  const LayerGroup &parent_group() const;
  LayerGroup &parent_group();

  const Map<FramesMapKeyT, GreasePencilFrame> &frames() const;
  Map<FramesMapKeyT, GreasePencilFrame> &frames_for_write();

  bool is_empty() const;

  GreasePencilFrame *add_frame(FramesMapKeyT key, int duration = 0);
  bool remove_frame(FramesMapKeyT key);

  Span<FramesMapKeyT> sorted_keys() const;

  int drawing_index_at(const int frame_number) const;

  bool has_drawing_at(const int frame_number) const;

  std::optional<int> start_frame_at(int frame_number) const;

  int sorted_keys_index_at(int frame_number) const;
  SortedKeysIterator sorted_keys_iterator_at(int frame_number) const;

  const GreasePencilFrame *frame_at(const int frame_number) const;
  GreasePencilFrame *frame_at(const int frame_number);

  int get_frame_duration_at(const int frame_number) const;
 
  void tag_frames_map_changed();

  void tag_frames_map_keys_changed();

  void prepare_for_dna_write();

  void update_from_dna_read();
 
  float4x4 parent_inverse() const;

  float4x4 local_transform() const;

  void set_local_transform(const float4x4 &transform);

  float4x4 to_object_space(const Object &object) const;

  float4x4 to_world_space(const Object &object) const;

  StringRefNull parent_bone_name() const;
  void set_parent_bone_name(StringRef new_name);

  StringRefNull view_layer_name() const;
  void set_view_layer_name(StringRef new_name);
 
 private:
  std::optional<FramesMapKeyT> frame_key_at(int frame_number) const;
 
  GreasePencilFrame *add_frame_internal(int frame_number);

  SortedKeysIterator remove_leading_end_frames_in_range(SortedKeysIterator begin,
                                                        SortedKeysIterator end);

  float4x4 parent_to_world(const Object &parent) const;
};
static_assert(sizeof(Layer) == sizeof(::GreasePencilLayer));
 
class LayerGroupRuntime {
 public:
  mutable CacheMutex nodes_cache_mutex_;
  mutable Vector<TreeNode *> nodes_cache_;
  mutable Vector<Layer *> layer_cache_;
  mutable Vector<LayerGroup *> layer_group_cache_;

  bool is_visibility_animated_;
};

class LayerGroup : public ::GreasePencilLayerTreeGroup {
  friend struct ::GreasePencil;
 
 public:
  LayerGroup();
  explicit LayerGroup(StringRef name);
  LayerGroup(const LayerGroup &other);
  ~LayerGroup();
 
  LayerGroup &operator=(const LayerGroup &other);
 
 public:
  /* Define the common functions for #TreeNode. */
  TREENODE_COMMON_METHODS;
  const TreeNode &as_node() const;
  TreeNode &as_node();

  bool is_empty() const;

  int64_t num_direct_nodes() const;

  int64_t num_nodes_total() const;

  Span<const TreeNode *> nodes() const;
  Span<TreeNode *> nodes_for_write();

  Span<const Layer *> layers() const;
  Span<Layer *> layers_for_write();

  Span<const LayerGroup *> groups() const;
  Span<LayerGroup *> groups_for_write();

  const TreeNode *find_node_by_name(StringRef name) const;
  TreeNode *find_node_by_name(StringRef name);

  bool is_expanded() const;
  void set_expanded(bool expanded);

  void print_nodes(StringRef header) const;

  void prepare_for_dna_write();

  void update_from_dna_read();
 
 protected:
  TreeNode &add_node(TreeNode &node);

  void add_node_before(TreeNode &node, TreeNode &link);
  void add_node_after(TreeNode &node, TreeNode &link);

  void move_node_up(TreeNode &node, int step = 1);
  void move_node_down(TreeNode &node, int step = 1);
  void move_node_top(TreeNode &node);
  void move_node_bottom(TreeNode &node);

  bool unlink_node(TreeNode &link, bool keep_children = false);
 
 private:
  void ensure_nodes_cache() const;
  void tag_nodes_cache_dirty() const;
};
static_assert(sizeof(LayerGroup) == sizeof(::GreasePencilLayerTreeGroup));
 
inline void Drawing::add_user() const
{
  this->runtime->user_count.fetch_add(1, std::memory_order_relaxed);
}
inline void Drawing::remove_user() const
{
  this->runtime->user_count.fetch_sub(1, std::memory_order_relaxed);
}
inline bool Drawing::is_instanced() const
{
  return this->runtime->user_count.load(std::memory_order_relaxed) > 1;
}
inline bool Drawing::has_users() const
{
  return this->runtime->user_count.load(std::memory_order_relaxed) > 0;
}
inline int Drawing::user_count() const
{
  return this->runtime->user_count.load(std::memory_order_relaxed);
}
 
inline bool TreeNode::is_group() const
{
  return this->type == GP_LAYER_TREE_GROUP;
}
inline bool TreeNode::is_layer() const
{
  return this->type == GP_LAYER_TREE_LEAF;
}
inline bool TreeNode::is_visible() const
{
  return ((this->flag & GP_LAYER_TREE_NODE_HIDE) == 0) &&
         (!this->parent_group() || this->parent_group()->as_node().is_visible());
}
inline void TreeNode::set_visible(const bool visible)
{
  SET_FLAG_FROM_TEST(this->flag, !visible, GP_LAYER_TREE_NODE_HIDE);
}
inline bool TreeNode::is_locked() const
{
  return ((this->flag & GP_LAYER_TREE_NODE_LOCKED) != 0) ||
         (this->parent_group() && this->parent_group()->as_node().is_locked());
}
inline void TreeNode::set_locked(const bool locked)
{
  SET_FLAG_FROM_TEST(this->flag, locked, GP_LAYER_TREE_NODE_LOCKED);
}
inline bool TreeNode::is_editable() const
{
  return this->is_visible() && !this->is_locked();
}
inline bool TreeNode::is_selected() const
{
  return (this->flag & GP_LAYER_TREE_NODE_SELECT) != 0;
}
inline void TreeNode::set_selected(const bool selected)
{
  SET_FLAG_FROM_TEST(this->flag, selected, GP_LAYER_TREE_NODE_SELECT);
}
inline bool TreeNode::use_onion_skinning() const
{
  return ((this->flag & GP_LAYER_TREE_NODE_HIDE_ONION_SKINNING) == 0) &&
         (!this->parent_group() || this->parent_group()->as_node().use_onion_skinning());
}
inline bool TreeNode::use_masks() const
{
  return ((this->flag & GP_LAYER_TREE_NODE_HIDE_MASKS) == 0) &&
         (!this->parent_group() || this->parent_group()->as_node().use_masks());
}
inline bool TreeNode::ignore_locked_materials() const
{
  return (this->flag & GP_LAYER_TREE_NODE_IGNORE_LOCKED_MATERIALS) != 0;
}
inline bool TreeNode::is_child_of(const LayerGroup &group) const
{
  if (const LayerGroup *parent = this->parent_group()) {
    if (parent == &group) {
      return true;
    }
    return parent->is_child_of(group);
  }
  return false;
}
inline StringRefNull TreeNode::name() const
{
  return (this->GreasePencilLayerTreeNode::name != nullptr) ?
             this->GreasePencilLayerTreeNode::name :
             StringRefNull();
}
inline const TreeNode &LayerGroup::as_node() const
{
  return *reinterpret_cast<const TreeNode *>(this);
}
inline TreeNode &LayerGroup::as_node()
{
  return *reinterpret_cast<TreeNode *>(this);
}
inline const TreeNode &Layer::as_node() const
{
  return *reinterpret_cast<const TreeNode *>(this);
}
inline TreeNode &Layer::as_node()
{
  return *reinterpret_cast<TreeNode *>(this);
}
 
TREENODE_COMMON_METHODS_FORWARD_IMPL(Layer);
inline bool Layer::is_empty() const
{
  return (this->frames().is_empty());
}
inline const LayerGroup &Layer::parent_group() const
{
  return *this->as_node().parent_group();
}
inline LayerGroup &Layer::parent_group()
{
  return *this->as_node().parent_group();
}
 
TREENODE_COMMON_METHODS_FORWARD_IMPL(LayerGroup);
 
const AttributeAccessorFunctions &get_attribute_accessor_functions();

void ensure_non_empty_layer_names(Main &bmain, GreasePencil &grease_pencil);
 
}  // namespace greasepencil
 
class GreasePencilRuntime {
 public:
  void *batch_cache = nullptr;
  int eval_frame = 0;
  bool is_drawing_stroke = false;
  bool temp_use_eraser = false;
  float temp_eraser_size = 0.0f;
 
  std::unique_ptr<bake::BakeMaterialsList> bake_materials;
 
 public:
  GreasePencilRuntime();
  ~GreasePencilRuntime();
};
 
class GreasePencilDrawingEditHints {
 public:
  const greasepencil::Drawing *drawing_orig;
  ImplicitSharingPtrAndData positions_data;

  std::optional<Array<float3x3>> deform_mats;
 
  std::optional<Span<float3>> positions() const;
  std::optional<MutableSpan<float3>> positions_for_write();
};

class GreasePencilEditHints {
 public:
  const GreasePencil &grease_pencil_id_orig;
 
  GreasePencilEditHints(const GreasePencil &grease_pencil_id_orig)
      : grease_pencil_id_orig(grease_pencil_id_orig)
  {
  }

  std::optional<Array<GreasePencilDrawingEditHints>> drawing_hints;
};
 
}  // namespace blender::bke
 
inline blender::bke::greasepencil::Drawing &GreasePencilDrawing::wrap()
{
  return *reinterpret_cast<blender::bke::greasepencil::Drawing *>(this);
}
inline const blender::bke::greasepencil::Drawing &GreasePencilDrawing::wrap() const
{
  return *reinterpret_cast<const blender::bke::greasepencil::Drawing *>(this);
}
 
inline blender::bke::greasepencil::DrawingReference &GreasePencilDrawingReference::wrap()
{
  return *reinterpret_cast<blender::bke::greasepencil::DrawingReference *>(this);
}
inline const blender::bke::greasepencil::DrawingReference &GreasePencilDrawingReference::wrap()
    const
{
  return *reinterpret_cast<const blender::bke::greasepencil::DrawingReference *>(this);
}
 
inline GreasePencilFrame GreasePencilFrame::end()
{
  return GreasePencilFrame{-1, 0, 0};
}
 
inline bool GreasePencilFrame::is_end() const
{
  return this->drawing_index == -1;
}
 
inline bool GreasePencilFrame::is_implicit_hold() const
{
  return (this->flag & GP_FRAME_IMPLICIT_HOLD) != 0;
}
 
inline bool GreasePencilFrame::is_selected() const
{
  return (this->flag & GP_FRAME_SELECTED) != 0;
}
 
inline blender::bke::greasepencil::TreeNode &GreasePencilLayerTreeNode::wrap()
{
  return *reinterpret_cast<blender::bke::greasepencil::TreeNode *>(this);
}
inline const blender::bke::greasepencil::TreeNode &GreasePencilLayerTreeNode::wrap() const
{
  return *reinterpret_cast<const blender::bke::greasepencil::TreeNode *>(this);
}
 
inline blender::bke::greasepencil::Layer &GreasePencilLayer::wrap()
{
  return *reinterpret_cast<blender::bke::greasepencil::Layer *>(this);
}
inline const blender::bke::greasepencil::Layer &GreasePencilLayer::wrap() const
{
  return *reinterpret_cast<const blender::bke::greasepencil::Layer *>(this);
}
 
inline blender::bke::greasepencil::LayerGroup &GreasePencilLayerTreeGroup::wrap()
{
  return *reinterpret_cast<blender::bke::greasepencil::LayerGroup *>(this);
}
inline const blender::bke::greasepencil::LayerGroup &GreasePencilLayerTreeGroup::wrap() const
{
  return *reinterpret_cast<const blender::bke::greasepencil::LayerGroup *>(this);
}
 
inline const GreasePencilDrawingBase *GreasePencil::drawing(const int64_t index) const
{
  BLI_assert(index >= 0 && index < this->drawings().size());
  return this->drawings()[index];
}
inline GreasePencilDrawingBase *GreasePencil::drawing(const int64_t index)
{
  BLI_assert(index >= 0 && index < this->drawings().size());
  return this->drawings()[index];
}
 
inline const blender::bke::greasepencil::Layer &GreasePencil::layer(const int64_t index) const
{
  return *this->layers()[index];
}
inline blender::bke::greasepencil::Layer &GreasePencil::layer(const int64_t index)
{
  return *this->layers_for_write()[index];
}
 
inline const blender::bke::greasepencil::LayerGroup &GreasePencil::root_group() const
{
  return this->root_group_ptr->wrap();
}
inline blender::bke::greasepencil::LayerGroup &GreasePencil::root_group()
{
  return this->root_group_ptr->wrap();
}
 
inline bool GreasePencil::has_active_layer() const
{
  return (this->active_node != nullptr) && (this->active_node->wrap().is_layer());
}
 
inline bool GreasePencil::has_active_group() const
{
  return (this->active_node != nullptr) && (this->active_node->wrap().is_group());
}
 
bool BKE_grease_pencil_drawing_attribute_required(const GreasePencilDrawing *,
                                                  blender::StringRef name);
 
GreasePencil *BKE_grease_pencil_add(Main *bmain, const char *name);
GreasePencil *BKE_grease_pencil_new_nomain();
GreasePencil *BKE_grease_pencil_copy_for_eval(const GreasePencil *grease_pencil_src);
void BKE_grease_pencil_copy_parameters(const GreasePencil &src, GreasePencil &dst);
void BKE_grease_pencil_copy_layer_parameters(const blender::bke::greasepencil::Layer &src,
                                             blender::bke::greasepencil::Layer &dst);
void BKE_grease_pencil_copy_layer_group_parameters(
    const blender::bke::greasepencil::LayerGroup &src,
    blender::bke::greasepencil::LayerGroup &dst);

void BKE_grease_pencil_nomain_to_grease_pencil(GreasePencil *grease_pencil_src,
                                               GreasePencil *grease_pencil_dst);
 
void BKE_grease_pencil_vgroup_name_update(Object *ob, const char *old_name, const char *new_name);
 
void BKE_grease_pencil_eval_geometry(Depsgraph *depsgraph, GreasePencil *grease_pencil);
void BKE_object_eval_grease_pencil(Depsgraph *depsgraph, Scene *scene, Object *object);
void BKE_grease_pencil_duplicate_drawing_array(const GreasePencil *grease_pencil_src,
                                               GreasePencil *grease_pencil_dst);

int BKE_grease_pencil_stroke_point_count(const GreasePencil &grease_pencil);
bool BKE_grease_pencil_has_curve_with_type(const GreasePencil &grease_pencil, CurveType type);
void BKE_grease_pencil_point_coords_get(const GreasePencil &grease_pencil,
                                        blender::MutableSpan<blender::float3> all_positions,
                                        blender::MutableSpan<float> all_radii);
void BKE_grease_pencil_point_coords_apply(GreasePencil &grease_pencil,
                                          blender::Span<blender::float3> all_positions,
                                          blender::Span<float> all_radii);
void BKE_grease_pencil_point_coords_apply_with_mat4(GreasePencil &grease_pencil,
                                                    blender::Span<blender::float3> all_positions,
                                                    blender::Span<float> all_radii,
                                                    const blender::float4x4 &mat);
 
int BKE_grease_pencil_object_material_index_get_by_name(Object *ob, const char *name);
Material *BKE_grease_pencil_object_material_new(Main *bmain,
                                                Object *ob,
                                                const char *name,
                                                int *r_index);
Material *BKE_grease_pencil_object_material_from_brush_get(Object *ob, Brush *brush);
Material *BKE_grease_pencil_object_material_ensure_by_name(Main *bmain,
                                                           Object *ob,
                                                           const char *name,
                                                           int *r_index);
Material *BKE_grease_pencil_object_material_ensure_from_brush(Main *bmain,
                                                              Object *ob,
                                                              Brush *brush);
Material *BKE_grease_pencil_object_material_alt_ensure_from_brush(Main *bmain,
                                                                  Object *ob,
                                                                  Brush *brush);
void BKE_grease_pencil_material_remap(GreasePencil *grease_pencil, const uint *remap, int totcol);
void BKE_grease_pencil_material_index_remove(GreasePencil *grease_pencil, int index);
bool BKE_grease_pencil_material_index_used(GreasePencil *grease_pencil, int index);
 
bool BKE_grease_pencil_references_cyclic_check(const GreasePencil *id_reference,
                                               const GreasePencil *grease_pencil);