BKE_modifier.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include "BLI_compiler_attrs.h"
#include "BLI_function_ref.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_span.hh"
 
#include "DNA_modifier_types.h" /* Needed for all enum type definitions. */
 
#include "DNA_customdata_types.h"
 
namespace blender::bke {
struct GeometrySet;
}
struct ARegionType;
struct bArmature;
struct BMEditMesh;
struct BlendDataReader;
struct BlendWriter;
struct CustomData_MeshMasks;
struct DepsNodeHandle;
struct Depsgraph;
struct ID;
struct ListBase;
struct Main;
struct Mesh;
struct ModifierData;
struct Object;
struct PointerRNA;
struct PropertyRNA;
struct Scene;
struct StructRNA;
struct IDCacheKey;
 
enum class ModifierTypeType {
  /* Should not be used, only for None modifier type */
  None,
 
  OnlyDeform,
 
  Constructive,
  /* Modifier can add and remove geometry. */
  Nonconstructive,
 
  DeformOrConstruct,
 
  NonGeometrical,
};
 
enum ModifierTypeFlag {
  eModifierTypeFlag_AcceptsMesh = (1 << 0),
  eModifierTypeFlag_AcceptsCVs = (1 << 1),
  eModifierTypeFlag_SupportsMapping = (1 << 2),
  eModifierTypeFlag_SupportsEditmode = (1 << 3),
 
  eModifierTypeFlag_EnableInEditmode = (1 << 4),
 
  eModifierTypeFlag_RequiresOriginalData = (1 << 5),
 
  eModifierTypeFlag_UsesPointCache = (1 << 6),
 
  eModifierTypeFlag_Single = (1 << 7),
 
  eModifierTypeFlag_NoUserAdd = (1 << 8),
 
  eModifierTypeFlag_AcceptsVertexCosOnly = (1 << 10),
 
  eModifierTypeFlag_AcceptsBMesh = (1 << 11),
 
  eModifierTypeFlag_AcceptsGreasePencil = (1 << 12),
};
ENUM_OPERATORS(ModifierTypeFlag, eModifierTypeFlag_AcceptsGreasePencil)
 
using IDWalkFunc = void (*)(void *user_data, Object *ob, ID **idpoin, int cb_flag);
using TexWalkFunc = void (*)(void *user_data,
                             Object *ob,
                             ModifierData *md,
                             const PointerRNA *ptr,
                             PropertyRNA *texture_prop);
 
enum ModifierApplyFlag {
  MOD_APPLY_RENDER = 1 << 0,
  MOD_APPLY_USECACHE = 1 << 1,
  MOD_APPLY_ORCO = 1 << 2,
  MOD_APPLY_IGNORE_SIMPLIFY = 1 << 3,
  MOD_APPLY_TO_ORIGINAL = 1 << 4,
};
ENUM_OPERATORS(ModifierApplyFlag, MOD_APPLY_TO_ORIGINAL);
 
struct ModifierUpdateDepsgraphContext {
  Scene *scene;
  Object *object;
  DepsNodeHandle *node;
};
 
/* Contains the information for deformXXX and applyXXX functions below that
 * doesn't change between consecutive modifiers. */
struct ModifierEvalContext {
  Depsgraph *depsgraph;
  Object *object;
  ModifierApplyFlag flag;
};
 
struct ModifierTypeInfo {
  /* A unique identifier for this modifier. Used to generate the panel id type name.
   * See #BKE_modifier_type_panel_id. */
  char idname[64];
 
  /* The user visible name for this modifier */
  char name[64];
 
  /* The DNA struct name for the modifier data type, used to
   * write the DNA data out.
   */
  char struct_name[64];
 
  /* The size of the modifier data type, used by allocation. */
  int struct_size;
 
  /* StructRNA of this modifier. This is typically something like RNA_*Modifier. */
  StructRNA *srna;
 
  ModifierTypeType type;
  ModifierTypeFlag flags;
 
  /* Icon of the modifier. Usually something like ICON_MOD_*. */
  int icon;
 
  /********************* Non-optional functions *********************/
 
  void (*copy_data)(const ModifierData *md, ModifierData *target, int flag);
 
  /********************* Deform modifier functions *********************/
 
  void (*deform_verts)(ModifierData *md,
                       const ModifierEvalContext *ctx,
                       Mesh *mesh,
                       blender::MutableSpan<blender::float3> positions);
 
