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