doxygen: add newline after \file
[blender.git] / source / blender / blenkernel / BKE_gpencil_modifier.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16 #ifndef __BKE_GPENCIL_MODIFIER_H__
17 #define __BKE_GPENCIL_MODIFIER_H__
18
19 /** \file
20  * \ingroup bke
21  */
22
23 #include "DNA_gpencil_modifier_types.h"     /* needed for all enum typdefs */
24 #include "BLI_compiler_attrs.h"
25 #include "BKE_customdata.h"
26
27 struct BMEditMesh;
28 struct DepsNodeHandle;
29 struct Depsgraph;
30 struct DerivedMesh;
31 struct GpencilModifierData;
32 struct ID;
33 struct ListBase;
34 struct Main;
35 struct Mesh;
36 struct ModifierUpdateDepsgraphContext;
37 struct Object;
38 struct Scene;
39 struct ViewLayer;
40 struct bArmature;
41 struct bContext; /* NOTE: bakeModifier() - called from UI - needs to create new datablocks, hence the need for this */
42 struct bGPDframe;
43 struct bGPDlayer;
44 struct bGPDstroke;
45
46 #define GPENCIL_MODIFIER_ACTIVE(_md, _is_render) \
47         ((((_md)->mode & eGpencilModifierMode_Realtime) && (_is_render == false)) || \
48          (((_md)->mode & eGpencilModifierMode_Render) && (_is_render == true)))
49 #define GPENCIL_MODIFIER_EDIT(_md, _is_edit) \
50         ((((_md)->mode & eGpencilModifierMode_Editmode) == 0) && (_is_edit))
51
52 typedef enum {
53         /* Should not be used, only for None modifier type */
54         eGpencilModifierTypeType_None,
55
56         /* grease pencil modifiers */
57         eGpencilModifierTypeType_Gpencil,
58 }  GpencilModifierTypeType;
59
60 typedef enum {
61         eGpencilModifierTypeFlag_SupportsMapping = (1 << 0),
62         eGpencilModifierTypeFlag_SupportsEditmode = (1 << 1),
63
64         /* For modifiers that support editmode this determines if the
65          * modifier should be enabled by default in editmode. This should
66          * only be used by modifiers that are relatively speedy and
67          * also generally used in editmode, otherwise let the user enable
68          * it by hand.
69          */
70         eGpencilModifierTypeFlag_EnableInEditmode = (1 << 2),
71
72         /* For modifiers that require original data and so cannot
73          * be placed after any non-deformative modifier.
74          */
75         eGpencilModifierTypeFlag_RequiresOriginalData = (1 << 3),
76
77         /* max one per type */
78         eGpencilModifierTypeFlag_Single = (1 << 4),
79
80         /* can't be added manually by user */
81         eGpencilModifierTypeFlag_NoUserAdd = (1 << 5),
82         /* can't be applied */
83         eGpencilModifierTypeFlag_NoApply = (1 << 6),
84 } GpencilModifierTypeFlag;
85
86 /* IMPORTANT! Keep ObjectWalkFunc and IDWalkFunc signatures compatible. */
87 typedef void(*GreasePencilObjectWalkFunc)(void *userData, struct Object *ob, struct Object **obpoin, int cb_flag);
88 typedef void(*GreasePencilIDWalkFunc)(void *userData, struct Object *ob, struct ID **idpoin, int cb_flag);
89 typedef void(*GreasePencilTexWalkFunc)(void *userData, struct Object *ob, struct GpencilModifierData *md, const char *propname);
90
91 typedef struct GpencilModifierTypeInfo {
92         /** The user visible name for this modifier */
93         char name[32];
94
95         /**
96          * The DNA struct name for the modifier data type, used to
97          * write the DNA data out.
98          */
99         char struct_name[32];
100
101         /** The size of the modifier data type, used by allocation. */
102         int struct_size;
103
104         GpencilModifierTypeType type;
105         GpencilModifierTypeFlag flags;
106
107
108         /********************* Non-optional functions *********************/
109
110         /**
111          * Copy instance data for this modifier type. Should copy all user
112          * level settings to the target modifier.
113          */
114         void (*copyData)(const struct GpencilModifierData *md, struct GpencilModifierData *target);
115
116         /**
117          * Callback for GP "stroke" modifiers that operate on the
118          * shape and parameters of the provided strokes (e.g. Thickness, Noise, etc.)
119          *
120          * The gpl parameter contains the GP layer that the strokes come from.
121          * While access is provided to this data, you should not directly access
122          * the gpl->frames data from the modifier. Instead, use the gpf parameter
123          * instead.
124          *
125          * The gps parameter contains the GP stroke to operate on. This is usually a copy
126          * of the original (unmodified and saved to files) stroke data.
127          */
128         void (*deformStroke)(struct GpencilModifierData *md, struct Depsgraph *depsgraph,
129                              struct Object *ob, struct bGPDlayer *gpl, struct bGPDstroke *gps);
130
131         /**
132          * Callback for GP "geometry" modifiers that create extra geometry
133          * in the frame (e.g. Array)
134          *
135          * The gpf parameter contains the GP frame/strokes to operate on. This is
136          * usually a copy of the original (unmodified and saved to files) stroke data.
137          * Modifiers should only add any generated strokes to this frame (and not one accessed
138          * via the gpl parameter).
139          *
140          * The modifier_index parameter indicates where the modifier is
141          * in the modifier stack in relation to other modifiers.
142          */
143         void (*generateStrokes)(struct GpencilModifierData *md, struct Depsgraph *depsgraph,
144                                 struct Object *ob, struct bGPDlayer *gpl, struct bGPDframe *gpf);
145
146         /**
147          * Bake-down GP modifier's effects into the GP datablock.
148          *
149          * This gets called when the user clicks the "Apply" button in the UI.
150          * As such, this callback needs to go through all layers/frames in the
151          * datablock, mutating the geometry and/or creating new datablocks/objects
152          */
153         void (*bakeModifier)(struct Main *bmain, struct Depsgraph *depsgraph,
154                            struct GpencilModifierData *md, struct Object *ob);
155
156
157         /********************* Optional functions *********************/
158
159         /**
160          * Callback for GP "time" modifiers that offset keyframe time
161          * Returns the frame number to be used after apply the modifier. This is
162          * usually an offset of the animation for duplicated datablocks.
163          *
164          * This function is optional.
165          */
166         int (*remapTime)(struct GpencilModifierData *md, struct Depsgraph *depsgraph,
167                 struct Scene *scene, struct Object *ob, struct bGPDlayer *gpl, int cfra);
168
169         /**
170          * Initialize new instance data for this modifier type, this function
171          * should set modifier variables to their default values.
172          *
173          * This function is optional.
174          */
175         void (*initData)(struct GpencilModifierData *md);
176
177         /**
178          * Free internal modifier data variables, this function should
179          * not free the md variable itself.
180          *
181          * This function is optional.
182          */
183         void (*freeData)(struct GpencilModifierData *md);
184
185         /**
186          * Return a boolean value indicating if this modifier is able to be
187          * calculated based on the modifier data. This is *not* regarding the
188          * md->flag, that is tested by the system, this is just if the data
189          * validates (for example, a lattice will return false if the lattice
190          * object is not defined).
191          *
192          * This function is optional (assumes never disabled if not present).
193          */
194         bool (*isDisabled)(struct GpencilModifierData *md, int userRenderParams);
195
196         /**
197          * Add the appropriate relations to the dependency graph.
198          *
199          * This function is optional.
200          */
201         void (*updateDepsgraph)(struct GpencilModifierData *md,
202                                 const struct ModifierUpdateDepsgraphContext *ctx);
203
204         /**
205          * Should return true if the modifier needs to be recalculated on time
206          * changes.
207          *
208          * This function is optional (assumes false if not present).
209          */
210         bool (*dependsOnTime)(struct GpencilModifierData *md);
211
212
213         /**
214          * Should call the given walk function on with a pointer to each Object
215          * pointer that the modifier data stores. This is used for linking on file
216          * load and for unlinking objects or forwarding object references.
217          *
218          * This function is optional.
219          */
220         void (*foreachObjectLink)(struct GpencilModifierData *md, struct Object *ob,
221                                   GreasePencilObjectWalkFunc walk, void *userData);
222
223         /**
224          * Should call the given walk function with a pointer to each ID
225          * pointer (i.e. each datablock pointer) that the modifier data
226          * stores. This is used for linking on file load and for
227          * unlinking datablocks or forwarding datablock references.
228          *
229          * This function is optional. If it is not present, foreachObjectLink
230          * will be used.
231          */
232         void (*foreachIDLink)(struct GpencilModifierData *md, struct Object *ob,
233                               GreasePencilIDWalkFunc walk, void *userData);
234
235         /**
236          * Should call the given walk function for each texture that the
237          * modifier data stores. This is used for finding all textures in
238          * the context for the UI.
239          *
240          * This function is optional. If it is not present, it will be
241          * assumed the modifier has no textures.
242          */
243         void (*foreachTexLink)(struct GpencilModifierData *md, struct Object *ob,
244                                GreasePencilTexWalkFunc walk, void *userData);
245
246         /**
247          * Get the number of times the strokes are duplicated in this modifier.
248          * This is used to calculate the size of the GPU VBOs
249          */
250         int (*getDuplicationFactor)(struct GpencilModifierData *md);
251 } GpencilModifierTypeInfo;
252
253 /* Initialize modifier's global data (type info and some common global storages). */
254 void BKE_gpencil_modifier_init(void);
255
256 const GpencilModifierTypeInfo *BKE_gpencil_modifierType_getInfo(GpencilModifierType type);
257 struct GpencilModifierData  *BKE_gpencil_modifier_new(int type);
258 void BKE_gpencil_modifier_free_ex(struct GpencilModifierData *md, const int flag);
259 void BKE_gpencil_modifier_free(struct GpencilModifierData *md);
260 bool BKE_gpencil_modifier_unique_name(struct ListBase *modifiers, struct GpencilModifierData *gmd);
261 bool BKE_gpencil_modifier_dependsOnTime(struct GpencilModifierData *md);
262 struct GpencilModifierData *BKE_gpencil_modifiers_findByType(struct Object *ob, GpencilModifierType type);
263 struct GpencilModifierData *BKE_gpencil_modifiers_findByName(struct Object *ob, const char *name);
264 void BKE_gpencil_modifier_copyData_generic(const struct GpencilModifierData *md_src, struct GpencilModifierData *md_dst);
265 void BKE_gpencil_modifier_copyData(struct GpencilModifierData *md, struct GpencilModifierData *target);
266 void BKE_gpencil_modifier_copyData_ex(struct GpencilModifierData *md, struct GpencilModifierData *target, const int flag);
267 void BKE_gpencil_modifiers_foreachIDLink(struct Object *ob, GreasePencilIDWalkFunc walk, void *userData);
268 void BKE_gpencil_modifiers_foreachTexLink(struct Object *ob, GreasePencilTexWalkFunc walk, void *userData);
269
270 bool BKE_gpencil_has_geometry_modifiers(struct Object *ob);
271 bool BKE_gpencil_has_time_modifiers(struct Object *ob);
272
273 void BKE_gpencil_stroke_modifiers(
274         struct Depsgraph *depsgraph, struct Object *ob,
275         struct bGPDlayer *gpl, struct bGPDframe *gpf, struct bGPDstroke *gps, bool is_render);
276 void BKE_gpencil_geometry_modifiers(
277         struct Depsgraph *depsgraph, struct Object *ob,
278         struct bGPDlayer *gpl, struct bGPDframe *gpf, bool is_render);
279 int BKE_gpencil_time_modifier(
280         struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob,
281         struct bGPDlayer *gpl, int cfra, bool is_render);
282
283 void BKE_gpencil_lattice_init(struct Object *ob);
284 void BKE_gpencil_lattice_clear(struct Object *ob);
285
286 #endif /* __BKE_GPENCIL_MODIFIER_H__ */