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