Blender V5.3
usd_reader_curve.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later
4 * Adapted from the Blender Alembic importer implementation. Copyright 2016 Kévin Dietrich.
5 * Modifications Copyright 2021 Tangent Animation. All rights reserved. */
6
7#include "usd_reader_curve.hh"
8#include "usd.hh"
10
11#include "BKE_attribute.hh"
12#include "BKE_curves.hh"
13#include "BKE_geometry_set.hh"
14#include "BKE_object.hh"
15#include "BKE_report.hh"
16
17#include "BLI_index_range.hh"
19
20#include "DNA_curves_types.h"
21#include "DNA_object_types.h"
22
23#include <pxr/base/vt/types.h>
24#include <pxr/usd/usdGeom/basisCurves.h>
25#include <pxr/usd/usdGeom/primvarsAPI.h>
26
27namespace blender::io::usd {
28
29static inline float3 to_float3(pxr::GfVec3f vec3f)
30{
31 return float3(vec3f.data());
32}
33
34static inline int bezier_point_count(int usd_count, bool is_cyclic)
35{
36 return is_cyclic ? (usd_count / 3) : ((usd_count / 3) + 1);
37}
38
39static int point_count(int usdCount, CurveType curve_type, bool is_cyclic)
40{
41 if (curve_type == CURVE_TYPE_BEZIER) {
42 return bezier_point_count(usdCount, is_cyclic);
43 }
44 return usdCount;
45}
46
47static Array<int> calc_curve_offsets(const pxr::VtIntArray &usdCounts,
48 const CurveType curve_type,
49 bool is_cyclic)
50{
51 Array<int> offsets(usdCounts.size() + 1);
52 threading::parallel_for(IndexRange(usdCounts.size()), 4096, [&](const IndexRange range) {
53 for (const int i : range) {
54 offsets[i] = point_count(usdCounts[i], curve_type, is_cyclic);
55 }
56 });
58 return offsets;
59}
60
61static void add_bezier_control_point(int cp,
62 int offset,
63 MutableSpan<float3> positions,
64 MutableSpan<float3> handles_left,
65 MutableSpan<float3> handles_right,
66 const Span<pxr::GfVec3f> usdPoints)
67{
68 if (offset == 0) {
69 positions[cp] = to_float3(usdPoints[offset]);
70 handles_right[cp] = to_float3(usdPoints[offset + 1]);
71 handles_left[cp] = 2.0f * positions[cp] - handles_right[cp];
72 }
73 else if (offset >= usdPoints.size() - 1) {
74 positions[cp] = to_float3(usdPoints.last());
75 handles_left[cp] = to_float3(usdPoints.last(1));
76 handles_right[cp] = 2.0f * positions[cp] - handles_left[cp];
77 }
78 else {
79 positions[cp] = to_float3(usdPoints[offset]);
80 handles_left[cp] = to_float3(usdPoints[offset - 1]);
81 handles_right[cp] = to_float3(usdPoints[offset + 1]);
82 }
83}
84
86static bool curves_topology_changed(const bke::CurvesGeometry &curves, const Span<int> usd_offsets)
87{
88 if (curves.offsets() != usd_offsets) {
89 return true;
90 }
91
92 return false;
93}
94
95static CurveType get_curve_type(pxr::TfToken type, pxr::TfToken basis)
96{
97 if (type == pxr::UsdGeomTokens->cubic) {
98 if (basis == pxr::UsdGeomTokens->bezier) {
99 return CURVE_TYPE_BEZIER;
100 }
101 if (basis == pxr::UsdGeomTokens->bspline) {
102 return CURVE_TYPE_NURBS;
103 }
104 if (basis == pxr::UsdGeomTokens->catmullRom) {
106 }
107 }
108
109 return CURVE_TYPE_POLY;
110}
111
112static std::optional<bke::AttrDomain> convert_usd_interp_to_blender(const pxr::TfToken usd_domain)
113{
114 static const Map<pxr::TfToken, bke::AttrDomain> domain_map = []() {
116 map.add_new(pxr::UsdGeomTokens->vertex, bke::AttrDomain::Point);
117 map.add_new(pxr::UsdGeomTokens->varying, bke::AttrDomain::Point);
118 map.add_new(pxr::UsdGeomTokens->constant, bke::AttrDomain::Curve);
119 map.add_new(pxr::UsdGeomTokens->uniform, bke::AttrDomain::Curve);
120 return map;
121 }();
122
123 const bke::AttrDomain *value = domain_map.lookup_ptr(usd_domain);
124
125 if (value == nullptr) {
126 return std::nullopt;
127 }
128
129 return *value;
130}
131
133{
134 Curves *curve = BKE_curves_add(bmain, name_.c_str());
135
137 object_->data = id_cast<ID *>(curve);
138}
139
140void USDCurvesReader::read_object_data(Main *bmain, pxr::UsdTimeCode time)
141{
142 Curves *cu = id_cast<Curves *>(object_->data);
143 this->read_curve_sample(cu, time);
144
145 if (this->is_animated()) {
146 this->add_cache_modifier();
147 }
148
150}
151
153 const pxr::UsdGeomCurves &usd_curves,
154 const pxr::UsdTimeCode time) const
155{
156 pxr::VtVec3fArray velocities;
157 usd_curves.GetVelocitiesAttr().Get(&velocities, time);
158
159 if (!velocities.empty()) {
160 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
163
164 Span<pxr::GfVec3f> usd_data(velocities.cdata(), velocities.size());
165 velocity.span.copy_from(usd_data.cast<float3>());
166 velocity.finish();
167 }
168}
169
171 const pxr::UsdTimeCode time) const
172{
173 pxr::UsdGeomPrimvarsAPI pv_api(prim_);
174
175 std::vector<pxr::UsdGeomPrimvar> primvars = pv_api.GetPrimvarsWithValues();
176 for (const pxr::UsdGeomPrimvar &pv : primvars) {
177 const pxr::SdfValueTypeName pv_type = pv.GetTypeName();
178 if (!pv_type.IsArray()) {
179 continue; /* Skip non-array primvar attributes. */
180 }
181
182 const pxr::TfToken pv_interp = pv.GetInterpolation();
183 const std::optional<bke::AttrDomain> domain = convert_usd_interp_to_blender(pv_interp);
184 const std::optional<bke::AttrType> type = convert_usd_type_to_blender(pv_type);
185
186 if (!domain.has_value() || !type.has_value()) {
187 const pxr::TfToken pv_name = pxr::UsdGeomPrimvar::StripPrimvarsName(pv.GetPrimvarName());
190 "Primvar '%s' (interpolation %s, type %s) cannot be converted to Blender",
191 pv_name.GetText(),
192 pv_interp.GetText(),
193 pv_type.GetAsToken().GetText());
194 continue;
195 }
196
197 bke::MutableAttributeAccessor attributes = curves.attributes_for_write();
198 copy_primvar_to_blender_attribute(pv, time, *type, *domain, {}, attributes);
199 }
200}
201
203 const USDMeshReadParams params,
204 const char ** /*r_err_str*/)
205{
206 if (!geometry_set.has_curves()) {
207 return;
208 }
209
210 Curves *curves = geometry_set.get_curves_for_write();
212}
213
215{
216 if (curve_prim_.GetPointsAttr().ValueMightBeTimeVarying() ||
217 curve_prim_.GetWidthsAttr().ValueMightBeTimeVarying() ||
218 curve_prim_.GetVelocitiesAttr().ValueMightBeTimeVarying())
219 {
220 return true;
221 }
222
223 pxr::UsdGeomPrimvarsAPI pv_api(curve_prim_);
224 for (const pxr::UsdGeomPrimvar &pv : pv_api.GetPrimvarsWithValues()) {
225 if (pv.ValueMightBeTimeVarying()) {
226 return true;
227 }
228 }
229
230 return false;
231}
232
233void USDBasisCurvesReader::read_curve_sample(Curves *curves_id, const pxr::UsdTimeCode time)
234{
235 pxr::VtIntArray usd_counts;
236 pxr::VtVec3fArray usd_points;
237 pxr::VtFloatArray usd_widths;
238 pxr::TfToken basis;
239 pxr::TfToken type;
240 pxr::TfToken wrap;
241
242 curve_prim_.GetCurveVertexCountsAttr().Get(&usd_counts, time);
243 curve_prim_.GetPointsAttr().Get(&usd_points, time);
244 curve_prim_.GetWidthsAttr().Get(&usd_widths, time);
245 curve_prim_.GetBasisAttr().Get(&basis, time);
246 curve_prim_.GetTypeAttr().Get(&type, time);
247 curve_prim_.GetWrapAttr().Get(&wrap, time);
248
249 const CurveType curve_type = get_curve_type(type, basis);
250 const bool is_cyclic = wrap == pxr::UsdGeomTokens->periodic;
251 const int curves_num = usd_counts.size();
252 const Array<int> new_offsets = calc_curve_offsets(usd_counts, curve_type, is_cyclic);
253
254 // Check validity of curve counts
255 const int min_points = (curve_type == CURVE_TYPE_BEZIER) ? 3 : 1;
256 const bool all_valid = std::all_of(usd_counts.cbegin(),
257 usd_counts.cend(),
258 [min_points](int count) { return count >= min_points; });
259
260 bke::CurvesGeometry &curves = curves_id->geometry.wrap();
261 if (all_valid && curves_topology_changed(curves, new_offsets)) {
262 curves.resize(new_offsets.last(), curves_num);
263 }
264
265 // Early out if there are no curves to load.
266 if (curves.is_empty()) {
267 return;
268 }
269
270 curves.offsets_for_write().copy_from(new_offsets);
271 curves.fill_curve_types(curve_type);
272
273 if (is_cyclic) {
274 curves.attributes_for_write().add<bool>(
276 }
277
278 if (curve_type == CURVE_TYPE_NURBS) {
279 const int8_t curve_order = type == pxr::UsdGeomTokens->cubic ? 4 : 2;
280 curves.attributes_for_write().add<int8_t>(
281 "nurbs_order", bke::AttrDomain::Curve, bke::AttributeInitValue(curve_order));
282 }
283
284 MutableSpan<float3> positions = curves.positions_for_write();
285 Span<pxr::GfVec3f> points = Span(usd_points.cdata(), usd_points.size());
286 Span<int> counts = Span(usd_counts.cdata(), usd_counts.size());
287
288 /* If there's no points defined, fill positions with default values and exit. */
289 if (points.is_empty()) {
290 positions.fill(float3(0.0f, 0.0f, 0.0f));
291 return;
292 }
293
294 /* Bezier curves require care in filing out their left/right handles. */
295 if (type == pxr::UsdGeomTokens->cubic && basis == pxr::UsdGeomTokens->bezier) {
296 curves.handle_types_left_for_write().fill(BEZIER_HANDLE_ALIGN);
297 curves.handle_types_right_for_write().fill(BEZIER_HANDLE_ALIGN);
298
299 MutableSpan<float3> handles_right = curves.handle_positions_right_for_write();
300 MutableSpan<float3> handles_left = curves.handle_positions_left_for_write();
301
302 int usd_point_offset = 0;
303 int point_offset = 0;
304 for (const int i : curves.curves_range()) {
305 const int usd_point_count = counts[i];
306 const int point_count = bezier_point_count(usd_point_count, is_cyclic);
307
308 int cp_offset = 0;
309 for (const int cp : IndexRange(point_count)) {
311 cp_offset,
312 positions.slice(point_offset, point_count),
313 handles_left.slice(point_offset, point_count),
314 handles_right.slice(point_offset, point_count),
315 points.slice_safe(usd_point_offset, usd_point_count));
316 cp_offset += 3;
317 }
318
319 point_offset += point_count;
320 usd_point_offset += usd_point_count;
321 }
322 }
323 else {
324 static_assert(sizeof(pxr::GfVec3f) == sizeof(float3));
325 if (positions.size() != points.size()) {
326 positions.fill(float3(0.0f, 0.0f, 0.0f));
327 }
328 const int copy_size = std::min(positions.size(), points.size());
329 positions.slice(0, copy_size).copy_from(points.slice(0, copy_size).cast<float3>());
330 }
331
332 if (!usd_widths.empty()) {
333 Span<float> widths = Span(usd_widths.cdata(), usd_widths.size());
334
335 pxr::TfToken widths_interp = curve_prim_.GetWidthsInterpolation();
336 if (widths_interp == pxr::UsdGeomTokens->constant || widths.size() == 1) {
337 set_single_value(curves.attributes_for_write(),
338 "radius",
341 bke::AttributeInitValue(widths[0] / 2.0f));
342 }
343 else {
344 MutableSpan<float> radii = curves.radius_for_write();
345
346 const bool is_bezier_vertex_interp = (type == pxr::UsdGeomTokens->cubic &&
347 basis == pxr::UsdGeomTokens->bezier &&
348 widths_interp == pxr::UsdGeomTokens->vertex);
349 const bool is_bspline_varying_interp = (type == pxr::UsdGeomTokens->cubic &&
350 basis == pxr::UsdGeomTokens->bspline &&
351 widths_interp == pxr::UsdGeomTokens->varying);
352 const bool is_catmull_varying_interp = (type == pxr::UsdGeomTokens->cubic &&
353 basis == pxr::UsdGeomTokens->catmullRom &&
354 widths_interp == pxr::UsdGeomTokens->varying);
355 if (is_bezier_vertex_interp) {
356 /* Blender does not support bezier 'vertex' interpolation.
357 * Assign the widths as-if it were 'varying' only. */
358 int usd_point_offset = 0;
359 int point_offset = 0;
360 for (const int i : curves.curves_range()) {
361 const int usd_point_count = counts[i];
362 const int point_count = bezier_point_count(usd_point_count, is_cyclic);
363
364 int cp_offset = 0;
365 for (const int cp : IndexRange(point_count)) {
366 const int usd_index = std::min(usd_point_offset + cp_offset, int(widths.size()) - 1);
367 radii[point_offset + cp] = widths[usd_index] / 2.0f;
368 cp_offset += 3;
369 }
370
371 point_offset += point_count;
372 usd_point_offset += usd_point_count;
373 }
374 }
375 else if (!is_cyclic && (is_bspline_varying_interp || is_catmull_varying_interp)) {
376 /* Blender does not support general cubic 'varying' interpolation. Duplicate the first/last
377 * radius values as a best-effort solution. */
378 int radii_offset = 0;
379 int width_offset = 0;
380 for (const int i : curves.curves_range()) {
381 const int radii_count = counts[i];
382 const int width_count = std::max(2, counts[i] - 2);
383
384 Span<float> usd_curve_widths = widths.slice_safe(width_offset, width_count);
385 MutableSpan<float> curve_radii = radii.slice_safe(radii_offset, radii_count);
386 if (usd_curve_widths.size() != width_count || curve_radii.size() != radii_count) {
387 /* Generally unsafe to continue loading data. */
388 break;
389 }
390
391 curve_radii.first() = usd_curve_widths.first() / 2.0f;
392 curve_radii.last() = usd_curve_widths.last() / 2.0f;
393 for (const int i : usd_curve_widths.index_range()) {
394 curve_radii[i + 1] = usd_curve_widths[i] / 2.0f;
395 }
396
397 radii_offset += radii_count;
398 width_offset += width_count;
399 }
400 }
401 else {
402 for (const int i_point : IndexRange(std::min(radii.size(), widths.size()))) {
403 radii[i_point] = widths[i_point] / 2.0f;
404 }
405 }
406 }
407 }
408
409 this->read_velocities(curves, curve_prim_, time);
410 this->read_custom_data(curves, time);
411}
412
413} // namespace blender::io::usd
Low-level operations for curves.
General operations, lookup, etc. for blender objects.
Object is a sort of wrapper for general info.
constexpr Span()=default
const T & last(const int64_t n=0) const
Definition BLI_array.hh:307
constexpr IndexRange()=default
const Value * lookup_ptr(const Key &key) const
Definition BLI_map.hh:508
void add_new(const Key &key, const Value &value)
Definition BLI_map.hh:265
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
constexpr void fill(const T &value) const
Definition BLI_span.hh:523
constexpr MutableSpan slice_safe(const int64_t start, const int64_t size) const
Definition BLI_span.hh:596
constexpr T & first() const
Definition BLI_span.hh:685
constexpr void copy_from(Span< T > values) const
Definition BLI_span.hh:745
constexpr T & last(const int64_t n=0) const
Definition BLI_span.hh:695
Span< NewT > constexpr cast() const
Definition BLI_span.hh:422
constexpr Span slice_safe(const int64_t start, const int64_t size) const
Definition BLI_span.hh:158
constexpr Span slice(int64_t start, int64_t size) const
Definition BLI_span.hh:141
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr const T & last(const int64_t n=0) const
Definition BLI_span.hh:329
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
void read_curve_sample(Curves *curves_id, pxr::UsdTimeCode time) override
void read_object_data(Main *bmain, pxr::UsdTimeCode time) override
void read_geometry(bke::GeometrySet &geometry_set, USDMeshReadParams params, const char **r_err_str) override
void read_custom_data(bke::CurvesGeometry &curves, const pxr::UsdTimeCode time) const
void create_object(Main *bmain) override
virtual bool is_animated() const =0
virtual void read_curve_sample(Curves *curves_id, pxr::UsdTimeCode time)=0
void read_velocities(bke::CurvesGeometry &curves, const pxr::UsdGeomCurves &usd_curves, const pxr::UsdTimeCode time) const
void read_object_data(Main *bmain, pxr::UsdTimeCode time) override
#define uniform(slot)
#define vertex
BLI_INLINE Texture * wrap(MTLTexture *texture)
static int bezier_point_count(int usd_count, bool is_cyclic)
static Array< int > calc_curve_offsets(const pxr::VtIntArray &usdCounts, const CurveType curve_type, bool is_cyclic)
static void add_bezier_control_point(int cp, int offset, MutableSpan< float3 > positions, MutableSpan< float3 > handles_left, MutableSpan< float3 > handles_right, const Span< pxr::GfVec3f > usdPoints)
static int point_count(int usdCount, CurveType curve_type, bool is_cyclic)
void set_single_value(bke::MutableAttributeAccessor attributes, const StringRef attr_name, const bke::AttrDomain domain, const bke::AttrType data_type, const bke::AttributeInit &value)
static CurveType get_curve_type(pxr::TfToken type, pxr::TfToken basis)
void copy_primvar_to_blender_attribute(const pxr::UsdGeomPrimvar &primvar, const pxr::UsdTimeCode time, const bke::AttrType data_type, const bke::AttrDomain domain, const OffsetIndices< int > face_indices, bke::MutableAttributeAccessor attributes)
std::optional< bke::AttrType > convert_usd_type_to_blender(const pxr::SdfValueTypeName usd_type)
static bool curves_topology_changed(const bke::CurvesGeometry &curves, const Span< int > usd_offsets)
static std::optional< bke::AttrDomain > convert_usd_interp_to_blender(const pxr::TfToken usd_domain)
static float3 to_float3(pxr::GfVec3f vec3f)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
struct Curves * BKE_curves_add(struct Main *bmain, const char *name)
@ RPT_WARNING
Definition BKE_report.hh:40
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
@ CURVE_TYPE_CATMULL_ROM
VecBase< float, 3 > float3
Object * BKE_object_add_only_object(Main *bmain, ObjectType type, const char *name) ATTR_RETURNS_NONNULL
Definition object.cc:2265
signed char int8_t
Definition BKE_text.h:76