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