Rename any instance of scene layer or render layer in code with view layer
[blender.git] / source / blender / blenkernel / intern / object_dupli.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) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/blenkernel/intern/object_dupli.c
29  *  \ingroup bke
30  */
31
32 #include <limits.h>
33 #include <stdlib.h>
34 #include <stddef.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "BLI_listbase.h"
39 #include "BLI_string_utf8.h"
40
41 #include "BLI_math.h"
42 #include "BLI_rand.h"
43
44 #include "DNA_anim_types.h"
45 #include "DNA_group_types.h"
46 #include "DNA_mesh_types.h"
47 #include "DNA_scene_types.h"
48 #include "DNA_vfont_types.h"
49
50 #include "BKE_animsys.h"
51 #include "BKE_DerivedMesh.h"
52 #include "BKE_font.h"
53 #include "BKE_group.h"
54 #include "BKE_global.h"
55 #include "BKE_lattice.h"
56 #include "BKE_main.h"
57 #include "BKE_mesh.h"
58 #include "BKE_object.h"
59 #include "BKE_particle.h"
60 #include "BKE_scene.h"
61 #include "BKE_editmesh.h"
62 #include "BKE_anim.h"
63
64 #include "DEG_depsgraph.h"
65
66 #include "BLI_strict_flags.h"
67 #include "BLI_hash.h"
68
69 /* Dupli-Geometry */
70
71 typedef struct DupliContext {
72         const EvaluationContext *eval_ctx;
73         bool do_update;
74         bool animated;
75         Group *group; /* XXX child objects are selected from this group if set, could be nicer */
76
77         Scene *scene;
78         ViewLayer *view_layer;
79         Object *object;
80         float space_mat[4][4];
81
82         int persistent_id[MAX_DUPLI_RECUR];
83         int level;
84
85         const struct DupliGenerator *gen;
86
87         /* result containers */
88         ListBase *duplilist; /* legacy doubly-linked list */
89 } DupliContext;
90
91 typedef struct DupliGenerator {
92         short type;                             /* dupli type */
93         void (*make_duplis)(const DupliContext *ctx);
94 } DupliGenerator;
95
96 static const DupliGenerator *get_dupli_generator(const DupliContext *ctx);
97
98 /* create initial context for root object */
99 static void init_context(DupliContext *r_ctx, const EvaluationContext *eval_ctx, Scene *scene, Object *ob, float space_mat[4][4], bool update)
100 {
101         r_ctx->eval_ctx = eval_ctx;
102         r_ctx->scene = scene;
103         r_ctx->view_layer = eval_ctx->view_layer;
104         /* don't allow BKE_object_handle_update for viewport during render, can crash */
105         r_ctx->do_update = update && !(G.is_rendering && eval_ctx->mode != DAG_EVAL_RENDER);
106         r_ctx->animated = false;
107         r_ctx->group = NULL;
108
109         r_ctx->object = ob;
110         if (space_mat)
111                 copy_m4_m4(r_ctx->space_mat, space_mat);
112         else
113                 unit_m4(r_ctx->space_mat);
114         r_ctx->level = 0;
115
116         r_ctx->gen = get_dupli_generator(r_ctx);
117
118         r_ctx->duplilist = NULL;
119 }
120
121 /* create sub-context for recursive duplis */
122 static void copy_dupli_context(DupliContext *r_ctx, const DupliContext *ctx, Object *ob, float mat[4][4], int index, bool animated)
123 {
124         *r_ctx = *ctx;
125         
126         r_ctx->animated |= animated; /* object animation makes all children animated */
127
128         /* XXX annoying, previously was done by passing an ID* argument, this at least is more explicit */
129         if (ctx->gen->type == OB_DUPLIGROUP)
130                 r_ctx->group = ctx->object->dup_group;
131
132         r_ctx->object = ob;
133         if (mat)
134                 mul_m4_m4m4(r_ctx->space_mat, (float (*)[4])ctx->space_mat, mat);
135         r_ctx->persistent_id[r_ctx->level] = index;
136         ++r_ctx->level;
137
138         r_ctx->gen = get_dupli_generator(r_ctx);
139 }
140
141 /* generate a dupli instance
142  * mat is transform of the object relative to current context (including object obmat)
143  */
144 static DupliObject *make_dupli(const DupliContext *ctx,
145                                Object *ob, float mat[4][4], int index,
146                                bool animated, bool hide)
147 {
148         DupliObject *dob;
149         int i;
150
151         /* add a DupliObject instance to the result container */
152         if (ctx->duplilist) {
153                 dob = MEM_callocN(sizeof(DupliObject), "dupli object");
154                 BLI_addtail(ctx->duplilist, dob);
155         }
156         else {
157                 return NULL;
158         }
159
160         dob->ob = ob;
161         mul_m4_m4m4(dob->mat, (float (*)[4])ctx->space_mat, mat);
162         dob->type = ctx->gen->type;
163         dob->animated = animated || ctx->animated; /* object itself or some parent is animated */
164
165         /* set persistent id, which is an array with a persistent index for each level
166          * (particle number, vertex number, ..). by comparing this we can find the same
167          * dupli object between frames, which is needed for motion blur. last level
168          * goes first in the array. */
169         dob->persistent_id[0] = index;
170         for (i = 1; i < ctx->level + 1; i++)
171                 dob->persistent_id[i] = ctx->persistent_id[ctx->level - i];
172         /* fill rest of values with INT_MAX which index will never have as value */
173         for (; i < MAX_DUPLI_RECUR; i++)
174                 dob->persistent_id[i] = INT_MAX;
175
176         if (hide)
177                 dob->no_draw = true;
178         /* metaballs never draw in duplis, they are instead merged into one by the basis
179          * mball outside of the group. this does mean that if that mball is not in the
180          * scene, they will not show up at all, limitation that should be solved once. */
181         if (ob->type == OB_MBALL)
182                 dob->no_draw = true;
183
184         /* random number */
185         /* the logic here is designed to match Cycles */
186         dob->random_id = BLI_hash_string(dob->ob->id.name + 2);
187
188         if (dob->persistent_id[0] != INT_MAX) {
189                 for (i = 0; i < MAX_DUPLI_RECUR * 2; i++) {
190                         dob->random_id = BLI_hash_int_2d(dob->random_id, (unsigned int)dob->persistent_id[i]);
191                 }
192         }
193         else {
194                 dob->random_id = BLI_hash_int_2d(dob->random_id, 0);
195         }
196
197         if (ctx->object != ob) {
198                 dob->random_id ^= BLI_hash_int(BLI_hash_string(ctx->object->id.name + 2));
199         }
200
201         return dob;
202 }
203
204 /* recursive dupli objects
205  * space_mat is the local dupli space (excluding dupli object obmat!)
206  */
207 static void make_recursive_duplis(const DupliContext *ctx, Object *ob, float space_mat[4][4], int index, bool animated)
208 {
209         /* simple preventing of too deep nested groups with MAX_DUPLI_RECUR */
210         if (ctx->level < MAX_DUPLI_RECUR) {
211                 DupliContext rctx;
212                 copy_dupli_context(&rctx, ctx, ob, space_mat, index, animated);
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                 ob_parent = ob_parent->parent;
230         }
231         return false;
232 }
233
234 /* create duplis from every child in scene or group */
235 static void make_child_duplis(const DupliContext *ctx, void *userdata, MakeChildDuplisFunc make_child_duplis_cb)
236 {
237         Object *parent = ctx->object;
238         Object *obedit = ctx->scene->obedit;
239
240         if (ctx->group) {
241                 unsigned int lay = ctx->group->layer;
242                 int groupid = 0;
243                 GroupObject *go;
244                 for (go = ctx->group->gobject.first; go; go = go->next, groupid++) {
245                         Object *ob = go->ob;
246
247                         if ((ob->lay & lay) && ob != obedit && is_child(ob, parent)) {
248                                 DupliContext pctx;
249                                 copy_dupli_context(&pctx, ctx, ctx->object, NULL, groupid, false);
250
251                                 /* mballs have a different dupli handling */
252                                 if (ob->type != OB_MBALL)
253                                         ob->flag |= OB_DONE;  /* doesnt render */
254
255                                 make_child_duplis_cb(&pctx, userdata, ob);
256                         }
257                 }
258         }
259         else {
260                 int baseid = 0;
261                 ViewLayer *view_layer = ctx->view_layer;
262                 for (Base *base = view_layer->object_bases.first; base; base = base->next, baseid++) {
263                         Object *ob = base->object;
264                         if ((base->flag & BASE_VISIBLED) && ob != obedit && is_child(ob, parent)) {
265                                 DupliContext pctx;
266                                 copy_dupli_context(&pctx, ctx, ctx->object, NULL, baseid, false);
267
268                                 /* mballs have a different dupli handling */
269                                 if (ob->type != OB_MBALL)
270                                         ob->flag |= OB_DONE;  /* doesnt render */
271
272                                 make_child_duplis_cb(&pctx, userdata, ob);
273                         }
274                 }
275         }
276 }
277
278
279 /*---- Implementations ----*/
280
281 /* OB_DUPLIGROUP */
282 static void make_duplis_group(const DupliContext *ctx)
283 {
284         bool for_render = (ctx->eval_ctx->mode == DAG_EVAL_RENDER);
285         Object *ob = ctx->object;
286         Group *group;
287         GroupObject *go;
288         float group_mat[4][4];
289         int id;
290         bool animated, hide;
291
292         if (ob->dup_group == NULL) return;
293         group = ob->dup_group;
294
295         /* combine group offset and obmat */
296         unit_m4(group_mat);
297         sub_v3_v3(group_mat[3], group->dupli_ofs);
298         mul_m4_m4m4(group_mat, ob->obmat, group_mat);
299         /* don't access 'ob->obmat' from now on. */
300
301         /* handles animated groups */
302
303         /* we need to check update for objects that are not in scene... */
304         if (ctx->do_update) {
305                 /* note: update is optional because we don't always need object
306                  * transformations to be correct. Also fixes bug [#29616]. */
307                 BKE_group_handle_recalc_and_update(ctx->eval_ctx, ctx->scene, ob, group);
308         }
309
310         animated = BKE_group_is_animated(group, ob);
311
312         for (go = group->gobject.first, id = 0; go; go = go->next, id++) {
313                 /* note, if you check on layer here, render goes wrong... it still deforms verts and uses parent imat */
314                 if (go->ob != ob) {
315                         float mat[4][4];
316
317                         /* Special case for instancing dupli-groups, see: T40051
318                          * this object may be instanced via dupli-verts/faces, in this case we don't want to render
319                          * (blender convention), but _do_ show in the viewport.
320                          *
321                          * Regular objects work fine but not if we're instancing dupli-groups,
322                          * because the rules for rendering aren't applied to objects they instance.
323                          * We could recursively pass down the 'hide' flag instead, but that seems unnecessary.
324                          */
325                         if (for_render && go->ob->parent && go->ob->parent->transflag & (OB_DUPLIVERTS | OB_DUPLIFACES)) {
326                                 continue;
327                         }
328
329                         /* group dupli offset, should apply after everything else */
330                         mul_m4_m4m4(mat, group_mat, go->ob->obmat);
331
332                         /* check the group instance and object layers match, also that the object visible flags are ok. */
333                         hide = (go->ob->lay & group->layer) == 0 ||
334                                (for_render ? go->ob->restrictflag & OB_RESTRICT_RENDER : go->ob->restrictflag & OB_RESTRICT_VIEW);
335
336                         make_dupli(ctx, go->ob, mat, id, animated, hide);
337
338                         /* recursion */
339                         make_recursive_duplis(ctx, go->ob, group_mat, id, animated);
340                 }
341         }
342 }
343
344 static const DupliGenerator gen_dupli_group = {
345     OB_DUPLIGROUP,                  /* type */
346     make_duplis_group               /* make_duplis */
347 };
348
349 /* OB_DUPLIFRAMES */
350 static void make_duplis_frames(const DupliContext *ctx)
351 {
352         Scene *scene = ctx->scene;
353         Object *ob = ctx->object;
354         extern int enable_cu_speed; /* object.c */
355         Object copyob;
356         int cfrao = scene->r.cfra;
357         int dupend = ob->dupend;
358
359         /* dupliframes not supported inside groups */
360         if (ctx->group)
361                 return;
362         /* if we don't have any data/settings which will lead to object movement,
363          * don't waste time trying, as it will all look the same...
364          */
365         if (ob->parent == NULL && BLI_listbase_is_empty(&ob->constraints) && ob->adt == NULL)
366                 return;
367
368         /* make a copy of the object's original data (before any dupli-data overwrites it)
369          * as we'll need this to keep track of unkeyed data
370          *      - this doesn't take into account other data that can be reached from the object,
371          *        for example it's shapekeys or bones, hence the need for an update flush at the end
372          */
373         copyob = *ob;
374
375         /* duplicate over the required range */
376         if (ob->transflag & OB_DUPLINOSPEED) enable_cu_speed = 0;
377
378         /* special flag to avoid setting recalc flags to notify the depsgraph of
379          * updates, as this is not a permanent change to the object */
380         ob->id.tag |= LIB_TAG_ANIM_NO_RECALC;
381
382         for (scene->r.cfra = ob->dupsta; scene->r.cfra <= dupend; scene->r.cfra++) {
383                 int ok = 1;
384
385                 /* - dupoff = how often a frames within the range shouldn't be made into duplis
386                  * - dupon = the length of each "skipping" block in frames
387                  */
388                 if (ob->dupoff) {
389                         ok = scene->r.cfra - ob->dupsta;
390                         ok = ok % (ob->dupon + ob->dupoff);
391                         ok = (ok < ob->dupon);
392                 }
393
394                 if (ok) {
395                         /* WARNING: doing animation updates in this way is not terribly accurate, as the dependencies
396                          * and/or other objects which may affect this object's transforms are not updated either.
397                          * However, this has always been the way that this worked (i.e. pre 2.5), so I guess that it'll be fine!
398                          */
399                         BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, (float)scene->r.cfra, ADT_RECALC_ANIM); /* ob-eval will do drivers, so we don't need to do them */
400                         BKE_object_where_is_calc_time(ctx->eval_ctx, scene, ob, (float)scene->r.cfra);
401
402                         make_dupli(ctx, ob, ob->obmat, scene->r.cfra, false, false);
403                 }
404         }
405
406         enable_cu_speed = 1;
407
408         /* reset frame to original frame, then re-evaluate animation as above
409          * as 2.5 animation data may have far-reaching consequences
410          */
411         scene->r.cfra = cfrao;
412
413         BKE_animsys_evaluate_animdata(scene, &ob->id, ob->adt, (float)scene->r.cfra, ADT_RECALC_ANIM); /* ob-eval will do drivers, so we don't need to do them */
414         BKE_object_where_is_calc_time(ctx->eval_ctx, scene, ob, (float)scene->r.cfra);
415
416         /* but, to make sure unkeyed object transforms are still sane,
417          * let's copy object's original data back over
418          */
419         *ob = copyob;
420 }
421
422 static const DupliGenerator gen_dupli_frames = {
423     OB_DUPLIFRAMES,                 /* type */
424     make_duplis_frames              /* make_duplis */
425 };
426
427 /* OB_DUPLIVERTS */
428 typedef struct VertexDupliData {
429         DerivedMesh *dm;
430         BMEditMesh *edit_btmesh;
431         int totvert;
432         float (*orco)[3];
433         bool use_rotation;
434
435         const DupliContext *ctx;
436         Object *inst_ob; /* object to instantiate (argument for vertex map callback) */
437         float child_imat[4][4];
438 } VertexDupliData;
439
440 static void get_duplivert_transform(const float co[3], const float nor_f[3], const short nor_s[3],
441                                     bool use_rotation, short axis, short upflag, float mat[4][4])
442 {
443         float quat[4];
444         const float size[3] = {1.0f, 1.0f, 1.0f};
445
446         if (use_rotation) {
447                 float nor[3];
448                 /* construct rotation matrix from normals */
449                 if (nor_f) {
450                         nor[0] = -nor_f[0];
451                         nor[1] = -nor_f[1];
452                         nor[2] = -nor_f[2];
453                 }
454                 else if (nor_s) {
455                         nor[0] = (float)-nor_s[0];
456                         nor[1] = (float)-nor_s[1];
457                         nor[2] = (float)-nor_s[2];
458                 }
459                 vec_to_quat(quat, nor, axis, upflag);
460         }
461         else
462                 unit_qt(quat);
463
464         loc_quat_size_to_mat4(mat, co, quat, size);
465 }
466
467 static void vertex_dupli__mapFunc(void *userData, int index, const float co[3],
468                                   const float nor_f[3], const short nor_s[3])
469 {
470         const VertexDupliData *vdd = userData;
471         Object *inst_ob = vdd->inst_ob;
472         DupliObject *dob;
473         float obmat[4][4], space_mat[4][4];
474
475         /* obmat is transform to vertex */
476         get_duplivert_transform(co, nor_f, nor_s, vdd->use_rotation, inst_ob->trackflag, inst_ob->upflag, obmat);
477         /* make offset relative to inst_ob using relative child transform */
478         mul_mat3_m4_v3((float (*)[4])vdd->child_imat, obmat[3]);
479         /* apply obmat _after_ the local vertex transform */
480         mul_m4_m4m4(obmat, inst_ob->obmat, obmat);
481
482         /* space matrix is constructed by removing obmat transform,
483          * this yields the worldspace transform for recursive duplis
484          */
485         mul_m4_m4m4(space_mat, obmat, inst_ob->imat);
486
487         dob = make_dupli(vdd->ctx, vdd->inst_ob, obmat, index, false, false);
488
489         if (vdd->orco)
490                 copy_v3_v3(dob->orco, vdd->orco[index]);
491
492         /* recursion */
493         make_recursive_duplis(vdd->ctx, vdd->inst_ob, space_mat, index, false);
494 }
495
496 static void make_child_duplis_verts(const DupliContext *ctx, void *userdata, Object *child)
497 {
498         VertexDupliData *vdd = userdata;
499         DerivedMesh *dm = vdd->dm;
500
501         vdd->inst_ob = child;
502         invert_m4_m4(child->imat, child->obmat);
503         /* relative transform from parent to child space */
504         mul_m4_m4m4(vdd->child_imat, child->imat, ctx->object->obmat);
505
506         if (vdd->edit_btmesh) {
507                 dm->foreachMappedVert(dm, vertex_dupli__mapFunc, vdd,
508                                       vdd->use_rotation ? DM_FOREACH_USE_NORMAL : 0);
509         }
510         else {
511                 int a, totvert = vdd->totvert;
512                 float vec[3], no[3];
513
514                 if (vdd->use_rotation) {
515                         for (a = 0; a < totvert; a++) {
516                                 dm->getVertCo(dm, a, vec);
517                                 dm->getVertNo(dm, a, no);
518
519                                 vertex_dupli__mapFunc(vdd, a, vec, no, NULL);
520                         }
521                 }
522                 else {
523                         for (a = 0; a < totvert; a++) {
524                                 dm->getVertCo(dm, a, vec);
525
526                                 vertex_dupli__mapFunc(vdd, a, vec, NULL, NULL);
527                         }
528                 }
529         }
530 }
531
532 static void make_duplis_verts(const DupliContext *ctx)
533 {
534         Scene *scene = ctx->scene;
535         Object *parent = ctx->object;
536         bool use_texcoords = ELEM(ctx->eval_ctx->mode, DAG_EVAL_RENDER, DAG_EVAL_PREVIEW);
537         VertexDupliData vdd;
538
539         vdd.ctx = ctx;
540         vdd.use_rotation = parent->transflag & OB_DUPLIROT;
541
542         /* gather mesh info */
543         {
544                 Mesh *me = parent->data;
545                 BMEditMesh *em = BKE_editmesh_from_object(parent);
546                 CustomDataMask dm_mask = (use_texcoords ? CD_MASK_BAREMESH | CD_MASK_ORCO : CD_MASK_BAREMESH);
547
548                 if (ctx->eval_ctx->mode == DAG_EVAL_RENDER) {
549                         vdd.dm = mesh_create_derived_render(ctx->eval_ctx, scene, parent, dm_mask);
550                 }
551                 else if (em) {
552                         vdd.dm = editbmesh_get_derived_cage(ctx->eval_ctx, scene, parent, em, dm_mask);
553                 }
554                 else {
555                         vdd.dm = mesh_get_derived_final(ctx->eval_ctx, scene, parent, dm_mask);
556                 }
557                 vdd.edit_btmesh = me->edit_btmesh;
558
559                 if (use_texcoords)
560                         vdd.orco = vdd.dm->getVertDataArray(vdd.dm, CD_ORCO);
561                 else
562                         vdd.orco = NULL;
563
564                 vdd.totvert = vdd.dm->getNumVerts(vdd.dm);
565         }
566
567         make_child_duplis(ctx, &vdd, make_child_duplis_verts);
568
569         vdd.dm->release(vdd.dm);
570 }
571
572 static const DupliGenerator gen_dupli_verts = {
573     OB_DUPLIVERTS,                  /* type */
574     make_duplis_verts               /* make_duplis */
575 };
576
577 /* OB_DUPLIVERTS - FONT */
578 static Object *find_family_object(const char *family, size_t family_len, unsigned int ch, GHash *family_gh)
579 {
580         Object **ob_pt;
581         Object *ob;
582         void *ch_key = SET_UINT_IN_POINTER(ch);
583
584         if ((ob_pt = (Object **)BLI_ghash_lookup_p(family_gh, ch_key))) {
585                 ob = *ob_pt;
586         }
587         else {
588                 char ch_utf8[7];
589                 size_t ch_utf8_len;
590
591                 ch_utf8_len = BLI_str_utf8_from_unicode(ch, ch_utf8);
592                 ch_utf8[ch_utf8_len] = '\0';
593                 ch_utf8_len += 1;  /* compare with null terminator */
594
595                 for (ob = G.main->object.first; ob; ob = ob->id.next) {
596                         if (STREQLEN(ob->id.name + 2 + family_len, ch_utf8, ch_utf8_len)) {
597                                 if (STREQLEN(ob->id.name + 2, family, family_len)) {
598                                         break;
599                                 }
600                         }
601                 }
602
603                 /* inserted value can be NULL, just to save searches in future */
604                 BLI_ghash_insert(family_gh, ch_key, ob);
605         }
606
607         return ob;
608 }
609
610 static void make_duplis_font(const DupliContext *ctx)
611 {
612         Object *par = ctx->object;
613         GHash *family_gh;
614         Object *ob;
615         Curve *cu;
616         struct CharTrans *ct, *chartransdata = NULL;
617         float vec[3], obmat[4][4], pmat[4][4], fsize, xof, yof;
618         int text_len, a;
619         size_t family_len;
620         const wchar_t *text = NULL;
621         bool text_free = false;
622
623         /* font dupliverts not supported inside groups */
624         if (ctx->group)
625                 return;
626
627         copy_m4_m4(pmat, par->obmat);
628
629         /* in par the family name is stored, use this to find the other objects */
630
631         BKE_vfont_to_curve_ex(G.main, par, FO_DUPLI, NULL,
632                               &text, &text_len, &text_free, &chartransdata);
633
634         if (text == NULL || chartransdata == NULL) {
635                 return;
636         }
637
638         cu = par->data;
639         fsize = cu->fsize;
640         xof = cu->xof;
641         yof = cu->yof;
642
643         ct = chartransdata;
644
645         /* cache result */
646         family_len = strlen(cu->family);
647         family_gh = BLI_ghash_int_new_ex(__func__, 256);
648
649         /* advance matching BLI_strncpy_wchar_from_utf8 */
650         for (a = 0; a < text_len; a++, ct++) {
651
652                 ob = find_family_object(cu->family, family_len, (unsigned int)text[a], family_gh);
653                 if (ob) {
654                         vec[0] = fsize * (ct->xof - xof);
655                         vec[1] = fsize * (ct->yof - yof);
656                         vec[2] = 0.0;
657
658                         mul_m4_v3(pmat, vec);
659
660                         copy_m4_m4(obmat, par->obmat);
661
662                         if (UNLIKELY(ct->rot != 0.0f)) {
663                                 float rmat[4][4];
664
665                                 zero_v3(obmat[3]);
666                                 axis_angle_to_mat4_single(rmat, 'Z', -ct->rot);
667                                 mul_m4_m4m4(obmat, obmat, rmat);
668                         }
669
670                         copy_v3_v3(obmat[3], vec);
671
672                         make_dupli(ctx, ob, obmat, a, false, false);
673                 }
674         }
675
676         if (text_free) {
677                 MEM_freeN((void *)text);
678         }
679
680         BLI_ghash_free(family_gh, NULL, NULL);
681
682         MEM_freeN(chartransdata);
683 }
684
685 static const DupliGenerator gen_dupli_verts_font = {
686     OB_DUPLIVERTS,                  /* type */
687     make_duplis_font                /* make_duplis */
688 };
689
690 /* OB_DUPLIFACES */
691 typedef struct FaceDupliData {
692         DerivedMesh *dm;
693         int totface;
694         MPoly *mpoly;
695         MLoop *mloop;
696         MVert *mvert;
697         float (*orco)[3];
698         MLoopUV *mloopuv;
699         bool use_scale;
700 } FaceDupliData;
701
702 static void get_dupliface_transform(MPoly *mpoly, MLoop *mloop, MVert *mvert,
703                                     bool use_scale, float scale_fac, float mat[4][4])
704 {
705         float loc[3], quat[4], scale, size[3];
706         float f_no[3];
707
708         /* location */
709         BKE_mesh_calc_poly_center(mpoly, mloop, mvert, loc);
710         /* rotation */
711         {
712                 const float *v1, *v2, *v3;
713                 BKE_mesh_calc_poly_normal(mpoly, mloop, mvert, f_no);
714                 v1 = mvert[mloop[0].v].co;
715                 v2 = mvert[mloop[1].v].co;
716                 v3 = mvert[mloop[2].v].co;
717                 tri_to_quat_ex(quat, v1, v2, v3, f_no);
718         }
719         /* scale */
720         if (use_scale) {
721                 float area = BKE_mesh_calc_poly_area(mpoly, mloop, mvert);
722                 scale = sqrtf(area) * scale_fac;
723         }
724         else
725                 scale = 1.0f;
726         size[0] = size[1] = size[2] = scale;
727
728         loc_quat_size_to_mat4(mat, loc, quat, size);
729 }
730
731 static void make_child_duplis_faces(const DupliContext *ctx, void *userdata, Object *inst_ob)
732 {
733         FaceDupliData *fdd = userdata;
734         MPoly *mpoly = fdd->mpoly, *mp;
735         MLoop *mloop = fdd->mloop;
736         MVert *mvert = fdd->mvert;
737         float (*orco)[3] = fdd->orco;
738         MLoopUV *mloopuv = fdd->mloopuv;
739         int a, totface = fdd->totface;
740         bool use_texcoords = ELEM(ctx->eval_ctx->mode, DAG_EVAL_RENDER, DAG_EVAL_PREVIEW);
741         float child_imat[4][4];
742         DupliObject *dob;
743
744         invert_m4_m4(inst_ob->imat, inst_ob->obmat);
745         /* relative transform from parent to child space */
746         mul_m4_m4m4(child_imat, inst_ob->imat, ctx->object->obmat);
747
748         for (a = 0, mp = mpoly; a < totface; a++, mp++) {
749                 MLoop *loopstart = mloop + mp->loopstart;
750                 float space_mat[4][4], obmat[4][4];
751
752                 if (UNLIKELY(mp->totloop < 3))
753                         continue;
754
755                 /* obmat is transform to face */
756                 get_dupliface_transform(mp, loopstart, mvert, fdd->use_scale, ctx->object->dupfacesca, obmat);
757                 /* make offset relative to inst_ob using relative child transform */
758                 mul_mat3_m4_v3(child_imat, obmat[3]);
759
760                 /* XXX ugly hack to ensure same behavior as in master
761                  * this should not be needed, parentinv is not consistent
762                  * outside of parenting.
763                  */
764                 {
765                         float imat[3][3];
766                         copy_m3_m4(imat, inst_ob->parentinv);
767                         mul_m4_m3m4(obmat, imat, obmat);
768                 }
769
770                 /* apply obmat _after_ the local face transform */
771                 mul_m4_m4m4(obmat, inst_ob->obmat, obmat);
772
773                 /* space matrix is constructed by removing obmat transform,
774                  * this yields the worldspace transform for recursive duplis
775                  */
776                 mul_m4_m4m4(space_mat, obmat, inst_ob->imat);
777
778                 dob = make_dupli(ctx, inst_ob, obmat, a, false, false);
779                 if (use_texcoords) {
780                         float w = 1.0f / (float)mp->totloop;
781
782                         if (orco) {
783                                 int j;
784                                 for (j = 0; j < mp->totloop; j++) {
785                                         madd_v3_v3fl(dob->orco, orco[loopstart[j].v], w);
786                                 }
787                         }
788
789                         if (mloopuv) {
790                                 int j;
791                                 for (j = 0; j < mp->totloop; j++) {
792                                         madd_v2_v2fl(dob->uv, mloopuv[mp->loopstart + j].uv, w);
793                                 }
794                         }
795                 }
796
797                 /* recursion */
798                 make_recursive_duplis(ctx, inst_ob, space_mat, a, false);
799         }
800 }
801
802 static void make_duplis_faces(const DupliContext *ctx)
803 {
804         Scene *scene = ctx->scene;
805         Object *parent = ctx->object;
806         bool use_texcoords = ELEM(ctx->eval_ctx->mode, DAG_EVAL_RENDER, DAG_EVAL_PREVIEW);
807         FaceDupliData fdd;
808
809         fdd.use_scale = ((parent->transflag & OB_DUPLIFACES_SCALE) != 0);
810
811         /* gather mesh info */
812         {
813                 BMEditMesh *em = BKE_editmesh_from_object(parent);
814                 CustomDataMask dm_mask = (use_texcoords ? CD_MASK_BAREMESH | CD_MASK_ORCO | CD_MASK_MLOOPUV : CD_MASK_BAREMESH);
815
816                 if (ctx->eval_ctx->mode == DAG_EVAL_RENDER) {
817                         fdd.dm = mesh_create_derived_render(ctx->eval_ctx, scene, parent, dm_mask);
818                 }
819                 else if (em) {
820                         fdd.dm = editbmesh_get_derived_cage(ctx->eval_ctx, scene, parent, em, dm_mask);
821                 }
822                 else {
823                         fdd.dm = mesh_get_derived_final(ctx->eval_ctx, scene, parent, dm_mask);
824                 }
825
826                 if (use_texcoords) {
827                         CustomData *ml_data = fdd.dm->getLoopDataLayout(fdd.dm);
828                         const int uv_idx = CustomData_get_render_layer(ml_data, CD_MLOOPUV);
829                         fdd.orco = fdd.dm->getVertDataArray(fdd.dm, CD_ORCO);
830                         fdd.mloopuv = CustomData_get_layer_n(ml_data, CD_MLOOPUV, uv_idx);
831                 }
832                 else {
833                         fdd.orco = NULL;
834                         fdd.mloopuv = NULL;
835                 }
836
837                 fdd.totface = fdd.dm->getNumPolys(fdd.dm);
838                 fdd.mpoly = fdd.dm->getPolyArray(fdd.dm);
839                 fdd.mloop = fdd.dm->getLoopArray(fdd.dm);
840                 fdd.mvert = fdd.dm->getVertArray(fdd.dm);
841         }
842
843         make_child_duplis(ctx, &fdd, make_child_duplis_faces);
844
845         fdd.dm->release(fdd.dm);
846 }
847
848 static const DupliGenerator gen_dupli_faces = {
849     OB_DUPLIFACES,                  /* type */
850     make_duplis_faces               /* make_duplis */
851 };
852
853 /* OB_DUPLIPARTS */
854 static void make_duplis_particle_system(const DupliContext *ctx, ParticleSystem *psys)
855 {
856         Scene *scene = ctx->scene;
857         Object *par = ctx->object;
858         bool for_render = ctx->eval_ctx->mode == DAG_EVAL_RENDER;
859         bool use_texcoords = ELEM(ctx->eval_ctx->mode, DAG_EVAL_RENDER, DAG_EVAL_PREVIEW);
860
861         GroupObject *go;
862         Object *ob = NULL, **oblist = NULL, obcopy, *obcopylist = NULL;
863         DupliObject *dob;
864         ParticleDupliWeight *dw;
865         ParticleSettings *part;
866         ParticleData *pa;
867         ChildParticle *cpa = NULL;
868         ParticleKey state;
869         ParticleCacheKey *cache;
870         float ctime, pa_time, scale = 1.0f;
871         float tmat[4][4], mat[4][4], pamat[4][4], vec[3], size = 0.0;
872         float (*obmat)[4];
873         int a, b, hair = 0;
874         int totpart, totchild, totgroup = 0 /*, pa_num */;
875         const bool dupli_type_hack = !BKE_scene_use_new_shading_nodes(scene);
876
877         int no_draw_flag = PARS_UNEXIST;
878
879         if (psys == NULL) return;
880
881         part = psys->part;
882
883         if (part == NULL)
884                 return;
885
886         if (!psys_check_enabled(par, psys, (ctx->eval_ctx->mode == DAG_EVAL_RENDER)))
887                 return;
888
889         if (!for_render)
890                 no_draw_flag |= PARS_NO_DISP;
891
892         ctime = BKE_scene_frame_get(scene); /* NOTE: in old animsys, used parent object's timeoffset... */
893
894         totpart = psys->totpart;
895         totchild = psys->totchild;
896
897         BLI_srandom((unsigned int)(31415926 + psys->seed));
898
899         if ((psys->renderdata || part->draw_as == PART_DRAW_REND) && ELEM(part->ren_as, PART_DRAW_OB, PART_DRAW_GR)) {
900                 ParticleSimulationData sim = {NULL};
901                 sim.eval_ctx = ctx->eval_ctx;
902                 sim.scene = scene;
903                 sim.ob = par;
904                 sim.psys = psys;
905                 sim.psmd = psys_get_modifier(par, psys);
906                 /* make sure emitter imat is in global coordinates instead of render view coordinates */
907                 invert_m4_m4(par->imat, par->obmat);
908
909                 /* first check for loops (particle system object used as dupli object) */
910                 if (part->ren_as == PART_DRAW_OB) {
911                         if (ELEM(part->dup_ob, NULL, par))
912                                 return;
913                 }
914                 else { /*PART_DRAW_GR */
915                         if (part->dup_group == NULL || BLI_listbase_is_empty(&part->dup_group->gobject))
916                                 return;
917
918                         if (BLI_findptr(&part->dup_group->gobject, par, offsetof(GroupObject, ob))) {
919                                 return;
920                         }
921                 }
922
923                 /* if we have a hair particle system, use the path cache */
924                 if (part->type == PART_HAIR) {
925                         if (psys->flag & PSYS_HAIR_DONE)
926                                 hair = (totchild == 0 || psys->childcache) && psys->pathcache;
927                         if (!hair)
928                                 return;
929
930                         /* we use cache, update totchild according to cached data */
931                         totchild = psys->totchildcache;
932                         totpart = psys->totcached;
933                 }
934
935                 psys_check_group_weights(part);
936
937                 psys->lattice_deform_data = psys_create_lattice_deform_data(&sim);
938
939                 /* gather list of objects or single object */
940                 if (part->ren_as == PART_DRAW_GR) {
941                         if (ctx->do_update) {
942                                 BKE_group_handle_recalc_and_update(ctx->eval_ctx, scene, par, part->dup_group);
943                         }
944
945                         if (part->draw & PART_DRAW_COUNT_GR) {
946                                 for (dw = part->dupliweights.first; dw; dw = dw->next)
947                                         totgroup += dw->count;
948                         }
949                         else {
950                                 for (go = part->dup_group->gobject.first; go; go = go->next)
951                                         totgroup++;
952                         }
953
954                         /* we also copy the actual objects to restore afterwards, since
955                          * BKE_object_where_is_calc_time will change the object which breaks transform */
956                         oblist = MEM_callocN((size_t)totgroup * sizeof(Object *), "dupgroup object list");
957                         obcopylist = MEM_callocN((size_t)totgroup * sizeof(Object), "dupgroup copy list");
958
959                         if (part->draw & PART_DRAW_COUNT_GR && totgroup) {
960                                 dw = part->dupliweights.first;
961
962                                 for (a = 0; a < totgroup; dw = dw->next) {
963                                         for (b = 0; b < dw->count; b++, a++) {
964                                                 oblist[a] = dw->ob;
965                                                 obcopylist[a] = *dw->ob;
966                                         }
967                                 }
968                         }
969                         else {
970                                 go = part->dup_group->gobject.first;
971                                 for (a = 0; a < totgroup; a++, go = go->next) {
972                                         oblist[a] = go->ob;
973                                         obcopylist[a] = *go->ob;
974                                 }
975                         }
976                 }
977                 else {
978                         ob = part->dup_ob;
979                         obcopy = *ob;
980                 }
981
982                 if (totchild == 0 || part->draw & PART_DRAW_PARENT)
983                         a = 0;
984                 else
985                         a = totpart;
986
987                 for (pa = psys->particles; a < totpart + totchild; a++, pa++) {
988                         if (a < totpart) {
989                                 /* handle parent particle */
990                                 if (pa->flag & no_draw_flag)
991                                         continue;
992
993                                 /* pa_num = pa->num; */ /* UNUSED */
994                                 pa_time = pa->time;
995                                 size = pa->size;
996                         }
997                         else {
998                                 /* handle child particle */
999                                 cpa = &psys->child[a - totpart];
1000
1001                                 /* pa_num = a; */ /* UNUSED */
1002                                 pa_time = psys->particles[cpa->parent].time;
1003                                 size = psys_get_child_size(psys, cpa, ctime, NULL);
1004                         }
1005
1006                         /* some hair paths might be non-existent so they can't be used for duplication */
1007                         if (hair && psys->pathcache &&
1008                             ((a < totpart && psys->pathcache[a]->segments < 0) ||
1009                              (a >= totpart && psys->childcache[a - totpart]->segments < 0)))
1010                         {
1011                                 continue;
1012                         }
1013
1014                         if (part->ren_as == PART_DRAW_GR) {
1015                                 /* prevent divide by zero below [#28336] */
1016                                 if (totgroup == 0)
1017                                         continue;
1018
1019                                 /* for groups, pick the object based on settings */
1020                                 if (part->draw & PART_DRAW_RAND_GR)
1021                                         b = BLI_rand() % totgroup;
1022                                 else
1023                                         b = a % totgroup;
1024
1025                                 ob = oblist[b];
1026                                 obmat = oblist[b]->obmat;
1027                         }
1028                         else {
1029                                 obmat = ob->obmat;
1030                         }
1031
1032                         if (hair) {
1033                                 /* hair we handle separate and compute transform based on hair keys */
1034                                 if (a < totpart) {
1035                                         cache = psys->pathcache[a];
1036                                         psys_get_dupli_path_transform(&sim, pa, NULL, cache, pamat, &scale);
1037                                 }
1038                                 else {
1039                                         cache = psys->childcache[a - totpart];
1040                                         psys_get_dupli_path_transform(&sim, NULL, cpa, cache, pamat, &scale);
1041                                 }
1042
1043                                 copy_v3_v3(pamat[3], cache->co);
1044                                 pamat[3][3] = 1.0f;
1045
1046                         }
1047                         else {
1048                                 /* first key */
1049                                 state.time = ctime;
1050                                 if (psys_get_particle_state(&sim, a, &state, 0) == 0) {
1051                                         continue;
1052                                 }
1053                                 else {
1054                                         float tquat[4];
1055                                         normalize_qt_qt(tquat, state.rot);
1056                                         quat_to_mat4(pamat, tquat);
1057                                         copy_v3_v3(pamat[3], state.co);
1058                                         pamat[3][3] = 1.0f;
1059                                 }
1060                         }
1061
1062                         if (part->ren_as == PART_DRAW_GR && psys->part->draw & PART_DRAW_WHOLE_GR) {
1063                                 for (go = part->dup_group->gobject.first, b = 0; go; go = go->next, b++) {
1064
1065                                         copy_m4_m4(tmat, oblist[b]->obmat);
1066                                         /* apply particle scale */
1067                                         mul_mat3_m4_fl(tmat, size * scale);
1068                                         mul_v3_fl(tmat[3], size * scale);
1069                                         /* group dupli offset, should apply after everything else */
1070                                         if (!is_zero_v3(part->dup_group->dupli_ofs))
1071                                                 sub_v3_v3(tmat[3], part->dup_group->dupli_ofs);
1072                                         /* individual particle transform */
1073                                         mul_m4_m4m4(mat, pamat, tmat);
1074
1075                                         dob = make_dupli(ctx, go->ob, mat, a, false, false);
1076                                         dob->particle_system = psys;
1077                                         if (use_texcoords)
1078                                                 psys_get_dupli_texture(psys, part, sim.psmd, pa, cpa, dob->uv, dob->orco);
1079                                 }
1080                         }
1081                         else {
1082                                 /* to give ipos in object correct offset */
1083                                 BKE_object_where_is_calc_time(ctx->eval_ctx, scene, ob, ctime - pa_time);
1084
1085                                 copy_v3_v3(vec, obmat[3]);
1086                                 obmat[3][0] = obmat[3][1] = obmat[3][2] = 0.0f;
1087
1088                                 /* particle rotation uses x-axis as the aligned axis, so pre-rotate the object accordingly */
1089                                 if ((part->draw & PART_DRAW_ROTATE_OB) == 0) {
1090                                         float xvec[3], q[4], size_mat[4][4], original_size[3];
1091
1092                                         mat4_to_size(original_size, obmat);
1093                                         size_to_mat4(size_mat, original_size);
1094
1095                                         xvec[0] = -1.f;
1096                                         xvec[1] = xvec[2] = 0;
1097                                         vec_to_quat(q, xvec, ob->trackflag, ob->upflag);
1098                                         quat_to_mat4(obmat, q);
1099                                         obmat[3][3] = 1.0f;
1100
1101                                         /* add scaling if requested */
1102                                         if ((part->draw & PART_DRAW_NO_SCALE_OB) == 0)
1103                                                 mul_m4_m4m4(obmat, obmat, size_mat);
1104                                 }
1105                                 else if (part->draw & PART_DRAW_NO_SCALE_OB) {
1106                                         /* remove scaling */
1107                                         float size_mat[4][4], original_size[3];
1108
1109                                         mat4_to_size(original_size, obmat);
1110                                         size_to_mat4(size_mat, original_size);
1111                                         invert_m4(size_mat);
1112
1113                                         mul_m4_m4m4(obmat, obmat, size_mat);
1114                                 }
1115
1116                                 mul_m4_m4m4(tmat, pamat, obmat);
1117                                 mul_mat3_m4_fl(tmat, size * scale);
1118
1119                                 copy_m4_m4(mat, tmat);
1120
1121                                 if (part->draw & PART_DRAW_GLOBAL_OB)
1122                                         add_v3_v3v3(mat[3], mat[3], vec);
1123
1124                                 dob = make_dupli(ctx, ob, mat, a, false, false);
1125                                 dob->particle_system = psys;
1126                                 if (use_texcoords)
1127                                         psys_get_dupli_texture(psys, part, sim.psmd, pa, cpa, dob->uv, dob->orco);
1128                                 /* XXX blender internal needs this to be set to dupligroup to render
1129                                  * groups correctly, but we don't want this hack for cycles */
1130                                 if (dupli_type_hack && ctx->group)
1131                                         dob->type = OB_DUPLIGROUP;
1132                         }
1133                 }
1134
1135                 /* restore objects since they were changed in BKE_object_where_is_calc_time */
1136                 if (part->ren_as == PART_DRAW_GR) {
1137                         for (a = 0; a < totgroup; a++)
1138                                 *(oblist[a]) = obcopylist[a];
1139                 }
1140                 else
1141                         *ob = obcopy;
1142         }
1143
1144         /* clean up */
1145         if (oblist)
1146                 MEM_freeN(oblist);
1147         if (obcopylist)
1148                 MEM_freeN(obcopylist);
1149
1150         if (psys->lattice_deform_data) {
1151                 end_latt_deform(psys->lattice_deform_data);
1152                 psys->lattice_deform_data = NULL;
1153         }
1154 }
1155
1156 static void make_duplis_particles(const DupliContext *ctx)
1157 {
1158         ParticleSystem *psys;
1159         int psysid;
1160
1161         /* particle system take up one level in id, the particles another */
1162         for (psys = ctx->object->particlesystem.first, psysid = 0; psys; psys = psys->next, psysid++) {
1163                 /* particles create one more level for persistent psys index */
1164                 DupliContext pctx;
1165                 copy_dupli_context(&pctx, ctx, ctx->object, NULL, psysid, false);
1166                 make_duplis_particle_system(&pctx, psys);
1167         }
1168 }
1169
1170 static const DupliGenerator gen_dupli_particles = {
1171     OB_DUPLIPARTS,                  /* type */
1172     make_duplis_particles           /* make_duplis */
1173 };
1174
1175 /* ------------- */
1176
1177 /* select dupli generator from given context */
1178 static const DupliGenerator *get_dupli_generator(const DupliContext *ctx)
1179 {
1180         int transflag = ctx->object->transflag;
1181         int restrictflag = ctx->object->restrictflag;
1182
1183         if ((transflag & OB_DUPLI) == 0)
1184                 return NULL;
1185
1186         /* Should the dupli's be generated for this object? - Respect restrict flags */
1187         if (ctx->eval_ctx->mode == DAG_EVAL_RENDER ? (restrictflag & OB_RESTRICT_RENDER) : (restrictflag & OB_RESTRICT_VIEW))
1188                 return NULL;
1189
1190         if (transflag & OB_DUPLIPARTS) {
1191                 return &gen_dupli_particles;
1192         }
1193         else if (transflag & OB_DUPLIVERTS) {
1194                 if (ctx->object->type == OB_MESH) {
1195                         return &gen_dupli_verts;
1196                 }
1197                 else if (ctx->object->type == OB_FONT) {
1198                         return &gen_dupli_verts_font;
1199                 }
1200         }
1201         else if (transflag & OB_DUPLIFACES) {
1202                 if (ctx->object->type == OB_MESH)
1203                         return &gen_dupli_faces;
1204         }
1205         else if (transflag & OB_DUPLIFRAMES) {
1206                 return &gen_dupli_frames;
1207         }
1208         else if (transflag & OB_DUPLIGROUP) {
1209                 return &gen_dupli_group;
1210         }
1211
1212         return NULL;
1213 }
1214
1215
1216 /* ---- ListBase dupli container implementation ---- */
1217
1218 /* Returns a list of DupliObject */
1219 ListBase *object_duplilist_ex(const EvaluationContext *eval_ctx, Scene *scene, Object *ob, bool update)
1220 {
1221         ListBase *duplilist = MEM_callocN(sizeof(ListBase), "duplilist");
1222         DupliContext ctx;
1223         init_context(&ctx, eval_ctx, scene, ob, NULL, update);
1224         if (ctx.gen) {
1225                 ctx.duplilist = duplilist;
1226                 ctx.gen->make_duplis(&ctx);
1227         }
1228
1229         return duplilist;
1230 }
1231
1232 /* note: previously updating was always done, this is why it defaults to be on
1233  * but there are likely places it can be called without updating */
1234 ListBase *object_duplilist(const EvaluationContext *eval_ctx, Scene *sce, Object *ob)
1235 {
1236         return object_duplilist_ex(eval_ctx, sce, ob, true);
1237 }
1238
1239 void free_object_duplilist(ListBase *lb)
1240 {
1241         BLI_freelistN(lb);
1242         MEM_freeN(lb);
1243 }
1244
1245 int count_duplilist(Object *ob)
1246 {
1247         if (ob->transflag & OB_DUPLI) {
1248                 if (ob->transflag & OB_DUPLIVERTS) {
1249                         if (ob->type == OB_MESH) {
1250                                 if (ob->transflag & OB_DUPLIVERTS) {
1251                                         ParticleSystem *psys = ob->particlesystem.first;
1252                                         int pdup = 0;
1253
1254                                         for (; psys; psys = psys->next)
1255                                                 pdup += psys->totpart;
1256
1257                                         if (pdup == 0) {
1258                                                 Mesh *me = ob->data;
1259                                                 return me->totvert;
1260                                         }
1261                                         else
1262                                                 return pdup;
1263                                 }
1264                         }
1265                 }
1266                 else if (ob->transflag & OB_DUPLIFRAMES) {
1267                         int tot = ob->dupend - ob->dupsta;
1268                         tot /= (ob->dupon + ob->dupoff);
1269                         return tot * ob->dupon;
1270                 }
1271         }
1272         return 1;
1273 }
1274
1275 DupliApplyData *duplilist_apply(const EvaluationContext *eval_ctx, Object *ob, Scene *scene, ListBase *duplilist)
1276 {
1277         DupliApplyData *apply_data = NULL;
1278         int num_objects = BLI_listbase_count(duplilist);
1279         
1280         if (num_objects > 0) {
1281                 DupliObject *dob;
1282                 int i;
1283                 apply_data = MEM_mallocN(sizeof(DupliApplyData), "DupliObject apply data");
1284                 apply_data->num_objects = num_objects;
1285                 apply_data->extra = MEM_mallocN(sizeof(DupliExtraData) * (size_t) num_objects,
1286                                                 "DupliObject apply extra data");
1287
1288                 for (dob = duplilist->first, i = 0; dob; dob = dob->next, ++i) {
1289                         /* make sure derivedmesh is calculated once, before drawing */
1290                         if (scene && !(dob->ob->transflag & OB_DUPLICALCDERIVED) && dob->ob->type == OB_MESH) {
1291                                 mesh_get_derived_final(eval_ctx, scene, dob->ob, scene->customdata_mask);
1292                                 dob->ob->transflag |= OB_DUPLICALCDERIVED;
1293                         }
1294                 }
1295
1296                 for (dob = duplilist->first, i = 0; dob; dob = dob->next, ++i) {
1297                         /* copy obmat from duplis */
1298                         copy_m4_m4(apply_data->extra[i].obmat, dob->ob->obmat);
1299                         copy_m4_m4(dob->ob->obmat, dob->mat);
1300                         
1301                         /* copy layers from the main duplicator object */
1302                         apply_data->extra[i].lay = dob->ob->lay;
1303                         dob->ob->lay = ob->lay;
1304                 }
1305         }
1306         return apply_data;
1307 }
1308
1309 void duplilist_restore(ListBase *duplilist, DupliApplyData *apply_data)
1310 {
1311         DupliObject *dob;
1312         int i;
1313         /* Restore object matrices.
1314          * NOTE: this has to happen in reverse order, since nested
1315          * dupli objects can repeatedly override the obmat.
1316          */
1317         for (dob = duplilist->last, i = apply_data->num_objects - 1; dob; dob = dob->prev, --i) {
1318                 copy_m4_m4(dob->ob->obmat, apply_data->extra[i].obmat);
1319                 dob->ob->transflag &= ~OB_DUPLICALCDERIVED;
1320                 
1321                 dob->ob->lay = apply_data->extra[i].lay;
1322         }
1323 }
1324
1325 void duplilist_free_apply_data(DupliApplyData *apply_data)
1326 {
1327         MEM_freeN(apply_data->extra);
1328         MEM_freeN(apply_data);
1329 }