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 "BKE_lib_query.hh" /* For LibraryForeachIDCallbackFlag. */
 
#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,
                            LibraryForeachIDCallbackFlag 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;
};

struct ModifierEvalContext {
  Depsgraph *depsgraph;
  Object *object;
  ModifierApplyFlag flag;
};
 
struct ModifierTypeInfo {
  char idname[64];

  char name[64];

  char struct_name[64];

  int struct_size;

  StructRNA *srna;
 
  ModifierTypeType type;
  ModifierTypeFlag flags;

  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);
};

#define MODIFIER_TYPE_PANEL_PREFIX "MOD_PT_"

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);

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);

void BKE_modifier_set_error(const Object *ob, ModifierData *md, const char *format, ...)
    ATTR_PRINTF_FORMAT(3, 4);

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);

bool 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