Fix T51701: Alembic cache screws up mesh.
[blender.git] / source / blender / modifiers / intern / MOD_meshsequencecache.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_meshsequencecache.c
24  *  \ingroup modifiers
25  */
26
27 #include "DNA_cachefile_types.h"
28 #include "DNA_mesh_types.h"
29 #include "DNA_modifier_types.h"
30 #include "DNA_object_types.h"
31 #include "DNA_scene_types.h"
32
33 #include "BKE_cachefile.h"
34 #include "BKE_DerivedMesh.h"
35 #include "BKE_cdderivedmesh.h"
36 #include "BKE_global.h"
37 #include "BKE_library.h"
38 #include "BKE_library_query.h"
39 #include "BKE_scene.h"
40
41 #include "depsgraph_private.h"
42 #include "DEG_depsgraph_build.h"
43
44 #include "MOD_modifiertypes.h"
45
46 #ifdef WITH_ALEMBIC
47 #       include "ABC_alembic.h"
48 #endif
49
50 static void initData(ModifierData *md)
51 {
52         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
53
54         mcmd->cache_file = NULL;
55         mcmd->object_path[0] = '\0';
56         mcmd->read_flag = MOD_MESHSEQ_READ_ALL;
57 }
58
59 static void copyData(ModifierData *md, ModifierData *target)
60 {
61 #if 0
62         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
63 #endif
64         MeshSeqCacheModifierData *tmcmd = (MeshSeqCacheModifierData *)target;
65
66         modifier_copyData_generic(md, target);
67
68         if (tmcmd->cache_file) {
69                 id_us_plus(&tmcmd->cache_file->id);
70                 tmcmd->reader = NULL;
71         }
72 }
73
74 static void freeData(ModifierData *md)
75 {
76         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
77
78         if (mcmd->cache_file) {
79                 id_us_min(&mcmd->cache_file->id);
80         }
81
82         if (mcmd->reader) {
83 #ifdef WITH_ALEMBIC
84                 CacheReader_free(mcmd->reader);
85 #endif
86                 mcmd->reader = NULL;
87         }
88 }
89
90 static bool isDisabled(ModifierData *md, int UNUSED(useRenderParams))
91 {
92         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
93
94         /* leave it up to the modifier to check the file is valid on calculation */
95         return (mcmd->cache_file == NULL) || (mcmd->object_path[0] == '\0');
96 }
97
98 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
99                                   DerivedMesh *dm,
100                                   ModifierApplyFlag UNUSED(flag))
101 {
102 #ifdef WITH_ALEMBIC
103         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
104
105         /* Only used to check wehther we are operating on org data or not... */
106         Mesh *me = (ob->type == OB_MESH) ? ob->data : NULL;
107         DerivedMesh *org_dm = dm;
108
109         Scene *scene = md->scene;
110         const float frame = BKE_scene_frame_get(scene);
111         const float time = BKE_cachefile_time_offset(mcmd->cache_file, frame, FPS);
112
113         const char *err_str = NULL;
114
115         CacheFile *cache_file = mcmd->cache_file;
116
117         BKE_cachefile_ensure_handle(G.main, cache_file);
118
119         if (!mcmd->reader) {
120                 mcmd->reader = CacheReader_open_alembic_object(cache_file->handle,
121                                                                NULL,
122                                                                ob,
123                                                                mcmd->object_path);
124                 if (!mcmd->reader) {
125                         modifier_setError(md, "Could not create Alembic reader for file %s", cache_file->filepath);
126                         return dm;
127                 }
128         }
129
130         if (me != NULL) {
131                 MVert *mvert = dm->getVertArray(dm);
132                 MEdge *medge = dm->getEdgeArray(dm);
133                 MPoly *mpoly = dm->getPolyArray(dm);
134                 if ((me->mvert == mvert) || (me->medge == medge) || (me->mpoly == mpoly)) {
135                         /* We need to duplicate data here, otherwise we'll modify org mesh, see T51701. */
136                         dm = CDDM_copy(dm);
137                 }
138         }
139
140         DerivedMesh *result = ABC_read_mesh(mcmd->reader,
141                                             ob,
142                                             dm,
143                                             time,
144                                             &err_str,
145                                             mcmd->read_flag);
146
147         if (err_str) {
148                 modifier_setError(md, "%s", err_str);
149         }
150
151         if (!ELEM(result, NULL, dm) && (dm != org_dm)) {
152                 dm->release(dm);
153                 dm = org_dm;
154         }
155
156         return result ? result : dm;
157 #else
158         return dm;
159         UNUSED_VARS(md, ob);
160 #endif
161 }
162
163 static bool dependsOnTime(ModifierData *md)
164 {
165         UNUSED_VARS(md);
166         return true;
167 }
168
169 static void foreachIDLink(ModifierData *md, Object *ob,
170                           IDWalkFunc walk, void *userData)
171 {
172         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
173
174         walk(userData, ob, (ID **)&mcmd->cache_file, IDWALK_CB_USER);
175 }
176
177
178 static void updateDepgraph(ModifierData *md, DagForest *forest,
179                            struct Main *bmain,
180                            struct Scene *scene,
181                            Object *ob, DagNode *obNode)
182 {
183         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
184
185         if (mcmd->cache_file != NULL) {
186                 DagNode *curNode = dag_get_node(forest, mcmd->cache_file);
187
188                 dag_add_relation(forest, curNode, obNode,
189                                  DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Cache File Modifier");
190         }
191
192         UNUSED_VARS(bmain, scene, ob);
193 }
194
195 static void updateDepsgraph(ModifierData *md,
196                             struct Main *bmain,
197                             struct Scene *scene,
198                             Object *ob,
199                             struct DepsNodeHandle *node)
200 {
201         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
202
203         if (mcmd->cache_file != NULL) {
204                 DEG_add_object_cache_relation(node, mcmd->cache_file, DEG_OB_COMP_CACHE, "Mesh Cache File");
205         }
206
207         UNUSED_VARS(bmain, scene, ob);
208 }
209
210 ModifierTypeInfo modifierType_MeshSequenceCache = {
211     /* name */              "Mesh Sequence Cache",
212     /* structName */        "MeshSeqCacheModifierData",
213     /* structSize */        sizeof(MeshSeqCacheModifierData),
214     /* type */              eModifierTypeType_Constructive,
215     /* flags */             eModifierTypeFlag_AcceptsMesh |
216                             eModifierTypeFlag_AcceptsCVs,
217     /* copyData */          copyData,
218     /* deformVerts */       NULL,
219     /* deformMatrices */    NULL,
220     /* deformVertsEM */     NULL,
221     /* deformMatricesEM */  NULL,
222     /* applyModifier */     applyModifier,
223     /* applyModifierEM */   NULL,
224     /* initData */          initData,
225     /* requiredDataMask */  NULL,
226     /* freeData */          freeData,
227     /* isDisabled */        isDisabled,
228     /* updateDepgraph */    updateDepgraph,
229     /* updateDepsgraph */   updateDepsgraph,
230     /* dependsOnTime */     dependsOnTime,
231     /* dependsOnNormals */  NULL,
232     /* foreachObjectLink */ NULL,
233     /* foreachIDLink */     foreachIDLink,
234     /* foreachTexLink */    NULL,
235 };