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