Depsgraph: New dependency graph integration commit
[blender.git] / source / blender / modifiers / intern / MOD_meshcache.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  * Contributor(s): Campbell Barton
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/modifiers/intern/MOD_meshcache.c
24  *  \ingroup modifiers
25  */
26
27 #include <stdio.h>
28
29 #include "DNA_scene_types.h"
30 #include "DNA_object_types.h"
31 #include "DNA_mesh_types.h"
32 #include "DNA_meshdata_types.h"
33
34 #include "BLI_utildefines.h"
35 #include "BLI_string.h"
36 #include "BLI_path_util.h"
37 #include "BLI_math.h"
38
39 #include "BKE_DerivedMesh.h"
40 #include "BKE_scene.h"
41 #include "BKE_global.h"
42 #include "BKE_mesh.h"
43 #include "BKE_main.h"
44
45 #include "MEM_guardedalloc.h"
46
47 #include "MOD_meshcache_util.h"  /* utility functions */
48
49 #include "MOD_modifiertypes.h"
50
51 static void initData(ModifierData *md)
52 {
53         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
54
55         mcmd->flag = 0;
56         mcmd->type = MOD_MESHCACHE_TYPE_MDD;
57         mcmd->interp = MOD_MESHCACHE_INTERP_LINEAR;
58         mcmd->frame_scale = 1.0f;
59
60         mcmd->factor = 1.0f;
61
62         /* (Y, Z). Blender default */
63         mcmd->forward_axis = 1;
64         mcmd->up_axis      = 2;
65 }
66
67 static void copyData(ModifierData *md, ModifierData *target)
68 {
69 #if 0
70         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
71         MeshCacheModifierData *tmcmd = (MeshCacheModifierData *)target;
72 #endif
73         modifier_copyData_generic(md, target);
74 }
75
76 static bool dependsOnTime(ModifierData *md)
77 {
78         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
79         return (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA);
80 }
81
82 static bool isDisabled(ModifierData *md, int UNUSED(useRenderParams))
83 {
84         MeshCacheModifierData *mcmd = (MeshCacheModifierData *) md;
85
86         /* leave it up to the modifier to check the file is valid on calculation */
87         return (mcmd->factor <= 0.0f) || (mcmd->filepath[0] == '\0');
88 }
89
90
91 static void meshcache_do(
92         MeshCacheModifierData *mcmd, Object *ob, DerivedMesh *UNUSED(dm),
93         float (*vertexCos_Real)[3], int numVerts)
94 {
95         const bool use_factor = mcmd->factor < 1.0f;
96         float (*vertexCos_Store)[3] = (use_factor || (mcmd->deform_mode == MOD_MESHCACHE_DEFORM_INTEGRATE)) ?
97                                       MEM_mallocN(sizeof(*vertexCos_Store) * numVerts, __func__) : NULL;
98         float (*vertexCos)[3] = vertexCos_Store ? vertexCos_Store : vertexCos_Real;
99
100         Scene *scene = mcmd->modifier.scene;
101         const float fps = FPS;
102
103         char filepath[FILE_MAX];
104         const char *err_str = NULL;
105         bool ok;
106
107         float time;
108
109
110         /* -------------------------------------------------------------------- */
111         /* Interpret Time (the reading functions also do some of this ) */
112         if (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA) {
113                 const float cfra = BKE_scene_frame_get(scene);
114
115                 switch (mcmd->time_mode) {
116                         case MOD_MESHCACHE_TIME_FRAME:
117                         {
118                                 time = cfra;
119                                 break;
120                         }
121                         case MOD_MESHCACHE_TIME_SECONDS:
122                         {
123                                 time = cfra / fps;
124                                 break;
125                         }
126                         case MOD_MESHCACHE_TIME_FACTOR:
127                         default:
128                         {
129                                 time = cfra / fps;
130                                 break;
131                         }
132                 }
133
134                 /* apply offset and scale */
135                 time = (mcmd->frame_scale * time) - mcmd->frame_start;
136         }
137         else {  /*  if (mcmd->play_mode == MOD_MESHCACHE_PLAY_EVAL) { */
138                 switch (mcmd->time_mode) {
139                         case MOD_MESHCACHE_TIME_FRAME:
140                         {
141                                 time = mcmd->eval_frame;
142                                 break;
143                         }
144                         case MOD_MESHCACHE_TIME_SECONDS:
145                         {
146                                 time = mcmd->eval_time;
147                                 break;
148                         }
149                         case MOD_MESHCACHE_TIME_FACTOR:
150                         default:
151                         {
152                                 time = mcmd->eval_factor;
153                                 break;
154                         }
155                 }
156         }
157
158
159         /* -------------------------------------------------------------------- */
160         /* Read the File (or error out when the file is bad) */
161
162         /* would be nice if we could avoid doing this _every_ frame */
163         BLI_strncpy(filepath, mcmd->filepath, sizeof(filepath));
164         BLI_path_abs(filepath, ID_BLEND_PATH(G.main, (ID *)ob));
165
166         switch (mcmd->type) {
167                 case MOD_MESHCACHE_TYPE_MDD:
168                         ok = MOD_meshcache_read_mdd_times(filepath, vertexCos, numVerts,
169                                                           mcmd->interp, time, fps, mcmd->time_mode, &err_str);
170                         break;
171                 case MOD_MESHCACHE_TYPE_PC2:
172                         ok = MOD_meshcache_read_pc2_times(filepath, vertexCos, numVerts,
173                                                           mcmd->interp, time, fps, mcmd->time_mode, &err_str);
174                         break;
175                 default:
176                         ok = false;
177                         break;
178         }
179
180
181         /* -------------------------------------------------------------------- */
182         /* tricky shape key integration (slow!) */
183         if (mcmd->deform_mode == MOD_MESHCACHE_DEFORM_INTEGRATE) {
184                 Mesh *me = ob->data;
185
186                 /* we could support any object type */
187                 if (UNLIKELY(ob->type != OB_MESH)) {
188                         modifier_setError(&mcmd->modifier, "'Integrate' only valid for Mesh objects");
189                 }
190                 else if (UNLIKELY(me->totvert != numVerts)) {
191                         modifier_setError(&mcmd->modifier, "'Integrate' original mesh vertex mismatch");
192                 }
193                 else if (UNLIKELY(me->totpoly == 0)) {
194                         modifier_setError(&mcmd->modifier, "'Integrate' requires faces");
195                 }
196                 else {
197                         /* the moons align! */
198                         int i;
199
200                         float (*vertexCos_Source)[3] = MEM_mallocN(sizeof(*vertexCos_Source) * numVerts, __func__);
201                         float (*vertexCos_New)[3]    = MEM_mallocN(sizeof(*vertexCos_New) * numVerts, __func__);
202                         MVert *mv = me->mvert;
203
204                         for (i = 0; i < numVerts; i++, mv++) {
205                                 copy_v3_v3(vertexCos_Source[i], mv->co);
206                         }
207
208                         BKE_mesh_calc_relative_deform(
209                                 me->mpoly, me->totpoly,
210                                 me->mloop, me->totvert,
211
212                                 (const float (*)[3])vertexCos_Source,   /* from the original Mesh*/
213                                 (const float (*)[3])vertexCos_Real,     /* the input we've been given (shape keys!) */
214
215                                 (const float (*)[3])vertexCos,          /* the result of this modifier */
216                                 vertexCos_New                           /* the result of this function */
217                                 );
218
219                         /* write the corrected locations back into the result */
220                         memcpy(vertexCos, vertexCos_New, sizeof(*vertexCos) * numVerts);
221
222                         MEM_freeN(vertexCos_Source);
223                         MEM_freeN(vertexCos_New);
224                 }
225         }
226
227
228         /* -------------------------------------------------------------------- */
229         /* Apply the transformation matrix (if needed) */
230         if (UNLIKELY(err_str)) {
231                 modifier_setError(&mcmd->modifier, "%s", err_str);
232         }
233         else if (ok) {
234                 bool use_matrix = false;
235                 float mat[3][3];
236                 unit_m3(mat);
237
238                 if (mat3_from_axis_conversion(mcmd->forward_axis, mcmd->up_axis, 1, 2, mat)) {
239                         use_matrix = true;
240                 }
241
242                 if (mcmd->flip_axis) {
243                         float tmat[3][3];
244                         unit_m3(tmat);
245                         if (mcmd->flip_axis & (1 << 0)) tmat[0][0] = -1.0f;
246                         if (mcmd->flip_axis & (1 << 1)) tmat[1][1] = -1.0f;
247                         if (mcmd->flip_axis & (1 << 2)) tmat[2][2] = -1.0f;
248                         mul_m3_m3m3(mat, tmat, mat);
249
250                         use_matrix = true;
251                 }
252
253                 if (use_matrix) {
254                         int i;
255                         for (i = 0; i < numVerts; i++) {
256                                 mul_m3_v3(mat, vertexCos[i]);
257                         }
258                 }
259         }
260
261         if (vertexCos_Store) {
262                 if (ok) {
263                         if (use_factor) {
264                                 interp_vn_vn(*vertexCos_Real, *vertexCos_Store, mcmd->factor, numVerts * 3);
265                         }
266                         else {
267                                 memcpy(vertexCos_Real, vertexCos_Store, sizeof(*vertexCos_Store) * numVerts);
268                         }
269                 }
270
271                 MEM_freeN(vertexCos_Store);
272         }
273 }
274
275 static void deformVerts(ModifierData *md, Object *ob,
276                         DerivedMesh *derivedData,
277                         float (*vertexCos)[3],
278                         int numVerts,
279                         ModifierApplyFlag UNUSED(flag))
280 {
281         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
282
283         meshcache_do(mcmd, ob, derivedData, vertexCos, numVerts);
284 }
285
286 static void deformVertsEM(
287         ModifierData *md, Object *ob, struct BMEditMesh *UNUSED(editData),
288         DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
289 {
290         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
291
292         meshcache_do(mcmd, ob, derivedData, vertexCos, numVerts);
293 }
294
295
296 ModifierTypeInfo modifierType_MeshCache = {
297         /* name */              "Mesh Cache",
298         /* structName */        "MeshCacheModifierData",
299         /* structSize */        sizeof(MeshCacheModifierData),
300         /* type */              eModifierTypeType_OnlyDeform,
301         /* flags */             eModifierTypeFlag_AcceptsCVs |
302                                 eModifierTypeFlag_SupportsEditmode,
303
304         /* copyData */          copyData,
305         /* deformVerts */       deformVerts,
306         /* deformMatrices */    NULL,
307         /* deformVertsEM */     deformVertsEM,
308         /* deformMatricesEM */  NULL,
309         /* applyModifier */     NULL,
310         /* applyModifierEM */   NULL,
311         /* initData */          initData,
312         /* requiredDataMask */  NULL,
313         /* freeData */          NULL,
314         /* isDisabled */        isDisabled,
315         /* updateDepgraph */    NULL,
316         /* updateDepsgraph */   NULL,
317         /* dependsOnTime */     dependsOnTime,
318         /* dependsOnNormals */  NULL,
319         /* foreachObjectLink */ NULL,
320         /* foreachIDLink */     NULL,
321         /* foreachTexLink */    NULL,
322 };