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