GPencil: Fix unreported unable to deselect when masking is OFF
[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 GpencilModifierData;
31 struct ID;
32 struct ListBase;
33 struct Main;
34 struct Mesh;
35 struct ModifierUpdateDepsgraphContext;
36 struct Object;
37 struct Scene;
38 struct ViewLayer;
39 struct bArmature;
40 /* NOTE: bakeModifier() called from UI:
41  * needs to create new databloc-ks, hence the need for this. */
42 struct bContext;
43 struct bGPDframe;
44 struct bGPDlayer;
45 struct bGPDstroke;
46
47 #define GPENCIL_MODIFIER_ACTIVE(_md, _is_render) \
48   ((((_md)->mode & eGpencilModifierMode_Realtime) && (_is_render == false)) || \
49    (((_md)->mode & eGpencilModifierMode_Render) && (_is_render == true)))
50 #define GPENCIL_MODIFIER_EDIT(_md, _is_edit) \
51   ((((_md)->mode & eGpencilModifierMode_Editmode) == 0) && (_is_edit))
52
53 typedef enum {
54   /** Should not be used, only for None modifier type. */
55   eGpencilModifierTypeType_None,
56
57   /** Grease pencil modifiers. */
58   eGpencilModifierTypeType_Gpencil,
59 } GpencilModifierTypeType;
60
61 typedef enum {
62   eGpencilModifierTypeFlag_SupportsMapping = (1 << 0),
63   eGpencilModifierTypeFlag_SupportsEditmode = (1 << 1),
64
65   /**
66    * For modifiers that support edit-mode this determines if the
67    * modifier should be enabled by default in edit-mode. This should
68    * only be used by modifiers that are relatively speedy and
69    * also generally used in edit-mode, otherwise let the user enable it by hand.
70    */
71   eGpencilModifierTypeFlag_EnableInEditmode = (1 << 2),
72
73   /**
74    * For modifiers that require original data and so cannot
75    * be placed after any non-deform modifier.
76    */
77   eGpencilModifierTypeFlag_RequiresOriginalData = (1 << 3),
78
79   /** Max one per type. */
80   eGpencilModifierTypeFlag_Single = (1 << 4),
81
82   /** Can't be added manually by user. */
83   eGpencilModifierTypeFlag_NoUserAdd = (1 << 5),
84   /** Can't be applied. */
85   eGpencilModifierTypeFlag_NoApply = (1 << 6),
86 } GpencilModifierTypeFlag;
87
88 /* IMPORTANT! Keep ObjectWalkFunc and IDWalkFunc signatures compatible. */
89 typedef void (*GreasePencilObjectWalkFunc)(void *userData,
90                                            struct Object *ob,
91                                            struct Object **obpoin,
92                                            int cb_flag);
93 typedef void (*GreasePencilIDWalkFunc)(void *userData,
94                                        struct Object *ob,
95                                        struct ID **idpoin,
96                                        int cb_flag);
97 typedef void (*GreasePencilTexWalkFunc)(void *userData,
98                                         struct Object *ob,
99                                         struct GpencilModifierData *md,
100                                         const char *propname);
101
102 typedef struct GpencilModifierTypeInfo {
103   /** The user visible name for this modifier */
104   char name[32];
105
106   /**
107    * The DNA struct name for the modifier data type, used to
108    * write the DNA data out.
109    */
110   char struct_name[32];
111
112   /** The size of the modifier data type, used by allocation. */
113   int struct_size;
114
115   GpencilModifierTypeType type;
116   GpencilModifierTypeFlag flags;
117
118   /********************* Non-optional functions *********************/
119
120   /**
121    * Copy instance data for this modifier type. Should copy all user
122    * level settings to the target modifier.
123    */
124   void (*copyData)(const struct GpencilModifierData *md, struct GpencilModifierData *target);
125
126   /**
127    * Callback for GP "stroke" modifiers that operate on the
128    * shape and parameters of the provided strokes (e.g. Thickness, Noise, etc.)
129    *
130    * The gpl parameter contains the GP layer that the strokes come from.
131    * While access is provided to this data, you should not directly access
132    * the gpl->frames data from the modifier. Instead, use the gpf parameter
133    * instead.
134    *
135    * The gps parameter contains the GP stroke to operate on. This is usually a copy
136    * of the original (unmodified and saved to files) stroke data.
137    */
138   void (*deformStroke)(struct GpencilModifierData *md,
139                        struct Depsgraph *depsgraph,
140                        struct Object *ob,
141                        struct bGPDlayer *gpl,
142                        struct bGPDframe *gpf,
143                        struct bGPDstroke *gps);
144
145   /**
146    * Callback for GP "geometry" modifiers that create extra geometry
147    * in the frame (e.g. Array)
148    *
149    * The gpf parameter contains the GP frame/strokes to operate on. This is
150    * usually a copy of the original (unmodified and saved to files) stroke data.
151    * Modifiers should only add any generated strokes to this frame (and not one accessed
152    * via the gpl parameter).
153    *
154    * The modifier_index parameter indicates where the modifier is
155    * in the modifier stack in relation to other modifiers.
156    */
157   void (*generateStrokes)(struct GpencilModifierData *md,
158                           struct Depsgraph *depsgraph,
159                           struct Object *ob,
160                           struct bGPDlayer *gpl,
161                           struct bGPDframe *gpf);
162
163   /**
164    * Bake-down GP modifier's effects into the GP data-block.
165    *
166    * This gets called when the user clicks the "Apply" button in the UI.
167    * As such, this callback needs to go through all layers/frames in the
168    * data-block, mutating the geometry and/or creating new data-blocks/objects
169    */
170   void (*bakeModifier)(struct Main *bmain,
171                        struct Depsgraph *depsgraph,
172                        struct GpencilModifierData *md,
173                        struct Object *ob);
174
175   /********************* Optional functions *********************/
176
177   /**
178    * Callback for GP "time" modifiers that offset keyframe time
179    * Returns the frame number to be used after apply the modifier. This is
180    * usually an offset of the animation for duplicated data-blocks.
181    *
182    * This function is optional.
183    */
184   int (*remapTime)(struct GpencilModifierData *md,
185                    struct Depsgraph *depsgraph,
186                    struct Scene *scene,
187                    struct Object *ob,
188                    struct bGPDlayer *gpl,
189                    int cfra);
190
191   /**
192    * Initialize new instance data for this modifier type, this function
193    * should set modifier variables to their default values.
194    *
195    * This function is optional.
196    */
197   void (*initData)(struct GpencilModifierData *md);
198
199   /**
200    * Free internal modifier data variables, this function should
201    * not free the md variable itself.
202    *
203    * This function is optional.
204    */
205   void (*freeData)(struct GpencilModifierData *md);
206
207   /**
208    * Return a boolean value indicating if this modifier is able to be
209    * calculated based on the modifier data. This is *not* regarding the
210    * md->flag, that is tested by the system, this is just if the data
211    * validates (for example, a lattice will return false if the lattice
212    * object is not defined).
213    *
214    * This function is optional (assumes never disabled if not present).
215    */
216   bool (*isDisabled)(struct GpencilModifierData *md, int userRenderParams);
217
218   /**
219    * Add the appropriate relations to the dependency graph.
220    *
221    * This function is optional.
222    */
223   void (*updateDepsgraph)(struct GpencilModifierData *md,
224                           const struct ModifierUpdateDepsgraphContext *ctx);
225
226   /**
227    * Should return true if the modifier needs to be recalculated on time
228    * changes.
229    *
230    * This function is optional (assumes false if not present).
231    */
232   bool (*dependsOnTime)(struct GpencilModifierData *md);
233
234   /**
235    * Should call the given walk function on with a pointer to each Object
236    * pointer that the modifier data stores. This is used for linking on file
237    * load and for unlinking objects or forwarding object references.
238    *
239    * This function is optional.
240    */
241   void (*foreachObjectLink)(struct GpencilModifierData *md,
242                             struct Object *ob,
243                             GreasePencilObjectWalkFunc walk,
244                             void *userData);
245
246   /**
247    * Should call the given walk function with a pointer to each ID
248    * pointer (i.e. each data-block pointer) that the modifier data
249    * stores. This is used for linking on file load and for
250    * unlinking data-blocks or forwarding data-block references.
251    *
252    * This function is optional. If it is not present, foreachObjectLink
253    * will be used.
254    */
255   void (*foreachIDLink)(struct GpencilModifierData *md,
256                         struct Object *ob,
257                         GreasePencilIDWalkFunc walk,
258                         void *userData);
259
260   /**
261    * Should call the given walk function for each texture that the
262    * modifier data stores. This is used for finding all textures in
263    * the context for the UI.
264    *
265    * This function is optional. If it is not present, it will be
266    * assumed the modifier has no textures.
267    */
268   void (*foreachTexLink)(struct GpencilModifierData *md,
269                          struct Object *ob,
270                          GreasePencilTexWalkFunc walk,
271                          void *userData);
272
273   /**
274    * Get the number of times the strokes are duplicated in this modifier.
275    * This is used to calculate the size of the GPU VBOs
276    */
277   int (*getDuplicationFactor)(struct GpencilModifierData *md);
278 } GpencilModifierTypeInfo;
279
280 /* Initialize modifier's global data (type info and some common global storages). */
281 void BKE_gpencil_modifier_init(void);
282
283 const GpencilModifierTypeInfo *BKE_gpencil_modifierType_getInfo(GpencilModifierType type);
284 struct GpencilModifierData *BKE_gpencil_modifier_new(int type);
285 void BKE_gpencil_modifier_free_ex(struct GpencilModifierData *md, const int flag);
286 void BKE_gpencil_modifier_free(struct GpencilModifierData *md);
287 bool BKE_gpencil_modifier_unique_name(struct ListBase *modifiers, struct GpencilModifierData *gmd);
288 bool BKE_gpencil_modifier_dependsOnTime(struct GpencilModifierData *md);
289 struct GpencilModifierData *BKE_gpencil_modifiers_findByType(struct Object *ob,
290                                                              GpencilModifierType type);
291 struct GpencilModifierData *BKE_gpencil_modifiers_findByName(struct Object *ob, const char *name);
292 void BKE_gpencil_modifier_copyData_generic(const struct GpencilModifierData *md_src,
293                                            struct GpencilModifierData *md_dst);
294 void BKE_gpencil_modifier_copyData(struct GpencilModifierData *md,
295                                    struct GpencilModifierData *target);
296 void BKE_gpencil_modifier_copyData_ex(struct GpencilModifierData *md,
297                                       struct GpencilModifierData *target,
298                                       const int flag);
299 void BKE_gpencil_modifiers_foreachIDLink(struct Object *ob,
300                                          GreasePencilIDWalkFunc walk,
301                                          void *userData);
302 void BKE_gpencil_modifiers_foreachTexLink(struct Object *ob,
303                                           GreasePencilTexWalkFunc walk,
304                                           void *userData);
305
306 bool BKE_gpencil_has_geometry_modifiers(struct Object *ob);
307 bool BKE_gpencil_has_time_modifiers(struct Object *ob);
308
309 void BKE_gpencil_stroke_modifiers(struct Depsgraph *depsgraph,
310                                   struct Object *ob,
311                                   struct bGPDlayer *gpl,
312                                   struct bGPDframe *gpf,
313                                   struct bGPDstroke *gps,
314                                   bool is_render);
315 void BKE_gpencil_geometry_modifiers(struct Depsgraph *depsgraph,
316                                     struct Object *ob,
317                                     struct bGPDlayer *gpl,
318                                     struct bGPDframe *gpf,
319                                     bool is_render);
320 int BKE_gpencil_time_modifier(struct Depsgraph *depsgraph,
321                               struct Scene *scene,
322                               struct Object *ob,
323                               struct bGPDlayer *gpl,
324                               int cfra,
325                               bool is_render);
326
327 void BKE_gpencil_lattice_init(struct Object *ob);
328 void BKE_gpencil_lattice_clear(struct Object *ob);
329
330 void BKE_gpencil_modifiers_calc(struct Depsgraph *depsgraph,
331                                 struct Scene *scene,
332                                 struct Object *ob);
333
334 #endif /* __BKE_GPENCIL_MODIFIER_H__ */