Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenkernel / intern / cachefile.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  * The Original Code is Copyright (C) 2016 Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Kevin Dietrich.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/blenkernel/intern/cachefile.c
27  *  \ingroup bke
28  */
29
30 #include "DNA_anim_types.h"
31 #include "DNA_cachefile_types.h"
32 #include "DNA_constraint_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "BLI_fileops.h"
37 #include "BLI_listbase.h"
38 #include "BLI_path_util.h"
39 #include "BLI_string.h"
40 #include "BLI_threads.h"
41 #include "BLI_utildefines.h"
42
43 #include "BKE_animsys.h"
44 #include "BKE_cachefile.h"
45 #include "BKE_library.h"
46 #include "BKE_main.h"
47 #include "BKE_modifier.h"
48 #include "BKE_scene.h"
49
50 #ifdef WITH_ALEMBIC
51 #  include "ABC_alembic.h"
52 #endif
53
54 static SpinLock spin;
55
56 void BKE_cachefiles_init(void)
57 {
58         BLI_spin_init(&spin);
59 }
60
61 void BKE_cachefiles_exit(void)
62 {
63         BLI_spin_end(&spin);
64 }
65
66 void *BKE_cachefile_add(Main *bmain, const char *name)
67 {
68         CacheFile *cache_file = BKE_libblock_alloc(bmain, ID_CF, name, 0);
69
70         BKE_cachefile_init(cache_file);
71
72         return cache_file;
73 }
74
75 void BKE_cachefile_init(CacheFile *cache_file)
76 {
77         cache_file->handle = NULL;
78         cache_file->filepath[0] = '\0';
79         cache_file->override_frame = false;
80         cache_file->frame = 0.0f;
81         cache_file->is_sequence = false;
82         cache_file->scale = 1.0f;
83         cache_file->handle_mutex = BLI_mutex_alloc();
84         BLI_listbase_clear(&cache_file->object_paths);
85 }
86
87 /** Free (or release) any data used by this cachefile (does not free the cachefile itself). */
88 void BKE_cachefile_free(CacheFile *cache_file)
89 {
90         BKE_animdata_free((ID *)cache_file, false);
91
92         if (cache_file->id.tag & LIB_TAG_NO_MAIN) {
93                 /* CoW/no-main copies reuse the existing ArchiveReader and mutex */
94                 return;
95         }
96
97         if (cache_file->handle) {
98 #ifdef WITH_ALEMBIC
99                 ABC_free_handle(cache_file->handle);
100 #endif
101                 cache_file->handle = NULL;
102         }
103         if (cache_file->handle_mutex) {
104                 BLI_mutex_free(cache_file->handle_mutex);
105                 cache_file->handle_mutex = NULL;
106         }
107
108         BLI_freelistN(&cache_file->object_paths);
109 }
110
111 /**
112  * Only copy internal data of CacheFile ID from source to already allocated/initialized destination.
113  * You probably nerver want to use that directly, use id_copy or BKE_id_copy_ex for typical needs.
114  *
115  * WARNING! This function will not handle ID user count!
116  *
117  * \param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more).
118  */
119 void BKE_cachefile_copy_data(
120         Main *UNUSED(bmain), CacheFile *cache_file_dst, const CacheFile *UNUSED(cache_file_src), const int UNUSED(flag))
121 {
122         if (cache_file_dst->id.tag & LIB_TAG_NO_MAIN) {
123                 /* CoW/no-main copies reuse the existing ArchiveReader and mutex */
124                 return;
125         }
126
127         cache_file_dst->handle = NULL;
128         cache_file_dst->handle_mutex = NULL;
129         BLI_duplicatelist(&cache_file_dst->object_paths, &cache_file_dst->object_paths);
130 }
131
132 CacheFile *BKE_cachefile_copy(Main *bmain, const CacheFile *cache_file)
133 {
134         CacheFile *cache_file_copy;
135         BKE_id_copy_ex(bmain, &cache_file->id, (ID **)&cache_file_copy, 0, false);
136         return cache_file_copy;
137 }
138
139 void BKE_cachefile_make_local(Main *bmain, CacheFile *cache_file, const bool lib_local)
140 {
141         BKE_id_make_local_generic(bmain, &cache_file->id, true, lib_local);
142 }
143
144 void BKE_cachefile_reload(const Main *bmain, CacheFile *cache_file)
145 {
146         char filepath[FILE_MAX];
147
148         BLI_strncpy(filepath, cache_file->filepath, sizeof(filepath));
149         BLI_path_abs(filepath, ID_BLEND_PATH(bmain, &cache_file->id));
150
151 #ifdef WITH_ALEMBIC
152         if (cache_file->handle) {
153                 ABC_free_handle(cache_file->handle);
154         }
155
156         cache_file->handle = ABC_create_handle(filepath, &cache_file->object_paths);
157 #endif
158 }
159
160 void BKE_cachefile_ensure_handle(const Main *bmain, CacheFile *cache_file)
161 {
162         BLI_spin_lock(&spin);
163         if (cache_file->handle_mutex == NULL) {
164                 cache_file->handle_mutex = BLI_mutex_alloc();
165         }
166         BLI_spin_unlock(&spin);
167
168         BLI_mutex_lock(cache_file->handle_mutex);
169
170         if (cache_file->handle == NULL) {
171                 /* Assigning to a CoW copy is a bad idea; assign to the original instead. */
172                 BLI_assert((cache_file->id.tag & LIB_TAG_COPIED_ON_WRITE) == 0);
173                 BKE_cachefile_reload(bmain, cache_file);
174         }
175
176         BLI_mutex_unlock(cache_file->handle_mutex);
177 }
178
179 void BKE_cachefile_update_frame(
180         Main *bmain, struct Depsgraph *depsgraph, Scene *scene,
181         const float ctime, const float fps)
182 {
183         CacheFile *cache_file;
184         char filename[FILE_MAX];
185
186         for (cache_file = bmain->cachefiles.first; cache_file; cache_file = cache_file->id.next) {
187                 /* Execute drivers only, as animation has already been done. */
188                 BKE_animsys_evaluate_animdata(depsgraph, scene, &cache_file->id, cache_file->adt, ctime, ADT_RECALC_DRIVERS);
189
190                 if (!cache_file->is_sequence) {
191                         continue;
192                 }
193
194                 const float time = BKE_cachefile_time_offset(cache_file, ctime, fps);
195
196                 if (BKE_cachefile_filepath_get(bmain, cache_file, time, filename)) {
197                         BKE_cachefile_clean(bmain, cache_file);
198 #ifdef WITH_ALEMBIC
199                         ABC_free_handle(cache_file->handle);
200                         cache_file->handle = ABC_create_handle(filename, NULL);
201 #endif
202                 }
203         }
204 }
205
206 bool BKE_cachefile_filepath_get(
207         const Main *bmain, const CacheFile *cache_file, float frame,
208         char r_filepath[FILE_MAX])
209 {
210         BLI_strncpy(r_filepath, cache_file->filepath, FILE_MAX);
211         BLI_path_abs(r_filepath, ID_BLEND_PATH(bmain, &cache_file->id));
212
213         int fframe;
214         int frame_len;
215
216         if (cache_file->is_sequence && BLI_path_frame_get(r_filepath, &fframe, &frame_len)) {
217                 char ext[32];
218                 BLI_path_frame_strip(r_filepath, true, ext);
219                 BLI_path_frame(r_filepath, frame, frame_len);
220                 BLI_path_extension_ensure(r_filepath, FILE_MAX, ext);
221
222                 /* TODO(kevin): store sequence range? */
223                 return BLI_exists(r_filepath);
224         }
225
226         return true;
227 }
228
229 float BKE_cachefile_time_offset(CacheFile *cache_file, const float time, const float fps)
230 {
231         const float time_offset = cache_file->frame_offset / fps;
232         const float frame = (cache_file->override_frame ? cache_file->frame : time);
233         return cache_file->is_sequence ? frame : frame / fps - time_offset;
234 }
235
236 /* TODO(kevin): replace this with some depsgraph mechanism, or something similar. */
237 void BKE_cachefile_clean(struct Main *bmain, CacheFile *cache_file)
238 {
239         for (Object *ob = bmain->object.first; ob; ob = ob->id.next) {
240                 ModifierData *md = modifiers_findByType(ob, eModifierType_MeshSequenceCache);
241
242                 if (md) {
243                         MeshSeqCacheModifierData *mcmd = (MeshSeqCacheModifierData *)md;
244
245                         if (cache_file == mcmd->cache_file) {
246 #ifdef WITH_ALEMBIC
247                                 if (mcmd->reader != NULL) {
248                                         CacheReader_free(mcmd->reader);
249                                 }
250 #endif
251                                 mcmd->reader = NULL;
252                         }
253                 }
254
255                 for (bConstraint *con = ob->constraints.first; con; con = con->next) {
256                         if (con->type != CONSTRAINT_TYPE_TRANSFORM_CACHE) {
257                                 continue;
258                         }
259
260                         bTransformCacheConstraint *data = con->data;
261
262                         if (cache_file == data->cache_file) {
263 #ifdef WITH_ALEMBIC
264                                 if (data->reader != NULL) {
265                                         CacheReader_free(data->reader);
266                                 }
267 #endif
268                                 data->reader = NULL;
269                         }
270                 }
271         }
272 }