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