2011-02-18 14:05:18 +01:00
|
|
|
/*
|
2005-07-19 22:14:17 +02:00
|
|
|
* 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
|
2008-04-17 00:40:48 +02:00
|
|
|
* of the License, or (at your option) any later version.
|
2005-07-19 22:14:17 +02:00
|
|
|
*
|
|
|
|
* 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,
|
2010-02-12 14:34:04 +01:00
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
2005-07-19 22:14:17 +02:00
|
|
|
*/
|
2012-02-17 19:59:41 +01:00
|
|
|
#ifndef __BKE_MODIFIER_H__
|
|
|
|
#define __BKE_MODIFIER_H__
|
2005-07-19 22:14:17 +02:00
|
|
|
|
2019-02-17 22:08:12 +01:00
|
|
|
/** \file
|
|
|
|
* \ingroup bke
|
2011-02-18 14:05:18 +01:00
|
|
|
*/
|
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
#include "DNA_modifier_types.h" /* needed for all enum typdefs */
|
2013-09-01 17:01:15 +02:00
|
|
|
#include "BLI_compiler_attrs.h"
|
2006-12-05 18:42:03 +01:00
|
|
|
#include "BKE_customdata.h"
|
|
|
|
|
2020-02-07 17:22:11 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2019-01-28 11:08:24 +01:00
|
|
|
struct BMEditMesh;
|
Refactor CDData masks, to have one mask per mesh elem type.
We already have different storages for cddata of verts, edges etc.,
'simply' do the same for the mask flags we use all around Blender code
to request some data, or limit some operation to some layers, etc.
Reason we need this is that some cddata types (like Normals) are
actually shared between verts/polys/loops, and we don’t want to generate
clnors everytime we request vnors!
As a side note, this also does final fix to T59338, which was the
trigger for this patch (need to request computed loop normals for
another mesh than evaluated one).
Reviewers: brecht, campbellbarton, sergey
Differential Revision: https://developer.blender.org/D4407
2019-03-07 11:13:40 +01:00
|
|
|
struct CustomData_MeshMasks;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct DepsNodeHandle;
|
2018-04-06 12:07:27 +02:00
|
|
|
struct Depsgraph;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct ID;
|
|
|
|
struct ListBase;
|
|
|
|
struct Main;
|
2018-04-18 15:45:54 +02:00
|
|
|
struct Mesh;
|
2019-01-28 11:08:24 +01:00
|
|
|
struct ModifierData;
|
2005-07-19 22:14:17 +02:00
|
|
|
struct Object;
|
2009-01-04 15:14:06 +01:00
|
|
|
struct Scene;
|
2006-06-21 17:14:44 +02:00
|
|
|
struct bArmature;
|
2005-07-19 22:14:17 +02:00
|
|
|
|
|
|
|
typedef enum {
|
2019-04-17 06:17:24 +02:00
|
|
|
/* Should not be used, only for None modifier type */
|
|
|
|
eModifierTypeType_None,
|
|
|
|
|
|
|
|
/* Modifier only does deformation, implies that modifier
|
|
|
|
* type should have a valid deformVerts function. OnlyDeform
|
|
|
|
* style modifiers implicitly accept either mesh or CV
|
|
|
|
* input but should still declare flags appropriately.
|
|
|
|
*/
|
|
|
|
eModifierTypeType_OnlyDeform,
|
|
|
|
|
2019-10-10 13:25:44 +02:00
|
|
|
/* Modifier adds geometry. */
|
2019-04-17 06:17:24 +02:00
|
|
|
eModifierTypeType_Constructive,
|
2019-10-10 13:25:44 +02:00
|
|
|
/* Modifier can add and remove geometry. */
|
2019-04-17 06:17:24 +02:00
|
|
|
eModifierTypeType_Nonconstructive,
|
|
|
|
|
|
|
|
/* both deformVerts & applyModifier are valid calls
|
|
|
|
* used for particles modifier that doesn't actually modify the object
|
|
|
|
* unless it's a mesh and can be exploded -> curve can also emit particles
|
|
|
|
*/
|
|
|
|
eModifierTypeType_DeformOrConstruct,
|
|
|
|
|
|
|
|
/* Like eModifierTypeType_Nonconstructive, but does not affect the geometry
|
|
|
|
* of the object, rather some of its CustomData layers.
|
|
|
|
* E.g. UVProject and WeightVG modifiers. */
|
|
|
|
eModifierTypeType_NonGeometrical,
|
2005-07-19 22:14:17 +02:00
|
|
|
} ModifierTypeType;
|
|
|
|
|
|
|
|
typedef enum {
|
2019-04-17 06:17:24 +02:00
|
|
|
eModifierTypeFlag_AcceptsMesh = (1 << 0),
|
|
|
|
eModifierTypeFlag_AcceptsCVs = (1 << 1),
|
|
|
|
eModifierTypeFlag_SupportsMapping = (1 << 2),
|
|
|
|
eModifierTypeFlag_SupportsEditmode = (1 << 3),
|
|
|
|
|
|
|
|
/* For modifiers that support editmode this determines if the
|
|
|
|
* modifier should be enabled by default in editmode. This should
|
|
|
|
* only be used by modifiers that are relatively speedy and
|
|
|
|
* also generally used in editmode, otherwise let the user enable
|
|
|
|
* it by hand.
|
|
|
|
*/
|
|
|
|
eModifierTypeFlag_EnableInEditmode = (1 << 4),
|
|
|
|
|
|
|
|
/* For modifiers that require original data and so cannot
|
|
|
|
* be placed after any non-deformative modifier.
|
|
|
|
*/
|
|
|
|
eModifierTypeFlag_RequiresOriginalData = (1 << 5),
|
|
|
|
|
2019-04-27 04:07:07 +02:00
|
|
|
/* For modifiers that support pointcache,
|
|
|
|
* so we can check to see if it has files we need to deal with. */
|
2019-04-17 06:17:24 +02:00
|
|
|
eModifierTypeFlag_UsesPointCache = (1 << 6),
|
|
|
|
|
|
|
|
/* For physics modifiers, max one per type */
|
|
|
|
eModifierTypeFlag_Single = (1 << 7),
|
|
|
|
|
|
|
|
/* Some modifier can't be added manually by user */
|
|
|
|
eModifierTypeFlag_NoUserAdd = (1 << 8),
|
|
|
|
|
|
|
|
/* For modifiers that use CD_PREVIEW_MCOL for preview. */
|
|
|
|
eModifierTypeFlag_UsesPreview = (1 << 9),
|
|
|
|
eModifierTypeFlag_AcceptsLattice = (1 << 10),
|
2005-07-19 22:14:17 +02:00
|
|
|
} ModifierTypeFlag;
|
|
|
|
|
2015-10-05 15:57:10 +02:00
|
|
|
/* IMPORTANT! Keep ObjectWalkFunc and IDWalkFunc signatures compatible. */
|
2019-04-17 06:17:24 +02:00
|
|
|
typedef void (*ObjectWalkFunc)(void *userData,
|
|
|
|
struct Object *ob,
|
|
|
|
struct Object **obpoin,
|
|
|
|
int cb_flag);
|
2017-01-31 10:41:25 +01:00
|
|
|
typedef void (*IDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin, int cb_flag);
|
2019-04-17 06:17:24 +02:00
|
|
|
typedef void (*TexWalkFunc)(void *userData,
|
|
|
|
struct Object *ob,
|
|
|
|
struct ModifierData *md,
|
|
|
|
const char *propname);
|
2006-08-28 03:12:36 +02:00
|
|
|
|
2012-05-09 17:00:26 +02:00
|
|
|
typedef enum ModifierApplyFlag {
|
2019-04-18 07:21:26 +02:00
|
|
|
/** Render time. */
|
|
|
|
MOD_APPLY_RENDER = 1 << 0,
|
|
|
|
/** Result of evaluation will be cached, so modifier might
|
|
|
|
* want to cache data for quick updates (used by subsurf) */
|
|
|
|
MOD_APPLY_USECACHE = 1 << 1,
|
|
|
|
/** Modifier evaluated for undeformed texture coordinates */
|
|
|
|
MOD_APPLY_ORCO = 1 << 2,
|
|
|
|
/** Ignore scene simplification flag and use subdivisions
|
|
|
|
* level set in multires modifier. */
|
|
|
|
MOD_APPLY_IGNORE_SIMPLIFY = 1 << 3,
|
2012-05-09 17:00:26 +02:00
|
|
|
} ModifierApplyFlag;
|
|
|
|
|
2018-02-22 12:54:06 +01:00
|
|
|
typedef struct ModifierUpdateDepsgraphContext {
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Scene *scene;
|
|
|
|
struct Object *object;
|
|
|
|
struct DepsNodeHandle *node;
|
2018-02-22 12:54:06 +01:00
|
|
|
} ModifierUpdateDepsgraphContext;
|
|
|
|
|
2018-05-01 17:33:04 +02:00
|
|
|
/* Contains the information for deformXXX and applyXXX functions below that
|
|
|
|
* doesn't change between consecutive modifiers. */
|
|
|
|
typedef struct ModifierEvalContext {
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Depsgraph *depsgraph;
|
|
|
|
struct Object *object;
|
|
|
|
ModifierApplyFlag flag;
|
2018-05-01 17:33:04 +02:00
|
|
|
} ModifierEvalContext;
|
|
|
|
|
2005-07-19 22:14:17 +02:00
|
|
|
typedef struct ModifierTypeInfo {
|
2019-04-17 06:17:24 +02:00
|
|
|
/* 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;
|
|
|
|
|
|
|
|
ModifierTypeType type;
|
|
|
|
ModifierTypeFlag flags;
|
|
|
|
|
|
|
|
/********************* Non-optional functions *********************/
|
|
|
|
|
|
|
|
/* Copy instance data for this modifier type. Should copy all user
|
|
|
|
* level settings to the target modifier.
|
|
|
|
*
|
|
|
|
* \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
|
|
|
|
*/
|
|
|
|
void (*copyData)(const struct ModifierData *md, struct ModifierData *target, const int flag);
|
|
|
|
|
|
|
|
/********************* Deform modifier functions *********************/
|
|
|
|
|
|
|
|
/* Only for deform types, should apply the deformation
|
|
|
|
* to the given vertex array. If the deformer requires information from
|
|
|
|
* the object it can obtain it from the mesh argument if non-NULL,
|
|
|
|
* and otherwise the ob argument.
|
|
|
|
*/
|
|
|
|
void (*deformVerts)(struct ModifierData *md,
|
|
|
|
const struct ModifierEvalContext *ctx,
|
|
|
|
struct Mesh *mesh,
|
|
|
|
float (*vertexCos)[3],
|
|
|
|
int numVerts);
|
|
|
|
|
|
|
|
/* Like deformMatricesEM but called from object mode (for supporting modifiers in sculpt mode) */
|
|
|
|
void (*deformMatrices)(struct ModifierData *md,
|
|
|
|
const struct ModifierEvalContext *ctx,
|
|
|
|
struct Mesh *mesh,
|
|
|
|
float (*vertexCos)[3],
|
|
|
|
float (*defMats)[3][3],
|
|
|
|
int numVerts);
|
|
|
|
|
|
|
|
/* Like deformVerts but called during editmode (for supporting modifiers)
|
|
|
|
*/
|
|
|
|
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 crazyspace 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 *********************/
|
|
|
|
|
|
|
|
/* For non-deform types: apply the modifier and return a mesh object.
|
|
|
|
*
|
|
|
|
* The mesh argument should always be non-NULL; the modifier
|
|
|
|
* should read the object data from the mesh object instead of the
|
|
|
|
* actual object data.
|
|
|
|
*
|
|
|
|
* The modifier may reuse the mesh argument (i.e. return it in
|
|
|
|
* modified form), but must not release it.
|
|
|
|
*/
|
|
|
|
struct Mesh *(*applyModifier)(struct ModifierData *md,
|
|
|
|
const struct ModifierEvalContext *ctx,
|
|
|
|
struct Mesh *mesh);
|
|
|
|
|
|
|
|
/********************* Optional functions *********************/
|
|
|
|
|
|
|
|
/* Initialize new instance data for this modifier type, this function
|
|
|
|
* should set modifier variables to their default values.
|
|
|
|
*
|
|
|
|
* This function is optional.
|
|
|
|
*/
|
|
|
|
void (*initData)(struct ModifierData *md);
|
|
|
|
|
|
|
|
/* Should add to passed \a r_cddata_masks the data types that this
|
|
|
|
* modifier needs. If (mask & (1 << (layer type))) != 0, this modifier
|
|
|
|
* needs that custom data layer. It can change required layers
|
|
|
|
* depending on the modifier's settings.
|
|
|
|
*
|
|
|
|
* Note that this means extra data (e.g. vertex groups) - it is assumed
|
|
|
|
* that all modifiers need mesh data and deform modifiers need vertex
|
|
|
|
* coordinates.
|
|
|
|
*
|
|
|
|
* If this function is not present, it is assumed that no extra data is needed.
|
|
|
|
*
|
|
|
|
* This function is optional.
|
|
|
|
*/
|
|
|
|
void (*requiredDataMask)(struct Object *ob,
|
|
|
|
struct ModifierData *md,
|
|
|
|
struct CustomData_MeshMasks *r_cddata_masks);
|
|
|
|
|
|
|
|
/* Free internal modifier data variables, this function should
|
|
|
|
* not free the md variable itself.
|
|
|
|
*
|
|
|
|
* This function is responsible for freeing the runtime data as well.
|
|
|
|
*
|
|
|
|
* This function is optional.
|
|
|
|
*/
|
|
|
|
void (*freeData)(struct ModifierData *md);
|
|
|
|
|
|
|
|
/* Return a boolean value indicating if this modifier is able to be
|
|
|
|
* calculated based on the modifier data. This is *not* regarding the
|
|
|
|
* md->flag, that is tested by the system, this is just if the data
|
|
|
|
* validates (for example, a lattice will return false if the lattice
|
|
|
|
* object is not defined).
|
|
|
|
*
|
|
|
|
* This function is optional (assumes never disabled if not present).
|
|
|
|
*/
|
|
|
|
bool (*isDisabled)(const struct Scene *scene, struct ModifierData *md, bool userRenderParams);
|
|
|
|
|
|
|
|
/* Add the appropriate relations to the dependency graph.
|
|
|
|
*
|
|
|
|
* This function is optional.
|
|
|
|
*/
|
|
|
|
void (*updateDepsgraph)(struct ModifierData *md, const ModifierUpdateDepsgraphContext *ctx);
|
|
|
|
|
|
|
|
/* Should return true if the modifier needs to be recalculated on time
|
|
|
|
* changes.
|
|
|
|
*
|
|
|
|
* This function is optional (assumes false if not present).
|
|
|
|
*/
|
|
|
|
bool (*dependsOnTime)(struct ModifierData *md);
|
|
|
|
|
|
|
|
/* True when a deform modifier uses normals, the requiredDataMask
|
|
|
|
* cant be used here because that refers to a normal layer whereas
|
|
|
|
* in this case we need to know if the deform modifier uses normals.
|
|
|
|
*
|
|
|
|
* this is needed because applying 2 deform modifiers will give the
|
|
|
|
* second modifier bogus normals.
|
|
|
|
* */
|
|
|
|
bool (*dependsOnNormals)(struct ModifierData *md);
|
|
|
|
|
|
|
|
/* Should call the given walk function on with a pointer to each Object
|
|
|
|
* pointer that the modifier data stores. This is used for linking on file
|
|
|
|
* load and for unlinking objects or forwarding object references.
|
|
|
|
*
|
|
|
|
* This function is optional.
|
|
|
|
*/
|
|
|
|
void (*foreachObjectLink)(struct ModifierData *md,
|
|
|
|
struct Object *ob,
|
|
|
|
ObjectWalkFunc walk,
|
|
|
|
void *userData);
|
|
|
|
|
|
|
|
/* Should call the given walk function with a pointer to each ID
|
2019-06-12 01:04:10 +02:00
|
|
|
* pointer (i.e. each data-block pointer) that the modifier data
|
2019-04-17 06:17:24 +02:00
|
|
|
* stores. This is used for linking on file load and for
|
2019-06-12 01:04:10 +02:00
|
|
|
* unlinking data-blocks or forwarding data-block references.
|
2019-04-17 06:17:24 +02:00
|
|
|
*
|
|
|
|
* This function is optional. If it is not present, foreachObjectLink
|
|
|
|
* will be used.
|
|
|
|
*/
|
|
|
|
void (*foreachIDLink)(struct ModifierData *md,
|
|
|
|
struct Object *ob,
|
|
|
|
IDWalkFunc walk,
|
|
|
|
void *userData);
|
|
|
|
|
|
|
|
/* Should call the given walk function for each texture that the
|
|
|
|
* modifier data stores. This is used for finding all textures in
|
|
|
|
* the context for the UI.
|
|
|
|
*
|
|
|
|
* This function is optional. If it is not present, it will be
|
|
|
|
* assumed the modifier has no textures.
|
|
|
|
*/
|
|
|
|
void (*foreachTexLink)(struct ModifierData *md,
|
|
|
|
struct Object *ob,
|
|
|
|
TexWalkFunc walk,
|
|
|
|
void *userData);
|
|
|
|
|
2019-06-12 01:04:10 +02:00
|
|
|
/* Free given run-time data.
|
2019-04-17 06:17:24 +02:00
|
|
|
*
|
|
|
|
* This data is coming from a modifier of the corresponding type, but actual
|
|
|
|
* modifier data is not known here.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* - The data itself is to be de-allocated as well.
|
2019-06-12 01:04:10 +02:00
|
|
|
* - This callback is allowed to receive NULL pointer as a data, so it's
|
2019-04-17 06:17:24 +02:00
|
|
|
* more like "ensure the data is freed".
|
|
|
|
*/
|
|
|
|
void (*freeRuntimeData)(void *runtime_data);
|
2006-08-28 03:12:36 +02:00
|
|
|
} ModifierTypeInfo;
|
2005-08-11 04:23:52 +02:00
|
|
|
|
2013-08-19 11:05:34 +02:00
|
|
|
/* Initialize modifier's global data (type info and some common global storages). */
|
|
|
|
void BKE_modifier_init(void);
|
|
|
|
|
2015-03-30 12:17:07 +02:00
|
|
|
const ModifierTypeInfo *modifierType_getInfo(ModifierType type);
|
2005-08-11 04:23:52 +02:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
/* Modifier utility calls, do call through type pointer and return
|
|
|
|
* default values if pointer is optional.
|
|
|
|
*/
|
2019-04-17 06:17:24 +02:00
|
|
|
struct ModifierData *modifier_new(int type);
|
|
|
|
void modifier_free_ex(struct ModifierData *md, const int flag);
|
|
|
|
void modifier_free(struct ModifierData *md);
|
|
|
|
|
|
|
|
bool modifier_unique_name(struct ListBase *modifiers, struct ModifierData *md);
|
|
|
|
|
|
|
|
void modifier_copyData_generic(const struct ModifierData *md,
|
|
|
|
struct ModifierData *target,
|
|
|
|
const int flag);
|
|
|
|
void modifier_copyData(struct ModifierData *md, struct ModifierData *target);
|
|
|
|
void modifier_copyData_ex(struct ModifierData *md, struct ModifierData *target, const int flag);
|
|
|
|
bool modifier_dependsOnTime(struct ModifierData *md);
|
|
|
|
bool modifier_supportsMapping(struct ModifierData *md);
|
|
|
|
bool modifier_supportsCage(struct Scene *scene, struct ModifierData *md);
|
|
|
|
bool modifier_couldBeCage(struct Scene *scene, struct ModifierData *md);
|
|
|
|
bool modifier_isCorrectableDeformed(struct ModifierData *md);
|
|
|
|
bool modifier_isSameTopology(ModifierData *md);
|
|
|
|
bool modifier_isNonGeometrical(ModifierData *md);
|
|
|
|
bool modifier_isEnabled(const struct Scene *scene, struct ModifierData *md, int required_mode);
|
|
|
|
void modifier_setError(struct ModifierData *md, const char *format, ...) ATTR_PRINTF_FORMAT(2, 3);
|
|
|
|
bool modifier_isPreview(struct ModifierData *md);
|
|
|
|
|
|
|
|
void modifiers_foreachObjectLink(struct Object *ob, ObjectWalkFunc walk, void *userData);
|
|
|
|
void modifiers_foreachIDLink(struct Object *ob, IDWalkFunc walk, void *userData);
|
|
|
|
void modifiers_foreachTexLink(struct Object *ob, TexWalkFunc walk, void *userData);
|
|
|
|
|
|
|
|
struct ModifierData *modifiers_findByType(struct Object *ob, ModifierType type);
|
|
|
|
struct ModifierData *modifiers_findByName(struct Object *ob, const char *name);
|
|
|
|
void modifiers_clearErrors(struct Object *ob);
|
|
|
|
int modifiers_getCageIndex(struct Scene *scene,
|
|
|
|
struct Object *ob,
|
|
|
|
int *r_lastPossibleCageIndex,
|
|
|
|
bool is_virtual);
|
|
|
|
|
|
|
|
bool modifiers_isModifierEnabled(struct Object *ob, int modifierType);
|
|
|
|
bool modifiers_isSoftbodyEnabled(struct Object *ob);
|
|
|
|
bool modifiers_isClothEnabled(struct Object *ob);
|
|
|
|
bool modifiers_isParticleEnabled(struct Object *ob);
|
2008-01-29 22:01:12 +01:00
|
|
|
|
2006-08-28 03:12:36 +02:00
|
|
|
struct Object *modifiers_isDeformedByArmature(struct Object *ob);
|
2018-05-11 08:16:41 +02:00
|
|
|
struct Object *modifiers_isDeformedByMeshDeform(struct Object *ob);
|
2006-12-23 12:56:22 +01:00
|
|
|
struct Object *modifiers_isDeformedByLattice(struct Object *ob);
|
2012-10-15 05:16:38 +02:00
|
|
|
struct Object *modifiers_isDeformedByCurve(struct Object *ob);
|
2019-10-01 22:30:14 +02:00
|
|
|
bool modifiers_usesMultires(struct Object *ob);
|
2019-04-17 06:17:24 +02:00
|
|
|
bool modifiers_usesArmature(struct Object *ob, struct bArmature *arm);
|
2019-07-07 18:58:11 +02:00
|
|
|
bool modifiers_usesSubsurfFacedots(struct Scene *scene, struct Object *ob);
|
2019-04-17 06:17:24 +02:00
|
|
|
bool modifiers_isCorrectableDeformed(struct Scene *scene, struct Object *ob);
|
|
|
|
void modifier_freeTemporaryData(struct ModifierData *md);
|
|
|
|
bool modifiers_isPreview(struct Object *ob);
|
2005-09-18 15:27:12 +02:00
|
|
|
|
2012-03-26 18:25:21 +02:00
|
|
|
typedef struct CDMaskLink {
|
2019-04-17 06:17:24 +02:00
|
|
|
struct CDMaskLink *next;
|
|
|
|
struct CustomData_MeshMasks mask;
|
2012-03-26 18:25:21 +02:00
|
|
|
} CDMaskLink;
|
|
|
|
|
2019-06-10 15:42:15 +02:00
|
|
|
/* Calculates and returns a linked list of CustomData_MeshMasks and modified
|
|
|
|
* final datamask, indicating the data required by each modifier in the stack
|
|
|
|
* pointed to by md for correct evaluation, assuming the data indicated by
|
|
|
|
* final_datamask is required at the end of the stack.
|
2006-12-05 18:42:03 +01:00
|
|
|
*/
|
2013-06-13 02:33:48 +02:00
|
|
|
struct CDMaskLink *modifiers_calcDataMasks(struct Scene *scene,
|
2012-05-12 22:39:39 +02:00
|
|
|
struct Object *ob,
|
|
|
|
struct ModifierData *md,
|
2019-06-10 15:42:15 +02:00
|
|
|
struct CustomData_MeshMasks *final_datamask,
|
2013-06-13 02:33:48 +02:00
|
|
|
int required_mode,
|
Refactor CDData masks, to have one mask per mesh elem type.
We already have different storages for cddata of verts, edges etc.,
'simply' do the same for the mask flags we use all around Blender code
to request some data, or limit some operation to some layers, etc.
Reason we need this is that some cddata types (like Normals) are
actually shared between verts/polys/loops, and we don’t want to generate
clnors everytime we request vnors!
As a side note, this also does final fix to T59338, which was the
trigger for this patch (need to request computed loop normals for
another mesh than evaluated one).
Reviewers: brecht, campbellbarton, sergey
Differential Revision: https://developer.blender.org/D4407
2019-03-07 11:13:40 +01:00
|
|
|
ModifierData *previewmd,
|
|
|
|
const struct CustomData_MeshMasks *previewmask);
|
Add weight preview to WeightVG modifiers, and first, simple/basic refactor of how modifiers can generate preview.
User side:
* Preview for DynamicPaint should keep the same behavior (for now). Weight preview should be somawhat quicker, though.
* Preview for WeightVG modifiers is only active in WeightPaint mode, and if the affected vgroup is the active one.
* Last active preview modifier in stack wins!
Note: that modifier preview topic is yet to be further refined, quite raw/incomplete for now.
Dev side:
* In draw code, renamed DRAW_DYNAMIC_PAINT_PREVIEW flag to DRAW_MODIFIERS_PREVIEW
* Removed use of MOD_DPAINT_PREVIEW_READY in DynamicPaint code (seems unecessary, and if it was, should be of more general scope).
* Added eModifierTypeFlag_UsesPreview to ModifierTypeFlag, for modifiers that can generate some preview data.
* Added three new modifier funcs, to handle preview modifiers in draw code / mod stack.
* For weights preview: added the generic DM_update_weight_mcol func, which can update WEIGHT_MCOL layer with either a given array of weights (currently used by DynamicPaint only), or from current active vgroup(s).
So now, draw code is fully generic (i.e. no more modifier-type checking in it). Mod stack code is generic to some extent, but will need more work.
2012-01-22 18:54:23 +01:00
|
|
|
struct ModifierData *modifiers_getLastPreview(struct Scene *scene,
|
|
|
|
struct ModifierData *md,
|
|
|
|
int required_mode);
|
2013-08-19 11:05:34 +02:00
|
|
|
|
|
|
|
typedef struct VirtualModifierData {
|
2019-04-17 06:17:24 +02:00
|
|
|
ArmatureModifierData amd;
|
|
|
|
CurveModifierData cmd;
|
|
|
|
LatticeModifierData lmd;
|
|
|
|
ShapeKeyModifierData smd;
|
2013-08-19 11:05:34 +02:00
|
|
|
} VirtualModifierData;
|
|
|
|
|
2019-11-26 15:11:20 +01:00
|
|
|
struct ModifierData *modifiers_getVirtualModifierList(const struct Object *ob,
|
2019-04-17 06:17:24 +02:00
|
|
|
struct VirtualModifierData *data);
|
2005-09-18 15:27:12 +02:00
|
|
|
|
2010-09-09 02:14:51 +02:00
|
|
|
/* ensure modifier correctness when changing ob->data */
|
|
|
|
void test_object_modifiers(struct Object *ob);
|
|
|
|
|
2010-04-23 13:19:06 +02:00
|
|
|
/* here for do_versions */
|
|
|
|
void modifier_mdef_compact_influences(struct ModifierData *md);
|
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
void modifier_path_init(char *path, int path_maxlen, const char *name);
|
2018-05-31 15:24:30 +02:00
|
|
|
const char *modifier_path_relbase(struct Main *bmain, struct Object *ob);
|
2018-06-09 15:16:44 +02:00
|
|
|
const char *modifier_path_relbase_from_global(struct Object *ob);
|
2013-06-19 10:00:20 +02:00
|
|
|
|
2019-04-04 14:42:33 +02:00
|
|
|
/* 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 *modifier_get_original(struct ModifierData *md);
|
2019-04-17 06:17:24 +02:00
|
|
|
struct ModifierData *modifier_get_evaluated(struct Depsgraph *depsgraph,
|
|
|
|
struct Object *object,
|
|
|
|
struct ModifierData *md);
|
2019-04-04 14:42:33 +02:00
|
|
|
|
2018-04-18 15:45:54 +02:00
|
|
|
/* wrappers for modifier callbacks that ensure valid normals */
|
2013-06-19 10:00:20 +02:00
|
|
|
|
2019-04-17 06:17:24 +02:00
|
|
|
struct Mesh *modwrap_applyModifier(ModifierData *md,
|
|
|
|
const struct ModifierEvalContext *ctx,
|
|
|
|
struct Mesh *me);
|
|
|
|
|
|
|
|
void modwrap_deformVerts(ModifierData *md,
|
|
|
|
const struct ModifierEvalContext *ctx,
|
|
|
|
struct Mesh *me,
|
|
|
|
float (*vertexCos)[3],
|
|
|
|
int numVerts);
|
|
|
|
|
|
|
|
void modwrap_deformVertsEM(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);
|
2018-05-09 12:44:22 +02:00
|
|
|
|
2019-11-29 11:42:18 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-07-19 22:14:17 +02:00
|
|
|
#endif
|