BKE_modifier.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
#pragma once
 
#include "BKE_customdata.h"
#include "BLI_compiler_attrs.h"
#include "DNA_modifier_types.h" /* needed for all enum typdefs */
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct ARegionType;
struct BMEditMesh;
struct BlendDataReader;
struct BlendLibReader;
struct BlendWriter;
struct CustomData_MeshMasks;
struct DepsNodeHandle;
struct Depsgraph;
struct GeometrySet;
struct ID;
struct ListBase;
struct Main;
struct Mesh;
struct ModifierData;
struct Object;
struct Scene;
struct bArmature;
 
typedef enum {
  /* Should not be used, only for None modifier type */
  eModifierTypeType_None,
 
  eModifierTypeType_OnlyDeform,
 
  eModifierTypeType_Constructive,
  /* Modifier can add and remove geometry. */
  eModifierTypeType_Nonconstructive,
 
  eModifierTypeType_DeformOrConstruct,
 
  eModifierTypeType_NonGeometrical,
} ModifierTypeType;
 
typedef enum {
  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_UsesPreview = (1 << 9),
  eModifierTypeFlag_AcceptsVertexCosOnly = (1 << 10),
 
  eModifierTypeFlag_AcceptsBMesh = (1 << 11),
} ModifierTypeFlag;
 
typedef void (*IDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin, int cb_flag);
typedef void (*TexWalkFunc)(void *userData,
                            struct Object *ob,
                            struct ModifierData *md,
                            const char *propname);
 
typedef 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_BASE_MESH = 1 << 4,
} ModifierApplyFlag;
 
typedef struct ModifierUpdateDepsgraphContext {
  struct Scene *scene;
  struct Object *object;
  struct DepsNodeHandle *node;
} ModifierUpdateDepsgraphContext;
 
/* Contains the information for deformXXX and applyXXX functions below that
 * doesn't change between consecutive modifiers. */
typedef struct ModifierEvalContext {
  struct Depsgraph *depsgraph;
  struct Object *object;
  ModifierApplyFlag flag;
} ModifierEvalContext;
 
typedef struct ModifierTypeInfo {
  /* The user visible name for this modifier */
  char name[32];
 
  /* The DNA struct name for the modifier data type, used to
   * write the DNA data out.
   */
  char structName[32];
 
  /* The size of the modifier data type, used by allocation. */
  int structSize;
 
  /* StructRNA of this modifier. This is typically something like RNA_*Modifier. */
  struct StructRNA *srna;
 
  ModifierTypeType type;
  ModifierTypeFlag flags;
 
  /* Icon of the modifier. Usually something like ICON_MOD_*. */
  int icon;
 
  /********************* Non-optional functions *********************/
 
  void (*copyData)(const struct ModifierData *md, struct ModifierData *target, const int flag);
 
  /********************* Deform modifier functions *********************/
 
  void (*deformVerts)(struct ModifierData *md,
                      const struct ModifierEvalContext *ctx,
                      struct Mesh *mesh,
                      float (*vertexCos)[3],
                      int numVerts);
 
  void (*deformMatrices)(struct ModifierData *md,
                         const struct ModifierEvalContext *ctx,
                         struct Mesh *mesh,
                         float (*vertexCos)[3],
                         float (*defMats)[3][3],
                         int numVerts);
  void (*deformVertsEM)(struct ModifierData *md,
                        const struct ModifierEvalContext *ctx,
                        struct BMEditMesh *editData,
                        struct Mesh *mesh,
                        float (*vertexCos)[3],
                        int numVerts);
 
  /* Set deform matrix per vertex for crazy-space correction */
  void (*deformMatricesEM)(struct ModifierData *md,
                           const struct ModifierEvalContext *ctx,
                           struct BMEditMesh *editData,
                           struct Mesh *mesh,
                           float (*vertexCos)[3],
                           float (*defMats)[3][3],
                           int numVerts);
 
  /********************* Non-deform modifier functions *********************/
 
  struct Mesh *(*modifyMesh)(struct ModifierData *md,
                             const struct ModifierEvalContext *ctx,
                             struct Mesh *mesh);
 
  struct Hair *(*modifyHair)(struct ModifierData *md,
                             const struct ModifierEvalContext *ctx,
                             struct Hair *hair);
 
  void (*modifyGeometrySet)(struct ModifierData *md,
                            const struct ModifierEvalContext *ctx,
                            struct GeometrySet *geometry_set);
 
  struct Volume *(*modifyVolume)(struct ModifierData *md,
                                 const struct ModifierEvalContext *ctx,
                                 struct Volume *volume);
 
  /********************* Optional functions *********************/
 
  void (*initData)(struct ModifierData *md);
 
  void (*requiredDataMask)(struct Object *ob,
                           struct ModifierData *md,
                           struct CustomData_MeshMasks *r_cddata_masks);
 
  void (*freeData)(struct ModifierData *md);
 
  bool (*isDisabled)(const struct Scene *scene, struct ModifierData *md, bool userRenderParams);
 
  void (*updateDepsgraph)(struct ModifierData *md, const ModifierUpdateDepsgraphContext *ctx);
 
  bool (*dependsOnTime)(struct ModifierData *md);
 
  bool (*dependsOnNormals)(struct ModifierData *md);
 
  void (*foreachIDLink)(struct ModifierData *md,
                        struct Object *ob,
                        IDWalkFunc walk,
                        void *userData);
 
  void (*foreachTexLink)(struct ModifierData *md,
                         struct Object *ob,
                         TexWalkFunc walk,
                         void *userData);
 
  void (*freeRuntimeData)(void *runtime_data);
 
  void (*panelRegister)(struct ARegionType *region_type);
 
  void (*blendWrite)(struct BlendWriter *writer, const struct ModifierData *md);
 
  void (*blendRead)(struct BlendDataReader *reader, struct ModifierData *md);
} ModifierTypeInfo;
 
