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