Alembic import: port DerivedMesh → 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_cdderivedmesh.h"
35 #include "BKE_library.h"
36 #include "BKE_library_query.h"
37 #include "BKE_scene.h"
38
39 #include "DEG_depsgraph_build.h"
40 #include "DEG_depsgraph_query.h"
41
42 #include "MOD_modifiertypes.h"
43
44 #ifdef WITH_ALEMBIC
45 #       include "ABC_alembic.h"
46 #       include "BKE_global.h"
47 #endif
48
49 static void initData(ModifierData *md)
50 {
51         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
52
53         mcmd->cache_file = NULL;
54         mcmd->object_path[0] = '\0';
55         mcmd->read_flag = MOD_MESHSEQ_READ_ALL;
56 }
57
58 static void copyData(const ModifierData *md, ModifierData *target)
59 {
60 #if 0
61         const MeshSeqCacheModifierData *mcmd = (const MeshSeqCacheModifierData *)md;
62 #endif
63         MeshSeqCacheModifierData *tmcmd = (MeshSeqCacheModifierData *)target;
64
65         modifier_copyData_generic(md, target);
66
67         tmcmd->reader = NULL;
68 }
69
70 static void freeData(ModifierData *md)
71 {
72         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
73
74         if (mcmd->reader) {
75 #ifdef WITH_ALEMBIC
76                 CacheReader_free(mcmd->reader);
77 #endif
78                 mcmd->reader = NULL;
79         }
80 }
81
82 static bool isDisabled(ModifierData *md, int UNUSED(useRenderParams))
83 {
84         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
85
86         /* leave it up to the modifier to check the file is valid on calculation */
87         return (mcmd->cache_file == NULL) || (mcmd->object_path[0] == '\0');
88 }
89
90 static Mesh *applyModifier(
91         ModifierData *md, const ModifierEvalContext *ctx,
92         Mesh *mesh)
93 {
94 #ifdef WITH_ALEMBIC
95         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
96
97         /* Only used to check whether we are operating on org data or not... */
98         Mesh *me = (ctx->object->type == OB_MESH) ? ctx->object->data : NULL;
99         Mesh *org_mesh = mesh;
100
101         Scene *scene = md->scene; /* for FPS macro */
102         const float frame = DEG_get_ctime(ctx->depsgraph);
103         const float time = BKE_cachefile_time_offset(mcmd->cache_file, frame, FPS);
104         const char *err_str = NULL;
105
106         CacheFile *cache_file = mcmd->cache_file;
107
108         BKE_cachefile_ensure_handle(G.main, cache_file);
109
110         if (!mcmd->reader) {
111                 mcmd->reader = CacheReader_open_alembic_object(cache_file->handle,
112                                                                NULL,
113                                                                ctx->object,
114                                                                mcmd->object_path);
115                 if (!mcmd->reader) {
116                         modifier_setError(md, "Could not create Alembic reader for file %s", cache_file->filepath);
117                         return mesh;
118                 }
119         }
120
121         if (me != NULL) {
122                 MVert *mvert = mesh->mvert;
123                 MEdge *medge = mesh->medge;
124                 MPoly *mpoly = mesh->mpoly;
125                 if ((me->mvert == mvert) || (me->medge == medge) || (me->mpoly == mpoly)) {
126                         /* We need to duplicate data here, otherwise we'll modify org mesh, see T51701. */
127                         BKE_id_copy_ex(NULL, &mesh->id, (ID **)&mesh,
128                                        LIB_ID_CREATE_NO_MAIN |
129                                        LIB_ID_CREATE_NO_USER_REFCOUNT |
130                                        LIB_ID_CREATE_NO_DEG_TAG |
131                                        LIB_ID_COPY_NO_PREVIEW,
132                                        false);
133                 }
134         }
135
136         Mesh *result = ABC_read_mesh(mcmd->reader,
137                                      ctx->object,
138                                      mesh,
139                                      time,
140                                      &err_str,
141                                      mcmd->read_flag);
142
143         if (err_str) {
144                 modifier_setError(md, "%s", err_str);
145         }
146
147         if (!ELEM(result, NULL, mesh) && (mesh != org_mesh)) {
148                 BKE_id_free(NULL, mesh);
149                 mesh = org_mesh;
150         }
151
152         return result ? result : mesh;
153 #else
154         return mesh;
155         UNUSED_VARS(ctx, md);
156 #endif
157 }
158
159 static bool dependsOnTime(ModifierData *md)
160 {
161         UNUSED_VARS(md);
162         return true;
163 }
164
165 static void foreachIDLink(
166         ModifierData *md, Object *ob,
167         IDWalkFunc walk, void *userData)
168 {
169         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
170
171         walk(userData, ob, (ID **)&mcmd->cache_file, IDWALK_CB_USER);
172 }
173
174
175 static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
176 {
177         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *) md;
178
179         if (mcmd->cache_file != NULL) {
180                 DEG_add_object_cache_relation(ctx->node, mcmd->cache_file, DEG_OB_COMP_CACHE, "Mesh Cache File");
181         }
182 }
183
184 ModifierTypeInfo modifierType_MeshSequenceCache = {
185         /* name */              "Mesh Sequence Cache",
186         /* structName */        "MeshSeqCacheModifierData",
187         /* structSize */        sizeof(MeshSeqCacheModifierData),
188         /* type */              eModifierTypeType_Constructive,
189         /* flags */             eModifierTypeFlag_AcceptsMesh |
190                                 eModifierTypeFlag_AcceptsCVs,
191
192         /* copyData */          copyData,
193
194         /* deformVerts_DM */    NULL,
195         /* deformMatrices_DM */ NULL,
196         /* deformVertsEM_DM */  NULL,
197         /* deformMatricesEM_DM*/NULL,
198         /* applyModifier_DM */  NULL,
199         /* applyModifierEM_DM */NULL,
200
201         /* deformVerts */       NULL,
202         /* deformMatrices */    NULL,
203         /* deformVertsEM */     NULL,
204         /* deformMatricesEM */  NULL,
205         /* applyModifier */     applyModifier,
206         /* applyModifierEM */   NULL,
207
208         /* initData */          initData,
209         /* requiredDataMask */  NULL,
210         /* freeData */          freeData,
211         /* isDisabled */        isDisabled,
212         /* updateDepsgraph */   updateDepsgraph,
213         /* dependsOnTime */     dependsOnTime,
214         /* dependsOnNormals */  NULL,
215         /* foreachObjectLink */ NULL,
216         /* foreachIDLink */     foreachIDLink,
217         /* foreachTexLink */    NULL,
218 };