/* Used to find 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(void);
 
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(struct ModifierData *md);
 
/* Modifier utility calls, do call through type pointer and return
 * default values if pointer is optional.
 */
struct ModifierData *BKE_modifier_new(int type);
 
void BKE_modifier_free_ex(struct ModifierData *md, const int flag);
void BKE_modifier_free(struct ModifierData *md);
void BKE_modifier_remove_from_list(struct Object *ob, struct ModifierData *md);
 
/* Generate new UUID for the given modifier. */
void BKE_modifier_session_uuid_generate(struct ModifierData *md);
 
bool BKE_modifier_unique_name(struct ListBase *modifiers, struct ModifierData *md);
 
void BKE_modifier_copydata_generic(const struct ModifierData *md,
                                   struct ModifierData *md_dst,
                                   const int flag);
void BKE_modifier_copydata(struct ModifierData *md, struct ModifierData *target);
void BKE_modifier_copydata_ex(struct ModifierData *md,
                              struct ModifierData *target,
                              const int flag);
bool BKE_modifier_depends_ontime(struct ModifierData *md);
bool BKE_modifier_supports_mapping(struct ModifierData *md);
bool BKE_modifier_supports_cage(struct Scene *scene, struct ModifierData *md);
bool BKE_modifier_couldbe_cage(struct Scene *scene, struct ModifierData *md);
bool BKE_modifier_is_correctable_deformed(struct ModifierData *md);
bool BKE_modifier_is_same_topology(ModifierData *md);
bool BKE_modifier_is_non_geometrical(ModifierData *md);
bool BKE_modifier_is_enabled(const struct Scene *scene,
                             struct ModifierData *md,
                             int required_mode);
bool BKE_modifier_is_nonlocal_in_liboverride(const struct Object *ob,
                                             const struct ModifierData *md);
void BKE_modifier_set_error(const struct Object *ob,
                            struct ModifierData *md,
                            const char *format,
                            ...) ATTR_PRINTF_FORMAT(3, 4);
bool BKE_modifier_is_preview(struct ModifierData *md);
 
void BKE_modifiers_foreach_ID_link(struct Object *ob, IDWalkFunc walk, void *userData);
void BKE_modifiers_foreach_tex_link(struct Object *ob, TexWalkFunc walk, void *userData);
 
struct ModifierData *BKE_modifiers_findby_type(const struct Object *ob, ModifierType type);
struct ModifierData *BKE_modifiers_findby_name(const struct Object *ob, const char *name);
void BKE_modifiers_clear_errors(struct Object *ob);
int BKE_modifiers_get_cage_index(const struct Scene *scene,
                                 struct Object *ob,
                                 int *r_lastPossibleCageIndex,
                                 bool is_virtual);
 
