add an influence slider to mesh cache.
[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
32 #include "BLI_utildefines.h"
33 #include "BLI_string.h"
34 #include "BLI_path_util.h"
35 #include "BLI_math.h"
36
37 #include "BKE_DerivedMesh.h"
38 #include "BKE_scene.h"
39 #include "BKE_global.h"
40 #include "BKE_main.h"
41
42 #include "MEM_guardedalloc.h"
43
44 #include "MOD_meshcache_util.h"  /* utility functions */
45
46 #include "MOD_modifiertypes.h"
47
48 #include "MOD_util.h"
49
50 /* -------------------------------------------------------------------- */
51 /* Utility function shared by formats */
52 void MOD_meshcache_calc_range(const float frame, const char interp,
53                               const int frame_tot,
54                               int r_index_range[2], float *r_factor)
55 {
56         if (interp == MOD_MESHCACHE_INTERP_NONE) {
57                 r_index_range[0] = r_index_range[1] = max_ii(0, min_ii(frame_tot - 1, (int)(floorf(frame) + 0.5f)));
58                 *r_factor = 1.0f; /* dummy */
59         }
60         else {
61                 const float tframe = floorf(frame);
62                 const float range  = frame - tframe;
63                 r_index_range[0] = (int)tframe;
64                 if (range <= FRAME_SNAP_EPS) {
65                         /* we're close enough not to need blending */
66                         r_index_range[1] = r_index_range[0];
67                         *r_factor = 1.0f; /* dummy */
68                 }
69                 else {
70                         /* blend between 2 frames */
71                         r_index_range[1] = r_index_range[0] + 1;
72                         *r_factor = range;
73                 }
74
75                 /* clamp */
76                 if ((r_index_range[0] >= frame_tot) ||
77                     (r_index_range[1] >= frame_tot))
78                 {
79                         r_index_range[0] = r_index_range[1] = frame_tot - 1;
80                         *r_factor = 1.0f; /* dummy */
81                 }
82                 else if ((r_index_range[0] < 0) ||
83                          (r_index_range[1] < 0))
84                 {
85                         r_index_range[0] = r_index_range[1] = 0;
86                         *r_factor = 1.0f; /* dummy */
87                 }
88         }
89 }
90
91
92 /* -------------------------------------------------------------------- */
93
94 static void initData(ModifierData *md)
95 {
96         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
97
98         mcmd->flag = 0;
99         mcmd->type = MOD_MESHCACHE_TYPE_MDD;
100         mcmd->interp = MOD_MESHCACHE_INTERP_LINEAR;
101         mcmd->frame_scale = 1.0f;
102
103         mcmd->factor = 1.0f;
104
105         /* (Y, Z). Blender default */
106         mcmd->forward_axis = 1;
107         mcmd->up_axis      = 2;
108 }
109
110 static void copyData(ModifierData *md, ModifierData *target)
111 {
112         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
113         MeshCacheModifierData *tmcmd = (MeshCacheModifierData *)target;
114
115         tmcmd->flag = mcmd->flag;
116         tmcmd->type = mcmd->type;
117
118         tmcmd->time_mode = mcmd->time_mode;
119         tmcmd->play_mode = mcmd->play_mode;
120
121         tmcmd->forward_axis = mcmd->forward_axis;
122         tmcmd->up_axis      = mcmd->up_axis;
123         tmcmd->flip_axis    = mcmd->flip_axis;
124
125         tmcmd->interp = mcmd->interp;
126
127         tmcmd->frame_start = mcmd->frame_start;
128         tmcmd->frame_scale = mcmd->frame_scale;
129
130         tmcmd->factor = mcmd->factor;
131
132         tmcmd->eval_frame  = mcmd->eval_frame;
133         tmcmd->eval_time   = mcmd->eval_time;
134         tmcmd->eval_factor = mcmd->eval_factor;
135
136         BLI_strncpy(tmcmd->filepath, mcmd->filepath, sizeof(tmcmd->filepath));
137 }
138
139 static int dependsOnTime(ModifierData *md)
140 {
141         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
142         return (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA);
143 }
144
145 static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
146 {
147         MeshCacheModifierData *mcmd = (MeshCacheModifierData *) md;
148
149         /* leave it up to the modifier to check the file is valid on calculation */
150         return (mcmd->factor <= 0.0f) || (mcmd->filepath[0] == '\0');
151 }
152
153
154 static void meshcache_do(
155         MeshCacheModifierData *mcmd, Object *ob, DerivedMesh *UNUSED(dm),
156         float (*vertexCos_)[3], int numVerts)
157 {
158         float (*vertexCos_Store)[3] = (mcmd->factor < 1.0f) ?
159                                       MEM_mallocN(sizeof(*vertexCos_Store) * numVerts, __func__) : NULL;
160         float (*vertexCos_Real)[3] = vertexCos_;
161         float (*vertexCos)[3] = vertexCos_Store ? vertexCos_Store : vertexCos_Real;
162
163         Scene *scene = mcmd->modifier.scene;
164         const float fps = FPS;
165
166         char filepath[FILE_MAX];
167         const char *err_str = NULL;
168         bool ok;
169
170         float time;
171
172
173         /* -------------------------------------------------------------------- */
174         /* Interpret Time (the reading functions also do some of this ) */
175         if (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA) {
176                 const float cfra = BKE_scene_frame_get(scene);
177
178                 switch (mcmd->time_mode) {
179                         case MOD_MESHCACHE_TIME_FRAME:
180                         {
181                                 time = cfra;
182                                 break;
183                         }
184                         case MOD_MESHCACHE_TIME_SECONDS:
185                         {
186                                 time = cfra / fps;
187                                 break;
188                         }
189                         case MOD_MESHCACHE_TIME_FACTOR:
190                         default:
191                         {
192                                 time = cfra / fps;
193                                 break;
194                         }
195                 }
196
197                 /* apply offset and scale */
198                 time = (mcmd->frame_scale * time) - mcmd->frame_start;
199         }
200         else {  /*  if (mcmd->play_mode == MOD_MESHCACHE_PLAY_EVAL) { */
201                 switch (mcmd->time_mode) {
202                         case MOD_MESHCACHE_TIME_FRAME:
203                         {
204                                 time = mcmd->eval_frame;
205                                 break;
206                         }
207                         case MOD_MESHCACHE_TIME_SECONDS:
208                         {
209                                 time = mcmd->eval_time;
210                                 break;
211                         }
212                         case MOD_MESHCACHE_TIME_FACTOR:
213                         default:
214                         {
215                                 time = mcmd->eval_factor;
216                                 break;
217                         }
218                 }
219         }
220
221
222         /* -------------------------------------------------------------------- */
223         /* Read the File (or error out when the file is bad) */
224
225         /* would be nice if we could avoid doing this _every_ frame */
226         BLI_strncpy(filepath, mcmd->filepath, sizeof(filepath));
227         BLI_path_abs(filepath, ID_BLEND_PATH(G.main, (ID *)ob));
228
229         switch (mcmd->type) {
230                 case MOD_MESHCACHE_TYPE_MDD:
231                         ok = MOD_meshcache_read_mdd_times(filepath, vertexCos, numVerts,
232                                                           mcmd->interp, time, fps, mcmd->time_mode, &err_str);
233                         break;
234                 case MOD_MESHCACHE_TYPE_PC2:
235                         ok = MOD_meshcache_read_pc2_times(filepath, vertexCos, numVerts,
236                                                           mcmd->interp, time, fps, mcmd->time_mode, &err_str);
237                         break;
238                 default:
239                         ok = false;
240                         break;
241         }
242
243
244         /* -------------------------------------------------------------------- */
245         /* Apply the transformation matrix (if needed) */
246         if (UNLIKELY(err_str)) {
247                 modifier_setError(&mcmd->modifier, err_str);
248         }
249         else if (ok) {
250                 bool use_matrix = false;
251                 float mat[3][3];
252                 unit_m3(mat);
253
254                 if (mat3_from_axis_conversion(mcmd->forward_axis, mcmd->up_axis, 1, 2, mat)) {
255                         use_matrix = true;
256                 }
257
258                 if (mcmd->flip_axis) {
259                         float tmat[3][3];
260                         unit_m3(tmat);
261                         if (mcmd->flip_axis & (1 << 0)) tmat[0][0] = -1.0f;
262                         if (mcmd->flip_axis & (1 << 1)) tmat[1][1] = -1.0f;
263                         if (mcmd->flip_axis & (1 << 2)) tmat[2][2] = -1.0f;
264                         mul_m3_m3m3(mat, tmat, mat);
265
266                         use_matrix = true;
267                 }
268
269                 if (use_matrix) {
270                         int i;
271                         for (i = 0; i < numVerts; i++) {
272                                 mul_m3_v3(mat, vertexCos[i]);
273                         }
274                 }
275         }
276
277         if (vertexCos_Store) {
278                 if (ok) {
279                         interp_vn_vn(*vertexCos_Real, *vertexCos_Store, mcmd->factor, numVerts * 3);
280                 }
281
282                 MEM_freeN(vertexCos_Store);
283         }
284 }
285
286 static void deformVerts(ModifierData *md, Object *ob,
287                         DerivedMesh *derivedData,
288                         float (*vertexCos)[3],
289                         int numVerts,
290                         ModifierApplyFlag UNUSED(flag))
291 {
292         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
293
294         meshcache_do(mcmd, ob, derivedData, vertexCos, numVerts);
295 }
296
297 static void deformVertsEM(
298         ModifierData *md, Object *ob, struct BMEditMesh *UNUSED(editData),
299         DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
300 {
301         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
302
303         meshcache_do(mcmd, ob, derivedData, vertexCos, numVerts);
304 }
305
306
307 ModifierTypeInfo modifierType_MeshCache = {
308         /* name */              "Mesh Cache",
309         /* structName */        "MeshCacheModifierData",
310         /* structSize */        sizeof(MeshCacheModifierData),
311         /* type */              eModifierTypeType_OnlyDeform,
312         /* flags */             eModifierTypeFlag_AcceptsCVs |
313                                 eModifierTypeFlag_SupportsEditmode,
314
315         /* copyData */          copyData,
316         /* deformVerts */       deformVerts,
317         /* deformMatrices */    NULL,
318         /* deformVertsEM */     deformVertsEM,
319         /* deformMatricesEM */  NULL,
320         /* applyModifier */     NULL,
321         /* applyModifierEM */   NULL,
322         /* initData */          initData,
323         /* requiredDataMask */  NULL,
324         /* freeData */          NULL,
325         /* isDisabled */        isDisabled,
326         /* updateDepgraph */    NULL,
327         /* dependsOnTime */     dependsOnTime,
328         /* dependsOnNormals */  NULL,
329         /* foreachObjectLink */ NULL,
330         /* foreachIDLink */     NULL,
331         /* foreachTexLink */    NULL,
332 };