  void (*deform_matrices)(ModifierData *md,
                          const ModifierEvalContext *ctx,
                          Mesh *mesh,
                          blender::MutableSpan<blender::float3> positions,
                          blender::MutableSpan<blender::float3x3> matrices);
  void (*deform_verts_EM)(ModifierData *md,
                          const ModifierEvalContext *ctx,
                          const BMEditMesh *em,
                          Mesh *mesh,
                          blender::MutableSpan<blender::float3> positions);
 
  /* Set deform matrix per vertex for crazy-space correction */
  void (*deform_matrices_EM)(ModifierData *md,
                             const ModifierEvalContext *ctx,
                             const BMEditMesh *em,
                             Mesh *mesh,
                             blender::MutableSpan<blender::float3> positions,
                             blender::MutableSpan<blender::float3x3> matrices);
 
  /********************* Non-deform modifier functions *********************/
 
  Mesh *(*modify_mesh)(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh);
 
  void (*modify_geometry_set)(ModifierData *md,
                              const ModifierEvalContext *ctx,
                              blender::bke::GeometrySet *geometry_set);
 
  /********************* Optional functions *********************/
 
  void (*init_data)(ModifierData *md);
 
  void (*required_data_mask)(ModifierData *md, CustomData_MeshMasks *r_cddata_masks);
 
  void (*free_data)(ModifierData *md);
 
  bool (*is_disabled)(const Scene *scene, ModifierData *md, bool use_render_params);
 
  void (*update_depsgraph)(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx);
 
  bool (*depends_on_time)(Scene *scene, ModifierData *md);
 
  bool (*depends_on_normals)(ModifierData *md);
 
  void (*foreach_ID_link)(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data);
 
  void (*foreach_tex_link)(ModifierData *md, Object *ob, TexWalkFunc walk, void *user_data);
 
  void (*free_runtime_data)(void *runtime_data);
 
  void (*panel_register)(ARegionType *region_type);
 
  void (*blend_write)(BlendWriter *writer, const ID *id_owner, const ModifierData *md);
 
  void (*blend_read)(BlendDataReader *reader, ModifierData *md);
 
  void (*foreach_cache)(
      Object *object,
      ModifierData *md,
      blender::FunctionRef<void(const IDCacheKey &cache_key, void **cache_p, uint flags)> fn);
};
 
/* Used to set a modifier's panel type. */
#define MODIFIER_TYPE_PANEL_PREFIX "MOD_PT_"
 
/* Initialize modifier's global data (type info and some common global storage). */
void BKE_modifier_init();
 
const ModifierTypeInfo *BKE_modifier_get_info(ModifierType type);
 
/* For modifier UI panels. */
 
void BKE_modifier_type_panel_id(ModifierType type, char *r_idname);
void BKE_modifier_panel_expand(ModifierData *md);
 
/* Modifier utility calls, do call through type pointer and return
 * default values if pointer is optional.
 */
ModifierData *BKE_modifier_new(int type);
 
void BKE_modifier_free_ex(ModifierData *md, int flag);
void BKE_modifier_free(ModifierData *md);
void BKE_modifier_remove_from_list(Object *ob, ModifierData *md);
 
void BKE_modifier_unique_name(ListBase *modifiers, ModifierData *md);
 
ModifierData *BKE_modifier_copy_ex(const ModifierData *md, int flag);
 
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag);
void BKE_modifier_copydata(const ModifierData *md, ModifierData *target);
void BKE_modifier_copydata_ex(const ModifierData *md, ModifierData *target, int flag);
bool BKE_modifier_depends_ontime(Scene *scene, ModifierData *md);
bool BKE_modifier_supports_mapping(ModifierData *md);
bool BKE_modifier_supports_cage(Scene *scene, ModifierData *md);
bool BKE_modifier_couldbe_cage(Scene *scene, ModifierData *md);
bool BKE_modifier_is_correctable_deformed(ModifierData *md);
bool BKE_modifier_is_same_topology(ModifierData *md);
bool BKE_modifier_is_non_geometrical(ModifierData *md);
bool BKE_modifier_is_enabled(const Scene *scene, ModifierData *md, int required_mode);
bool BKE_modifier_is_nonlocal_in_liboverride(const Object *ob, const ModifierData *md);
 