bool BKE_modifiers_is_modifier_enabled(struct Object *ob, int modifierType);
bool BKE_modifiers_is_softbody_enabled(struct Object *ob);
bool BKE_modifiers_is_cloth_enabled(struct Object *ob);
bool BKE_modifiers_is_particle_enabled(struct Object *ob);
 
struct Object *BKE_modifiers_is_deformed_by_armature(struct Object *ob);
struct Object *BKE_modifiers_is_deformed_by_meshdeform(struct Object *ob);
struct Object *BKE_modifiers_is_deformed_by_lattice(struct Object *ob);
struct Object *BKE_modifiers_is_deformed_by_curve(struct Object *ob);
bool BKE_modifiers_uses_multires(struct Object *ob);
bool BKE_modifiers_uses_armature(struct Object *ob, struct bArmature *arm);
bool BKE_modifiers_uses_subsurf_facedots(const struct Scene *scene, struct Object *ob);
bool BKE_modifiers_is_correctable_deformed(const struct Scene *scene, struct Object *ob);
void BKE_modifier_free_temporary_data(struct ModifierData *md);
 
typedef struct CDMaskLink {
  struct CDMaskLink *next;
  struct CustomData_MeshMasks mask;
} CDMaskLink;
 
struct CDMaskLink *BKE_modifier_calc_data_masks(const struct Scene *scene,
                                                struct Object *ob,
                                                struct ModifierData *md,
                                                struct CustomData_MeshMasks *final_datamask,
                                                int required_mode,
                                                ModifierData *previewmd,
                                                const struct CustomData_MeshMasks *previewmask);
struct ModifierData *BKE_modifier_get_last_preview(const struct Scene *scene,
                                                   struct ModifierData *md,
                                                   int required_mode);
 
typedef struct VirtualModifierData {
  ArmatureModifierData amd;
  CurveModifierData cmd;
  LatticeModifierData lmd;
  ShapeKeyModifierData smd;
} VirtualModifierData;
 
struct ModifierData *BKE_modifiers_get_virtual_modifierlist(const struct Object *ob,
                                                            struct VirtualModifierData *data);
 
void BKE_modifiers_test_object(struct Object *ob);
 
/* here for do_versions */
void BKE_modifier_mdef_compact_influences(struct ModifierData *md);
 
void BKE_modifier_path_init(char *path, int path_maxlen, const char *name);
const char *BKE_modifier_path_relbase(struct Main *bmain, struct Object *ob);
const char *BKE_modifier_path_relbase_from_global(struct Object *ob);
 
/* Accessors of original/evaluated modifiers. */
 
/* For a given modifier data, get corresponding original one.
 * If the modifier data is already original, return it as-is. */
struct ModifierData *BKE_modifier_get_original(struct ModifierData *md);
struct ModifierData *BKE_modifier_get_evaluated(struct Depsgraph *depsgraph,
                                                struct Object *object,
                                                struct ModifierData *md);
 
/* wrappers for modifier callbacks that ensure valid normals */
 
struct Mesh *BKE_modifier_modify_mesh(ModifierData *md,
                                      const struct ModifierEvalContext *ctx,
                                      struct Mesh *me);
 
void BKE_modifier_deform_verts(ModifierData *md,
                               const struct ModifierEvalContext *ctx,
                               struct Mesh *me,
                               float (*vertexCos)[3],
                               int numVerts);
 
void BKE_modifier_deform_vertsEM(ModifierData *md,
                                 const struct ModifierEvalContext *ctx,
                                 struct BMEditMesh *em,
                                 struct Mesh *me,
                                 float (*vertexCos)[3],
                                 int numVerts);
 
struct Mesh *BKE_modifier_get_evaluated_mesh_from_evaluated_object(struct Object *ob_eval,
                                                                   const bool get_cage_mesh);
 
void BKE_modifier_check_uuids_unique_and_report(const struct Object *object);
 
void BKE_modifier_blend_write(struct BlendWriter *writer, struct ListBase *modbase);
void BKE_modifier_blend_read_data(struct BlendDataReader *reader,
                                  struct ListBase *lb,
                                  struct Object *ob);
void BKE_modifier_blend_read_lib(struct BlendLibReader *reader, struct Object *ob);
 
#ifdef __cplusplus
}
#endif