GP: Refactor drawing engine to single VBO
[blender.git] / source / blender / gpencil_modifiers / intern / MOD_gpencilarray.c
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 Copyright (C) 2017, Blender Foundation
19  * This is a new part of Blender
20  *
21  * Contributor(s): Antonio Vazquez, Joshua Leung
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  *
25  */
26
27 /** \file blender/gpencil_modifiers/intern/MOD_gpencilarray.c
28  *  \ingroup modifiers
29  */
30
31 #include <stdio.h>
32
33 #include "MEM_guardedalloc.h"
34
35 #include "DNA_scene_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_gpencil_types.h"
38 #include "DNA_gpencil_modifier_types.h"
39
40 #include "BLI_blenlib.h"
41 #include "BLI_rand.h"
42 #include "BLI_math.h"
43 #include "BLI_utildefines.h"
44
45 #include "BKE_gpencil.h"
46 #include "BKE_gpencil_modifier.h"
47 #include "BKE_modifier.h"
48 #include "BKE_context.h"
49 #include "BKE_global.h"
50 #include "BKE_object.h"
51 #include "BKE_main.h"
52 #include "BKE_scene.h"
53 #include "BKE_layer.h"
54 #include "BKE_library_query.h"
55 #include "BKE_collection.h"
56
57 #include "DEG_depsgraph.h"
58 #include "DEG_depsgraph_build.h"
59 #include "DEG_depsgraph_query.h"
60
61 #include "MOD_gpencil_util.h"
62 #include "MOD_gpencil_modifiertypes.h"
63
64 static void initData(GpencilModifierData *md)
65 {
66         ArrayGpencilModifierData *gpmd = (ArrayGpencilModifierData *)md;
67         gpmd->count = 2;
68         gpmd->offset[0] = 1.0f;
69         gpmd->offset[1] = 0.0f;
70         gpmd->offset[2] = 0.0f;
71         gpmd->shift[0] = 0.0f;
72         gpmd->shift[1] = 0.0f;
73         gpmd->shift[2] = 0.0f;
74         gpmd->scale[0] = 1.0f;
75         gpmd->scale[1] = 1.0f;
76         gpmd->scale[2] = 1.0f;
77         gpmd->rnd_rot = 0.5f;
78         gpmd->rnd_size = 0.5f;
79         gpmd->object = NULL;
80
81         /* fill random values */
82         BLI_array_frand(gpmd->rnd, 20, 1);
83         gpmd->rnd[0] = 1;
84 }
85
86 static void copyData(const GpencilModifierData *md, GpencilModifierData *target)
87 {
88         BKE_gpencil_modifier_copyData_generic(md, target);
89 }
90
91 /* -------------------------------- */
92 /* helper function for per-instance positioning */
93 static void BKE_gpencil_instance_modifier_instance_tfm(
94         Object *ob, ArrayGpencilModifierData *mmd, const int elem_idx,
95         float r_mat[4][4], float r_offset[4][4])
96 {
97         float offset[3], rot[3], scale[3];
98         int ri = mmd->rnd[0];
99         float factor;
100
101         offset[0] = mmd->offset[0] * elem_idx;
102         offset[1] = mmd->offset[1] * elem_idx;
103         offset[2] = mmd->offset[2] * elem_idx;
104
105         /* rotation */
106         if (mmd->flag & GP_ARRAY_RANDOM_ROT) {
107                 factor = mmd->rnd_rot * mmd->rnd[ri];
108                 mul_v3_v3fl(rot, mmd->rot, factor);
109                 add_v3_v3(rot, mmd->rot);
110         }
111         else {
112                 copy_v3_v3(rot, mmd->rot);
113         }
114
115         /* scale */
116         if (mmd->flag & GP_ARRAY_RANDOM_SIZE) {
117                 factor = mmd->rnd_size * mmd->rnd[ri];
118                 mul_v3_v3fl(scale, mmd->scale, factor);
119                 add_v3_v3(scale, mmd->scale);
120         }
121         else {
122                 copy_v3_v3(scale, mmd->scale);
123         }
124
125         /* advance random index */
126         mmd->rnd[0]++;
127         if (mmd->rnd[0] > 19) {
128                 mmd->rnd[0] = 1;
129         }
130
131         /* calculate matrix */
132         loc_eul_size_to_mat4(r_mat, offset, rot, scale);
133
134         copy_m4_m4(r_offset, r_mat);
135
136         /* offset object */
137         if (mmd->object) {
138                 float mat_offset[4][4];
139                 float obinv[4][4];
140
141                 unit_m4(mat_offset);
142                 add_v3_v3(mat_offset[3], mmd->offset);
143                 invert_m4_m4(obinv, ob->obmat);
144
145                 mul_m4_series(r_offset, mat_offset,
146                         obinv, mmd->object->obmat);
147                 copy_m4_m4(mat_offset, r_offset);
148
149                 /* clear r_mat locations to avoid double transform */
150                 zero_v3(r_mat[3]);
151         }
152 }
153
154 /* array modifier - generate geometry callback (for viewport/rendering) */
155 static void generate_geometry(
156         GpencilModifierData *md, Depsgraph *UNUSED(depsgraph),
157         Object *ob, bGPDlayer *gpl, bGPDframe *gpf)
158 {
159         ArrayGpencilModifierData *mmd = (ArrayGpencilModifierData *)md;
160         ListBase stroke_cache = {NULL, NULL};
161         bGPDstroke *gps;
162         int idx;
163
164         /* Check which strokes we can use once, and store those results in an array
165          * for quicker checking of what's valid (since string comparisons are expensive)
166          */
167         const int num_strokes = BLI_listbase_count(&gpf->strokes);
168         int num_valid = 0;
169
170         bool *valid_strokes = MEM_callocN(sizeof(bool) * num_strokes, __func__);
171
172         for (gps = gpf->strokes.first, idx = 0; gps; gps = gps->next, idx++) {
173                 /* Record whether this stroke can be used
174                  * ATTENTION: The logic here is the inverse of what's used everywhere else!
175                  */
176                 if (is_stroke_affected_by_modifier(
177                             ob,
178                             mmd->layername, mmd->pass_index, mmd->layer_pass, 1, gpl, gps,
179                             mmd->flag & GP_ARRAY_INVERT_LAYER, mmd->flag & GP_ARRAY_INVERT_PASS,
180                             mmd->flag & GP_ARRAY_INVERT_LAYERPASS))
181                 {
182                         valid_strokes[idx] = true;
183                         num_valid++;
184                 }
185         }
186
187         /* Early exit if no strokes can be copied */
188         if (num_valid == 0) {
189                 if (G.debug & G_DEBUG) {
190                         printf("GP Array Mod - No strokes to be included\n");
191                 }
192
193                 MEM_SAFE_FREE(valid_strokes);
194                 return;
195         }
196
197
198         /* Generate new instances of all existing strokes,
199          * keeping each instance together so they maintain
200          * the correct ordering relative to each other
201          */
202         float current_offset[4][4];
203         unit_m4(current_offset);
204
205         for (int x = 0; x < mmd->count; x++) {
206                 /* original strokes are at index = 0 */
207                 if (x == 0) {
208                         continue;
209                 }
210
211                 /* Compute transforms for this instance */
212                 float mat[4][4];
213                 float mat_offset[4][4];
214                 BKE_gpencil_instance_modifier_instance_tfm(ob, mmd, x, mat, mat_offset);
215
216                 if (mmd->object) {
217                         /* recalculate cumulative offset here */
218                         mul_m4_m4m4(current_offset, current_offset, mat_offset);
219                 }
220                 else {
221                         copy_m4_m4(current_offset, mat);
222                 }
223                 /* apply shift */
224                 madd_v3_v3fl(current_offset[3], mmd->shift, x);
225
226                 /* Duplicate original strokes to create this instance */
227                 for (gps = gpf->strokes.first, idx = 0; gps; gps = gps->next, idx++) {
228                         /* check if stroke can be duplicated */
229                         if (valid_strokes[idx]) {
230                                 /* Duplicate stroke */
231                                 bGPDstroke *gps_dst = MEM_dupallocN(gps);
232                                 gps_dst->points = MEM_dupallocN(gps->points);
233                                 if (gps->dvert) {
234                                         gps_dst->dvert = MEM_dupallocN(gps->dvert);
235                                         BKE_gpencil_stroke_weights_duplicate(gps, gps_dst);
236                                 }
237                                 gps_dst->triangles = MEM_dupallocN(gps->triangles);
238
239                                 /* Move points */
240                                 for (int i = 0; i < gps->totpoints; i++) {
241                                         bGPDspoint *pt = &gps_dst->points[i];
242                                         if (mmd->object) {
243                                                 /* apply local changes (rot/scale) */
244                                                 mul_m4_v3(mat, &pt->x);
245                                         }
246                                         /* global changes */
247                                         mul_m4_v3(current_offset, &pt->x);
248                                 }
249
250                                 /* if replace material, use new one */
251                                 if ((mmd->mat_rpl > 0) && (mmd->mat_rpl <= ob->totcol)) {
252                                         gps_dst->mat_nr = mmd->mat_rpl - 1;
253                                 }
254
255                                 /* Add new stroke to cache, to be added to the frame once
256                                  * all duplicates have been made
257                                  */
258                                 BLI_addtail(&stroke_cache, gps_dst);
259                         }
260                 }
261         }
262
263         /* merge newly created stroke instances back into the main stroke list */
264         if (mmd->flag & GP_ARRAY_KEEP_ONTOP) {
265                 BLI_movelisttolist_reverse(&gpf->strokes, &stroke_cache);
266         }
267         else {
268                 BLI_movelisttolist(&gpf->strokes, &stroke_cache);
269         }
270
271         /* free temp data */
272         MEM_SAFE_FREE(valid_strokes);
273 }
274
275 static void bakeModifier(
276         Main *UNUSED(bmain), Depsgraph *depsgraph,
277         GpencilModifierData *md, Object *ob)
278 {
279
280         bGPdata *gpd = ob->data;
281
282         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
283                 for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
284                         generate_geometry(md, depsgraph, ob, gpl, gpf);
285                 }
286         }
287 }
288
289 /* -------------------------------- */
290
291 /* Generic "generateStrokes" callback */
292 static void generateStrokes(
293         GpencilModifierData *md, Depsgraph *depsgraph,
294         Object *ob, bGPDlayer *gpl, bGPDframe *gpf)
295 {
296         generate_geometry(md, depsgraph, ob, gpl, gpf);
297 }
298
299 static void updateDepsgraph(GpencilModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
300 {
301         ArrayGpencilModifierData *lmd = (ArrayGpencilModifierData *)md;
302         if (lmd->object != NULL) {
303                 DEG_add_object_relation(ctx->node, lmd->object, DEG_OB_COMP_GEOMETRY, "Array Modifier");
304                 DEG_add_object_relation(ctx->node, lmd->object, DEG_OB_COMP_TRANSFORM, "Array Modifier");
305         }
306         DEG_add_object_relation(ctx->node, ctx->object, DEG_OB_COMP_TRANSFORM, "Array Modifier");
307 }
308
309 static void foreachObjectLink(
310         GpencilModifierData *md, Object *ob,
311         ObjectWalkFunc walk, void *userData)
312 {
313         ArrayGpencilModifierData *mmd = (ArrayGpencilModifierData *)md;
314
315         walk(userData, ob, &mmd->object, IDWALK_CB_NOP);
316 }
317
318 static int getDuplicationFactor(GpencilModifierData *md)
319 {
320         ArrayGpencilModifierData *mmd = (ArrayGpencilModifierData *)md;
321         int t = mmd->count;
322         CLAMP_MIN(t, 1);
323         return t;
324 }
325
326 GpencilModifierTypeInfo modifierType_Gpencil_Array = {
327         /* name */              "Array",
328         /* structName */        "ArrayGpencilModifierData",
329         /* structSize */        sizeof(ArrayGpencilModifierData),
330         /* type */              eGpencilModifierTypeType_Gpencil,
331         /* flags */             0,
332
333         /* copyData */          copyData,
334
335         /* deformStroke */      NULL,
336         /* generateStrokes */   generateStrokes,
337         /* bakeModifier */      bakeModifier,
338         /* remapTime */         NULL,
339
340         /* initData */          initData,
341         /* freeData */          NULL,
342         /* isDisabled */        NULL,
343         /* updateDepsgraph */   updateDepsgraph,
344         /* dependsOnTime */     NULL,
345         /* foreachObjectLink */ foreachObjectLink,
346         /* foreachIDLink */     NULL,
347         /* foreachTexLink */    NULL,
348         /* getDuplicationFactor */ getDuplicationFactor,
349 };