24#include <pxr/base/gf/quatf.h>
25#include <pxr/base/gf/vec3d.h>
26#include <pxr/base/gf/vec3f.h>
27#include <pxr/base/vt/array.h>
28#include <pxr/usd/usdGeom/pointInstancer.h>
29#include <pxr/usd/usdGeom/primvarsAPI.h>
37 const Set<std::pair<pxr::SdfPath, Object *>> &prototype_paths,
38 std::unique_ptr<USDAbstractWriter> base_writer)
40 base_writer_(std::move(base_writer)),
41 prototype_paths_(prototype_paths)
49 base_writer_->write(context);
60 const Object *object_eval = context.object;
70 const pxr::UsdGeomPointInstancer usd_instancer = pxr::UsdGeomPointInstancer::Define(stage,
77 if (transforms.
size() != instance_num) {
80 "Instances number '%d' does not match transforms size '%d'",
82 int(transforms.
size()));
87 pxr::UsdAttribute position_attr = usd_instancer.CreatePositionsAttr();
88 pxr::VtArray<pxr::GfVec3f> positions(instance_num);
89 for (
int i = 0; i < instance_num; i++) {
90 const float3 &pos = transforms[i].location();
91 positions[i] = pxr::GfVec3f(pos.x, pos.y, pos.z);
96 pxr::UsdAttribute orientations_attr = usd_instancer.CreateOrientationsAttr();
97 pxr::VtArray<pxr::GfQuath> orientation(instance_num);
98 for (
int i = 0; i < instance_num; i++) {
101 orientation[i] = pxr::GfQuath(quat.
w, pxr::GfVec3h(quat.
x, quat.
y, quat.
z));
106 pxr::UsdAttribute scales_attr = usd_instancer.CreateScalesAttr();
107 pxr::VtArray<pxr::GfVec3f> scales(instance_num);
108 for (
int i = 0; i < instance_num; i++) {
111 scales[i] = pxr::GfVec3f(scale_vec.x, scale_vec.y, scale_vec.z);
117 pxr::VtInt64Array usd_ids(ids.
begin(), ids.
end());
118 pxr::UsdAttribute attr_ids = usd_instancer.CreateIdsAttr();
125 ELEM(iter.
name,
"instance_transform",
"scale",
"orientation",
"mask",
"proto_index",
"id"))
130 this->write_attribute_data(iter, usd_instancer, time);
134 const pxr::SdfPath protoParentPath =
usd_path.AppendChild(pxr::TfToken(
"Prototypes"));
135 pxr::UsdPrim prototypesOver = stage->DefinePrim(protoParentPath);
136 pxr::SdfPathVector proto_wrapper_paths;
141 if (!prototype_paths_.is_empty() && usd_instancer) {
144 for (
const std::pair<pxr::SdfPath, Object *> &entry : prototype_paths_) {
145 const pxr::SdfPath &source_path = entry.first;
148 if (source_path.IsEmpty()) {
152 const pxr::SdfPath proto_path = protoParentPath.AppendChild(
153 pxr::TfToken(
"Prototype_" + std::to_string(iter)));
155 pxr::UsdPrim prim = stage->DefinePrim(proto_path);
159 stage->DefinePrim(source_path);
160 prim.GetReferences().AddReference(pxr::SdfReference(
"", source_path));
161 proto_wrapper_paths.push_back(proto_path);
164 proto_index_map.
add_new(ob_name, iter);
165 proto_path_map.
add_new(ob_name, proto_path);
169 usd_instancer.GetPrototypesRel().SetTargets(proto_wrapper_paths);
174 pxr::UsdAttribute proto_indices_attr = usd_instancer.CreateProtoIndicesAttr();
175 pxr::VtArray<int> proto_indices;
182 for (
int i = 0; i < instance_num; i++) {
185 process_instance_reference(reference,
188 final_proto_index_map,
192 collection_instance_object_count_map);
198 if (!collection_instance_object_count_map.
is_empty()) {
199 handle_collection_prototypes(
200 usd_instancer, time, instance_num, collection_instance_object_count_map);
208 compact_prototypes(usd_instancer, time, proto_wrapper_paths);
211void USDPointInstancerWriter::process_instance_reference(
217 pxr::UsdStageRefPtr stage,
218 pxr::VtArray<int> &proto_indices,
219 Vector<std::pair<int, int>> &collection_instance_object_count_map)
224 switch (reference.
type()) {
229 if (proto_index_map.
contains(ob_name)) {
230 proto_indices.push_back(proto_index_map.
lookup(ob_name));
247 if (proto_index_map.
contains(ob_name)) {
249 proto_indices.push_back(proto_index_map.
lookup(ob_name));
255 collection_instance_object_count_map.append(std::make_pair(
instance_index, object_num));
260 bke::GeometrySet geometry_set = reference.
geometry_set();
261 const StringRef set_name = geometry_set.
name();
264 proto_indices.push_back(proto_index_map.
lookup_as(set_name));
269 Vector<const bke::GeometryComponent *> components = geometry_set.get_components();
270 for (
const bke::GeometryComponent *comp : components) {
271 if (
const bke::Instances *instances =
272 static_cast<const bke::InstancesComponent &
>(*comp).get())
274 Span<int> ref_handles = instances->reference_handles();
275 Span<bke::InstanceReference> refs = instances->references();
281 if (!proto_index_map.
contains(set_name)) {
283 const bke::InstanceReference &child_ref = refs[ref_handles[
index]];
287 process_instance_reference(child_ref,
290 final_proto_index_map,
294 collection_instance_object_count_map);
300 Span<float4x4> transforms = instances->transforms();
301 if (transforms.
size() == 1) {
302 if (proto_path_map.
contains(set_name)) {
303 override_transform(stage, proto_path_map.
lookup(set_name), transforms[0]);
317void USDPointInstancerWriter::compact_prototypes(
const pxr::UsdGeomPointInstancer &usd_instancer,
318 const pxr::UsdTimeCode time,
319 const pxr::SdfPathVector &proto_paths)
const
321 pxr::UsdAttribute proto_indices_attr = usd_instancer.GetProtoIndicesAttr();
322 pxr::VtArray<int> proto_indices;
323 if (!proto_indices_attr.Get(&proto_indices, time)) {
328 Set<int> used_proto_indices;
329 used_proto_indices.add_multiple(
Span(proto_indices.cbegin(), proto_indices.size()));
333 for (
int i = 0; i < proto_paths.size(); ++i) {
334 if (used_proto_indices.contains(i)) {
335 remap.add(i, new_index++);
340 for (
int &idx : proto_indices) {
341 idx = remap.lookup(idx);
343 proto_indices_attr.Set(proto_indices, time);
345 pxr::SdfPathVector compact_proto_paths;
346 for (
int i = 0; i < proto_paths.size(); ++i) {
347 if (used_proto_indices.contains(i)) {
348 compact_proto_paths.push_back(proto_paths[i]);
352 usd_instancer.GetPrototypesRel().SetTargets(compact_proto_paths);
355void USDPointInstancerWriter::override_transform(
const pxr::UsdStageRefPtr stage,
356 const pxr::SdfPath &proto_path,
359 pxr::UsdPrim prim = stage->GetPrimAtPath(proto_path);
366 pxr::GfVec3d override_position(pos.
x, pos.
y, pos.
z);
370 pxr::GfVec3f override_rotation(euler.
x, euler.
y, euler.
z);
374 pxr::GfVec3f override_scale(scale_vec.
x, scale_vec.
y, scale_vec.
z);
376 pxr::UsdGeomXformable xformable(prim);
377 xformable.ClearXformOpOrder();
378 xformable.AddTranslateOp().Set(override_position);
379 xformable.AddRotateXYZOp().Set(override_rotation);
380 xformable.AddScaleOp().Set(override_scale);
384static pxr::VtArray<T>
DuplicateArray(
const pxr::VtArray<T> &original,
size_t copies)
386 pxr::VtArray<T> newArray;
387 size_t originalSize = original.size();
388 newArray.resize(originalSize * copies);
389 for (
size_t i = 0; i < copies; ++i) {
390 std::copy(original.begin(), original.end(), newArray.begin() + i * originalSize);
395template<
typename T,
typename GetterFunc,
typename CreatorFunc>
397 const CreatorFunc &creator,
399 const pxr::UsdTimeCode &time)
401 pxr::VtArray<T> values;
402 if (getter().Get(&values, time) && !values.empty()) {
404 creator().Set(newValues, time);
408template<
typename T,
typename GetterFunc,
typename CreatorFunc>
410 const CreatorFunc &creator,
411 const Span<std::pair<int, int>> instance_object_map,
412 const pxr::UsdTimeCode &time)
423 pxr::VtArray<T> original_values;
424 if (!getter().Get(&original_values, time) || original_values.empty()) {
428 pxr::VtArray<T> expanded_values;
429 for (
const auto &[
instance_index, object_count] : instance_object_map) {
431 for (
int i = 0; i < object_count; ++i) {
437 creator().Set(expanded_values, time);
440void USDPointInstancerWriter::handle_collection_prototypes(
441 const pxr::UsdGeomPointInstancer &usd_instancer,
442 const pxr::UsdTimeCode time,
443 const int instance_num,
444 const Span<std::pair<int, int>> collection_instance_object_count_map)
const
447 if (usd_instancer.GetPositionsAttr().HasAuthoredValue()) {
449 [&]() {
return usd_instancer.CreatePositionsAttr(); },
450 collection_instance_object_count_map,
453 if (usd_instancer.GetOrientationsAttr().HasAuthoredValue()) {
455 [&]() {
return usd_instancer.GetOrientationsAttr(); },
456 [&]() {
return usd_instancer.CreateOrientationsAttr(); },
457 collection_instance_object_count_map,
460 if (usd_instancer.GetScalesAttr().HasAuthoredValue()) {
462 [&]() {
return usd_instancer.CreateScalesAttr(); },
463 collection_instance_object_count_map,
466 if (usd_instancer.GetVelocitiesAttr().HasAuthoredValue()) {
468 [&]() {
return usd_instancer.GetVelocitiesAttr(); },
469 [&]() {
return usd_instancer.CreateVelocitiesAttr(); },
470 collection_instance_object_count_map,
473 if (usd_instancer.GetAngularVelocitiesAttr().HasAuthoredValue()) {
475 [&]() {
return usd_instancer.GetAngularVelocitiesAttr(); },
476 [&]() {
return usd_instancer.CreateAngularVelocitiesAttr(); },
477 collection_instance_object_count_map,
482 const pxr::UsdGeomPrimvarsAPI primvars_api(usd_instancer);
483 for (
const pxr::UsdGeomPrimvar &primvar : primvars_api.GetPrimvars()) {
484 if (!primvar.HasAuthoredValue()) {
487 const pxr::TfToken pv_name = primvar.GetPrimvarName();
488 const pxr::SdfValueTypeName pv_type = primvar.GetTypeName();
489 const pxr::TfToken pv_interp = primvar.GetInterpolation();
490 auto create = [&]() {
return primvars_api.CreatePrimvar(pv_name, pv_type, pv_interp); };
492 if (pv_type == pxr::SdfValueTypeNames->FloatArray) {
494 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
496 else if (pv_type == pxr::SdfValueTypeNames->IntArray) {
498 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
500 else if (pv_type == pxr::SdfValueTypeNames->UCharArray) {
502 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
504 else if (pv_type == pxr::SdfValueTypeNames->Float2Array) {
506 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
508 else if (
ELEM(pv_type,
509 pxr::SdfValueTypeNames->Float3Array,
510 pxr::SdfValueTypeNames->Color3fArray,
511 pxr::SdfValueTypeNames->Color4fArray))
514 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
516 else if (pv_type == pxr::SdfValueTypeNames->QuatfArray) {
518 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
520 else if (pv_type == pxr::SdfValueTypeNames->BoolArray) {
522 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
524 else if (pv_type == pxr::SdfValueTypeNames->StringArray) {
526 [&]() {
return primvar; },
create, collection_instance_object_count_map,
time);
535 pxr::UsdAttribute proto_indices_attr = usd_instancer.GetProtoIndicesAttr();
536 if (!proto_indices_attr.HasAuthoredValue()) {
538 for (
int i = 0; i < prototype_paths_.size(); i++) {
539 index.append_n_times(i, instance_num);
542 proto_indices_attr.Set(pxr::VtArray<int>(
index.begin(),
index.end()));
546void USDPointInstancerWriter::write_attribute_data(
const bke::AttributeIter &attr,
547 const pxr::UsdGeomPointInstancer &usd_instancer,
548 const pxr::UsdTimeCode time)
555 "Attribute '%s' (Blender domain %d, type %d) cannot be converted to USD",
558 int(attr.data_type));
567 if (attr.name ==
"mask") {
568 pxr::UsdAttribute idsAttr = usd_instancer.GetIdsAttr();
570 idsAttr = usd_instancer.CreateIdsAttr();
573 pxr::UsdAttribute invisibleIdsAttr = usd_instancer.GetInvisibleIdsAttr();
574 if (!invisibleIdsAttr) {
575 invisibleIdsAttr = usd_instancer.CreateInvisibleIdsAttr();
578 Vector<bool> mask_values(
attribute.size());
581 pxr::VtArray<int64_t> ids;
582 pxr::VtArray<int64_t> invisibleIds;
583 ids.reserve(mask_values.size());
585 for (
int64_t i = 0; i < mask_values.size(); i++) {
587 if (!mask_values[i]) {
588 invisibleIds.push_back(i);
596 const pxr::TfToken pv_name(
598 const pxr::UsdGeomPrimvarsAPI pv_api = pxr::UsdGeomPrimvarsAPI(usd_instancer);
600 pxr::UsdGeomPrimvar pv_attr = pv_api.CreatePrimvar(pv_name, *pv_type);
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_END
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN(_collection, _object)
Object groups, one object can be in many groups at once.
Object is a sort of wrapper for general info.
constexpr int64_t size() const
bool add_overwrite(const Key &key, const Value &value)
const Value & lookup(const Key &key) const
void add_new(const Key &key, const Value &value)
const Value & lookup_as(const ForwardKey &key) const
bool contains_as(const ForwardKey &key) const
bool contains(const Key &key) const
constexpr int64_t size() const
constexpr const T * end() const
constexpr const T * begin() const
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
virtual std::optional< AttributeAccessor > attributes() const
GeometrySet & geometry_set()
Collection & collection() const
const Instances * get() const
Span< int > reference_handles() const
Span< float4x4 > transforms() const
Span< InstanceReference > references() const
int instances_num() const
Span< int > unique_ids() const
const pxr::SdfPath & usd_path() const
ReportList * reports() const
pxr::UsdTimeCode get_export_time_code() const
pxr::UsdUtilsSparseValueWriter usd_value_writer_
USDAbstractWriter(const USDExporterContext &usd_export_context)
const USDExporterContext usd_export_context_
USDPointInstancerWriter(const USDExporterContext &ctx, const Set< std::pair< pxr::SdfPath, Object * > > &prototype_paths, std::unique_ptr< USDAbstractWriter > base_writer)
void do_write(HierarchyContext &context) override
std::unique_ptr< IDProperty, IDPropertyDeleter > create(StringRef prop_name, int32_t value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_INT, set its name and value.
bool attribute_name_is_anonymous(const StringRef name)
GeometrySet object_get_evaluated_geometry_set(const Object &object, bool apply_subdiv=true)
std::string time(const std::tm &date_time, TimeFormat format=TimeFormat::H24)
void copy_blender_attribute_to_primvar(const GVArray &attribute, const bke::AttrType data_type, const pxr::UsdTimeCode time, const pxr::UsdGeomPrimvar &primvar, pxr::UsdUtilsSparseValueWriter &value_writer)
std::optional< pxr::SdfValueTypeName > convert_blender_type_to_usd(const bke::AttrType blender_type, bool use_color3f_type)
static pxr::VtArray< T > DuplicateArray(const pxr::VtArray< T > &original, size_t copies)
void set_attribute(const pxr::UsdAttribute &attr, const USDT value, pxr::UsdTimeCode time, pxr::UsdUtilsSparseValueWriter &value_writer)
static void ExpandAttributePerInstance(const GetterFunc &getter, const CreatorFunc &creator, const Span< std::pair< int, int > > instance_object_map, const pxr::UsdTimeCode &time)
static void DuplicatePerInstanceAttribute(const GetterFunc &getter, const CreatorFunc &creator, size_t copies, const pxr::UsdTimeCode &time)
std::string make_safe_primvar_name(const StringRef name, bool allow_unicode)
QuaternionBase< float > Quaternion
QuaternionBase< T > to_quaternion(const AxisAngleBase< T, AngleT > &axis_angle)
EulerXYZBase< float > EulerXYZ
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
VecBase< T, 3 > to_scale(const MatBase< T, NumCol, NumRow > &mat)
Euler3Base< T > to_euler(const AxisAngleBase< T, AngleT > &axis_angle, EulerOrder order)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MatBase< float, 4, 4 > float4x4
const char * BKE_id_name(const ID &id)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
VecBase< float, 3 > float3
float4 transform(float4 hs_position)
static MatBase identity()
StringRefNull name() const
const GeometryComponent * get_component(GeometryComponent::Type component_type) const
std::function< void(const Object *, const pxr::SdfPath &)> add_skel_mapping_fn
const USDExportParams & export_params
const pxr::SdfPath usd_path
const pxr::UsdStageRefPtr stage