Blender V5.3
abc_hierarchy_iterator.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2020 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10#include "abc_writer_abstract.h"
11#include "abc_writer_camera.h"
12#include "abc_writer_curves.h"
13#include "abc_writer_hair.h"
14#include "abc_writer_instance.h"
15#include "abc_writer_mball.h"
16#include "abc_writer_mesh.h"
17#include "abc_writer_nurbs.h"
18#include "abc_writer_points.h"
20#include "intern/abc_util.h"
21
22#include <memory>
23#include <string>
24
25#include "BLI_assert.hh"
26
27#include "DNA_layer_types.h"
28#include "DNA_object_types.h"
29
30namespace blender::io::alembic {
31
33 Depsgraph *depsgraph,
34 ABCArchive *abc_archive,
35 const AlembicExportParams &params)
36 : AbstractHierarchyIterator(bmain, depsgraph), abc_archive_(abc_archive), params_(params)
37{
38}
39
45
46void ABCHierarchyIterator::update_archive_bounding_box()
47{
48 Imath::Box3d bounds;
49 update_bounding_box_recursive(bounds, HierarchyContext::root());
50 abc_archive_->update_bounding_box(bounds);
51}
52
53void ABCHierarchyIterator::update_bounding_box_recursive(Imath::Box3d &bounds,
54 const HierarchyContext *context)
55{
56 if (context != nullptr) {
57 AbstractHierarchyWriter *abstract_writer = writers_.lookup(context->export_path);
58 ABCAbstractWriter *abc_writer = static_cast<ABCAbstractWriter *>(abstract_writer);
59
60 if (abc_writer != nullptr) {
61 bounds.extendBy(abc_writer->bounding_box());
62 }
63 }
64
65 ExportChildren *children = graph_children(context);
66 if (!children) {
67 return;
68 }
69
70 for (HierarchyContext *child_context : *children) {
71 update_bounding_box_recursive(bounds, child_context);
72 }
73}
74
76{
77 if (params_.selected_only && (object->base_flag & BASE_SELECTED) == 0) {
78 return true;
79 }
80 /* TODO(Sybren): handle other flags too? */
81 return false;
82}
83
85{
86 delete writer;
87}
88
89std::string ABCHierarchyIterator::make_valid_name(const std::string &name) const
90{
91 return get_valid_abc_name(name.c_str());
92}
93
103
105 const HierarchyContext *context,
106 const DupliObject *dupli_object,
107 const DupliParentFinder &dupli_parent_finder)
108{
109 if (params_.flatten_hierarchy) {
111 }
112
114 context, dupli_object, dupli_parent_finder);
115}
116
118 const std::string &export_path) const
119{
120 if (export_path.empty()) {
121 return Alembic::Abc::OObject();
122 }
123
124 AbstractHierarchyWriter *writer = get_writer(export_path);
125 if (writer == nullptr) {
126 return Alembic::Abc::OObject();
127 }
128
129 ABCAbstractWriter *abc_writer = static_cast<ABCAbstractWriter *>(writer);
130 return abc_writer->get_alembic_object();
131}
132
133Alembic::Abc::OObject ABCHierarchyIterator::get_alembic_parent(
134 const HierarchyContext *context) const
135{
136 Alembic::Abc::OObject parent = get_alembic_object(context->higher_up_export_path);
137
138 if (!parent.valid()) {
139 /* An invalid parent object means "no parent", which should be translated to Alembic's top
140 * archive object. */
141 return abc_archive_->archive->getTop();
142 }
143
144 return parent;
145}
146
147ABCWriterConstructorArgs ABCHierarchyIterator::writer_constructor_args(
148 const HierarchyContext *context) const
149{
150 ABCWriterConstructorArgs constructor_args;
151 constructor_args.depsgraph = depsgraph_;
152 constructor_args.abc_archive = abc_archive_;
153 constructor_args.abc_parent = get_alembic_parent(context);
154 constructor_args.abc_name = context->export_name;
155 constructor_args.abc_path = context->export_path;
156 constructor_args.hierarchy_iterator = this;
157 constructor_args.export_params = &params_;
158 return constructor_args;
159}
160
162 const HierarchyContext *context)
163{
164 ABCAbstractWriter *transform_writer = new ABCTransformWriter(writer_constructor_args(context));
165 transform_writer->create_alembic_objects(context);
166 return transform_writer;
167}
168
170{
171 const ABCWriterConstructorArgs writer_args = writer_constructor_args(context);
172 ABCAbstractWriter *data_writer = nullptr;
173
174 if (params_.use_instancing && context->is_instance()) {
175 data_writer = new ABCInstanceWriter(writer_args);
176 }
177 else {
178 data_writer = create_data_writer_for_object_type(context, writer_args);
179 }
180
181 if (data_writer == nullptr || !data_writer->is_supported(context)) {
182 delete data_writer;
183 return nullptr;
184 }
185
186 data_writer->create_alembic_objects(context);
187 return data_writer;
188}
189
190ABCAbstractWriter *ABCHierarchyIterator::create_data_writer_for_object_type(
191 const HierarchyContext *context, const ABCWriterConstructorArgs &writer_args)
192{
193 switch (context->object->type) {
194 case OB_MESH:
195 return new ABCMeshWriter(writer_args);
196 case OB_CAMERA:
197 return new ABCCameraWriter(writer_args);
198 case OB_CURVES_LEGACY:
199 case OB_CURVES:
200 if (params_.curves_as_mesh) {
201 return new ABCCurveMeshWriter(writer_args);
202 }
203 return new ABCCurveWriter(writer_args);
204 case OB_SURF:
205 if (params_.curves_as_mesh) {
206 return new ABCCurveMeshWriter(writer_args);
207 }
208 return new ABCNurbsWriter(writer_args);
209 case OB_MBALL:
210 return new ABCMetaballWriter(writer_args);
211 case OB_POINTCLOUD:
212 return new ABCPointCloudWriter(writer_args);
213
214 case OB_EMPTY:
215 case OB_LAMP:
216 case OB_FONT:
217 case OB_SPEAKER:
218 case OB_LIGHTPROBE:
219 case OB_LATTICE:
220 case OB_ARMATURE:
222 case OB_VOLUME:
223 case OB_GREASE_PENCIL:
224 return nullptr;
225 case OB_TYPE_MAX:
226 BLI_assert_msg(0, "OB_TYPE_MAX should not be used");
227 return nullptr;
228 }
229
230 /* Just to please the compiler, all cases should be handled by the above switch. */
231 return nullptr;
232}
233
235{
236 if (!params_.export_hair) {
237 return nullptr;
238 }
239
240 const ABCWriterConstructorArgs writer_args = writer_constructor_args(context);
241 ABCAbstractWriter *hair_writer = new ABCHairWriter(writer_args);
242
243 if (!hair_writer->is_supported(context)) {
244 delete hair_writer;
245 return nullptr;
246 }
247
248 hair_writer->create_alembic_objects(context);
249 return hair_writer;
250}
251
253 const HierarchyContext *context)
254{
255 if (!params_.export_particles) {
256 return nullptr;
257 }
258
259 const ABCWriterConstructorArgs writer_args = writer_constructor_args(context);
260 std::unique_ptr<ABCPointsWriter> particle_writer(std::make_unique<ABCPointsWriter>(writer_args));
261
262 if (!particle_writer->is_supported(context)) {
263 return nullptr;
264 }
265
266 particle_writer->create_alembic_objects(context);
267 return particle_writer.release();
268}
269
270} // namespace blender::io::alembic
Object is a sort of wrapper for general info.
#define BLI_assert_msg(a, msg)
const Value & lookup(const Key &key) const
Definition BLI_map.hh:545
virtual ObjectIdentifier determine_graph_index_object(const HierarchyContext *context)
ExportChildren * graph_children(const HierarchyContext *context)
AbstractHierarchyIterator(Main *bmain, Depsgraph *depsgraph)
virtual ObjectIdentifier determine_graph_index_dupli(const HierarchyContext *context, const DupliObject *dupli_object, const DupliParentFinder &dupli_parent_finder)
AbstractHierarchyWriter * get_writer(const std::string &export_path) const
static ObjectIdentifier for_graph_root()
virtual void create_alembic_objects(const HierarchyContext *context)=0
virtual bool is_supported(const HierarchyContext *context) const
virtual Alembic::Abc::OObject get_alembic_object() const =0
Alembic::Abc::OArchive * archive
Definition abc_archive.h:36
void update_bounding_box(const Imath::Box3d &bounds)
ABCCameraWriter(const ABCWriterConstructorArgs &args)
ABCCurveMeshWriter(const ABCWriterConstructorArgs &args)
ABCCurveWriter(const ABCWriterConstructorArgs &args)
ABCHairWriter(const ABCWriterConstructorArgs &args)
bool mark_as_weak_export(const Object *object) const override
AbstractHierarchyWriter * create_particle_writer(const HierarchyContext *context) override
Alembic::Abc::OObject get_alembic_object(const std::string &export_path) const
AbstractHierarchyWriter * create_hair_writer(const HierarchyContext *context) override
ObjectIdentifier determine_graph_index_dupli(const HierarchyContext *context, const DupliObject *dupli_object, const DupliParentFinder &dupli_parent_finder) override
std::string make_valid_name(const std::string &name) const override
AbstractHierarchyWriter * create_data_writer(const HierarchyContext *context) override
ObjectIdentifier determine_graph_index_object(const HierarchyContext *context) override
AbstractHierarchyWriter * create_transform_writer(const HierarchyContext *context) override
void release_writer(AbstractHierarchyWriter *writer) override
ABCHierarchyIterator(Main *bmain, Depsgraph *depsgraph, ABCArchive *abc_archive, const AlembicExportParams &params)
ABCInstanceWriter(const ABCWriterConstructorArgs &args)
ABCMeshWriter(const ABCWriterConstructorArgs &args)
ABCMetaballWriter(const ABCWriterConstructorArgs &args)
ABCNurbsWriter(const ABCWriterConstructorArgs &args)
ABCPointCloudWriter(const ABCWriterConstructorArgs &args)
ABCTransformWriter(const ABCWriterConstructorArgs &args)
std::string get_valid_abc_name(const char *name)
Definition abc_util.cc:36
static const HierarchyContext * root()