Depsgraph: Add evaluation callbacks for granular nodes update
[blender-staging.git] / source / blender / blenkernel / intern / object_update.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) 20014 by Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Sergey Sharybin.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenkernel/intern/object_update.c
27  *  \ingroup bke
28  */
29
30 #include "DNA_anim_types.h"
31 #include "DNA_constraint_types.h"
32 #include "DNA_group_types.h"
33 #include "DNA_key_types.h"
34 #include "DNA_material_types.h"
35 #include "DNA_scene_types.h"
36
37 #include "BLI_blenlib.h"
38 #include "BLI_utildefines.h"
39 #include "BLI_math.h"
40
41 #include "BKE_global.h"
42 #include "BKE_armature.h"
43 #include "BKE_action.h"
44 #include "BKE_constraint.h"
45 #include "BKE_depsgraph.h"
46 #include "BKE_DerivedMesh.h"
47 #include "BKE_animsys.h"
48 #include "BKE_displist.h"
49 #include "BKE_effect.h"
50 #include "BKE_key.h"
51 #include "BKE_lamp.h"
52 #include "BKE_lattice.h"
53 #include "BKE_editmesh.h"
54 #include "BKE_object.h"
55 #include "BKE_particle.h"
56 #include "BKE_scene.h"
57 #include "BKE_material.h"
58 #include "BKE_image.h"
59
60 #ifdef WITH_LEGACY_DEPSGRAPH
61 #  define DEBUG_PRINT if (!DEG_depsgraph_use_legacy() && G.debug & G_DEBUG_DEPSGRAPH) printf
62 #else
63 #  define DEBUG_PRINT if (G.debug & G_DEBUG_DEPSGRAPH) printf
64 #endif
65
66 void BKE_object_eval_local_transform(EvaluationContext *UNUSED(eval_ctx),
67                                      Scene *UNUSED(scene),
68                                      Object *ob)
69 {
70         DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
71
72         /* calculate local matrix */
73         BKE_object_to_mat4(ob, ob->obmat);
74 }
75
76 /* Evaluate parent */
77 /* NOTE: based on solve_parenting(), but with the cruft stripped out */
78 void BKE_object_eval_parent(EvaluationContext *UNUSED(eval_ctx),
79                             Scene *scene,
80                             Object *ob)
81 {
82         Object *par = ob->parent;
83
84         float totmat[4][4];
85         float tmat[4][4];
86         float locmat[4][4];
87
88         DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
89
90         /* get local matrix (but don't calculate it, as that was done already!) */
91         // XXX: redundant?
92         copy_m4_m4(locmat, ob->obmat);
93
94         /* get parent effect matrix */
95         BKE_object_get_parent_matrix(scene, ob, par, totmat);
96
97         /* total */
98         mul_m4_m4m4(tmat, totmat, ob->parentinv);
99         mul_m4_m4m4(ob->obmat, tmat, locmat);
100
101         /* origin, for help line */
102         if ((ob->partype & PARTYPE) == PARSKEL) {
103                 copy_v3_v3(ob->orig, par->obmat[3]);
104         }
105         else {
106                 copy_v3_v3(ob->orig, totmat[3]);
107         }
108 }
109
110 void BKE_object_eval_constraints(EvaluationContext *UNUSED(eval_ctx),
111                                  Scene *scene,
112                                  Object *ob)
113 {
114         bConstraintOb *cob;
115         float ctime = BKE_scene_frame_get(scene);
116
117         DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
118
119         /* evaluate constraints stack */
120         /* TODO: split this into:
121          * - pre (i.e. BKE_constraints_make_evalob, per-constraint (i.e.
122          * - inner body of BKE_constraints_solve),
123          * - post (i.e. BKE_constraints_clear_evalob)
124          *
125          * Not sure why, this is from Joshua - sergey
126          *
127          */
128         cob = BKE_constraints_make_evalob(scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
129         BKE_constraints_solve(&ob->constraints, cob, ctime);
130         BKE_constraints_clear_evalob(cob);
131 }
132
133 void BKE_object_eval_done(EvaluationContext *UNUSED(eval_ctx), Object *ob)
134 {
135         DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
136
137         /* Set negative scale flag in object. */
138         if (is_negative_m4(ob->obmat)) ob->transflag |= OB_NEG_SCALE;
139         else ob->transflag &= ~OB_NEG_SCALE;
140 }
141
142 void BKE_object_eval_modifier(struct EvaluationContext *eval_ctx,
143                               struct Scene *scene,
144                               struct Object *ob,
145                               struct ModifierData *md)
146 {
147         DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
148         (void) eval_ctx;  /* Ignored. */
149         (void) scene;  /* Ignored. */
150         (void) ob;  /* Ignored. */
151         (void) md;  /* Ignored. */
152 }
153
154 void BKE_object_handle_data_update(EvaluationContext *eval_ctx,
155                                    Scene *scene,
156                                    Object *ob)
157 {
158         ID *data_id = (ID *)ob->data;
159         AnimData *adt = BKE_animdata_from_id(data_id);
160         Key *key;
161         float ctime = BKE_scene_frame_get(scene);
162
163         if (G.debug & G_DEBUG_DEPSGRAPH)
164                 printf("recalcdata %s\n", ob->id.name + 2);
165
166         /* TODO(sergey): Only used by legacy depsgraph. */
167         if (adt) {
168                 /* evaluate drivers - datalevel */
169                 /* XXX: for mesh types, should we push this to derivedmesh instead? */
170                 BKE_animsys_evaluate_animdata(scene, data_id, adt, ctime, ADT_RECALC_DRIVERS);
171         }
172
173         /* TODO(sergey): Only used by legacy depsgraph. */
174         key = BKE_key_from_object(ob);
175         if (key && key->block.first) {
176                 if (!(ob->shapeflag & OB_SHAPE_LOCK))
177                         BKE_animsys_evaluate_animdata(scene, &key->id, key->adt, ctime, ADT_RECALC_DRIVERS);
178         }
179
180         /* includes all keys and modifiers */
181         switch (ob->type) {
182                 case OB_MESH:
183                 {
184                         BMEditMesh *em = (ob == scene->obedit) ? BKE_editmesh_from_object(ob) : NULL;
185                         uint64_t data_mask = scene->customdata_mask | CD_MASK_BAREMESH;
186 #ifdef WITH_FREESTYLE
187                         /* make sure Freestyle edge/face marks appear in DM for render (see T40315) */
188                         if (eval_ctx->mode != DAG_EVAL_VIEWPORT) {
189                                 data_mask |= CD_MASK_FREESTYLE_EDGE | CD_MASK_FREESTYLE_FACE;
190                         }
191 #endif
192                         if (em) {
193                                 makeDerivedMesh(scene, ob, em,  data_mask, 0); /* was CD_MASK_BAREMESH */
194                         }
195                         else {
196                                 makeDerivedMesh(scene, ob, NULL, data_mask, 0);
197                         }
198                         break;
199                 }
200                 case OB_ARMATURE:
201                         if (ob->id.lib && ob->proxy_from) {
202                                 if (BKE_pose_copy_result(ob->pose, ob->proxy_from->pose) == false) {
203                                         printf("Proxy copy error, lib Object: %s proxy Object: %s\n",
204                                                ob->id.name + 2, ob->proxy_from->id.name + 2);
205                                 }
206                         }
207                         else {
208                                 BKE_pose_where_is(scene, ob);
209                         }
210                         break;
211
212                 case OB_MBALL:
213                         BKE_displist_make_mball(eval_ctx, scene, ob);
214                         break;
215
216                 case OB_CURVE:
217                 case OB_SURF:
218                 case OB_FONT:
219                         BKE_displist_make_curveTypes(scene, ob, 0);
220                         break;
221
222                 case OB_LATTICE:
223                         BKE_lattice_modifiers_calc(scene, ob);
224                         break;
225
226                 case OB_EMPTY:
227                         if (ob->empty_drawtype == OB_EMPTY_IMAGE && ob->data)
228                                 if (BKE_image_is_animated(ob->data))
229                                         BKE_image_user_check_frame_calc(ob->iuser, (int)ctime, 0);
230                         break;
231         }
232
233         /* related materials */
234         /* XXX: without depsgraph tagging, this will always need to be run, which will be slow!
235          * However, not doing anything (or trying to hack around this lack) is not an option
236          * anymore, especially due to Cycles [#31834]
237          */
238         if (ob->totcol) {
239                 int a;
240                 for (a = 1; a <= ob->totcol; a++) {
241                         Material *ma = give_current_material(ob, a);
242                         if (ma) {
243                                 /* recursively update drivers for this material */
244                                 material_drivers_update(scene, ma, ctime);
245                         }
246                 }
247         }
248         else if (ob->type == OB_LAMP)
249                 lamp_drivers_update(scene, ob->data, ctime);
250
251         /* particles */
252         if (ob != scene->obedit && ob->particlesystem.first) {
253                 ParticleSystem *tpsys, *psys;
254                 DerivedMesh *dm;
255                 ob->transflag &= ~OB_DUPLIPARTS;
256                 psys = ob->particlesystem.first;
257                 while (psys) {
258                         /* ensure this update always happens even if psys is disabled */
259                         if (psys->recalc & PSYS_RECALC_TYPE) {
260                                 psys_changed_type(ob, psys);
261                         }
262
263                         if (psys_check_enabled(ob, psys)) {
264                                 /* check use of dupli objects here */
265                                 if (psys->part && (psys->part->draw_as == PART_DRAW_REND || eval_ctx->mode == DAG_EVAL_RENDER) &&
266                                     ((psys->part->ren_as == PART_DRAW_OB && psys->part->dup_ob) ||
267                                      (psys->part->ren_as == PART_DRAW_GR && psys->part->dup_group)))
268                                 {
269                                         ob->transflag |= OB_DUPLIPARTS;
270                                 }
271
272                                 particle_system_update(scene, ob, psys);
273                                 psys = psys->next;
274                         }
275                         else if (psys->flag & PSYS_DELETE) {
276                                 tpsys = psys->next;
277                                 BLI_remlink(&ob->particlesystem, psys);
278                                 psys_free(ob, psys);
279                                 psys = tpsys;
280                         }
281                         else
282                                 psys = psys->next;
283                 }
284
285                 if (eval_ctx->mode == DAG_EVAL_RENDER && ob->transflag & OB_DUPLIPARTS) {
286                         /* this is to make sure we get render level duplis in groups:
287                          * the derivedmesh must be created before init_render_mesh,
288                          * since object_duplilist does dupliparticles before that */
289                         dm = mesh_create_derived_render(scene, ob, CD_MASK_BAREMESH | CD_MASK_MTFACE | CD_MASK_MCOL);
290                         dm->release(dm);
291
292                         for (psys = ob->particlesystem.first; psys; psys = psys->next)
293                                 psys_get_modifier(ob, psys)->flag &= ~eParticleSystemFlag_psys_updated;
294                 }
295         }
296
297         /* quick cache removed */
298 }
299
300 void BKE_object_eval_uber_transform(EvaluationContext *UNUSED(eval_ctx),
301                                     Scene *UNUSED(scene),
302                                     Object *ob)
303 {
304         /* TODO(sergey): Currently it's a duplicate of logic in BKE_object_handle_update_ex(). */
305         // XXX: it's almost redundant now...
306
307         /* Handle proxy copy for target, */
308         if (ob->id.lib && ob->proxy_from) {
309                 if (ob->proxy_from->proxy_group) {
310                         /* Transform proxy into group space. */
311                         Object *obg = ob->proxy_from->proxy_group;
312                         invert_m4_m4(obg->imat, obg->obmat);
313                         mul_m4_m4m4(ob->obmat, obg->imat, ob->proxy_from->obmat);
314                         /* Should always be true. */
315                         if (obg->dup_group) {
316                                 add_v3_v3(ob->obmat[3], obg->dup_group->dupli_ofs);
317                         }
318                 }
319                 else
320                         copy_m4_m4(ob->obmat, ob->proxy_from->obmat);
321         }
322
323         ob->recalc &= ~(OB_RECALC_OB|OB_RECALC_TIME);
324         if (ob->data == NULL) {
325                 ob->recalc &= ~OB_RECALC_DATA;
326         }
327 }
328
329 void BKE_object_eval_uber_data(EvaluationContext *eval_ctx,
330                                Scene *scene,
331                                Object *ob)
332 {
333         DEBUG_PRINT("%s on %s\n", __func__, ob->id.name);
334         BLI_assert(ob->type != OB_ARMATURE);
335         BKE_object_handle_data_update(eval_ctx, scene, ob);
336
337         ob->recalc &= ~(OB_RECALC_DATA|OB_RECALC_TIME);
338 }