Cleanup: misc spelling fixes
[blender.git] / source / blender / alembic / intern / alembic_capi.cc
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
17 /** \file
18  * \ingroup balembic
19  */
20
21 #include "../ABC_alembic.h"
22
23 #include <Alembic/AbcMaterial/IMaterial.h>
24
25 #include "abc_archive.h"
26 #include "abc_camera.h"
27 #include "abc_curves.h"
28 #include "abc_hair.h"
29 #include "abc_mesh.h"
30 #include "abc_nurbs.h"
31 #include "abc_points.h"
32 #include "abc_transform.h"
33 #include "abc_util.h"
34
35 extern "C" {
36 #include "MEM_guardedalloc.h"
37
38 #include "DNA_cachefile_types.h"
39 #include "DNA_curve_types.h"
40 #include "DNA_modifier_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_scene_types.h"
43
44 #include "BKE_cachefile.h"
45 #include "BKE_cdderivedmesh.h"
46 #include "BKE_context.h"
47 #include "BKE_curve.h"
48 #include "BKE_global.h"
49 #include "BKE_layer.h"
50 #include "BKE_library.h"
51 #include "BKE_scene.h"
52
53 #include "DEG_depsgraph.h"
54 #include "DEG_depsgraph_build.h"
55
56 /* SpaceType struct has a member called 'new' which obviously conflicts with C++
57  * so temporarily redefining the new keyword to make it compile. */
58 #define new extern_new
59 #include "BKE_screen.h"
60 #undef new
61
62 #include "BLI_fileops.h"
63 #include "BLI_ghash.h"
64 #include "BLI_listbase.h"
65 #include "BLI_math.h"
66 #include "BLI_path_util.h"
67 #include "BLI_string.h"
68
69 #include "WM_api.h"
70 #include "WM_types.h"
71 }
72
73 using Alembic::Abc::Int32ArraySamplePtr;
74 using Alembic::Abc::ObjectHeader;
75
76 using Alembic::AbcGeom::kWrapExisting;
77 using Alembic::AbcGeom::MetaData;
78 using Alembic::AbcGeom::P3fArraySamplePtr;
79
80 using Alembic::AbcGeom::ICamera;
81 using Alembic::AbcGeom::ICompoundProperty;
82 using Alembic::AbcGeom::ICurves;
83 using Alembic::AbcGeom::ICurvesSchema;
84 using Alembic::AbcGeom::IFaceSet;
85 using Alembic::AbcGeom::ILight;
86 using Alembic::AbcGeom::IN3fArrayProperty;
87 using Alembic::AbcGeom::IN3fGeomParam;
88 using Alembic::AbcGeom::INuPatch;
89 using Alembic::AbcGeom::IObject;
90 using Alembic::AbcGeom::IPoints;
91 using Alembic::AbcGeom::IPointsSchema;
92 using Alembic::AbcGeom::IPolyMesh;
93 using Alembic::AbcGeom::IPolyMeshSchema;
94 using Alembic::AbcGeom::ISampleSelector;
95 using Alembic::AbcGeom::ISubD;
96 using Alembic::AbcGeom::IV2fGeomParam;
97 using Alembic::AbcGeom::IXform;
98 using Alembic::AbcGeom::IXformSchema;
99 using Alembic::AbcGeom::N3fArraySamplePtr;
100 using Alembic::AbcGeom::V3fArraySamplePtr;
101 using Alembic::AbcGeom::XformSample;
102
103 using Alembic::AbcMaterial::IMaterial;
104
105 struct AbcArchiveHandle {
106   int unused;
107 };
108
109 ABC_INLINE ArchiveReader *archive_from_handle(AbcArchiveHandle *handle)
110 {
111   return reinterpret_cast<ArchiveReader *>(handle);
112 }
113
114 ABC_INLINE AbcArchiveHandle *handle_from_archive(ArchiveReader *archive)
115 {
116   return reinterpret_cast<AbcArchiveHandle *>(archive);
117 }
118
119 //#define USE_NURBS
120
121 /* NOTE: this function is similar to visit_objects below, need to keep them in
122  * sync. */
123 static bool gather_objects_paths(const IObject &object, ListBase *object_paths)
124 {
125   if (!object.valid()) {
126     return false;
127   }
128
129   size_t children_claiming_this_object = 0;
130   size_t num_children = object.getNumChildren();
131
132   for (size_t i = 0; i < num_children; ++i) {
133     bool child_claims_this_object = gather_objects_paths(object.getChild(i), object_paths);
134     children_claiming_this_object += child_claims_this_object ? 1 : 0;
135   }
136
137   const MetaData &md = object.getMetaData();
138   bool get_path = false;
139   bool parent_is_part_of_this_object = false;
140
141   if (!object.getParent()) {
142     /* The root itself is not an object we should import. */
143   }
144   else if (IXform::matches(md)) {
145     if (has_property(object.getProperties(), "locator")) {
146       get_path = true;
147     }
148     else {
149       get_path = children_claiming_this_object == 0;
150     }
151
152     /* Transforms are never "data" for their parent. */
153     parent_is_part_of_this_object = false;
154   }
155   else {
156     /* These types are "data" for their parent. */
157     get_path = IPolyMesh::matches(md) || ISubD::matches(md) ||
158 #ifdef USE_NURBS
159                INuPatch::matches(md) ||
160 #endif
161                ICamera::matches(md) || IPoints::matches(md) || ICurves::matches(md);
162     parent_is_part_of_this_object = get_path;
163   }
164
165   if (get_path) {
166     void *abc_path_void = MEM_callocN(sizeof(AlembicObjectPath), "AlembicObjectPath");
167     AlembicObjectPath *abc_path = static_cast<AlembicObjectPath *>(abc_path_void);
168
169     BLI_strncpy(abc_path->path, object.getFullName().c_str(), sizeof(abc_path->path));
170     BLI_addtail(object_paths, abc_path);
171   }
172
173   return parent_is_part_of_this_object;
174 }
175
176 AbcArchiveHandle *ABC_create_handle(const char *filename, ListBase *object_paths)
177 {
178   ArchiveReader *archive = new ArchiveReader(filename);
179
180   if (!archive->valid()) {
181     delete archive;
182     return NULL;
183   }
184
185   if (object_paths) {
186     gather_objects_paths(archive->getTop(), object_paths);
187   }
188
189   return handle_from_archive(archive);
190 }
191
192 void ABC_free_handle(AbcArchiveHandle *handle)
193 {
194   delete archive_from_handle(handle);
195 }
196
197 int ABC_get_version()
198 {
199   return ALEMBIC_LIBRARY_VERSION;
200 }
201
202 static void find_iobject(const IObject &object, IObject &ret, const std::string &path)
203 {
204   if (!object.valid()) {
205     return;
206   }
207
208   std::vector<std::string> tokens;
209   split(path, '/', tokens);
210
211   IObject tmp = object;
212
213   std::vector<std::string>::iterator iter;
214   for (iter = tokens.begin(); iter != tokens.end(); ++iter) {
215     IObject child = tmp.getChild(*iter);
216     tmp = child;
217   }
218
219   ret = tmp;
220 }
221
222 struct ExportJobData {
223   ViewLayer *view_layer;
224   Main *bmain;
225
226   char filename[1024];
227   ExportSettings settings;
228
229   short *stop;
230   short *do_update;
231   float *progress;
232
233   bool was_canceled;
234   bool export_ok;
235 };
236
237 static void export_startjob(void *customdata, short *stop, short *do_update, float *progress)
238 {
239   ExportJobData *data = static_cast<ExportJobData *>(customdata);
240
241   data->stop = stop;
242   data->do_update = do_update;
243   data->progress = progress;
244
245   /* XXX annoying hack: needed to prevent data corruption when changing
246    * scene frame in separate threads
247    */
248   G.is_rendering = true;
249   BKE_spacedata_draw_locks(true);
250
251   G.is_break = false;
252
253   DEG_graph_build_from_view_layer(
254       data->settings.depsgraph, data->bmain, data->settings.scene, data->view_layer);
255   BKE_scene_graph_update_tagged(data->settings.depsgraph, data->bmain);
256
257   try {
258     AbcExporter exporter(data->bmain, data->filename, data->settings);
259
260     Scene *scene = data->settings.scene; /* for the CFRA macro */
261     const int orig_frame = CFRA;
262
263     data->was_canceled = false;
264     exporter(*data->progress, data->was_canceled);
265
266     if (CFRA != orig_frame) {
267       CFRA = orig_frame;
268
269       BKE_scene_graph_update_for_newframe(data->settings.depsgraph, data->bmain);
270     }
271
272     data->export_ok = !data->was_canceled;
273   }
274   catch (const std::exception &e) {
275     ABC_LOG(data->settings.logger) << "Abc Export error: " << e.what() << '\n';
276   }
277   catch (...) {
278     ABC_LOG(data->settings.logger) << "Abc Export: unknown error...\n";
279   }
280 }
281
282 static void export_endjob(void *customdata)
283 {
284   ExportJobData *data = static_cast<ExportJobData *>(customdata);
285
286   DEG_graph_free(data->settings.depsgraph);
287
288   if (data->was_canceled && BLI_exists(data->filename)) {
289     BLI_delete(data->filename, false, false);
290   }
291
292   std::string log = data->settings.logger.str();
293   if (!log.empty()) {
294     std::cerr << log;
295     WM_report(RPT_ERROR, "Errors occurred during the export, look in the console to know more...");
296   }
297
298   G.is_rendering = false;
299   BKE_spacedata_draw_locks(false);
300 }
301
302 bool ABC_export(Scene *scene,
303                 bContext *C,
304                 const char *filepath,
305                 const struct AlembicExportParams *params,
306                 bool as_background_job)
307 {
308   ExportJobData *job = static_cast<ExportJobData *>(
309       MEM_mallocN(sizeof(ExportJobData), "ExportJobData"));
310
311   job->view_layer = CTX_data_view_layer(C);
312   job->bmain = CTX_data_main(C);
313   job->export_ok = false;
314   BLI_strncpy(job->filename, filepath, 1024);
315
316   /* Alright, alright, alright....
317    *
318    * ExportJobData contains an ExportSettings containing a SimpleLogger.
319    *
320    * Since ExportJobData is a C-style struct dynamically allocated with
321    * MEM_mallocN (see above), its constructor is never called, therefore the
322    * ExportSettings constructor is not called which implies that the
323    * SimpleLogger one is not called either. SimpleLogger in turn does not call
324    * the constructor of its data members which ultimately means that its
325    * std::ostringstream member has a NULL pointer. To be able to properly use
326    * the stream's operator<<, the pointer needs to be set, therefore we have
327    * to properly construct everything. And this is done using the placement
328    * new operator as here below. It seems hackish, but I'm too lazy to
329    * do bigger refactor and maybe there is a better way which does not involve
330    * hardcore refactoring. */
331   new (&job->settings) ExportSettings();
332   job->settings.scene = scene;
333   job->settings.depsgraph = DEG_graph_new(scene, job->view_layer, DAG_EVAL_RENDER);
334
335   /* TODO(Sybren): for now we only export the active scene layer.
336    * Later in the 2.8 development process this may be replaced by using
337    * a specific collection for Alembic I/O, which can then be toggled
338    * between "real" objects and cached Alembic files. */
339   job->settings.view_layer = job->view_layer;
340
341   job->settings.frame_start = params->frame_start;
342   job->settings.frame_end = params->frame_end;
343   job->settings.frame_samples_xform = params->frame_samples_xform;
344   job->settings.frame_samples_shape = params->frame_samples_shape;
345   job->settings.shutter_open = params->shutter_open;
346   job->settings.shutter_close = params->shutter_close;
347
348   /* TODO(Sybren): For now this is ignored, until we can get selection
349    * detection working through Base pointers (instead of ob->flags). */
350   job->settings.selected_only = params->selected_only;
351
352   job->settings.export_face_sets = params->face_sets;
353   job->settings.export_normals = params->normals;
354   job->settings.export_uvs = params->uvs;
355   job->settings.export_vcols = params->vcolors;
356   job->settings.export_hair = params->export_hair;
357   job->settings.export_particles = params->export_particles;
358   job->settings.apply_subdiv = params->apply_subdiv;
359   job->settings.curves_as_mesh = params->curves_as_mesh;
360   job->settings.flatten_hierarchy = params->flatten_hierarchy;
361
362   /* TODO(Sybren): visible_layer & renderable only is ignored for now,
363    * to be replaced with collections later in the 2.8 dev process
364    * (also see note above). */
365   job->settings.visible_layers_only = params->visible_layers_only;
366   job->settings.renderable_only = params->renderable_only;
367
368   job->settings.use_subdiv_schema = params->use_subdiv_schema;
369   job->settings.export_ogawa = (params->compression_type == ABC_ARCHIVE_OGAWA);
370   job->settings.pack_uv = params->packuv;
371   job->settings.global_scale = params->global_scale;
372   job->settings.triangulate = params->triangulate;
373   job->settings.quad_method = params->quad_method;
374   job->settings.ngon_method = params->ngon_method;
375
376   if (job->settings.frame_start > job->settings.frame_end) {
377     std::swap(job->settings.frame_start, job->settings.frame_end);
378   }
379
380   bool export_ok = false;
381   if (as_background_job) {
382     wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C),
383                                 CTX_wm_window(C),
384                                 job->settings.scene,
385                                 "Alembic Export",
386                                 WM_JOB_PROGRESS,
387                                 WM_JOB_TYPE_ALEMBIC);
388
389     /* setup job */
390     WM_jobs_customdata_set(wm_job, job, MEM_freeN);
391     WM_jobs_timer(wm_job, 0.1, NC_SCENE | ND_FRAME, NC_SCENE | ND_FRAME);
392     WM_jobs_callbacks(wm_job, export_startjob, NULL, NULL, export_endjob);
393
394     WM_jobs_start(CTX_wm_manager(C), wm_job);
395   }
396   else {
397     /* Fake a job context, so that we don't need NULL pointer checks while exporting. */
398     short stop = 0, do_update = 0;
399     float progress = 0.f;
400
401     export_startjob(job, &stop, &do_update, &progress);
402     export_endjob(job);
403     export_ok = job->export_ok;
404
405     MEM_freeN(job);
406   }
407
408   return export_ok;
409 }
410
411 /* ********************** Import file ********************** */
412
413 /**
414  * Generates an AbcObjectReader for this Alembic object and its children.
415  *
416  * \param object: The Alembic IObject to visit.
417  * \param readers: The created AbcObjectReader * will be appended to this vector.
418  * \param settings: Import settings, not used directly but passed to the
419  *                 AbcObjectReader subclass constructors.
420  * \param r_assign_as_parent: Return parameter, contains a list of reader
421  *                 pointers, whose parent pointer should still be set.
422  *                 This is filled when this call to visit_object() didn't create
423  *                 a reader that should be the parent.
424  * \return A pair of boolean and reader pointer. The boolean indicates whether
425  *         this IObject claims its parent as part of the same object
426  *         (for example an IPolyMesh object would claim its parent, as the mesh
427  *         is interpreted as the object's data, and the parent IXform as its
428  *         Blender object). The pointer is the AbcObjectReader that represents
429  *         the IObject parameter.
430  *
431  * NOTE: this function is similar to gather_object_paths above, need to keep
432  * them in sync. */
433 static std::pair<bool, AbcObjectReader *> visit_object(
434     const IObject &object,
435     AbcObjectReader::ptr_vector &readers,
436     ImportSettings &settings,
437     AbcObjectReader::ptr_vector &r_assign_as_parent)
438 {
439   const std::string &full_name = object.getFullName();
440
441   if (!object.valid()) {
442     std::cerr << "  - " << full_name << ": object is invalid, skipping it and all its children.\n";
443     return std::make_pair(false, static_cast<AbcObjectReader *>(NULL));
444   }
445
446   /* The interpretation of data by the children determine the role of this
447    * object. This is especially important for Xform objects, as they can be
448    * either part of a Blender object or a Blender object (Empty) themselves.
449    */
450   size_t children_claiming_this_object = 0;
451   size_t num_children = object.getNumChildren();
452   AbcObjectReader::ptr_vector claiming_child_readers;
453   AbcObjectReader::ptr_vector nonclaiming_child_readers;
454   AbcObjectReader::ptr_vector assign_as_parent;
455   for (size_t i = 0; i < num_children; ++i) {
456     const IObject ichild = object.getChild(i);
457
458     /* TODO: When we only support C++11, use std::tie() instead. */
459     std::pair<bool, AbcObjectReader *> child_result;
460     child_result = visit_object(ichild, readers, settings, assign_as_parent);
461
462     bool child_claims_this_object = child_result.first;
463     AbcObjectReader *child_reader = child_result.second;
464
465     if (child_reader == NULL) {
466       BLI_assert(!child_claims_this_object);
467     }
468     else {
469       if (child_claims_this_object) {
470         claiming_child_readers.push_back(child_reader);
471       }
472       else {
473         nonclaiming_child_readers.push_back(child_reader);
474       }
475     }
476
477     children_claiming_this_object += child_claims_this_object ? 1 : 0;
478   }
479   BLI_assert(children_claiming_this_object == claiming_child_readers.size());
480
481   AbcObjectReader *reader = NULL;
482   const MetaData &md = object.getMetaData();
483   bool parent_is_part_of_this_object = false;
484
485   if (!object.getParent()) {
486     /* The root itself is not an object we should import. */
487   }
488   else if (IXform::matches(md)) {
489     bool create_empty;
490
491     /* An xform can either be a Blender Object (if it contains a mesh, for
492      * example), but it can also be an Empty. Its correct translation to
493      * Blender's data model depends on its children. */
494
495     /* Check whether or not this object is a Maya locator, which is
496      * similar to empties used as parent object in Blender. */
497     if (has_property(object.getProperties(), "locator")) {
498       create_empty = true;
499     }
500     else {
501       create_empty = claiming_child_readers.empty();
502     }
503
504     if (create_empty) {
505       reader = new AbcEmptyReader(object, settings);
506     }
507   }
508   else if (IPolyMesh::matches(md)) {
509     reader = new AbcMeshReader(object, settings);
510     parent_is_part_of_this_object = true;
511   }
512   else if (ISubD::matches(md)) {
513     reader = new AbcSubDReader(object, settings);
514     parent_is_part_of_this_object = true;
515   }
516   else if (INuPatch::matches(md)) {
517 #ifdef USE_NURBS
518     /* TODO(kevin): importing cyclic NURBS from other software crashes
519      * at the moment. This is due to the fact that NURBS in other
520      * software have duplicated points which causes buffer overflows in
521      * Blender. Need to figure out exactly how these points are
522      * duplicated, in all cases (cyclic U, cyclic V, and cyclic UV).
523      * Until this is fixed, disabling NURBS reading. */
524     reader = new AbcNurbsReader(object, settings);
525     parent_is_part_of_this_object = true;
526 #endif
527   }
528   else if (ICamera::matches(md)) {
529     reader = new AbcCameraReader(object, settings);
530     parent_is_part_of_this_object = true;
531   }
532   else if (IPoints::matches(md)) {
533     reader = new AbcPointsReader(object, settings);
534     parent_is_part_of_this_object = true;
535   }
536   else if (IMaterial::matches(md)) {
537     /* Pass for now. */
538   }
539   else if (ILight::matches(md)) {
540     /* Pass for now. */
541   }
542   else if (IFaceSet::matches(md)) {
543     /* Pass, those are handled in the mesh reader. */
544   }
545   else if (ICurves::matches(md)) {
546     reader = new AbcCurveReader(object, settings);
547     parent_is_part_of_this_object = true;
548   }
549   else {
550     std::cerr << "Alembic object " << full_name << " is of unsupported schema type '"
551               << object.getMetaData().get("schemaObjTitle") << "'" << std::endl;
552   }
553
554   if (reader) {
555     /* We have created a reader, which should imply that this object is
556      * not claimed as part of any child Alembic object. */
557     BLI_assert(claiming_child_readers.empty());
558
559     readers.push_back(reader);
560     reader->incref();
561
562     AlembicObjectPath *abc_path = static_cast<AlembicObjectPath *>(
563         MEM_callocN(sizeof(AlembicObjectPath), "AlembicObjectPath"));
564     BLI_strncpy(abc_path->path, full_name.c_str(), sizeof(abc_path->path));
565     BLI_addtail(&settings.cache_file->object_paths, abc_path);
566
567     /* We can now assign this reader as parent for our children. */
568     if (nonclaiming_child_readers.size() + assign_as_parent.size() > 0) {
569       for (AbcObjectReader *child_reader : nonclaiming_child_readers) {
570         child_reader->parent_reader = reader;
571       }
572       for (AbcObjectReader *child_reader : assign_as_parent) {
573         child_reader->parent_reader = reader;
574       }
575     }
576   }
577   else if (object.getParent()) {
578     if (claiming_child_readers.size() > 0) {
579       /* The first claiming child will serve just fine as parent to
580        * our non-claiming children. Since all claiming children share
581        * the same XForm, it doesn't really matter which one we pick. */
582       AbcObjectReader *claiming_child = claiming_child_readers[0];
583       for (AbcObjectReader *child_reader : nonclaiming_child_readers) {
584         child_reader->parent_reader = claiming_child;
585       }
586       for (AbcObjectReader *child_reader : assign_as_parent) {
587         child_reader->parent_reader = claiming_child;
588       }
589       /* Claiming children should have our parent set as their parent. */
590       for (AbcObjectReader *child_reader : claiming_child_readers) {
591         r_assign_as_parent.push_back(child_reader);
592       }
593     }
594     else {
595       /* This object isn't claimed by any child, and didn't produce
596        * a reader. Odd situation, could be the top Alembic object, or
597        * an unsupported Alembic schema. Delegate to our parent. */
598       for (AbcObjectReader *child_reader : claiming_child_readers) {
599         r_assign_as_parent.push_back(child_reader);
600       }
601       for (AbcObjectReader *child_reader : nonclaiming_child_readers) {
602         r_assign_as_parent.push_back(child_reader);
603       }
604       for (AbcObjectReader *child_reader : assign_as_parent) {
605         r_assign_as_parent.push_back(child_reader);
606       }
607     }
608   }
609
610   return std::make_pair(parent_is_part_of_this_object, reader);
611 }
612
613 enum {
614   ABC_NO_ERROR = 0,
615   ABC_ARCHIVE_FAIL,
616   ABC_UNSUPPORTED_HDF5,
617 };
618
619 struct ImportJobData {
620   Main *bmain;
621   Scene *scene;
622   ViewLayer *view_layer;
623   wmWindowManager *wm;
624
625   char filename[1024];
626   ImportSettings settings;
627
628   ArchiveReader *archive;
629   std::vector<AbcObjectReader *> readers;
630
631   short *stop;
632   short *do_update;
633   float *progress;
634
635   char error_code;
636   bool was_cancelled;
637   bool import_ok;
638 };
639
640 static void import_startjob(void *user_data, short *stop, short *do_update, float *progress)
641 {
642   SCOPE_TIMER("Alembic import, objects reading and creation");
643
644   ImportJobData *data = static_cast<ImportJobData *>(user_data);
645
646   data->stop = stop;
647   data->do_update = do_update;
648   data->progress = progress;
649
650   WM_set_locked_interface(data->wm, true);
651
652   ArchiveReader *archive = new ArchiveReader(data->filename);
653
654   if (!archive->valid()) {
655 #ifndef WITH_ALEMBIC_HDF5
656     data->error_code = archive->is_hdf5() ? ABC_UNSUPPORTED_HDF5 : ABC_ARCHIVE_FAIL;
657 #else
658     data->error_code = ABC_ARCHIVE_FAIL;
659 #endif
660     delete archive;
661     return;
662   }
663
664   CacheFile *cache_file = static_cast<CacheFile *>(
665       BKE_cachefile_add(data->bmain, BLI_path_basename(data->filename)));
666
667   /* Decrement the ID ref-count because it is going to be incremented for each
668    * modifier and constraint that it will be attached to, so since currently
669    * it is not used by anyone, its use count will off by one. */
670   id_us_min(&cache_file->id);
671
672   cache_file->is_sequence = data->settings.is_sequence;
673   cache_file->scale = data->settings.scale;
674   STRNCPY(cache_file->filepath, data->filename);
675
676   data->archive = archive;
677   data->settings.cache_file = cache_file;
678
679   *data->do_update = true;
680   *data->progress = 0.05f;
681
682   /* Parse Alembic Archive. */
683   AbcObjectReader::ptr_vector assign_as_parent;
684   visit_object(archive->getTop(), data->readers, data->settings, assign_as_parent);
685
686   /* There shouldn't be any orphans. */
687   BLI_assert(assign_as_parent.size() == 0);
688
689   if (G.is_break) {
690     data->was_cancelled = true;
691     return;
692   }
693
694   *data->do_update = true;
695   *data->progress = 0.1f;
696
697   /* Create objects and set scene frame range. */
698
699   const float size = static_cast<float>(data->readers.size());
700   size_t i = 0;
701
702   chrono_t min_time = std::numeric_limits<chrono_t>::max();
703   chrono_t max_time = std::numeric_limits<chrono_t>::min();
704
705   ISampleSelector sample_sel(0.0f);
706   std::vector<AbcObjectReader *>::iterator iter;
707   for (iter = data->readers.begin(); iter != data->readers.end(); ++iter) {
708     AbcObjectReader *reader = *iter;
709
710     if (reader->valid()) {
711       reader->readObjectData(data->bmain, sample_sel);
712
713       min_time = std::min(min_time, reader->minTime());
714       max_time = std::max(max_time, reader->maxTime());
715     }
716     else {
717       std::cerr << "Object " << reader->name() << " in Alembic file " << data->filename
718                 << " is invalid.\n";
719     }
720
721     *data->progress = 0.1f + 0.3f * (++i / size);
722     *data->do_update = true;
723
724     if (G.is_break) {
725       data->was_cancelled = true;
726       return;
727     }
728   }
729
730   if (data->settings.set_frame_range) {
731     Scene *scene = data->scene;
732
733     if (data->settings.is_sequence) {
734       SFRA = data->settings.sequence_offset;
735       EFRA = SFRA + (data->settings.sequence_len - 1);
736       CFRA = SFRA;
737     }
738     else if (min_time < max_time) {
739       SFRA = static_cast<int>(round(min_time * FPS));
740       EFRA = static_cast<int>(round(max_time * FPS));
741       CFRA = SFRA;
742     }
743   }
744
745   /* Setup parenthood. */
746   for (iter = data->readers.begin(); iter != data->readers.end(); ++iter) {
747     const AbcObjectReader *reader = *iter;
748     const AbcObjectReader *parent_reader = reader->parent_reader;
749     Object *ob = reader->object();
750
751     if (parent_reader == NULL || !reader->inherits_xform()) {
752       ob->parent = NULL;
753     }
754     else {
755       ob->parent = parent_reader->object();
756     }
757   }
758
759   /* Setup transformations and constraints. */
760   i = 0;
761   for (iter = data->readers.begin(); iter != data->readers.end(); ++iter) {
762     AbcObjectReader *reader = *iter;
763     reader->setupObjectTransform(0.0f);
764
765     *data->progress = 0.7f + 0.3f * (++i / size);
766     *data->do_update = true;
767
768     if (G.is_break) {
769       data->was_cancelled = true;
770       return;
771     }
772   }
773 }
774
775 static void import_endjob(void *user_data)
776 {
777   SCOPE_TIMER("Alembic import, cleanup");
778
779   ImportJobData *data = static_cast<ImportJobData *>(user_data);
780
781   std::vector<AbcObjectReader *>::iterator iter;
782
783   /* Delete objects on cancellation. */
784   if (data->was_cancelled) {
785     for (iter = data->readers.begin(); iter != data->readers.end(); ++iter) {
786       Object *ob = (*iter)->object();
787
788       /* It's possible that cancellation occurred between the creation of
789        * the reader and the creation of the Blender object. */
790       if (ob == NULL) {
791         continue;
792       }
793
794       BKE_id_free_us(data->bmain, ob);
795     }
796   }
797   else {
798     /* Add object to scene. */
799     Base *base;
800     LayerCollection *lc;
801     ViewLayer *view_layer = data->view_layer;
802
803     BKE_view_layer_base_deselect_all(view_layer);
804
805     lc = BKE_layer_collection_get_active(view_layer);
806
807     for (iter = data->readers.begin(); iter != data->readers.end(); ++iter) {
808       Object *ob = (*iter)->object();
809
810       BKE_collection_object_add(data->bmain, lc->collection, ob);
811
812       base = BKE_view_layer_base_find(view_layer, ob);
813       /* TODO: is setting active needed? */
814       BKE_view_layer_base_select_and_set_active(view_layer, base);
815
816       DEG_id_tag_update(&lc->collection->id, ID_RECALC_COPY_ON_WRITE);
817       DEG_id_tag_update_ex(data->bmain,
818                            &ob->id,
819                            ID_RECALC_TRANSFORM | ID_RECALC_GEOMETRY | ID_RECALC_ANIMATION |
820                                ID_RECALC_BASE_FLAGS);
821     }
822
823     DEG_id_tag_update(&data->scene->id, ID_RECALC_BASE_FLAGS);
824     DEG_relations_tag_update(data->bmain);
825   }
826
827   for (iter = data->readers.begin(); iter != data->readers.end(); ++iter) {
828     AbcObjectReader *reader = *iter;
829     reader->decref();
830
831     if (reader->refcount() == 0) {
832       delete reader;
833     }
834   }
835
836   WM_set_locked_interface(data->wm, false);
837
838   switch (data->error_code) {
839     default:
840     case ABC_NO_ERROR:
841       data->import_ok = !data->was_cancelled;
842       break;
843     case ABC_ARCHIVE_FAIL:
844       WM_report(RPT_ERROR, "Could not open Alembic archive for reading! See console for detail.");
845       break;
846     case ABC_UNSUPPORTED_HDF5:
847       WM_report(RPT_ERROR, "Alembic archive in obsolete HDF5 format is not supported.");
848       break;
849   }
850
851   WM_main_add_notifier(NC_SCENE | ND_FRAME, data->scene);
852 }
853
854 static void import_freejob(void *user_data)
855 {
856   ImportJobData *data = static_cast<ImportJobData *>(user_data);
857   delete data->archive;
858   delete data;
859 }
860
861 bool ABC_import(bContext *C,
862                 const char *filepath,
863                 float scale,
864                 bool is_sequence,
865                 bool set_frame_range,
866                 int sequence_len,
867                 int offset,
868                 bool validate_meshes,
869                 bool as_background_job)
870 {
871   /* Using new here since MEM_* funcs do not call ctor to properly initialize
872    * data. */
873   ImportJobData *job = new ImportJobData();
874   job->bmain = CTX_data_main(C);
875   job->scene = CTX_data_scene(C);
876   job->view_layer = CTX_data_view_layer(C);
877   job->wm = CTX_wm_manager(C);
878   job->import_ok = false;
879   BLI_strncpy(job->filename, filepath, 1024);
880
881   job->settings.scale = scale;
882   job->settings.is_sequence = is_sequence;
883   job->settings.set_frame_range = set_frame_range;
884   job->settings.sequence_len = sequence_len;
885   job->settings.sequence_offset = offset;
886   job->settings.validate_meshes = validate_meshes;
887   job->error_code = ABC_NO_ERROR;
888   job->was_cancelled = false;
889   job->archive = NULL;
890
891   G.is_break = false;
892
893   bool import_ok = false;
894   if (as_background_job) {
895     wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C),
896                                 CTX_wm_window(C),
897                                 job->scene,
898                                 "Alembic Import",
899                                 WM_JOB_PROGRESS,
900                                 WM_JOB_TYPE_ALEMBIC);
901
902     /* setup job */
903     WM_jobs_customdata_set(wm_job, job, import_freejob);
904     WM_jobs_timer(wm_job, 0.1, NC_SCENE | ND_FRAME, NC_SCENE | ND_FRAME);
905     WM_jobs_callbacks(wm_job, import_startjob, NULL, NULL, import_endjob);
906
907     WM_jobs_start(CTX_wm_manager(C), wm_job);
908   }
909   else {
910     /* Fake a job context, so that we don't need NULL pointer checks while importing. */
911     short stop = 0, do_update = 0;
912     float progress = 0.f;
913
914     import_startjob(job, &stop, &do_update, &progress);
915     import_endjob(job);
916     import_ok = job->import_ok;
917
918     import_freejob(job);
919   }
920
921   return import_ok;
922 }
923
924 /* ************************************************************************** */
925
926 void ABC_get_transform(CacheReader *reader, float r_mat[4][4], float time, float scale)
927 {
928   if (!reader) {
929     return;
930   }
931
932   AbcObjectReader *abc_reader = reinterpret_cast<AbcObjectReader *>(reader);
933
934   bool is_constant = false;
935   abc_reader->read_matrix(r_mat, time, scale, is_constant);
936 }
937
938 /* ************************************************************************** */
939
940 Mesh *ABC_read_mesh(CacheReader *reader,
941                     Object *ob,
942                     Mesh *existing_mesh,
943                     const float time,
944                     const char **err_str,
945                     int read_flag)
946 {
947   AbcObjectReader *abc_reader = reinterpret_cast<AbcObjectReader *>(reader);
948   IObject iobject = abc_reader->iobject();
949
950   if (!iobject.valid()) {
951     *err_str = "Invalid object: verify object path";
952     return NULL;
953   }
954
955   const ObjectHeader &header = iobject.getHeader();
956   if (!abc_reader->accepts_object_type(header, ob, err_str)) {
957     /* err_str is set by acceptsObjectType() */
958     return NULL;
959   }
960
961   /* kFloorIndex is used to be compatible with non-interpolating
962    * properties; they use the floor. */
963   ISampleSelector sample_sel(time, ISampleSelector::kFloorIndex);
964   return abc_reader->read_mesh(existing_mesh, sample_sel, read_flag, err_str);
965 }
966
967 /* ************************************************************************** */
968
969 void CacheReader_free(CacheReader *reader)
970 {
971   AbcObjectReader *abc_reader = reinterpret_cast<AbcObjectReader *>(reader);
972   abc_reader->decref();
973
974   if (abc_reader->refcount() == 0) {
975     delete abc_reader;
976   }
977 }
978
979 void CacheReader_incref(CacheReader *reader)
980 {
981   AbcObjectReader *abc_reader = reinterpret_cast<AbcObjectReader *>(reader);
982   abc_reader->incref();
983 }
984
985 CacheReader *CacheReader_open_alembic_object(AbcArchiveHandle *handle,
986                                              CacheReader *reader,
987                                              Object *object,
988                                              const char *object_path)
989 {
990   if (object_path[0] == '\0') {
991     return reader;
992   }
993
994   ArchiveReader *archive = archive_from_handle(handle);
995
996   if (!archive || !archive->valid()) {
997     return reader;
998   }
999
1000   IObject iobject;
1001   find_iobject(archive->getTop(), iobject, object_path);
1002
1003   if (reader) {
1004     CacheReader_free(reader);
1005   }
1006
1007   ImportSettings settings;
1008   AbcObjectReader *abc_reader = create_reader(iobject, settings);
1009   if (abc_reader == NULL) {
1010     /* This object is not supported */
1011     return NULL;
1012   }
1013   abc_reader->object(object);
1014   abc_reader->incref();
1015
1016   return reinterpret_cast<CacheReader *>(abc_reader);
1017 }