8#include <pxr/usd/usdGeom/basisCurves.h>
9#include <pxr/usd/usdGeom/curves.h>
10#include <pxr/usd/usdGeom/nurbsCurves.h>
11#include <pxr/usd/usdGeom/primvar.h>
12#include <pxr/usd/usdGeom/primvarsAPI.h>
13#include <pxr/usd/usdGeom/tokens.h>
14#include <pxr/usd/usdShade/material.h>
15#include <pxr/usd/usdShade/materialBindingAPI.h>
47pxr::UsdGeomBasisCurves USDCurvesWriter::DefineUsdGeomBasisCurves(pxr::VtValue curve_basis,
49 const bool is_cubic)
const
51 pxr::UsdGeomBasisCurves basis_curves = pxr::UsdGeomBasisCurves::Define(
56 basis_curves.CreateTypeAttr(pxr::VtValue(pxr::UsdGeomTokens->cubic));
57 basis_curves.CreateBasisAttr(curve_basis);
60 basis_curves.CreateTypeAttr(pxr::VtValue(pxr::UsdGeomTokens->linear));
64 basis_curves.CreateWrapAttr(pxr::VtValue(pxr::UsdGeomTokens->periodic));
66 else if (curve_basis == pxr::VtValue(pxr::UsdGeomTokens->catmullRom)) {
71 basis_curves.CreateWrapAttr(pxr::VtValue(pxr::UsdGeomTokens->pinned));
74 basis_curves.CreateWrapAttr(pxr::VtValue(pxr::UsdGeomTokens->nonperiodic));
84 widths.resize(radii.
size());
86 widths[i] = radii[i] * 2.0f;
91 const pxr::VtArray<int> &segments,
92 const pxr::VtIntArray &control_point_counts,
97 return pxr::TfToken();
100 const size_t accumulated_control_point_count = std::accumulate(
101 control_point_counts.begin(), control_point_counts.end(), 0);
106 if (widths.size() == accumulated_control_point_count) {
107 return pxr::UsdGeomTokens->vertex;
110 size_t expectedVaryingSize = std::accumulate(segments.begin(), segments.end(), 0);
112 expectedVaryingSize += control_point_counts.size();
115 if (widths.size() == expectedVaryingSize) {
116 return pxr::UsdGeomTokens->varying;
120 return pxr::TfToken();
125 pxr::VtArray<pxr::GfVec3f> &verts,
126 pxr::VtIntArray &control_point_counts,
127 pxr::VtArray<int> &segments,
128 const bool is_cyclic,
132 for (
const int i_curve :
curves.curves_range()) {
134 const IndexRange points = points_by_curve[i_curve];
135 for (
const int i_point : points) {
137 pxr::GfVec3f(positions[i_point][0], positions[i_point][1], positions[i_point][2]));
140 const int tot_points = points.
size();
141 control_point_counts[i_curve] = tot_points;
150 segments[i_curve] = tot_points;
153 segments[i_curve] = (tot_points - 4) + 1;
156 segments[i_curve] = tot_points - 1;
162 pxr::VtArray<pxr::GfVec3f> &verts,
163 pxr::VtIntArray &control_point_counts,
164 pxr::VtArray<float> &widths,
165 pxr::TfToken &interpolation,
166 const bool is_cyclic,
170 const int num_curves =
curves.curve_num;
173 pxr::VtArray<int> segments(num_curves);
176 curves, positions, verts, control_point_counts, segments, is_cyclic, is_cubic);
180 widths, segments, control_point_counts, is_cyclic, reports);
187 pxr::VtArray<pxr::GfVec3f> &verts,
188 pxr::VtIntArray &control_point_counts,
189 pxr::VtArray<int> &segments,
190 const bool is_cyclic)
192 const int bezier_vstep = 3;
195 for (
const int i_curve :
curves.curves_range()) {
197 const IndexRange points = points_by_curve[i_curve];
198 const int start_point_index = points[0];
199 const int last_point_index = points[points.
size() - 1];
201 const int start_verts_count = verts.
size();
203 for (
int i_point = start_point_index; i_point < last_point_index; i_point++) {
210 pxr::GfVec3f(positions[i_point][0], positions[i_point][1], positions[i_point][2]));
212 const float3 right_handle = handles_r[i_point];
213 verts.push_back(pxr::GfVec3f(right_handle[0], right_handle[1], right_handle[2]));
215 const float3 left_handle = handles_l[i_point + 1];
216 verts.push_back(pxr::GfVec3f(left_handle[0], left_handle[1], left_handle[2]));
219 verts.push_back(pxr::GfVec3f(positions[last_point_index][0],
220 positions[last_point_index][1],
221 positions[last_point_index][2]));
227 const float3 right_handle = handles_r[last_point_index];
228 verts.push_back(pxr::GfVec3f(right_handle[0], right_handle[1], right_handle[2]));
230 const float3 left_handle = handles_l[start_point_index];
231 verts.push_back(pxr::GfVec3f(left_handle[0], left_handle[1], left_handle[2]));
234 const int tot_points = verts.size() - start_verts_count;
235 control_point_counts[i_curve] = tot_points;
238 segments[i_curve] = tot_points / bezier_vstep;
241 segments[i_curve] = ((tot_points - 4) / bezier_vstep) + 1;
247 pxr::VtArray<pxr::GfVec3f> &verts,
248 pxr::VtIntArray &control_point_counts,
249 pxr::VtArray<float> &widths,
250 pxr::TfToken &interpolation,
251 const bool is_cyclic,
254 const int num_curves =
curves.curve_num;
257 const std::optional<Span<float3>> handles_l =
curves.handle_positions_left();
258 const std::optional<Span<float3>> handles_r =
curves.handle_positions_right();
260 pxr::VtArray<int> segments(num_curves);
267 control_point_counts,
273 widths, segments, control_point_counts, is_cyclic, reports);
277 pxr::VtArray<pxr::GfVec3f> &verts,
278 pxr::VtIntArray &control_point_counts,
279 pxr::VtArray<float> &widths,
280 pxr::VtArray<double> &knots,
281 pxr::VtArray<double> &weights,
282 pxr::VtArray<int> &orders,
283 pxr::TfToken &interpolation,
284 const bool is_cyclic)
288 const int num_curves =
curves.curve_num;
289 orders.resize(num_curves);
293 const std::optional<Span<float>> nurbs_weights =
curves.nurbs_weights();
301 for (
const int i_curve :
curves.curves_range()) {
302 const IndexRange points = points_by_curve[i_curve];
303 const size_t curr_vert_num = verts.
size();
304 for (
const int i_point : points) {
306 pxr::GfVec3f(positions[i_point][0], positions[i_point][1], positions[i_point][2]));
307 widths.push_back(radii[i_point] * 2.0f);
311 for (
const int i_point : points) {
312 weights.push_back((*nurbs_weights)[i_point]);
318 for (
const int i_point : points.
take_front(geom_orders[i_curve] - 1)) {
320 pxr::GfVec3f(positions[i_point][0], positions[i_point][1], positions[i_point][2]));
321 widths.push_back(radii[i_point] * 2.0f);
323 weights.push_back((*nurbs_weights)[i_point]);
328 const int tot_blender_points = int(points.
size());
329 const int tot_usd_points = int(verts.size() - curr_vert_num);
330 control_point_counts[i_curve] = tot_usd_points;
332 const int8_t order = geom_orders[i_curve];
333 orders[i_curve] = int(geom_orders[i_curve]);
343 custom_knots_by_curve[i_curve],
349 for (
int i_knot = 0; i_knot < knots_num; i_knot++) {
350 knots.push_back(
double(temp_knots[i_knot]));
355 int zeroth_knot_index = knots.size() - knots_num;
357 knots[zeroth_knot_index] = knots[zeroth_knot_index + 1] -
358 (knots[knots.size() - 2] - knots[knots.size() - 3]);
359 knots[knots.size() - 1] = knots[knots.size() - 2] +
360 (knots[zeroth_knot_index + 2] - knots[zeroth_knot_index + 1]);
363 knots[zeroth_knot_index] = knots[zeroth_knot_index + 1];
364 knots[knots.size() - 1] = knots[knots.size() - 2];
368 interpolation = pxr::UsdGeomTokens->vertex;
371void USDCurvesWriter::set_writer_attributes_for_nurbs(
372 const pxr::UsdGeomNurbsCurves &usd_nurbs_curves,
373 pxr::VtArray<double> &knots,
374 pxr::VtArray<double> &weights,
375 pxr::VtArray<int> &orders,
376 const pxr::UsdTimeCode time)
378 pxr::UsdAttribute attr_knots = usd_nurbs_curves.CreateKnotsAttr(pxr::VtValue(),
true);
380 pxr::UsdAttribute attr_weights = usd_nurbs_curves.CreatePointWeightsAttr(pxr::VtValue(),
true);
382 pxr::UsdAttribute attr_order = usd_nurbs_curves.CreateOrderAttr(pxr::VtValue(),
true);
386void USDCurvesWriter::set_writer_attributes(pxr::UsdGeomCurves &usd_curves,
387 pxr::VtArray<pxr::GfVec3f> &verts,
388 pxr::VtIntArray &control_point_counts,
389 pxr::VtArray<float> &widths,
390 const pxr::UsdTimeCode time,
391 const pxr::TfToken interpolation)
393 pxr::UsdAttribute attr_points = usd_curves.CreatePointsAttr(pxr::VtValue(),
true);
396 pxr::UsdAttribute attr_counts = usd_curves.CreateCurveVertexCountsAttr(pxr::VtValue(),
true);
399 pxr::UsdAttribute attr_widths = usd_curves.CreateWidthsAttr(pxr::VtValue(),
true);
402 if (!interpolation.IsEmpty()) {
403 usd_curves.SetWidthsInterpolation(interpolation);
410 switch (blender_domain) {
412 return is_bezier ? pxr::UsdGeomTokens->varying : pxr::UsdGeomTokens->vertex;
414 return pxr::UsdGeomTokens->uniform;
436 set.
add_new(
"handle_type_left");
437 set.
add_new(
"handle_type_right");
445 return excluded_attrs.
contains(name);
450 const pxr::UsdGeomCurves &usd_curves)
459 if (!pv_interp || !pv_type) {
462 "Attribute '%s' (Blender domain %d, type %d) cannot be converted to USD",
475 const pxr::TfToken pv_name(
477 const pxr::UsdGeomPrimvarsAPI pv_api = pxr::UsdGeomPrimvarsAPI(usd_curves);
479 pxr::UsdGeomPrimvar pv_attr = pv_api.CreatePrimvar(pv_name, *pv_type, *pv_interp);
484void USDCurvesWriter::write_uv_data(
const bke::AttributeIter &attr,
485 const pxr::UsdGeomCurves &usd_curves)
488 if (buffer.is_empty()) {
493 const pxr::TfToken pv_name(
495 const pxr::UsdGeomPrimvarsAPI pv_api = pxr::UsdGeomPrimvarsAPI(usd_curves);
497 pxr::UsdGeomPrimvar pv_uv = pv_api.CreatePrimvar(
498 pv_name, pxr::SdfValueTypeNames->TexCoord2fArray, pxr::UsdGeomTokens->
uniform);
503void USDCurvesWriter::write_velocities(
const bke::CurvesGeometry &curves,
504 const pxr::UsdGeomCurves &usd_curves)
506 const VArraySpan
velocity = *curves.attributes().lookup<
float3>(
"velocity",
513 Span<pxr::GfVec3f>
data =
velocity.cast<pxr::GfVec3f>();
514 pxr::VtVec3fArray usd_velocities;
515 usd_velocities.assign(
data.begin(),
data.end());
518 pxr::UsdAttribute attr_vel = usd_curves.CreateVelocitiesAttr(pxr::VtValue(),
true);
522void USDCurvesWriter::write_custom_data(
const bke::CurvesGeometry &curves,
523 const pxr::UsdGeomCurves &usd_curves)
525 const bke::AttributeAccessor attributes = curves.attributes();
527 attributes.foreach_attribute([&](
const bke::AttributeIter &iter) {
538 this->write_uv_data(iter, usd_curves);
544 this->write_generic_data(curves, iter, usd_curves);
552 std::unique_ptr<
Curves, std::function<void(
Curves *)>> converted_curves;
555 switch (context.object->type) {
557 const Curve *legacy_curve = id_cast<Curve *>(context.object->data);
558 converted_curves = std::unique_ptr<
Curves, std::function<void(
Curves *)>>(
560 curves_id = converted_curves.get();
565 curves_id = id_cast<Curves *>(context.object->data);
575 const std::array<int, CURVE_TYPES_NUM> &curve_type_counts =
curves.curve_type_counts();
576 const int number_of_curve_types = std::count_if(curve_type_counts.begin(),
577 curve_type_counts.end(),
578 [](
const int count) { return count > 0; });
579 if (number_of_curve_types > 1) {
588 "Cannot export mixed cyclic and non-cyclic curves in the same Curves object");
593 const int8_t curve_type_fallback = first_frame_curve_type == -1 ? curve_type_default :
594 first_frame_curve_type;
598 if (first_frame_curve_type == -1) {
599 first_frame_curve_type = curve_type;
601 else if (first_frame_curve_type != curve_type) {
602 const char *first_frame_curve_type_name =
nullptr;
606 const char *current_curve_type_name =
nullptr;
612 "USD does not support animating curve types. The curve type changes from %s to "
614 IFACE_(first_frame_curve_type_name),
615 IFACE_(current_curve_type_name),
620 const bool is_cyclic =
curves.curves_num() > 0 ?
curves.cyclic().first() :
false;
621 pxr::VtArray<pxr::GfVec3f> verts;
622 pxr::VtIntArray control_point_counts;
623 pxr::VtArray<float> widths;
624 pxr::TfToken interpolation;
626 pxr::UsdGeomBasisCurves usd_basis_curves;
627 pxr::UsdGeomNurbsCurves usd_nurbs_curves;
628 pxr::UsdGeomCurves *usd_curves =
nullptr;
630 control_point_counts.resize(
curves.curves_num());
631 switch (curve_type) {
633 usd_basis_curves = DefineUsdGeomBasisCurves(pxr::VtValue(), is_cyclic,
false);
634 usd_curves = &usd_basis_curves;
637 curves, verts, control_point_counts, widths, interpolation, is_cyclic,
false,
reports());
640 usd_basis_curves = DefineUsdGeomBasisCurves(
641 pxr::VtValue(pxr::UsdGeomTokens->catmullRom), is_cyclic,
true);
642 usd_curves = &usd_basis_curves;
645 curves, verts, control_point_counts, widths, interpolation, is_cyclic,
true,
reports());
648 usd_basis_curves = DefineUsdGeomBasisCurves(
649 pxr::VtValue(pxr::UsdGeomTokens->bezier), is_cyclic,
true);
650 usd_curves = &usd_basis_curves;
653 curves, verts, control_point_counts, widths, interpolation, is_cyclic,
reports());
656 pxr::VtArray<double> knots;
657 pxr::VtArray<double> weights;
658 pxr::VtArray<int> orders;
662 usd_curves = &usd_nurbs_curves;
666 control_point_counts,
674 set_writer_attributes_for_nurbs(usd_nurbs_curves, knots, weights, orders, time);
682 this->set_writer_attributes(
683 *usd_curves, verts, control_point_counts, widths, time, interpolation);
689 this->write_velocities(
curves, *usd_curves);
690 this->write_custom_data(
curves, *usd_curves);
694 const pxr::UsdPrim prim = usd_curves->GetPrim();
703 const pxr::UsdGeomCurves &usd_curves)
714 bool curve_material_bound =
false;
715 for (
int mat_num = 0; mat_num < totcol; mat_num++) {
717 if (material ==
nullptr) {
721 pxr::UsdPrim curve_prim = usd_curves.GetPrim();
722 pxr::UsdShadeMaterialBindingAPI api = pxr::UsdShadeMaterialBindingAPI(curve_prim);
724 api.Bind(usd_material);
725 pxr::UsdShadeMaterialBindingAPI::Apply(curve_prim);
729 usd_curves.CreateDoubleSidedAttr(
732 curve_material_bound =
true;
736 if (!curve_material_bound) {
738 usd_curves.CreateDoubleSidedAttr(pxr::VtValue(
true));
Low-level operations for curves.
General operations, lookup, etc. for materials.
Object is a sort of wrapper for general info.
#define BLI_assert_unreachable()
constexpr int64_t size() const
constexpr IndexRange take_front(int64_t n) const
bool contains(const Key &key) const
void add_new(const Key &key)
constexpr const char * c_str() const
IndexRange index_range() const
GAttributeReader get() const
constexpr bool is_empty() const
pxr::UsdShadeMaterial ensure_usd_material(const HierarchyContext &context, Material *material) const
void author_extent(const pxr::UsdGeomBoundable &boundable, const pxr::UsdTimeCode time)
void add_to_prim_map(const pxr::SdfPath &usd_path, const ID *id) const
ReportList * reports() const
pxr::UsdTimeCode get_export_time_code() const
pxr::UsdUtilsSparseValueWriter usd_value_writer_
void write_id_properties(const pxr::UsdPrim &prim, const ID &id, pxr::UsdTimeCode=pxr::UsdTimeCode::Default()) const
const USDExporterContext usd_export_context_
void do_write(HierarchyContext &context) override
void assign_materials(const HierarchyContext &context, const pxr::UsdGeomCurves &usd_curves)
BooleanMix booleans_mix_calc(const VArray< bool > &varray, IndexRange range_to_check)
int knots_num(int points_num, int8_t order, bool cyclic)
void load_curve_knots(KnotsMode mode, int points_num, int8_t order, bool cyclic, IndexRange curve_knots, Span< float > custom_knots, MutableSpan< float > knots)
bool attribute_name_is_anonymous(const StringRef name)
Curves * curve_legacy_to_curves(const Curve &curve_legacy)
std::string time(const std::tm &date_time, TimeFormat format=TimeFormat::H24)
static pxr::TfToken get_curve_width_interpolation(const pxr::VtArray< float > &widths, const pxr::VtArray< int > &segments, const pxr::VtIntArray &control_point_counts, const bool is_cyclic, ReportList *reports)
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)
static bool is_excluded_attr(StringRefNull name)
std::optional< pxr::SdfValueTypeName > convert_blender_type_to_usd(const bke::AttrType blender_type, bool use_color3f_type)
void copy_blender_buffer_to_primvar(const VArray< BlenderT > &buffer, const pxr::UsdTimeCode time, const pxr::UsdGeomPrimvar &primvar, pxr::UsdUtilsSparseValueWriter &value_writer)
static void populate_curve_props_for_bezier(const bke::CurvesGeometry &curves, pxr::VtArray< pxr::GfVec3f > &verts, pxr::VtIntArray &control_point_counts, pxr::VtArray< float > &widths, pxr::TfToken &interpolation, const bool is_cyclic, ReportList *reports)
static std::optional< pxr::TfToken > convert_blender_domain_to_usd(const bke::AttrDomain blender_domain, bool is_bezier)
static void populate_curve_verts(const bke::CurvesGeometry &curves, const Span< float3 > positions, pxr::VtArray< pxr::GfVec3f > &verts, pxr::VtIntArray &control_point_counts, pxr::VtArray< int > &segments, const bool is_cyclic, const bool is_cubic)
static void populate_curve_props(const bke::CurvesGeometry &curves, pxr::VtArray< pxr::GfVec3f > &verts, pxr::VtIntArray &control_point_counts, pxr::VtArray< float > &widths, pxr::TfToken &interpolation, const bool is_cyclic, const bool is_cubic, ReportList *reports)
static void populate_curve_verts_for_bezier(const bke::CurvesGeometry &curves, const Span< float3 > positions, const Span< float3 > handles_l, const Span< float3 > handles_r, pxr::VtArray< pxr::GfVec3f > &verts, pxr::VtIntArray &control_point_counts, pxr::VtArray< int > &segments, const bool is_cyclic)
void set_attribute(const pxr::UsdAttribute &attr, const USDT value, pxr::UsdTimeCode time, pxr::UsdUtilsSparseValueWriter &value_writer)
static void populate_curve_widths(const bke::CurvesGeometry &curves, pxr::VtArray< float > &widths)
static void populate_curve_props_for_nurbs(const bke::CurvesGeometry &curves, pxr::VtArray< pxr::GfVec3f > &verts, pxr::VtIntArray &control_point_counts, pxr::VtArray< float > &widths, pxr::VtArray< double > &knots, pxr::VtArray< double > &weights, pxr::VtArray< int > &orders, pxr::TfToken &interpolation, const bool is_cyclic)
std::string make_safe_primvar_name(const StringRef name, bool allow_unicode)
constexpr StringRefNull velocity
int BKE_object_material_count_eval(const Object *ob)
const EnumPropertyItem rna_enum_curves_type_items[]
VecBase< float, 2 > float2
bool RNA_enum_name_from_value(const EnumPropertyItem *item, int value, const char **r_name)
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
void BKE_id_free(Main *bmain, void *idv)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Material * BKE_object_material_get_eval(Object *ob, short act)
VecBase< float, 3 > float3
const USDExportParams & export_params
const pxr::SdfPath usd_path
const pxr::UsdStageRefPtr stage