Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / object_update.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 20014 by Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include "DNA_anim_types.h"
25 #include "DNA_collection_types.h"
26 #include "DNA_constraint_types.h"
27 #include "DNA_key_types.h"
28 #include "DNA_material_types.h"
29 #include "DNA_mesh_types.h"
30 #include "DNA_scene_types.h"
31
32 #include "BLI_blenlib.h"
33 #include "BLI_utildefines.h"
34 #include "BLI_math.h"
35
36 #include "BKE_animsys.h"
37 #include "BKE_armature.h"
38 #include "BKE_action.h"
39 #include "BKE_constraint.h"
40 #include "BKE_curve.h"
41 #include "BKE_DerivedMesh.h"
42 #include "BKE_displist.h"
43 #include "BKE_editmesh.h"
44 #include "BKE_effect.h"
45 #include "BKE_image.h"
46 #include "BKE_key.h"
47 #include "BKE_layer.h"
48 #include "BKE_light.h"
49 #include "BKE_lattice.h"
50 #include "BKE_material.h"
51 #include "BKE_mball.h"
52 #include "BKE_mesh.h"
53 #include "BKE_object.h"
54 #include "BKE_particle.h"
55 #include "BKE_pointcache.h"
56 #include "BKE_scene.h"
57 #include "BKE_gpencil.h"
58
59 #include "MEM_guardedalloc.h"
60
61 #include "DEG_depsgraph.h"
62 #include "DEG_depsgraph_query.h"
63
64 /**
65  * Restore the object->data to a non-modifier evaluated state.
66  *
67  * Some changes done directly in evaluated object require them to be reset
68  * before being re-evaluated.
69  * For example, we need to call this before #BKE_mesh_new_from_object(),
70  * in case we removed/added modifiers in the evaluated object.
71  */
72 void BKE_object_eval_reset(Object *ob_eval)
73 {
74   BKE_object_free_derived_caches(ob_eval);
75 }
76
77 void BKE_object_eval_local_transform(Depsgraph *depsgraph, Object *ob)
78 {
79   DEG_debug_print_eval(depsgraph, __func__, ob->id.name, ob);
80
81   /* calculate local matrix */
82   BKE_object_to_mat4(ob, ob->obmat);
83 }
84
85 /* Evaluate parent */
86 /* NOTE: based on solve_parenting(), but with the cruft stripped out */
87 void BKE_object_eval_parent(Depsgraph *depsgraph, Object *ob)
88 {
89   Object *par = ob->parent;
90
91   float totmat[4][4];
92   float tmat[4][4];
93   float locmat[4][4];
94
95   DEG_debug_print_eval(depsgraph, __func__, ob->id.name, ob);
96
97   /* get local matrix (but don't calculate it, as that was done already!) */
98   // XXX: redundant?
99   copy_m4_m4(locmat, ob->obmat);
100
101   /* get parent effect matrix */
102   BKE_object_get_parent_matrix(ob, par, totmat);
103
104   /* total */
105   mul_m4_m4m4(tmat, totmat, ob->parentinv);
106   mul_m4_m4m4(ob->obmat, tmat, locmat);
107
108   /* origin, for help line */
109   if ((ob->partype & PARTYPE) == PARSKEL) {
110     copy_v3_v3(ob->runtime.parent_display_origin, par->obmat[3]);
111   }
112   else {
113     copy_v3_v3(ob->runtime.parent_display_origin, totmat[3]);
114   }
115 }
116
117 void BKE_object_eval_constraints(Depsgraph *depsgraph, Scene *scene, Object *ob)
118 {
119   bConstraintOb *cob;
120   float ctime = BKE_scene_frame_get(scene);
121
122   DEG_debug_print_eval(depsgraph, __func__, ob->id.name, ob);
123
124   /* evaluate constraints stack */
125   /* TODO: split this into:
126    * - pre (i.e. BKE_constraints_make_evalob, per-constraint (i.e.
127    * - inner body of BKE_constraints_solve),
128    * - post (i.e. BKE_constraints_clear_evalob)
129    *
130    * Not sure why, this is from Joshua - sergey
131    *
132    */
133   cob = BKE_constraints_make_evalob(depsgraph, scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
134   BKE_constraints_solve(depsgraph, &ob->constraints, cob, ctime);
135   BKE_constraints_clear_evalob(cob);
136 }
137
138 void BKE_object_eval_transform_final(Depsgraph *depsgraph, Object *ob)
139 {
140   DEG_debug_print_eval(depsgraph, __func__, ob->id.name, ob);
141   /* Make sure inverse matrix is always up to date. This way users of it
142    * do not need to worry about relcalculating it. */
143   invert_m4_m4(ob->imat, ob->obmat);
144   /* Set negative scale flag in object. */
145   if (is_negative_m4(ob->obmat)) {
146     ob->transflag |= OB_NEG_SCALE;
147   }
148   else {
149     ob->transflag &= ~OB_NEG_SCALE;
150   }
151 }
152
153 void BKE_object_handle_data_update(Depsgraph *depsgraph, Scene *scene, Object *ob)
154 {
155   DEG_debug_print_eval(depsgraph, __func__, ob->id.name, ob);
156
157   /* includes all keys and modifiers */
158   switch (ob->type) {
159     case OB_MESH: {
160 #if 0
161       BMEditMesh *em = (ob->mode & OB_MODE_EDIT) ? BKE_editmesh_from_object(ob) : NULL;
162 #else
163       BMEditMesh *em = (ob->mode & OB_MODE_EDIT) ? ((Mesh *)ob->data)->edit_mesh : NULL;
164       if (em && em->ob != ob) {
165         em = NULL;
166       }
167 #endif
168
169       CustomData_MeshMasks cddata_masks = scene->customdata_mask;
170       CustomData_MeshMasks_update(&cddata_masks, &CD_MASK_BAREMESH);
171 #ifdef WITH_FREESTYLE
172       /* make sure Freestyle edge/face marks appear in DM for render (see T40315) */
173       if (DEG_get_mode(depsgraph) != DAG_EVAL_VIEWPORT) {
174         cddata_masks.emask |= CD_MASK_FREESTYLE_EDGE;
175         cddata_masks.pmask |= CD_MASK_FREESTYLE_FACE;
176       }
177 #endif
178       if (em) {
179         makeDerivedMesh(depsgraph, scene, ob, em, &cddata_masks); /* was CD_MASK_BAREMESH */
180       }
181       else {
182         makeDerivedMesh(depsgraph, scene, ob, NULL, &cddata_masks);
183       }
184       break;
185     }
186     case OB_ARMATURE:
187       if (ID_IS_LINKED(ob) && ob->proxy_from) {
188         if (BKE_pose_copy_result(ob->pose, ob->proxy_from->pose) == false) {
189           printf("Proxy copy error, lib Object: %s proxy Object: %s\n",
190                  ob->id.name + 2,
191                  ob->proxy_from->id.name + 2);
192         }
193       }
194       else {
195         BKE_pose_where_is(depsgraph, scene, ob);
196       }
197       break;
198
199     case OB_MBALL:
200       BKE_displist_make_mball(depsgraph, scene, ob);
201       break;
202
203     case OB_CURVE:
204     case OB_SURF:
205     case OB_FONT:
206       BKE_displist_make_curveTypes(depsgraph, scene, ob, false, false, NULL);
207       break;
208
209     case OB_LATTICE:
210       BKE_lattice_modifiers_calc(depsgraph, scene, ob);
211       break;
212   }
213
214   /* particles */
215   if (!(ob->mode & OB_MODE_EDIT) && ob->particlesystem.first) {
216     const bool use_render_params = (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER);
217     ParticleSystem *tpsys, *psys;
218     ob->transflag &= ~OB_DUPLIPARTS;
219     psys = ob->particlesystem.first;
220     while (psys) {
221       if (psys_check_enabled(ob, psys, use_render_params)) {
222         /* check use of dupli objects here */
223         if (psys->part && (psys->part->draw_as == PART_DRAW_REND || use_render_params) &&
224             ((psys->part->ren_as == PART_DRAW_OB && psys->part->instance_object) ||
225              (psys->part->ren_as == PART_DRAW_GR && psys->part->instance_collection))) {
226           ob->transflag |= OB_DUPLIPARTS;
227         }
228
229         particle_system_update(depsgraph, scene, ob, psys, use_render_params);
230         psys = psys->next;
231       }
232       else if (psys->flag & PSYS_DELETE) {
233         tpsys = psys->next;
234         BLI_remlink(&ob->particlesystem, psys);
235         psys_free(ob, psys);
236         psys = tpsys;
237       }
238       else {
239         psys = psys->next;
240       }
241     }
242   }
243   BKE_object_eval_boundbox(depsgraph, ob);
244 }
245
246 /**
247  * TODO(sergey): Ensure that bounding box is already calculated, and move this
248  * into #BKE_object_synchronize_to_original().
249  */
250 void BKE_object_eval_boundbox(Depsgraph *depsgraph, Object *object)
251 {
252   if (!DEG_is_active(depsgraph)) {
253     return;
254   }
255   Object *ob_orig = DEG_get_original_object(object);
256   BoundBox *bb = BKE_object_boundbox_get(object);
257   if (bb != NULL) {
258     if (ob_orig->runtime.bb == NULL) {
259       ob_orig->runtime.bb = MEM_mallocN(sizeof(*ob_orig->runtime.bb), __func__);
260     }
261     *ob_orig->runtime.bb = *bb;
262   }
263 }
264
265 void BKE_object_synchronize_to_original(Depsgraph *depsgraph, Object *object)
266 {
267   if (!DEG_is_active(depsgraph)) {
268     return;
269   }
270   Object *object_orig = DEG_get_original_object(object);
271   /* Base flags. */
272   object_orig->base_flag = object->base_flag;
273   /* Transformation flags. */
274   copy_m4_m4(object_orig->obmat, object->obmat);
275   copy_m4_m4(object_orig->imat, object->imat);
276   copy_m4_m4(object_orig->constinv, object->constinv);
277   object_orig->transflag = object->transflag;
278   object_orig->flag = object->flag;
279
280   /* Copy back error messages from modifiers. */
281   for (ModifierData *md = object->modifiers.first, *md_orig = object_orig->modifiers.first;
282        md != NULL && md_orig != NULL;
283        md = md->next, md_orig = md_orig->next) {
284     BLI_assert(md->type == md_orig->type && STREQ(md->name, md_orig->name));
285     MEM_SAFE_FREE(md_orig->error);
286     if (md->error != NULL) {
287       md_orig->error = BLI_strdup(md->error);
288     }
289   }
290 }
291
292 bool BKE_object_eval_proxy_copy(Depsgraph *depsgraph, Object *object)
293 {
294   /* Handle proxy copy for target, */
295   if (ID_IS_LINKED(object) && object->proxy_from) {
296     DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
297     if (object->proxy_from->proxy_group) {
298       /* Transform proxy into group space. */
299       Object *obg = object->proxy_from->proxy_group;
300       float imat[4][4];
301       invert_m4_m4(imat, obg->obmat);
302       mul_m4_m4m4(object->obmat, imat, object->proxy_from->obmat);
303       /* Should always be true. */
304       if (obg->instance_collection) {
305         add_v3_v3(object->obmat[3], obg->instance_collection->instance_offset);
306       }
307     }
308     else {
309       copy_m4_m4(object->obmat, object->proxy_from->obmat);
310     }
311     return true;
312   }
313   return false;
314 }
315
316 void BKE_object_eval_uber_transform(Depsgraph *depsgraph, Object *object)
317 {
318   BKE_object_eval_proxy_copy(depsgraph, object);
319 }
320
321 void BKE_object_batch_cache_dirty_tag(Object *ob)
322 {
323   switch (ob->type) {
324     case OB_MESH:
325       BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL);
326       break;
327     case OB_LATTICE:
328       BKE_lattice_batch_cache_dirty_tag(ob->data, BKE_LATTICE_BATCH_DIRTY_ALL);
329       break;
330     case OB_CURVE:
331     case OB_FONT:
332     case OB_SURF:
333       BKE_curve_batch_cache_dirty_tag(ob->data, BKE_CURVE_BATCH_DIRTY_ALL);
334       break;
335     case OB_MBALL:
336       BKE_mball_batch_cache_dirty_tag(ob->data, BKE_MBALL_BATCH_DIRTY_ALL);
337       break;
338     case OB_GPENCIL:
339       BKE_gpencil_batch_cache_dirty_tag(ob->data);
340       break;
341   }
342 }
343
344 void BKE_object_eval_uber_data(Depsgraph *depsgraph, Scene *scene, Object *ob)
345 {
346   DEG_debug_print_eval(depsgraph, __func__, ob->id.name, ob);
347   BLI_assert(ob->type != OB_ARMATURE);
348   BKE_object_handle_data_update(depsgraph, scene, ob);
349   BKE_object_batch_cache_dirty_tag(ob);
350 }
351
352 void BKE_object_eval_ptcache_reset(Depsgraph *depsgraph, Scene *scene, Object *object)
353 {
354   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
355   BKE_ptcache_object_reset(scene, object, PTCACHE_RESET_DEPSGRAPH);
356 }
357
358 void BKE_object_eval_transform_all(Depsgraph *depsgraph, Scene *scene, Object *object)
359 {
360   /* This mimics full transform update chain from new depsgraph. */
361   BKE_object_eval_local_transform(depsgraph, object);
362   if (object->parent != NULL) {
363     BKE_object_eval_parent(depsgraph, object);
364   }
365   if (!BLI_listbase_is_empty(&object->constraints)) {
366     BKE_object_eval_constraints(depsgraph, scene, object);
367   }
368   BKE_object_eval_uber_transform(depsgraph, object);
369   BKE_object_eval_transform_final(depsgraph, object);
370 }
371
372 void BKE_object_eval_update_shading(Depsgraph *depsgraph, Object *object)
373 {
374   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
375   if (object->type == OB_MESH) {
376     BKE_mesh_batch_cache_dirty_tag(object->data, BKE_MESH_BATCH_DIRTY_SHADING);
377   }
378 }
379
380 void BKE_object_data_select_update(Depsgraph *depsgraph, ID *object_data)
381 {
382   DEG_debug_print_eval(depsgraph, __func__, object_data->name, object_data);
383   switch (GS(object_data->name)) {
384     case ID_ME:
385       BKE_mesh_batch_cache_dirty_tag((Mesh *)object_data, BKE_MESH_BATCH_DIRTY_SELECT);
386       break;
387     case ID_CU:
388       BKE_curve_batch_cache_dirty_tag((Curve *)object_data, BKE_CURVE_BATCH_DIRTY_SELECT);
389       break;
390     case ID_LT:
391       BKE_lattice_batch_cache_dirty_tag((struct Lattice *)object_data,
392                                         BKE_LATTICE_BATCH_DIRTY_SELECT);
393       break;
394     default:
395       break;
396   }
397 }
398
399 void BKE_object_eval_eval_base_flags(Depsgraph *depsgraph,
400                                      Scene *scene,
401                                      const int view_layer_index,
402                                      Object *object,
403                                      int base_index,
404                                      const bool is_from_set)
405 {
406   /* TODO(sergey): Avoid list lookup. */
407   BLI_assert(view_layer_index >= 0);
408   ViewLayer *view_layer = BLI_findlink(&scene->view_layers, view_layer_index);
409   BLI_assert(view_layer != NULL);
410   BLI_assert(view_layer->object_bases_array != NULL);
411   BLI_assert(base_index >= 0);
412   BLI_assert(base_index < MEM_allocN_len(view_layer->object_bases_array) / sizeof(Base *));
413   Base *base = view_layer->object_bases_array[base_index];
414   BLI_assert(base->object == object);
415
416   DEG_debug_print_eval(depsgraph, __func__, object->id.name, object);
417
418   /* Set base flags based on collection and object restriction. */
419   BKE_base_eval_flags(base);
420
421   /* For render, compute base visibility again since BKE_base_eval_flags
422    * assumed viewport visibility. Selectability does not matter here. */
423   if (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER) {
424     if (base->flag & BASE_ENABLED_RENDER) {
425       base->flag |= BASE_VISIBLE;
426     }
427     else {
428       base->flag &= ~BASE_VISIBLE;
429     }
430   }
431
432   /* Copy flags and settings from base. */
433   object->base_flag = base->flag;
434   if (is_from_set) {
435     object->base_flag |= BASE_FROM_SET;
436     object->base_flag &= ~(BASE_SELECTED | BASE_SELECTABLE);
437   }
438   object->base_local_view_bits = base->local_view_bits;
439
440   if (object->mode == OB_MODE_PARTICLE_EDIT) {
441     for (ParticleSystem *psys = object->particlesystem.first; psys != NULL; psys = psys->next) {
442       BKE_particle_batch_cache_dirty_tag(psys, BKE_PARTICLE_BATCH_DIRTY_ALL);
443     }
444   }
445
446   /* Copy base flag back to the original view layer for editing. */
447   if (DEG_is_active(depsgraph) && (view_layer == DEG_get_evaluated_view_layer(depsgraph))) {
448     Base *base_orig = base->base_orig;
449     BLI_assert(base_orig != NULL);
450     BLI_assert(base_orig->object != NULL);
451     base_orig->flag = base->flag;
452   }
453 }