Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / object_dupli.c
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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <limits.h>
25 #include <stdlib.h>
26 #include <stddef.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_listbase.h"
31 #include "BLI_string_utf8.h"
32
33 #include "BLI_math.h"
34 #include "BLI_rand.h"
35
36 #include "DNA_anim_types.h"
37 #include "DNA_collection_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_meshdata_types.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_vfont_types.h"
42
43 #include "BKE_animsys.h"
44 #include "BKE_collection.h"
45 #include "BKE_font.h"
46 #include "BKE_global.h"
47 #include "BKE_idprop.h"
48 #include "BKE_lattice.h"
49 #include "BKE_main.h"
50 #include "BKE_mesh.h"
51 #include "BKE_mesh_iterators.h"
52 #include "BKE_mesh_runtime.h"
53 #include "BKE_object.h"
54 #include "BKE_particle.h"
55 #include "BKE_scene.h"
56 #include "BKE_editmesh.h"
57 #include "BKE_anim.h"
58
59 #include "DEG_depsgraph.h"
60 #include "DEG_depsgraph_query.h"
61
62 #include "BLI_strict_flags.h"
63 #include "BLI_hash.h"
64
65 /* Dupli-Geometry */
66
67 typedef struct DupliContext {
68   Depsgraph *depsgraph;
69   /** XXX child objects are selected from this group if set, could be nicer. */
70   Collection *collection;
71   /** Only to check if the object is in edit-mode. */
72   Object *obedit;
73
74   Scene *scene;
75   ViewLayer *view_layer;
76   Object *object;
77   float space_mat[4][4];
78
79   int persistent_id[MAX_DUPLI_RECUR];
80   int level;
81
82   const struct DupliGenerator *gen;
83
84   /** Result containers. */
85   ListBase *duplilist; /* legacy doubly-linked list */
86 } DupliContext;
87
88 typedef struct DupliGenerator {
89   short type; /* dupli type */
90   void (*make_duplis)(const DupliContext *ctx);
91 } DupliGenerator;
92
93 static const DupliGenerator *get_dupli_generator(const DupliContext *ctx);
94
95 /* create initial context for root object */
96 static void init_context(
97     DupliContext *r_ctx, Depsgraph *depsgraph, Scene *scene, Object *ob, float space_mat[4][4])
98 {
99   r_ctx->depsgraph = depsgraph;
100   r_ctx->scene = scene;
101   r_ctx->view_layer = DEG_get_evaluated_view_layer(depsgraph);
102   r_ctx->collection = NULL;
103
104   r_ctx->object = ob;
105   r_ctx->obedit = OBEDIT_FROM_OBACT(ob);
106   if (space_mat) {
107     copy_m4_m4(r_ctx->space_mat, space_mat);
108   }
109   else {
110     unit_m4(r_ctx->space_mat);
111   }
112   r_ctx->level = 0;
113
114   r_ctx->gen = get_dupli_generator(r_ctx);
115
116   r_ctx->duplilist = NULL;
117 }
118
119 /* create sub-context for recursive duplis */
120 static void copy_dupli_context(
121     DupliContext *r_ctx, const DupliContext *ctx, Object *ob, float mat[4][4], int index)
122 {
123   *r_ctx = *ctx;
124
125   /* XXX annoying, previously was done by passing an ID* argument, this at least is more explicit */
126   if (ctx->gen->type == OB_DUPLICOLLECTION) {
127     r_ctx->collection = ctx->object->instance_collection;
128   }
129
130   r_ctx->object = ob;
131   if (mat) {
132     mul_m4_m4m4(r_ctx->space_mat, (float(*)[4])ctx->space_mat, mat);
133   }
134   r_ctx->persistent_id[r_ctx->level] = index;
135   ++r_ctx->level;
136
137   r_ctx->gen = get_dupli_generator(r_ctx);
138 }
139
140 /* generate a dupli instance
141  * mat is transform of the object relative to current context (including object obmat)
142  */
143 static DupliObject *make_dupli(const DupliContext *ctx, Object *ob, float mat[4][4], int index)
144 {
145   DupliObject *dob;
146   int i;
147
148   /* add a DupliObject instance to the result container */
149   if (ctx->duplilist) {
150     dob = MEM_callocN(sizeof(DupliObject), "dupli object");
151     BLI_addtail(ctx->duplilist, dob);
152   }
153   else {
154     return NULL;
155   }
156
157   dob->ob = ob;
158   mul_m4_m4m4(dob->mat, (float(*)[4])ctx->space_mat, mat);
159   dob->type = ctx->gen->type;
160
161   /* set persistent id, which is an array with a persistent index for each level
162    * (particle number, vertex number, ..). by comparing this we can find the same
163    * dupli object between frames, which is needed for motion blur. last level
164    * goes first in the array. */
165   dob->persistent_id[0] = index;
166   for (i = 1; i < ctx->level + 1; i++) {
167     dob->persistent_id[i] = ctx->persistent_id[ctx->level - i];
168   }
169   /* fill rest of values with INT_MAX which index will never have as value */
170   for (; i < MAX_DUPLI_RECUR; i++) {
171     dob->persistent_id[i] = INT_MAX;
172   }
173
174   /* metaballs never draw in duplis, they are instead merged into one by the basis
175    * mball outside of the group. this does mean that if that mball is not in the
176    * scene, they will not show up at all, limitation that should be solved once. */
177   if (ob->type == OB_MBALL) {
178     dob->no_draw = true;
179   }
180
181   /* random number */
182   /* the logic here is designed to match Cycles */
183   dob->random_id = BLI_hash_string(dob->ob->id.name + 2);
184
185   if (dob->persistent_id[0] != INT_MAX) {
186     for (i = 0; i < MAX_DUPLI_RECUR * 2; i++) {
187       dob->random_id = BLI_hash_int_2d(dob->random_id, (unsigned int)dob->persistent_id[i]);
188     }
189   }
190   else {
191     dob->random_id = BLI_hash_int_2d(dob->random_id, 0);
192   }
193
194   if (ctx->object != ob) {
195     dob->random_id ^= BLI_hash_int(BLI_hash_string(ctx->object->id.name + 2));
196   }
197
198   return dob;
199 }
200
201 /* recursive dupli objects
202  * space_mat is the local dupli space (excluding dupli object obmat!)
203  */
204 static void make_recursive_duplis(const DupliContext *ctx,
205                                   Object *ob,
206                                   float space_mat[4][4],
207                                   int index)
208 {
209   /* simple preventing of too deep nested collections with MAX_DUPLI_RECUR */
210   if (ctx->level < MAX_DUPLI_RECUR) {
211     DupliContext rctx;
212     copy_dupli_context(&rctx, ctx, ob, space_mat, index);
213     if (rctx.gen) {
214       rctx.gen->make_duplis(&rctx);
215     }
216   }
217 }
218
219 /* ---- Child Duplis ---- */
220
221 typedef void (*MakeChildDuplisFunc)(const DupliContext *ctx, void *userdata, Object *child);
222
223 static bool is_child(const Object *ob, const Object *parent)
224 {
225   const Object *ob_parent = ob->parent;
226   while (ob_parent) {
227     if (ob_parent == parent) {
228       return true;
229     }
230     ob_parent = ob_parent->parent;
231   }
232   return false;
233 }
234
235 /* create duplis from every child in scene or collection */
236 static void make_child_duplis(const DupliContext *ctx,
237                               void *userdata,
238                               MakeChildDuplisFunc make_child_duplis_cb)
239 {
240   Object *parent = ctx->object;
241
242   if (ctx->collection) {
243     eEvaluationMode mode = DEG_get_mode(ctx->depsgraph);
244     FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (ctx->collection, ob, mode) {
245       if ((ob != ctx->obedit) && is_child(ob, parent)) {
246         DupliContext pctx;
247         copy_dupli_context(&pctx, ctx, ctx->object, NULL, _base_id);
248
249         /* metaballs have a different dupli handling */
250         if (ob->type != OB_MBALL) {
251           ob->flag |= OB_DONE; /* doesn't render */
252         }
253         make_child_duplis_cb(&pctx, userdata, ob);
254       }
255     }
256     FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
257   }
258   else {
259     int baseid = 0;
260     ViewLayer *view_layer = ctx->view_layer;
261     for (Base *base = view_layer->object_bases.first; base; base = base->next, baseid++) {
262       Object *ob = base->object;
263       if ((ob != ctx->obedit) && is_child(ob, parent)) {
264         DupliContext pctx;
265         copy_dupli_context(&pctx, ctx, ctx->object, NULL, baseid);
266
267         /* metaballs have a different dupli handling */
268         if (ob->type != OB_MBALL) {
269           ob->flag |= OB_DONE; /* doesn't render */
270         }
271
272         make_child_duplis_cb(&pctx, userdata, ob);
273       }
274     }
275   }
276 }
277
278 /*---- Implementations ----*/
279
280 /* OB_DUPLICOLLECTION */
281 static void make_duplis_collection(const DupliContext *ctx)
282 {
283   Object *ob = ctx->object;
284   Collection *collection;
285   float collection_mat[4][4];
286
287   if (ob->instance_collection == NULL) {
288     return;
289   }
290   collection = ob->instance_collection;
291
292   /* combine collection offset and obmat */
293   unit_m4(collection_mat);
294   sub_v3_v3(collection_mat[3], collection->instance_offset);
295   mul_m4_m4m4(collection_mat, ob->obmat, collection_mat);
296   /* don't access 'ob->obmat' from now on. */
297
298   eEvaluationMode mode = DEG_get_mode(ctx->depsgraph);
299   FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (collection, cob, mode) {
300     if (cob != ob) {
301       float mat[4][4];
302
303       /* collection dupli offset, should apply after everything else */
304       mul_m4_m4m4(mat, collection_mat, cob->obmat);
305
306       make_dupli(ctx, cob, mat, _base_id);
307
308       /* recursion */
309       make_recursive_duplis(ctx, cob, collection_mat, _base_id);
310     }
311   }
312   FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
313 }
314
315 static const DupliGenerator gen_dupli_collection = {
316     OB_DUPLICOLLECTION,    /* type */
317     make_duplis_collection /* make_duplis */
318 };
319
320 /* OB_DUPLIVERTS */
321 typedef struct VertexDupliData {
322   Mesh *me_eval;
323   BMEditMesh *edit_mesh;
324   int totvert;
325   float (*orco)[3];
326   bool use_rotation;
327
328   const DupliContext *ctx;
329   Object *inst_ob; /* object to instantiate (argument for vertex map callback) */
330   float child_imat[4][4];
331 } VertexDupliData;
332
333 static void get_duplivert_transform(const float co[3],
334                                     const short no[3],
335                                     bool use_rotation,
336                                     short axis,
337                                     short upflag,
338                                     float mat[4][4])
339 {
340   float quat[4];
341   const float size[3] = {1.0f, 1.0f, 1.0f};
342
343   if (use_rotation) {
344     /* construct rotation matrix from normals */
345     float nor_f[3];
346     nor_f[0] = (float)-no[0];
347     nor_f[1] = (float)-no[1];
348     nor_f[2] = (float)-no[2];
349     vec_to_quat(quat, nor_f, axis, upflag);
350   }
351   else {
352     unit_qt(quat);
353   }
354
355   loc_quat_size_to_mat4(mat, co, quat, size);
356 }
357
358 static void vertex_dupli(const VertexDupliData *vdd,
359                          int index,
360                          const float co[3],
361                          const short no[3])
362 {
363   Object *inst_ob = vdd->inst_ob;
364   DupliObject *dob;
365   float obmat[4][4], space_mat[4][4];
366
367   /* obmat is transform to vertex */
368   get_duplivert_transform(co, no, vdd->use_rotation, inst_ob->trackflag, inst_ob->upflag, obmat);
369   /* make offset relative to inst_ob using relative child transform */
370   mul_mat3_m4_v3((float(*)[4])vdd->child_imat, obmat[3]);
371   /* apply obmat _after_ the local vertex transform */
372   mul_m4_m4m4(obmat, inst_ob->obmat, obmat);
373
374   /* space matrix is constructed by removing obmat transform,
375    * this yields the worldspace transform for recursive duplis
376    */
377   mul_m4_m4m4(space_mat, obmat, inst_ob->imat);
378
379   dob = make_dupli(vdd->ctx, vdd->inst_ob, obmat, index);
380
381   if (vdd->orco) {
382     copy_v3_v3(dob->orco, vdd->orco[index]);
383   }
384
385   /* recursion */
386   make_recursive_duplis(vdd->ctx, vdd->inst_ob, space_mat, index);
387 }
388
389 static void make_child_duplis_verts(const DupliContext *ctx, void *userdata, Object *child)
390 {
391   VertexDupliData *vdd = userdata;
392   Mesh *me_eval = vdd->me_eval;
393
394   vdd->inst_ob = child;
395   invert_m4_m4(child->imat, child->obmat);
396   /* relative transform from parent to child space */
397   mul_m4_m4m4(vdd->child_imat, child->imat, ctx->object->obmat);
398
399   const MVert *mvert = me_eval->mvert;
400   const int *origindex = CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX);
401
402   for (int i = 0, j = 0; i < me_eval->totvert; i++) {
403     if (origindex == NULL || origindex[i] != ORIGINDEX_NONE) {
404       vertex_dupli(vdd, j++, mvert[i].co, mvert[i].no);
405     }
406   }
407 }
408
409 static void make_duplis_verts(const DupliContext *ctx)
410 {
411   Object *parent = ctx->object;
412   VertexDupliData vdd;
413
414   vdd.ctx = ctx;
415   vdd.use_rotation = parent->transflag & OB_DUPLIROT;
416
417   /* gather mesh info */
418   {
419     vdd.edit_mesh = BKE_editmesh_from_object(parent);
420
421     /* We do not need any render-specific handling anymore, depsgraph takes care of that. */
422     /* NOTE: Do direct access to the evaluated mesh: this function is used
423      * during meta balls evaluation. But even without those all the objects
424      * which are needed for correct instancing are already evaluated. */
425     if (vdd.edit_mesh != NULL) {
426       vdd.me_eval = vdd.edit_mesh->mesh_eval_cage;
427     }
428     else {
429       vdd.me_eval = parent->runtime.mesh_eval;
430     }
431
432     if (vdd.me_eval == NULL) {
433       return;
434     }
435
436     vdd.orco = CustomData_get_layer(&vdd.me_eval->vdata, CD_ORCO);
437     vdd.totvert = vdd.me_eval->totvert;
438   }
439
440   make_child_duplis(ctx, &vdd, make_child_duplis_verts);
441
442   vdd.me_eval = NULL;
443 }
444
445 static const DupliGenerator gen_dupli_verts = {
446     OB_DUPLIVERTS,    /* type */
447     make_duplis_verts /* make_duplis */
448 };
449
450 /* OB_DUPLIVERTS - FONT */
451 static Object *find_family_object(
452     Main *bmain, const char *family, size_t family_len, unsigned int ch, GHash *family_gh)
453 {
454   Object **ob_pt;
455   Object *ob;
456   void *ch_key = POINTER_FROM_UINT(ch);
457
458   if ((ob_pt = (Object **)BLI_ghash_lookup_p(family_gh, ch_key))) {
459     ob = *ob_pt;
460   }
461   else {
462     char ch_utf8[7];
463     size_t ch_utf8_len;
464
465     ch_utf8_len = BLI_str_utf8_from_unicode(ch, ch_utf8);
466     ch_utf8[ch_utf8_len] = '\0';
467     ch_utf8_len += 1; /* compare with null terminator */
468
469     for (ob = bmain->objects.first; ob; ob = ob->id.next) {
470       if (STREQLEN(ob->id.name + 2 + family_len, ch_utf8, ch_utf8_len)) {
471         if (STREQLEN(ob->id.name + 2, family, family_len)) {
472           break;
473         }
474       }
475     }
476
477     /* inserted value can be NULL, just to save searches in future */
478     BLI_ghash_insert(family_gh, ch_key, ob);
479   }
480
481   return ob;
482 }
483
484 static void make_duplis_font(const DupliContext *ctx)
485 {
486   Object *par = ctx->object;
487   GHash *family_gh;
488   Object *ob;
489   Curve *cu;
490   struct CharTrans *ct, *chartransdata = NULL;
491   float vec[3], obmat[4][4], pmat[4][4], fsize, xof, yof;
492   int text_len, a;
493   size_t family_len;
494   const wchar_t *text = NULL;
495   bool text_free = false;
496
497   /* font dupliverts not supported inside collections */
498   if (ctx->collection) {
499     return;
500   }
501
502   copy_m4_m4(pmat, par->obmat);
503
504   /* in par the family name is stored, use this to find the other objects */
505
506   BKE_vfont_to_curve_ex(
507       par, par->data, FO_DUPLI, NULL, &text, &text_len, &text_free, &chartransdata);
508
509   if (text == NULL || chartransdata == NULL) {
510     return;
511   }
512
513   cu = par->data;
514   fsize = cu->fsize;
515   xof = cu->xof;
516   yof = cu->yof;
517
518   ct = chartransdata;
519
520   /* cache result */
521   family_len = strlen(cu->family);
522   family_gh = BLI_ghash_int_new_ex(__func__, 256);
523
524   /* advance matching BLI_strncpy_wchar_from_utf8 */
525   for (a = 0; a < text_len; a++, ct++) {
526
527     /* XXX That G.main is *really* ugly, but not sure what to do here...
528      * Definitively don't think it would be safe to put back Main *bmain pointer in DupliContext as done in 2.7x? */
529     ob = find_family_object(G.main, cu->family, family_len, (unsigned int)text[a], family_gh);
530     if (ob) {
531       vec[0] = fsize * (ct->xof - xof);
532       vec[1] = fsize * (ct->yof - yof);
533       vec[2] = 0.0;
534
535       mul_m4_v3(pmat, vec);
536
537       copy_m4_m4(obmat, par->obmat);
538
539       if (UNLIKELY(ct->rot != 0.0f)) {
540         float rmat[4][4];
541
542         zero_v3(obmat[3]);
543         axis_angle_to_mat4_single(rmat, 'Z', -ct->rot);
544         mul_m4_m4m4(obmat, obmat, rmat);
545       }
546
547       copy_v3_v3(obmat[3], vec);
548
549       make_dupli(ctx, ob, obmat, a);
550     }
551   }
552
553   if (text_free) {
554     MEM_freeN((void *)text);
555   }
556
557   BLI_ghash_free(family_gh, NULL, NULL);
558
559   MEM_freeN(chartransdata);
560 }
561
562 static const DupliGenerator gen_dupli_verts_font = {
563     OB_DUPLIVERTS,   /* type */
564     make_duplis_font /* make_duplis */
565 };
566
567 /* OB_DUPLIFACES */
568 typedef struct FaceDupliData {
569   Mesh *me_eval;
570   int totface;
571   MPoly *mpoly;
572   MLoop *mloop;
573   MVert *mvert;
574   float (*orco)[3];
575   MLoopUV *mloopuv;
576   bool use_scale;
577 } FaceDupliData;
578
579 static void get_dupliface_transform(
580     MPoly *mpoly, MLoop *mloop, MVert *mvert, bool use_scale, float scale_fac, float mat[4][4])
581 {
582   float loc[3], quat[4], scale, size[3];
583   float f_no[3];
584
585   /* location */
586   BKE_mesh_calc_poly_center(mpoly, mloop, mvert, loc);
587   /* rotation */
588   {
589     const float *v1, *v2, *v3;
590     BKE_mesh_calc_poly_normal(mpoly, mloop, mvert, f_no);
591     v1 = mvert[mloop[0].v].co;
592     v2 = mvert[mloop[1].v].co;
593     v3 = mvert[mloop[2].v].co;
594     tri_to_quat_ex(quat, v1, v2, v3, f_no);
595   }
596   /* scale */
597   if (use_scale) {
598     float area = BKE_mesh_calc_poly_area(mpoly, mloop, mvert);
599     scale = sqrtf(area) * scale_fac;
600   }
601   else {
602     scale = 1.0f;
603   }
604   size[0] = size[1] = size[2] = scale;
605
606   loc_quat_size_to_mat4(mat, loc, quat, size);
607 }
608
609 static void make_child_duplis_faces(const DupliContext *ctx, void *userdata, Object *inst_ob)
610 {
611   FaceDupliData *fdd = userdata;
612   MPoly *mpoly = fdd->mpoly, *mp;
613   MLoop *mloop = fdd->mloop;
614   MVert *mvert = fdd->mvert;
615   float(*orco)[3] = fdd->orco;
616   MLoopUV *mloopuv = fdd->mloopuv;
617   int a, totface = fdd->totface;
618   float child_imat[4][4];
619   DupliObject *dob;
620
621   invert_m4_m4(inst_ob->imat, inst_ob->obmat);
622   /* relative transform from parent to child space */
623   mul_m4_m4m4(child_imat, inst_ob->imat, ctx->object->obmat);
624
625   for (a = 0, mp = mpoly; a < totface; a++, mp++) {
626     MLoop *loopstart = mloop + mp->loopstart;
627     float space_mat[4][4], obmat[4][4];
628
629     if (UNLIKELY(mp->totloop < 3)) {
630       continue;
631     }
632
633     /* obmat is transform to face */
634     get_dupliface_transform(
635         mp, loopstart, mvert, fdd->use_scale, ctx->object->instance_faces_scale, obmat);
636     /* make offset relative to inst_ob using relative child transform */
637     mul_mat3_m4_v3(child_imat, obmat[3]);
638
639     /* XXX ugly hack to ensure same behavior as in master
640      * this should not be needed, parentinv is not consistent
641      * outside of parenting.
642      */
643     {
644       float imat[3][3];
645       copy_m3_m4(imat, inst_ob->parentinv);
646       mul_m4_m3m4(obmat, imat, obmat);
647     }
648
649     /* apply obmat _after_ the local face transform */
650     mul_m4_m4m4(obmat, inst_ob->obmat, obmat);
651
652     /* space matrix is constructed by removing obmat transform,
653      * this yields the worldspace transform for recursive duplis
654      */
655     mul_m4_m4m4(space_mat, obmat, inst_ob->imat);
656
657     dob = make_dupli(ctx, inst_ob, obmat, a);
658
659     const float w = 1.0f / (float)mp->totloop;
660     if (orco) {
661       for (int j = 0; j < mp->totloop; j++) {
662         madd_v3_v3fl(dob->orco, orco[loopstart[j].v], w);
663       }
664     }
665     if (mloopuv) {
666       for (int j = 0; j < mp->totloop; j++) {
667         madd_v2_v2fl(dob->uv, mloopuv[mp->loopstart + j].uv, w);
668       }
669     }
670
671     /* recursion */
672     make_recursive_duplis(ctx, inst_ob, space_mat, a);
673   }
674 }
675
676 static void make_duplis_faces(const DupliContext *ctx)
677 {
678   Object *parent = ctx->object;
679   FaceDupliData fdd;
680
681   fdd.use_scale = ((parent->transflag & OB_DUPLIFACES_SCALE) != 0);
682
683   /* gather mesh info */
684   {
685     BMEditMesh *em = BKE_editmesh_from_object(parent);
686
687     /* We do not need any render-smecific handling anymore, depsgraph takes care of that. */
688     /* NOTE: Do direct access to the evaluated mesh: this function is used
689      * during meta balls evaluation. But even without those all the objects
690      * which are needed for correct instancing are already evaluated. */
691     if (em != NULL) {
692       fdd.me_eval = em->mesh_eval_cage;
693     }
694     else {
695       fdd.me_eval = parent->runtime.mesh_eval;
696     }
697
698     if (fdd.me_eval == NULL) {
699       return;
700     }
701
702     fdd.orco = CustomData_get_layer(&fdd.me_eval->vdata, CD_ORCO);
703     const int uv_idx = CustomData_get_render_layer(&fdd.me_eval->ldata, CD_MLOOPUV);
704     fdd.mloopuv = CustomData_get_layer_n(&fdd.me_eval->ldata, CD_MLOOPUV, uv_idx);
705
706     fdd.totface = fdd.me_eval->totpoly;
707     fdd.mpoly = fdd.me_eval->mpoly;
708     fdd.mloop = fdd.me_eval->mloop;
709     fdd.mvert = fdd.me_eval->mvert;
710   }
711
712   make_child_duplis(ctx, &fdd, make_child_duplis_faces);
713
714   fdd.me_eval = NULL;
715 }
716
717 static const DupliGenerator gen_dupli_faces = {
718     OB_DUPLIFACES,    /* type */
719     make_duplis_faces /* make_duplis */
720 };
721
722 /* OB_DUPLIPARTS */
723 static void make_duplis_particle_system(const DupliContext *ctx, ParticleSystem *psys)
724 {
725   Scene *scene = ctx->scene;
726   Object *par = ctx->object;
727   eEvaluationMode mode = DEG_get_mode(ctx->depsgraph);
728   bool for_render = mode == DAG_EVAL_RENDER;
729
730   Object *ob = NULL, **oblist = NULL;
731   DupliObject *dob;
732   ParticleDupliWeight *dw;
733   ParticleSettings *part;
734   ParticleData *pa;
735   ChildParticle *cpa = NULL;
736   ParticleKey state;
737   ParticleCacheKey *cache;
738   float ctime, scale = 1.0f;
739   float tmat[4][4], mat[4][4], pamat[4][4], size = 0.0;
740   int a, b, hair = 0;
741   int totpart, totchild;
742
743   int no_draw_flag = PARS_UNEXIST;
744
745   if (psys == NULL) {
746     return;
747   }
748
749   part = psys->part;
750
751   if (part == NULL) {
752     return;
753   }
754
755   if (!psys_check_enabled(par, psys, for_render)) {
756     return;
757   }
758
759   if (!for_render) {
760     no_draw_flag |= PARS_NO_DISP;
761   }
762
763   ctime = DEG_get_ctime(
764       ctx->depsgraph); /* NOTE: in old animsys, used parent object's timeoffset... */
765
766   totpart = psys->totpart;
767   totchild = psys->totchild;
768
769   if ((for_render || part->draw_as == PART_DRAW_REND) &&
770       ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) {
771     ParticleSimulationData sim = {NULL};
772     sim.depsgraph = ctx->depsgraph;
773     sim.scene = scene;
774     sim.ob = par;
775     sim.psys = psys;
776     sim.psmd = psys_get_modifier(par, psys);
777     /* make sure emitter imat is in global coordinates instead of render view coordinates */
778     invert_m4_m4(par->imat, par->obmat);
779
780     /* first check for loops (particle system object used as dupli object) */
781     if (part->ren_as == PART_DRAW_OB) {
782       if (ELEM(part->instance_object, NULL, par)) {
783         return;
784       }
785     }
786     else { /*PART_DRAW_GR */
787       if (part->instance_collection == NULL) {
788         return;
789       }
790
791       const ListBase dup_collection_objects = BKE_collection_object_cache_get(
792           part->instance_collection);
793       if (BLI_listbase_is_empty(&dup_collection_objects)) {
794         return;
795       }
796
797       if (BLI_findptr(&dup_collection_objects, par, offsetof(Base, object))) {
798         return;
799       }
800     }
801
802     /* if we have a hair particle system, use the path cache */
803     if (part->type == PART_HAIR) {
804       if (psys->flag & PSYS_HAIR_DONE) {
805         hair = (totchild == 0 || psys->childcache) && psys->pathcache;
806       }
807       if (!hair) {
808         return;
809       }
810
811       /* we use cache, update totchild according to cached data */
812       totchild = psys->totchildcache;
813       totpart = psys->totcached;
814     }
815
816     RNG *rng = BLI_rng_new_srandom(31415926u + (unsigned int)psys->seed);
817
818     psys->lattice_deform_data = psys_create_lattice_deform_data(&sim);
819
820     /* gather list of objects or single object */
821     int totcollection = 0;
822
823     if (part->ren_as == PART_DRAW_GR) {
824       if (part->draw & PART_DRAW_COUNT_GR) {
825         psys_find_group_weights(part);
826
827         for (dw = part->instance_weights.first; dw; dw = dw->next) {
828           FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (
829               part->instance_collection, object, mode) {
830             if (dw->ob == object) {
831               totcollection += dw->count;
832               break;
833             }
834           }
835           FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
836         }
837       }
838       else {
839         FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (
840             part->instance_collection, object, mode) {
841           (void)object;
842           totcollection++;
843         }
844         FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
845       }
846
847       oblist = MEM_callocN((size_t)totcollection * sizeof(Object *), "dupcollection object list");
848
849       if (part->draw & PART_DRAW_COUNT_GR) {
850         a = 0;
851         for (dw = part->instance_weights.first; dw; dw = dw->next) {
852           FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (
853               part->instance_collection, object, mode) {
854             if (dw->ob == object) {
855               for (b = 0; b < dw->count; b++, a++) {
856                 oblist[a] = dw->ob;
857               }
858               break;
859             }
860           }
861           FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
862         }
863       }
864       else {
865         a = 0;
866         FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (
867             part->instance_collection, object, mode) {
868           oblist[a] = object;
869           a++;
870         }
871         FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
872       }
873     }
874     else {
875       ob = part->instance_object;
876     }
877
878     if (totchild == 0 || part->draw & PART_DRAW_PARENT) {
879       a = 0;
880     }
881     else {
882       a = totpart;
883     }
884
885     for (pa = psys->particles; a < totpart + totchild; a++, pa++) {
886       if (a < totpart) {
887         /* handle parent particle */
888         if (pa->flag & no_draw_flag) {
889           continue;
890         }
891
892         /* pa_num = pa->num; */ /* UNUSED */
893         size = pa->size;
894       }
895       else {
896         /* handle child particle */
897         cpa = &psys->child[a - totpart];
898
899         /* pa_num = a; */ /* UNUSED */
900         size = psys_get_child_size(psys, cpa, ctime, NULL);
901       }
902
903       /* some hair paths might be non-existent so they can't be used for duplication */
904       if (hair && psys->pathcache &&
905           ((a < totpart && psys->pathcache[a]->segments < 0) ||
906            (a >= totpart && psys->childcache[a - totpart]->segments < 0))) {
907         continue;
908       }
909
910       if (part->ren_as == PART_DRAW_GR) {
911         /* prevent divide by zero below [#28336] */
912         if (totcollection == 0) {
913           continue;
914         }
915
916         /* for collections, pick the object based on settings */
917         if (part->draw & PART_DRAW_RAND_GR) {
918           b = BLI_rng_get_int(rng) % totcollection;
919         }
920         else {
921           b = a % totcollection;
922         }
923
924         ob = oblist[b];
925       }
926
927       if (hair) {
928         /* hair we handle separate and compute transform based on hair keys */
929         if (a < totpart) {
930           cache = psys->pathcache[a];
931           psys_get_dupli_path_transform(&sim, pa, NULL, cache, pamat, &scale);
932         }
933         else {
934           cache = psys->childcache[a - totpart];
935           psys_get_dupli_path_transform(&sim, NULL, cpa, cache, pamat, &scale);
936         }
937
938         copy_v3_v3(pamat[3], cache->co);
939         pamat[3][3] = 1.0f;
940       }
941       else {
942         /* first key */
943         state.time = ctime;
944         if (psys_get_particle_state(&sim, a, &state, 0) == 0) {
945           continue;
946         }
947         else {
948           float tquat[4];
949           normalize_qt_qt(tquat, state.rot);
950           quat_to_mat4(pamat, tquat);
951           copy_v3_v3(pamat[3], state.co);
952           pamat[3][3] = 1.0f;
953         }
954       }
955
956       if (part->ren_as == PART_DRAW_GR && psys->part->draw & PART_DRAW_WHOLE_GR) {
957         b = 0;
958         FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_BEGIN (
959             part->instance_collection, object, mode) {
960           copy_m4_m4(tmat, oblist[b]->obmat);
961
962           /* apply particle scale */
963           mul_mat3_m4_fl(tmat, size * scale);
964           mul_v3_fl(tmat[3], size * scale);
965
966           /* collection dupli offset, should apply after everything else */
967           if (!is_zero_v3(part->instance_collection->instance_offset)) {
968             sub_v3_v3(tmat[3], part->instance_collection->instance_offset);
969           }
970
971           /* individual particle transform */
972           mul_m4_m4m4(mat, pamat, tmat);
973
974           dob = make_dupli(ctx, object, mat, a);
975           dob->particle_system = psys;
976
977           psys_get_dupli_texture(psys, part, sim.psmd, pa, cpa, dob->uv, dob->orco);
978
979           b++;
980         }
981         FOREACH_COLLECTION_VISIBLE_OBJECT_RECURSIVE_END;
982       }
983       else {
984         float obmat[4][4];
985         copy_m4_m4(obmat, ob->obmat);
986
987         float vec[3];
988         copy_v3_v3(vec, obmat[3]);
989         zero_v3(obmat[3]);
990
991         /* particle rotation uses x-axis as the aligned axis, so pre-rotate the object accordingly */
992         if ((part->draw & PART_DRAW_ROTATE_OB) == 0) {
993           float xvec[3], q[4], size_mat[4][4], original_size[3];
994
995           mat4_to_size(original_size, obmat);
996           size_to_mat4(size_mat, original_size);
997
998           xvec[0] = -1.f;
999           xvec[1] = xvec[2] = 0;
1000           vec_to_quat(q, xvec, ob->trackflag, ob->upflag);
1001           quat_to_mat4(obmat, q);
1002           obmat[3][3] = 1.0f;
1003
1004           /* add scaling if requested */
1005           if ((part->draw & PART_DRAW_NO_SCALE_OB) == 0) {
1006             mul_m4_m4m4(obmat, obmat, size_mat);
1007           }
1008         }
1009         else if (part->draw & PART_DRAW_NO_SCALE_OB) {
1010           /* remove scaling */
1011           float size_mat[4][4], original_size[3];
1012
1013           mat4_to_size(original_size, obmat);
1014           size_to_mat4(size_mat, original_size);
1015           invert_m4(size_mat);
1016
1017           mul_m4_m4m4(obmat, obmat, size_mat);
1018         }
1019
1020         mul_m4_m4m4(tmat, pamat, obmat);
1021         mul_mat3_m4_fl(tmat, size * scale);
1022
1023         copy_m4_m4(mat, tmat);
1024
1025         if (part->draw & PART_DRAW_GLOBAL_OB) {
1026           add_v3_v3v3(mat[3], mat[3], vec);
1027         }
1028
1029         dob = make_dupli(ctx, ob, mat, a);
1030         dob->particle_system = psys;
1031         psys_get_dupli_texture(psys, part, sim.psmd, pa, cpa, dob->uv, dob->orco);
1032       }
1033     }
1034
1035     BLI_rng_free(rng);
1036   }
1037
1038   /* clean up */
1039   if (oblist) {
1040     MEM_freeN(oblist);
1041   }
1042
1043   if (psys->lattice_deform_data) {
1044     end_latt_deform(psys->lattice_deform_data);
1045     psys->lattice_deform_data = NULL;
1046   }
1047 }
1048
1049 static void make_duplis_particles(const DupliContext *ctx)
1050 {
1051   ParticleSystem *psys;
1052   int psysid;
1053
1054   /* particle system take up one level in id, the particles another */
1055   for (psys = ctx->object->particlesystem.first, psysid = 0; psys; psys = psys->next, psysid++) {
1056     /* particles create one more level for persistent psys index */
1057     DupliContext pctx;
1058     copy_dupli_context(&pctx, ctx, ctx->object, NULL, psysid);
1059     make_duplis_particle_system(&pctx, psys);
1060   }
1061 }
1062
1063 static const DupliGenerator gen_dupli_particles = {
1064     OB_DUPLIPARTS,        /* type */
1065     make_duplis_particles /* make_duplis */
1066 };
1067
1068 /* ------------- */
1069
1070 /* select dupli generator from given context */
1071 static const DupliGenerator *get_dupli_generator(const DupliContext *ctx)
1072 {
1073   int transflag = ctx->object->transflag;
1074   int restrictflag = ctx->object->restrictflag;
1075
1076   if ((transflag & OB_DUPLI) == 0) {
1077     return NULL;
1078   }
1079
1080   /* Should the dupli's be generated for this object? - Respect restrict flags */
1081   if (DEG_get_mode(ctx->depsgraph) == DAG_EVAL_RENDER ? (restrictflag & OB_RESTRICT_RENDER) :
1082                                                         (restrictflag & OB_RESTRICT_VIEW)) {
1083     return NULL;
1084   }
1085
1086   if (transflag & OB_DUPLIPARTS) {
1087     return &gen_dupli_particles;
1088   }
1089   else if (transflag & OB_DUPLIVERTS) {
1090     if (ctx->object->type == OB_MESH) {
1091       return &gen_dupli_verts;
1092     }
1093     else if (ctx->object->type == OB_FONT) {
1094       return &gen_dupli_verts_font;
1095     }
1096   }
1097   else if (transflag & OB_DUPLIFACES) {
1098     if (ctx->object->type == OB_MESH) {
1099       return &gen_dupli_faces;
1100     }
1101   }
1102   else if (transflag & OB_DUPLICOLLECTION) {
1103     return &gen_dupli_collection;
1104   }
1105
1106   return NULL;
1107 }
1108
1109 /* ---- ListBase dupli container implementation ---- */
1110
1111 /* Returns a list of DupliObject */
1112 ListBase *object_duplilist(Depsgraph *depsgraph, Scene *sce, Object *ob)
1113 {
1114   ListBase *duplilist = MEM_callocN(sizeof(ListBase), "duplilist");
1115   DupliContext ctx;
1116   init_context(&ctx, depsgraph, sce, ob, NULL);
1117   if (ctx.gen) {
1118     ctx.duplilist = duplilist;
1119     ctx.gen->make_duplis(&ctx);
1120   }
1121
1122   return duplilist;
1123 }
1124
1125 void free_object_duplilist(ListBase *lb)
1126 {
1127   BLI_freelistN(lb);
1128   MEM_freeN(lb);
1129 }