12#include <Alembic/AbcGeom/ILight.h>
13#include <Alembic/AbcGeom/INuPatch.h>
14#include <Alembic/AbcMaterial/IMaterial.h>
69using Alembic::Abc::IV3fArrayProperty;
70using Alembic::Abc::ObjectHeader;
71using Alembic::Abc::PropertyHeader;
72using Alembic::Abc::V3fArraySamplePtr;
73using Alembic::AbcGeom::ICamera;
74using Alembic::AbcGeom::ICurves;
75using Alembic::AbcGeom::IFaceSet;
76using Alembic::AbcGeom::ILight;
77using Alembic::AbcGeom::INuPatch;
78using Alembic::AbcGeom::IObject;
79using Alembic::AbcGeom::IPoints;
80using Alembic::AbcGeom::IPolyMesh;
81using Alembic::AbcGeom::IPolyMeshSchema;
82using Alembic::AbcGeom::ISampleSelector;
83using Alembic::AbcGeom::ISubD;
84using Alembic::AbcGeom::IXform;
85using Alembic::AbcGeom::kWrapExisting;
86using Alembic::AbcGeom::MetaData;
87using Alembic::AbcMaterial::IMaterial;
119static void add_object_path(ListBaseT<CacheObjectPath> *object_paths,
const IObject &
object)
121 CacheObjectPath *abc_path = MEM_new<CacheObjectPath>(
"CacheObjectPath");
122 STRNCPY(abc_path->
path,
object.getFullName().c_str());
132 if (!
object.valid()) {
136 size_t children_claiming_this_object = 0;
137 size_t num_children =
object.getNumChildren();
139 for (
size_t i = 0; i < num_children; i++) {
141 children_claiming_this_object += child_claims_this_object ? 1 : 0;
144 const MetaData &md =
object.getMetaData();
145 bool get_path =
false;
146 bool parent_is_part_of_this_object =
false;
151 else if (IXform::matches(md)) {
156 get_path = children_claiming_this_object == 0;
160 parent_is_part_of_this_object =
false;
164 get_path = IPolyMesh::matches(md) || ISubD::matches(md) ||
166 INuPatch::matches(md) ||
168 ICamera::matches(md) || IPoints::matches(md) || ICurves::matches(md);
169 parent_is_part_of_this_object = get_path;
176 return parent_is_part_of_this_object;
180 const char *filepath,
182 ListBaseT<CacheObjectPath> *object_paths)
184 std::vector<const char *> filepaths;
185 filepaths.push_back(filepath);
189 filepaths.push_back(layers->
filepath);
191 layers = layers->
next;
195 std::reverse(filepaths.begin(), filepaths.end());
199 if (!archive || !archive->
valid()) {
222 return ALEMBIC_LIBRARY_VERSION;
227 if (!
object.valid()) {
231 std::vector<std::string> tokens;
232 split(path,
'/', tokens);
236 std::vector<std::string>::iterator iter;
237 for (iter = tokens.begin(); iter != tokens.end(); ++iter) {
238 IObject child = tmp.getChild(*iter);
268 const IObject &
object,
273 const std::string &full_name =
object.getFullName();
275 if (!
object.valid()) {
276 std::cerr <<
" - " << full_name <<
": object is invalid, skipping it and all its children.\n";
284 size_t children_claiming_this_object = 0;
285 size_t num_children =
object.getNumChildren();
289 for (
size_t i = 0; i < num_children; i++) {
290 const IObject ichild =
object.getChild(i);
293 std::pair<bool, AbcObjectReader *> child_result;
294 child_result =
visit_object(ichild, readers, settings, assign_as_parent);
296 bool child_claims_this_object = child_result.first;
299 if (child_reader ==
nullptr) {
303 if (child_claims_this_object) {
304 claiming_child_readers.push_back(child_reader);
307 nonclaiming_child_readers.push_back(child_reader);
311 children_claiming_this_object += child_claims_this_object ? 1 : 0;
313 BLI_assert(children_claiming_this_object == claiming_child_readers.size());
317 const MetaData &md =
object.getMetaData();
318 bool parent_is_part_of_this_object =
false;
325 else if (IXform::matches(md)) {
338 create_empty = claiming_child_readers.empty();
345 else if (IPolyMesh::matches(md)) {
347 parent_is_part_of_this_object =
true;
349 else if (ISubD::matches(md)) {
351 parent_is_part_of_this_object =
true;
353 else if (INuPatch::matches(md)) {
362 parent_is_part_of_this_object =
true;
365 else if (ICamera::matches(md)) {
367 parent_is_part_of_this_object =
true;
369 else if (IPoints::matches(md)) {
371 parent_is_part_of_this_object =
true;
373 else if (IMaterial::matches(md)) {
376 else if (ILight::matches(md)) {
379 else if (IFaceSet::matches(md)) {
382 else if (ICurves::matches(md)) {
384 parent_is_part_of_this_object =
true;
387 std::cerr <<
"Alembic object " << full_name <<
" is of unsupported schema type '"
388 <<
object.getMetaData().get(
"schemaObjTitle") <<
"'" << std::endl;
396 readers.push_back(reader);
402 if (nonclaiming_child_readers.size() + assign_as_parent.size() > 0) {
404 child_reader->parent_reader = reader;
407 child_reader->parent_reader = reader;
412 if (!claiming_child_readers.empty()) {
418 child_reader->parent_reader = claiming_child;
421 child_reader->parent_reader = claiming_child;
425 r_assign_as_parent.push_back(child_reader);
433 r_assign_as_parent.push_back(child_reader);
436 r_assign_as_parent.push_back(child_reader);
439 r_assign_as_parent.push_back(child_reader);
444 return std::make_pair(parent_is_part_of_this_object, reader);
467 chrono_t
min_time = std::numeric_limits<chrono_t>::max();
469 chrono_t
max_time = -std::numeric_limits<chrono_t>::max();
485 std::cout <<
"Alembic import took ";
494 const char *na = a->name().c_str();
495 const char *nb = b->name().c_str();
496 return BLI_strcasecmp(na, nb) < 0;
506 if (!archive || !archive->
valid()) {
521 cache_file->
scale =
data->settings.scale;
524 data->archives.append(archive);
525 data->settings.cache_file = cache_file;
528 *
data->do_update =
true;
529 *
data->progress += 0.05f * progress_factor;
533 std::vector<AbcObjectReader *> readers{};
540 data->was_cancelled =
true;
541 data->readers.extend(readers);
545 *
data->do_update =
true;
546 *
data->progress += 0.05f * progress_factor;
553 data->readers.extend(readers);
555 const float size =
float(readers.size());
557 ISampleSelector sample_sel(0.0);
558 std::vector<AbcObjectReader *>::iterator iter;
559 const float read_object_progress_step = (0.6f / size) * progress_factor;
560 for (iter = readers.begin(); iter != readers.end(); ++iter) {
563 if (reader->
valid()) {
568 std::cerr <<
"Object " << reader->
name() <<
" in Alembic file " << filepath
571 *
data->progress += read_object_progress_step;
572 *
data->do_update =
true;
575 data->was_cancelled =
true;
587 for (iter = readers.begin(); iter != readers.end(); ++iter) {
590 if (reader->
valid()) {
599 for (iter = readers.begin(); iter != readers.end(); ++iter) {
613 const float setup_object_transform_progress_step = (0.3f / size) * progress_factor;
614 for (iter = readers.begin(); iter != readers.end(); ++iter) {
618 *
data->progress += setup_object_transform_progress_step;
619 *
data->do_update =
true;
622 data->was_cancelled =
true;
627 std::cout <<
"Alembic import " << filepath <<
" took ";
634 if (!
data->settings.set_frame_range) {
638 if (
data->settings.is_sequence) {
639 scene->
r.
sfra =
data->settings.sequence_min_frame;
640 scene->
r.
efra =
data->settings.sequence_max_frame;
643 else if (
data->min_time <
data->max_time) {
644 scene->
r.
sfra = int(
round(
data->min_time * scene->frames_per_second()));
645 scene->
r.
efra = int(
round(
data->max_time * scene->frames_per_second()));
656 data->start_time = timeit::Clock::now();
659 float file_progress_factor = 1.0f /
float(
data->paths.size());
660 for (
int idx :
data->paths.index_range()) {
663 if (
G.is_break ||
data->was_cancelled) {
664 data->was_cancelled =
true;
668 worker_status->
progress =
float(idx + 1) * file_progress_factor;
678 if (
data->was_cancelled) {
701 "Could not find an editable collection in current scene, imported data "
702 "will not be instantiated");
711 bool has_instantiated_object =
false;
712 bool has_uninstantiated_object =
false;
718 has_uninstantiated_object =
true;
721 has_instantiated_object =
true;
745 if (has_instantiated_object && has_uninstantiated_object) {
746 CLOG_ERROR(&
LOG,
"Some imported objects were not instantiated, while others were");
752 if (
data->is_background_job) {
769 switch (
data->error_code) {
772 data->import_ok = !
data->was_cancelled;
776 "Could not open Alembic archive for reading, see console for detail");
818 bool import_ok =
false;
819 if (as_background_job) {
823 "Importing Alembic...",
856 bool is_constant =
false;
863 if (
object->parent ==
nullptr) {
869 float mat_parent[4][4];
872 float mat_local[4][4];
883 IObject iobject = abc_reader->
iobject();
885 if (!iobject.valid()) {
886 *r_err_str =
RPT_(
"Invalid object: verify object path");
890 const ObjectHeader &header = iobject.getHeader();
903 return ISampleSelector(time, ISampleSelector::kFloorIndex);
910 const char **r_err_str)
913 if (abc_reader ==
nullptr) {
922 abc_reader->
read_geometry(geometry_set, sample_sel, read_params, r_err_str);
927 const Mesh *existing_mesh,
929 const char **r_err_str)
932 if (abc_reader ==
nullptr) {
955 const char *object_path,
956 const bool is_sequence)
958 if (object_path[0] ==
'\0') {
968 if (!archive || !archive->
valid()) {
987 if (abc_reader ==
nullptr) {
991 abc_reader->
object(
object);
994 return reinterpret_cast<CacheReader *
>(abc_reader);
General operations, lookup, etc. for blender objects.
#define CLOG_ERROR(clg_ref,...)
#define ID_IS_EDITABLE(_id)
Object groups, one object can be in many groups at once.
These structs are the foundation for all linked lists in the library system.
Object is a sort of wrapper for general info.
Read Blender memory allocation and freeing.
#define UNUSED_VARS_NDEBUG(...)
int getParent(int link_num) const
constexpr T * end() const
constexpr T * begin() const
AbcCameraReader(const AbcReaderConstructorArgs &args)
AbcCurveReader(const AbcReaderConstructorArgs &args)
AbcEmptyReader(const AbcReaderConstructorArgs &args)
AbcMeshReader(const AbcReaderConstructorArgs &args)
AbcNurbsReader(const AbcReaderConstructorArgs &args)
AbcObjectReader * parent_reader
virtual void read_geometry(bke::GeometrySet &geometry_set, const Alembic::Abc::ISampleSelector &sample_sel, const AbcReadGeometryParams &read_params, const char **r_err_str)
void getKeyFramingHelpers(Vector< std::unique_ptr< FCurveCreationHelper > > &keyframing_helpers)
void read_matrix(float r_mat[4][4], chrono_t time, float scale, bool &is_constant)
const Alembic::Abc::IObject & iobject() const
bool has_visibility_keyframes() const
virtual bool valid() const =0
virtual bool accepts_object_type(const Alembic::AbcCoreAbstract::ObjectHeader &alembic_header, const Object *const ob, const char **r_err_str) const =0
virtual bool topology_changed(const Mesh *existing_mesh, const Alembic::Abc::ISampleSelector &sample_sel)
void setupObjectTransform(chrono_t time)
bool inherits_xform() const
virtual void readObjectData(Main *bmain, const Alembic::Abc::ISampleSelector &sample_sel)=0
std::vector< AbcObjectReader * > ptr_vector
const std::string & name() const
AbcPointsReader(const AbcReaderConstructorArgs &args)
AbcSubDReader(const AbcReaderConstructorArgs &args)
Alembic::Abc::IObject getTop()
bool is_blender_archive_version_prior_44()
static ArchiveReader * get(const struct Main *bmain, const std::vector< const char * > &filenames)
float3x3 scale(float3x3 mat, float2 scale)
void create_keyframes(Main *bmain, Scene *scene, Span< std::unique_ptr< FCurveCreationHelper > > helpers, const TimeInfo time_info)
AbcObjectReader * create_reader(const AbcReaderConstructorArgs &args)
AbcReaderConstructorArgs create_reader_constructor_args(const IObject &object, ImportSettings &settings)
bool has_property(const Alembic::Abc::ICompoundProperty &prop, const std::string &name)
void split(const std::string &s, const char delim, std::vector< std::string > &tokens)
std::chrono::nanoseconds Nanoseconds
Clock::time_point TimePoint
void print_duration(Nanoseconds duration)
void WM_main_add_notifier(uint type, void *reference)
static bool gather_objects_paths(const IObject &object, ListBaseT< CacheObjectPath > *object_paths)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void * BKE_cachefile_add(Main *bmain, const char *name)
void ABC_get_transform(struct CacheReader *reader, float r_mat_world[4][4], double time, float scale)
char * STRNCPY(char(&dst)[N], const char *src)
LayerCollection * BKE_layer_collection_get_active_editable(ViewLayer *view_layer)
void BKE_view_layer_base_select_and_set_active(ViewLayer *view_layer, Base *selbase)
static void find_iobject(const IObject &object, IObject &ret, const std::string &path)
static void import_startjob(void *user_data, wmJobWorkerStatus *worker_status)
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
void BKE_id_free_us(Main *bmain, void *idv) ATTR_NONNULL()
void BKE_object_get_parent_matrix(const Object *ob, Object *par, float r_parentmat[4][4])
@ WM_JOB_TYPE_ALEMBIC_IMPORT
struct CacheArchiveHandle * ABC_create_handle(const struct Main *bmain, const char *filepath, const struct CacheFileLayer *layers, ListBaseT< CacheObjectPath > *object_paths)
void ABC_free_handle(struct CacheArchiveHandle *handle)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
static void import_endjob(void *user_data)
wmWindow * CTX_wm_window(const bContext *C)
void ABC_CacheReader_free(struct CacheReader *reader)
BLI_INLINE AlembicArchiveData * archive_from_handle(CacheArchiveHandle *handle)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
BLI_INLINE CacheArchiveHandle * handle_from_archive(AlembicArchiveData *archive)
static AbcObjectReader * get_abc_reader(CacheReader *reader, Object *ob, const char **r_err_str)
static void import_file(ImportJobData *data, const char *filepath, float progress_factor)
static void add_object_path(ListBaseT< CacheObjectPath > *object_paths, const IObject &object)
ViewLayer * CTX_data_view_layer(const bContext *C)
void ABC_read_geometry(CacheReader *reader, Object *ob, bke::GeometrySet &geometry_set, const ABCReadParams *params, const char **r_err_str)
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
void WM_locked_interface_set(wmWindowManager *wm, bool lock)
void parallel_sort(RandomAccessIterator begin, RandomAccessIterator end)
void void void const char * BLI_path_basename(const char *path) ATTR_NONNULL(1) ATTR_WARN_UNUSED_RESULT
void DEG_id_tag_update_ex(Main *bmain, ID *id, unsigned int flags)
void DEG_id_tag_update(ID *id, unsigned int flags)
BMesh const char void * data
wmWindowManager * CTX_wm_manager(const bContext *C)
static std::pair< bool, AbcObjectReader * > visit_object(const IObject &object, AbcObjectReader::ptr_vector &readers, ImportSettings &settings, AbcObjectReader::ptr_vector &r_assign_as_parent)
void ED_undo_push(bContext *C, const char *str, UndoEncodeHints hints=UndoEncodeHints(0))
static void import_freejob(void *user_data)
static void set_frame_range(ImportJobData *data)
static void sort_readers(MutableSpan< AbcObjectReader * > readers)
static ISampleSelector sample_selector_for_time(chrono_t time)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob)
void WM_global_report(eReportType type, const char *message)
bool ABC_mesh_topology_changed(struct CacheReader *reader, struct Object *ob, const struct Mesh *existing_mesh, double time, const char **r_err_str)
void BKE_view_layer_base_deselect_all(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
bool ABC_import(struct bContext *C, const struct AlembicImportParams *params, bool as_background_job)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Main * CTX_data_main(const bContext *C)
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
void BKE_base_eval_flags(Base *base)
struct CacheReader * CacheReader_open_alembic_object(struct CacheArchiveHandle *handle, struct CacheReader *reader, struct Object *object, const char *object_path, bool is_sequence)
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
void DEG_relations_tag_update(Main *bmain)
Scene * CTX_data_scene(const bContext *C)
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
static void report_job_duration(const ImportJobData *data)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
const char * velocity_name
ImportSettings * settings
AlembicArchiveData()=default
ArchiveReader * archive_reader
AlembicArchiveData & operator==(const AlembicArchiveData &)=delete
AlembicArchiveData(const AlembicArchiveData &)=delete
bool always_add_cache_reader
Vector< std::string > paths
eCacheFileLayer_Flag flag
struct CacheFileLayer * next
ListBaseT< CacheObjectPath > object_paths
Vector< AbcObjectReader * > readers
timeit::TimePoint start_time
Vector< std::string > paths
Vector< ArchiveReader * > archives
struct Collection * collection
eObject_VisibilityFlag visibility_flag
std::string velocity_name
bool blender_archive_version_prior_44
bool always_add_cache_reader
Alembic::Abc::chrono_t max_time
Alembic::Abc::chrono_t min_time