e74da2c5d2be9969b024d29311102c869218dd24
[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 static void initData(ModifierData *md)
51 {
52         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
53
54         mcmd->flag = 0;
55         mcmd->type = MOD_MESHCACHE_TYPE_MDD;
56         mcmd->interp = MOD_MESHCACHE_INTERP_LINEAR;
57         mcmd->frame_scale = 1.0f;
58
59         mcmd->factor = 1.0f;
60
61         /* (Y, Z). Blender default */
62         mcmd->forward_axis = 1;
63         mcmd->up_axis      = 2;
64 }
65
66 static void copyData(ModifierData *md, ModifierData *target)
67 {
68         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
69         MeshCacheModifierData *tmcmd = (MeshCacheModifierData *)target;
70
71         tmcmd->flag = mcmd->flag;
72         tmcmd->type = mcmd->type;
73
74         tmcmd->time_mode = mcmd->time_mode;
75         tmcmd->play_mode = mcmd->play_mode;
76
77         tmcmd->forward_axis = mcmd->forward_axis;
78         tmcmd->up_axis      = mcmd->up_axis;
79         tmcmd->flip_axis    = mcmd->flip_axis;
80
81         tmcmd->interp = mcmd->interp;
82
83         tmcmd->frame_start = mcmd->frame_start;
84         tmcmd->frame_scale = mcmd->frame_scale;
85
86         tmcmd->factor = mcmd->factor;
87
88         tmcmd->eval_frame  = mcmd->eval_frame;
89         tmcmd->eval_time   = mcmd->eval_time;
90         tmcmd->eval_factor = mcmd->eval_factor;
91
92         BLI_strncpy(tmcmd->filepath, mcmd->filepath, sizeof(tmcmd->filepath));
93 }
94
95 static int dependsOnTime(ModifierData *md)
96 {
97         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
98         return (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA);
99 }
100
101 static int isDisabled(ModifierData *md, int UNUSED(useRenderParams))
102 {
103         MeshCacheModifierData *mcmd = (MeshCacheModifierData *) md;
104
105         /* leave it up to the modifier to check the file is valid on calculation */
106         return (mcmd->factor <= 0.0f) || (mcmd->filepath[0] == '\0');
107 }
108
109
110 static void meshcache_do(
111         MeshCacheModifierData *mcmd, Object *ob, DerivedMesh *UNUSED(dm),
112         float (*vertexCos_Real)[3], int numVerts)
113 {
114         float (*vertexCos_Store)[3] = (mcmd->factor < 1.0f) ?
115                                       MEM_mallocN(sizeof(*vertexCos_Store) * numVerts, __func__) : NULL;
116         float (*vertexCos)[3] = vertexCos_Store ? vertexCos_Store : vertexCos_Real;
117
118         Scene *scene = mcmd->modifier.scene;
119         const float fps = FPS;
120
121         char filepath[FILE_MAX];
122         const char *err_str = NULL;
123         bool ok;
124
125         float time;
126
127
128         /* -------------------------------------------------------------------- */
129         /* Interpret Time (the reading functions also do some of this ) */
130         if (mcmd->play_mode == MOD_MESHCACHE_PLAY_CFEA) {
131                 const float cfra = BKE_scene_frame_get(scene);
132
133                 switch (mcmd->time_mode) {
134                         case MOD_MESHCACHE_TIME_FRAME:
135                         {
136                                 time = cfra;
137                                 break;
138                         }
139                         case MOD_MESHCACHE_TIME_SECONDS:
140                         {
141                                 time = cfra / fps;
142                                 break;
143                         }
144                         case MOD_MESHCACHE_TIME_FACTOR:
145                         default:
146                         {
147                                 time = cfra / fps;
148                                 break;
149                         }
150                 }
151
152                 /* apply offset and scale */
153                 time = (mcmd->frame_scale * time) - mcmd->frame_start;
154         }
155         else {  /*  if (mcmd->play_mode == MOD_MESHCACHE_PLAY_EVAL) { */
156                 switch (mcmd->time_mode) {
157                         case MOD_MESHCACHE_TIME_FRAME:
158                         {
159                                 time = mcmd->eval_frame;
160                                 break;
161                         }
162                         case MOD_MESHCACHE_TIME_SECONDS:
163                         {
164                                 time = mcmd->eval_time;
165                                 break;
166                         }
167                         case MOD_MESHCACHE_TIME_FACTOR:
168                         default:
169                         {
170                                 time = mcmd->eval_factor;
171                                 break;
172                         }
173                 }
174         }
175
176
177         /* -------------------------------------------------------------------- */
178         /* Read the File (or error out when the file is bad) */
179
180         /* would be nice if we could avoid doing this _every_ frame */
181         BLI_strncpy(filepath, mcmd->filepath, sizeof(filepath));
182         BLI_path_abs(filepath, ID_BLEND_PATH(G.main, (ID *)ob));
183
184         switch (mcmd->type) {
185                 case MOD_MESHCACHE_TYPE_MDD:
186                         ok = MOD_meshcache_read_mdd_times(filepath, vertexCos, numVerts,
187                                                           mcmd->interp, time, fps, mcmd->time_mode, &err_str);
188                         break;
189                 case MOD_MESHCACHE_TYPE_PC2:
190                         ok = MOD_meshcache_read_pc2_times(filepath, vertexCos, numVerts,
191                                                           mcmd->interp, time, fps, mcmd->time_mode, &err_str);
192                         break;
193                 default:
194                         ok = false;
195                         break;
196         }
197
198
199         /* -------------------------------------------------------------------- */
200         /* Apply the transformation matrix (if needed) */
201         if (UNLIKELY(err_str)) {
202                 modifier_setError(&mcmd->modifier, err_str);
203         }
204         else if (ok) {
205                 bool use_matrix = false;
206                 float mat[3][3];
207                 unit_m3(mat);
208
209                 if (mat3_from_axis_conversion(mcmd->forward_axis, mcmd->up_axis, 1, 2, mat)) {
210                         use_matrix = true;
211                 }
212
213                 if (mcmd->flip_axis) {
214                         float tmat[3][3];
215                         unit_m3(tmat);
216                         if (mcmd->flip_axis & (1 << 0)) tmat[0][0] = -1.0f;
217                         if (mcmd->flip_axis & (1 << 1)) tmat[1][1] = -1.0f;
218                         if (mcmd->flip_axis & (1 << 2)) tmat[2][2] = -1.0f;
219                         mul_m3_m3m3(mat, tmat, mat);
220
221                         use_matrix = true;
222                 }
223
224                 if (use_matrix) {
225                         int i;
226                         for (i = 0; i < numVerts; i++) {
227                                 mul_m3_v3(mat, vertexCos[i]);
228                         }
229                 }
230         }
231
232         if (vertexCos_Store) {
233                 if (ok) {
234                         interp_vn_vn(*vertexCos_Real, *vertexCos_Store, mcmd->factor, numVerts * 3);
235                 }
236
237                 MEM_freeN(vertexCos_Store);
238         }
239 }
240
241 static void deformVerts(ModifierData *md, Object *ob,
242                         DerivedMesh *derivedData,
243                         float (*vertexCos)[3],
244                         int numVerts,
245                         ModifierApplyFlag UNUSED(flag))
246 {
247         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
248
249         meshcache_do(mcmd, ob, derivedData, vertexCos, numVerts);
250 }
251
252 static void deformVertsEM(
253         ModifierData *md, Object *ob, struct BMEditMesh *UNUSED(editData),
254         DerivedMesh *derivedData, float (*vertexCos)[3], int numVerts)
255 {
256         MeshCacheModifierData *mcmd = (MeshCacheModifierData *)md;
257
258         meshcache_do(mcmd, ob, derivedData, vertexCos, numVerts);
259 }
260
261
262 ModifierTypeInfo modifierType_MeshCache = {
263         /* name */              "Mesh Cache",
264         /* structName */        "MeshCacheModifierData",
265         /* structSize */        sizeof(MeshCacheModifierData),
266         /* type */              eModifierTypeType_OnlyDeform,
267         /* flags */             eModifierTypeFlag_AcceptsCVs |
268                                 eModifierTypeFlag_SupportsEditmode,
269
270         /* copyData */          copyData,
271         /* deformVerts */       deformVerts,
272         /* deformMatrices */    NULL,
273         /* deformVertsEM */     deformVertsEM,
274         /* deformMatricesEM */  NULL,
275         /* applyModifier */     NULL,
276         /* applyModifierEM */   NULL,
277         /* initData */          initData,
278         /* requiredDataMask */  NULL,
279         /* freeData */          NULL,
280         /* isDisabled */        isDisabled,
281         /* updateDepgraph */    NULL,
282         /* dependsOnTime */     dependsOnTime,
283         /* dependsOnNormals */  NULL,
284         /* foreachObjectLink */ NULL,
285         /* foreachIDLink */     NULL,
286         /* foreachTexLink */    NULL,
287 };