/* Set modifier execution error.
 * The message will be shown in the interface and will be logged as an error to the console. */
void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format, ...)
    ATTR_PRINTF_FORMAT(3, 4);
 
/* Set modifier execution warning, which does not prevent the modifier from being applied but which
 * might need an attention. The message will only be shown in the interface, but will not appear in
 * the logs. */
void BKE_modifier_set_warning(const Object *ob, ModifierData *md, const char *format, ...)
    ATTR_PRINTF_FORMAT(3, 4);
 
void BKE_modifiers_foreach_ID_link(Object *ob, IDWalkFunc walk, void *user_data);
void BKE_modifiers_foreach_tex_link(Object *ob, TexWalkFunc walk, void *user_data);
 
ModifierData *BKE_modifiers_findby_type(const Object *ob, ModifierType type);
ModifierData *BKE_modifiers_findby_name(const Object *ob, const char *name);
ModifierData *BKE_modifiers_findby_persistent_uid(const Object *ob, int persistent_uid);
 
void BKE_modifiers_clear_errors(Object *ob);
 
void BKE_modifiers_persistent_uid_init(const Object &object, ModifierData &md);
bool BKE_modifiers_persistent_uids_are_valid(const Object &object);
 
int BKE_modifiers_get_cage_index(const Scene *scene,
                                 Object *ob,
                                 int *r_lastPossibleCageIndex,
                                 bool is_virtual);
 
Object *BKE_modifiers_is_deformed_by_armature(Object *ob);
Object *BKE_modifiers_is_deformed_by_meshdeform(Object *ob);
Object *BKE_modifiers_is_deformed_by_lattice(Object *ob);
Object *BKE_modifiers_is_deformed_by_curve(Object *ob);
bool BKE_modifiers_uses_multires(Object *ob);
bool BKE_modifiers_uses_armature(Object *ob, bArmature *arm);
bool BKE_modifiers_is_correctable_deformed(const Scene *scene, Object *ob);
void BKE_modifier_free_temporary_data(ModifierData *md);
 
struct CDMaskLink {
  CDMaskLink *next;
  CustomData_MeshMasks mask;
};
 
CDMaskLink *BKE_modifier_calc_data_masks(const Scene *scene,
                                         ModifierData *md,
                                         CustomData_MeshMasks *final_datamask,
                                         int required_mode);
 
struct VirtualModifierData {
  ArmatureModifierData amd;
  CurveModifierData cmd;
  LatticeModifierData lmd;
  ShapeKeyModifierData smd;
};
 
ModifierData *BKE_modifiers_get_virtual_modifierlist(const Object *ob, VirtualModifierData *data);
 
void BKE_modifiers_test_object(Object *ob);
 
void BKE_modifier_mdef_compact_influences(ModifierData *md);
 
void BKE_modifier_path_init(char *path, int path_maxncpy, const char *name);
const char *BKE_modifier_path_relbase(Main *bmain, Object *ob);
const char *BKE_modifier_path_relbase_from_global(Object *ob);
 
/* Accessors of original/evaluated modifiers. */
 
ModifierData *BKE_modifier_get_original(const Object *object, ModifierData *md);
ModifierData *BKE_modifier_get_evaluated(Depsgraph *depsgraph, Object *object, ModifierData *md);
 
/* wrappers for modifier callbacks that ensure valid normals */
 
Mesh *BKE_modifier_modify_mesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh);
 
void BKE_modifier_deform_verts(ModifierData *md,
                               const ModifierEvalContext *ctx,
                               Mesh *mesh,
                               blender::MutableSpan<blender::float3> positions);
 
void BKE_modifier_deform_vertsEM(ModifierData *md,
                                 const ModifierEvalContext *ctx,
                                 const BMEditMesh *em,
                                 Mesh *mesh,
                                 blender::MutableSpan<blender::float3> positions);
 
Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(Object *ob_eval);
 
void BKE_modifier_blend_write(BlendWriter *writer, const ID *id_owner, ListBase *modbase);
void BKE_modifier_blend_read_data(BlendDataReader *reader, ListBase *lb, Object *ob);
 
namespace blender::bke {
 
class ScopedModifierTimer {
 private:
  ModifierData &md_;
  double start_time_;
 
 public:
  ScopedModifierTimer(ModifierData &md);
  ~ScopedModifierTimer();
};
 
}  // namespace blender::bke