All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
xformOp.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 #ifndef USDGEOM_XFORMOP_H
25 #define USDGEOM_XFORMOP_H
26 
28 
29 #include "pxr/pxr.h"
30 #include "pxr/usd/usdGeom/api.h"
31 #include "pxr/usd/usd/attribute.h"
32 #include "pxr/usd/usd/attributeQuery.h"
33 #include "pxr/usd/usdGeom/tokens.h"
34 
35 #include <string>
36 #include <vector>
37 #include <typeinfo>
38 
39 #include <boost/variant.hpp>
40 
41 #include "pxr/base/tf/staticTokens.h"
42 
43 PXR_NAMESPACE_OPEN_SCOPE
44 
45 
47 #define USDGEOM_XFORM_OP_TYPES \
48  (translate) \
49  (scale) \
50  (rotateX) \
51  (rotateY) \
52  (rotateZ) \
53  (rotateXYZ) \
54  (rotateXZY) \
55  (rotateYXZ) \
56  (rotateYZX) \
57  (rotateZXY) \
58  (rotateZYX) \
59  (orient) \
60  (transform) \
61  ((resetXformStack, "!resetXformStack!"))
62 
86 TF_DECLARE_PUBLIC_TOKENS(UsdGeomXformOpTypes, USDGEOM_API, USDGEOM_XFORM_OP_TYPES);
87 
112 {
113 public:
114 
116  enum Type {
124  TypeRotateXZY,
126  TypeRotateYXZ,
128  TypeRotateYZX,
130  TypeRotateZXY,
132  TypeRotateZYX,
134  TypeOrient,
137  };
138 
140  enum Precision {
144  };
145 
146  // Default constructor returns an invalid XformOp. Exists for
147  // container classes
149  {
150  /* NOTHING */
151  }
152 
169  USDGEOM_API
170  explicit UsdGeomXformOp(const UsdAttribute &attr, bool isInverseOp=false);
171 
172  // -------------------------------------------------------
174  // -------------------------------------------------------
175 
180  USDGEOM_API
181  static bool IsXformOp(const UsdAttribute &attr);
182 
187  USDGEOM_API
188  static bool IsXformOp(const TfToken &attrName);
189 
191  USDGEOM_API
192  static TfToken const &GetOpTypeToken(Type const opType);
193 
195  USDGEOM_API
196  static Type GetOpTypeEnum(TfToken const &opTypeToken);
197 
199  USDGEOM_API
201 
204  USDGEOM_API
205  static const SdfValueTypeName &GetValueTypeName(const Type opType,
206  const Precision precision);
207 
211  USDGEOM_API
212  static TfToken GetOpName(const Type opType,
213  const TfToken &opSuffix=TfToken(),
214  bool inverse=false);
215 
216  // -------------------------------------------------------
218  // -------------------------------------------------------
219 
221  Type GetOpType() const {
222  return _opType;
223  }
224 
226  USDGEOM_API
227  Precision GetPrecision() const;
228 
230  bool IsInverseOp() const {
231  return _isInverseOp;
232  }
233 
241  USDGEOM_API
242  TfToken GetOpName() const;
243 
245  USDGEOM_API
246  bool HasSuffix(TfToken const &suffix) const;
247 
248  // ---------------------------------------------------------------
250  // ---------------------------------------------------------------
251 
265  template <typename T>
266  bool GetAs(T* value, UsdTimeCode time) const {
267  VtValue v;
268  if (!Get(&v, time)) {
269  return false;
270  }
271  v.Cast<T>();
272  if (v.IsEmpty()){
273  TfType thisType = GetTypeName().GetType();
274  TF_CODING_ERROR("Unable to convert xformOp %s's value from %s to "
275  "requested type %s.", GetAttr().GetPath().GetText(),
276  thisType.GetTypeName().c_str(),
277  TfType::GetCanonicalTypeName(typeid(*value)).c_str());
278  return false;
279  }
280  *value = v.UncheckedGet<T>();
281  return true;
282  }
283 
293  USDGEOM_API
294  static GfMatrix4d GetOpTransform(Type const opType,
295  VtValue const &opVal,
296  bool isInverseOp=false);
297 
298 
308  USDGEOM_API
310 
316  bool MightBeTimeVarying() const {
317  return boost::apply_visitor(_GetMightBeTimeVarying(), _attr);
318  }
319 
320  // ---------------------------------------------------------------
322  // ---------------------------------------------------------------
323 
327  operator UsdAttribute const& () const { return GetAttr(); }
328 
330  UsdAttribute const &GetAttr() const {
331  return boost::apply_visitor(_GetAttr(), _attr);
332  }
333 
336  bool IsDefined() const { return IsXformOp(GetAttr()); }
337 
338 public:
344  explicit operator bool() const {
345  return IsDefined();
346  }
347 
349  TfToken const &GetName() const { return GetAttr().GetName(); }
350 
352  TfToken GetBaseName() const { return GetAttr().GetBaseName(); }
353 
355  TfToken GetNamespace() const { return GetAttr().GetNamespace(); }
356 
358  std::vector<std::string> SplitName() const { return GetAttr().SplitName(); };
359 
362 
367  template <typename T>
368  bool Get(T* value, UsdTimeCode time = UsdTimeCode::Default()) const {
369  return boost::apply_visitor(_Get<T>(value, time), _attr);
370  }
371 
378  template <typename T>
379  bool Set(T const & value, UsdTimeCode time = UsdTimeCode::Default()) const {
380  // Issue a coding error and return without setting value,
381  // if this is an inverse op.
382  if (_isInverseOp) {
383  TF_CODING_ERROR("Cannot set a value on the inverse xformOp '%s'. "
384  "Please set value on the paired non-inverse xformOp instead.",
385  GetOpName().GetText());
386  return false;
387  }
388 
389  return GetAttr().Set(value, time);
390  }
391 
394  bool GetTimeSamples(std::vector<double> *times) const {
395  return boost::apply_visitor(_GetTimeSamples(times), _attr);
396  }
397 
400  bool GetTimeSamplesInInterval(const GfInterval &interval,
401  std::vector<double> *times) const {
402  return boost::apply_visitor(
403  _GetTimeSamplesInInterval(interval, times), _attr);
404  }
405 
407  size_t GetNumTimeSamples() const {
408  return boost::apply_visitor(_GetNumTimeSamples(), _attr);
409  }
410 
411 private:
412  struct _ValidAttributeTagType {};
413 
414 public:
415  // Allow clients that guarantee \p attr is valid avoid having
416  // UsdGeomXformOp's ctor check again.
417  USDGEOM_API
418  UsdGeomXformOp(const UsdAttribute &attr, bool isInverseOp,
419  _ValidAttributeTagType);
420  USDGEOM_API
421  UsdGeomXformOp(UsdAttributeQuery &&query, bool isInverseOp,
422  _ValidAttributeTagType);
423 private:
424  friend class UsdGeomXformable;
425 
426  // Shared initialization function.
427  void _Init();
428 
429  // Return the op-type for the string value \p str.
430  static Type _GetOpTypeEnumFromCString(char const *str, size_t len);
431 
432  // Returns the attribute belonging to \p prim that corresponds to the
433  // given \p opName. It also populates the output parameter \p isInverseOp
434  // appropriately.
435  //
436  // The attribute that's returned will be invalid if the
437  // corresponding xformOp attribute doesn't exist on the prim.
438  //
439  static UsdAttribute _GetXformOpAttr(UsdPrim const& prim,
440  const TfToken &opName, bool *isInverseOp);
441 
442  // Private method for creating and using an attribute query interally for
443  // this xformOp.
444  void _CreateAttributeQuery() const {
445  _attr = UsdAttributeQuery(GetAttr());
446  }
447 
448  // Factory for UsdGeomXformable's use, so that we can encapsulate the
449  // logic of what discriminates XformOp in this class, while
450  // preserving the pattern that attributes can only be created
451  // via their container objects.
452  //
453  // \p opType must be one of UsdGeomXformOp::Type
454  //
455  // \p precision must be one of UsdGeomXformOp::Precision.
456  //
457  // \return an invalid UsdGeomXformOp if we failed to create a valid
458  // attribute, a valid UsdGeomXformOp otherwise. It is not an
459  // error to create over an existing, compatible attribute.
460  //
461  // It is a failed verification for \p prim to be invalid/expired
462  //
463  // \sa UsdPrim::CreateAttribute()
464  UsdGeomXformOp(UsdPrim const& prim, Type const opType,
465  Precision const precision, TfToken const &opSuffix=TfToken(),
466  bool inverse=false);
467 
468  // UsdAttributeQuery already contains a copy of the associated UsdAttribute.
469  // To minimize the memory usage, we only store one or the other.
470  //
471  // The lifetime of a UsdAttributeQuery needs to be managed very carefully as
472  // it gets invalidated whenever the associated attribute is authored.
473  // Hence, access to the creation of an attribute query is restricted inside
474  // a private member function named _CreateAttributeQuery().
475  //
476  mutable boost::variant<UsdAttribute, UsdAttributeQuery> _attr;
477 
478  Type _opType;
479  bool _isInverseOp;
480 
481  // Visitor for getting xformOp value.
482  template <class T>
483  struct _Get : public boost::static_visitor<bool>
484  {
485  _Get(T *value_,
486  UsdTimeCode time_ = UsdTimeCode::Default()) : value (value_), time(time_)
487  {}
488 
489  bool operator()(const UsdAttribute &attr) const
490  {
491  return attr.Get(value, time);
492  }
493 
494  bool operator()(const UsdAttributeQuery &attrQuery) const
495  {
496  return attrQuery.Get(value, time);
497  }
498 
499  T *value;
500  UsdTimeCode time;
501  };
502 
503  // Visitor for getting a const-reference to the UsdAttribute.
504  struct _GetAttr : public boost::static_visitor<const UsdAttribute &> {
505 
506  _GetAttr() {}
507 
508  const UsdAttribute &operator()(const UsdAttribute &attr) const
509  {
510  return attr;
511  }
512 
513  const UsdAttribute &operator()(const UsdAttributeQuery &attrQuery) const
514  {
515  return attrQuery.GetAttribute();
516  }
517  };
518 
519  // Visitor for getting all the time samples.
520  struct _GetTimeSamples : public boost::static_visitor<bool> {
521 
522  _GetTimeSamples(std::vector<double> *times_) : times(times_) {}
523 
524  bool operator()(const UsdAttribute &attr) const
525  {
526  return attr.GetTimeSamples(times);
527  }
528 
529  bool operator()(const UsdAttributeQuery &attrQuery) const
530  {
531  return attrQuery.GetTimeSamples(times);
532  }
533 
534  std::vector<double> *times;
535  };
536 
537  // Visitor for getting all the time samples within a given interval.
538  struct _GetTimeSamplesInInterval : public boost::static_visitor<bool> {
539 
540  _GetTimeSamplesInInterval(const GfInterval &interval_,
541  std::vector<double> *times_)
542  : interval(interval_), times(times_)
543  {}
544 
545  bool operator()(const UsdAttribute &attr) const
546  {
547  return attr.GetTimeSamplesInInterval(interval, times);
548  }
549 
550  bool operator()(const UsdAttributeQuery &attrQuery) const
551  {
552  return attrQuery.GetTimeSamplesInInterval(interval, times);
553  }
554 
555  const GfInterval &interval;
556  std::vector<double> *times;
557  };
558 
559  // Visitor for getting the number of time samples.
560  struct _GetNumTimeSamples : public boost::static_visitor<size_t> {
561 
562  _GetNumTimeSamples() {}
563 
564  size_t operator()(const UsdAttribute &attr) const
565  {
566  return attr.GetNumTimeSamples();
567  }
568 
569  size_t operator()(const UsdAttributeQuery &attrQuery) const
570  {
571  return attrQuery.GetNumTimeSamples();
572  }
573  };
574 
575  // Visitor for determining whether the op might vary over time.
576  struct _GetMightBeTimeVarying : public boost::static_visitor<bool> {
577 
578  _GetMightBeTimeVarying() {}
579 
580  bool operator()(const UsdAttribute &attr) const
581  {
582  return attr.ValueMightBeTimeVarying();
583  }
584 
585  bool operator()(const UsdAttributeQuery &attrQuery) const
586  {
587  return attrQuery.ValueMightBeTimeVarying();
588  }
589  };
590 
591 };
592 
593 
594 
595 PXR_NAMESPACE_CLOSE_SCOPE
596 
597 #endif // USD_XFORMOP_H
bool Set(const T &value, UsdTimeCode time=UsdTimeCode::Default()) const
Set the value of this attribute in the current UsdEditTarget to value at UsdTimeCode time...
Definition: attribute.h:466
Set of 3 canonical Euler rotations in ZYX order.
Definition: xformOp.h:133
static USDGEOM_API Type GetOpTypeEnum(TfToken const &opTypeToken)
Returns the Type enum associated with the given opTypeToken.
USDGEOM_API TfToken GetOpName() const
Returns the opName as it appears in the xformOpOrder attribute.
SDF_API const TfType & GetType() const
Returns the TfType of the type.
USD_API size_t GetNumTimeSamples() const
Returns the number of time samples that have been authored.
TF_API const std::string & GetTypeName() const
Return the machine-independent name for this type.
Floating-point precision.
Definition: xformOp.h:142
Set of 3 canonical Euler rotations in ZXY order.
Definition: xformOp.h:131
T const & UncheckedGet() const
Returns a const reference to the held object if the held object is of type T.
Definition: value.h:836
static USDGEOM_API const SdfValueTypeName & GetValueTypeName(const Type opType, const Precision precision)
Returns the value typeName token that corresponds to the given combination of opType and precision...
Arbitrary axis/angle rotation, expressed as a quaternion.
Definition: xformOp.h:135
Object for efficiently making repeated queries for attribute values.
static USDGEOM_API TfToken const & GetOpTypeToken(Type const opType)
Returns the TfToken used to encode the given opType.
Schema wrapper for UsdAttribute for authoring and computing transformation operations, as consumed by UsdGeomXformable schema.
Definition: xformOp.h:111
bool GetAs(T *value, UsdTimeCode time) const
We allow ops to be encoded with varying degrees of precision, depending on the clients needs and cons...
Definition: xformOp.h:266
#define TF_CODING_ERROR(fmt, args)
Issue an internal programming error, but continue execution.
Definition: diagnostic.h:87
Type
Enumerates the set of all transformation operation types.
Definition: xformOp.h:116
USD_API bool GetTimeSamplesInInterval(const GfInterval &interval, std::vector< double > *times) const
Populates a vector with authored sample times in interval.
USD_API TfToken GetNamespace() const
Return this property&#39;s complete namespace prefix.
Represents a value type name, i.e.
Definition: valueTypeName.h:83
USD_API bool GetTimeSamples(std::vector< double > *times) const
Populates a vector with authored sample times.
std::vector< std::string > SplitName() const
Definition: xformOp.h:358
USD_API bool ValueMightBeTimeVarying() const
Return true if it is possible, but not certain, that this attribute&#39;s value changes over time...
Scenegraph object for authoring and retrieving numeric, string, and array valued data, sampled over time.
Definition: attribute.h:176
USD_API bool ValueMightBeTimeVarying() const
Return true if it is possible, but not certain, that this attribute&#39;s value changes over time...
bool GetTimeSamples(std::vector< double > *times) const
Populates the list of time samples at which the associated attribute is authored. ...
Definition: xformOp.h:394
TfToken GetBaseName() const
Definition: xformOp.h:352
static USDGEOM_API GfMatrix4d GetOpTransform(Type const opType, VtValue const &opVal, bool isInverseOp=false)
Return the 4x4 matrix that applies the transformation encoded by op opType and data value opVal...
TfToken const & GetName() const
Definition: xformOp.h:349
bool Get(T *value, UsdTimeCode time=UsdTimeCode::Default()) const
Get the attribute value of the XformOp at time.
Definition: xformOp.h:368
USD_API bool GetTimeSamples(std::vector< double > *times) const
Populates a vector with authored sample times.
bool IsDefined() const
Return true if the wrapped UsdAttribute::IsDefined(), and in addition the attribute is identified as ...
Definition: xformOp.h:336
Set of 3 canonical Euler rotations in XZY order.
Definition: xformOp.h:125
Token for efficient comparison, assignment, and hashing of known strings.
Definition: token.h:89
bool MightBeTimeVarying() const
Determine whether there is any possibility that this op&#39;s value may vary over time.
Definition: xformOp.h:316
USD_API std::vector< std::string > SplitName() const
Return this property&#39;s name elements including namespaces and its base name as the final element...
Double precision.
Definition: xformOp.h:141
SdfValueTypeName GetTypeName() const
Definition: xformOp.h:361
static TF_API std::string GetCanonicalTypeName(const std::type_info &)
Return the canonical typeName used for a given std::type_info.
Stores a 4x4 matrix of double elements.
Definition: matrix4d.h:88
Represent a time value, which may be either numeric, holding a double value, or a sentinel value UsdT...
Definition: timeCode.h:85
USDGEOM_API bool HasSuffix(TfToken const &suffix) const
Does this op have the given suffix in its name.
Rotation about the Z-axis, in degrees.
Definition: xformOp.h:122
#define TF_DECLARE_PUBLIC_TOKENS(...)
Macro to define public tokens.
Definition: staticTokens.h:118
Represents an invalid xformOp.
Definition: xformOp.h:117
UsdPrim is the sole persistent scenegraph object on a UsdStage, and is the embodiment of a &quot;Prim&quot; as ...
Definition: prim.h:131
A 4x4 matrix transformation.
Definition: xformOp.h:136
Rotation about the Y-axis, in degrees.
Definition: xformOp.h:121
A basic mathematical interval class.
Definition: interval.h:50
bool GetTimeSamplesInInterval(const GfInterval &interval, std::vector< double > *times) const
Populates the list of time samples within the given interval, at which the associated attribute is au...
Definition: xformOp.h:400
bool Get(T *value, UsdTimeCode time=UsdTimeCode::Default()) const
Perform value resolution to fetch the value of the attribute associated with this query at the reques...
USDGEOM_API Precision GetPrecision() const
Returns the precision level of the xform op.
TfToken GetNamespace() const
Definition: xformOp.h:355
static VtValue Cast(VtValue const &val)
Return a VtValue holding val cast to hold T.
Definition: value.h:898
size_t GetNumTimeSamples() const
Returns the number of time samples authored for this xformOp.
Definition: xformOp.h:407
bool Get(T *value, UsdTimeCode time=UsdTimeCode::Default()) const
Perform value resolution to fetch the value of this attribute at the requested UsdTimeCode time...
Definition: attribute.h:435
static USDGEOM_API Precision GetPrecisionFromValueTypeName(const SdfValueTypeName &typeName)
Returns the precision corresponding to the given value typeName.
Precision
Precision with which the value of the tranformation operation is encoded.
Definition: xformOp.h:140
Set of 3 canonical Euler rotations in YZX order.
Definition: xformOp.h:129
bool IsInverseOp() const
Returns whether the xformOp represents an inverse operation.
Definition: xformOp.h:230
XYZ translation.
Definition: xformOp.h:118
static constexpr UsdTimeCode Default()
Produce a UsdTimeCode representing the sentinel value for &#39;default&#39;.
Definition: timeCode.h:113
static USDGEOM_API bool IsXformOp(const UsdAttribute &attr)
Test whether a given UsdAttribute represents valid XformOp, which implies that creating a UsdGeomXfor...
Set of 3 canonical Euler rotations in YXZ order.
Definition: xformOp.h:127
const TfToken & GetName() const
Return the full name of this object, i.e.
Definition: object.h:228
USD_API bool GetTimeSamplesInInterval(const GfInterval &interval, std::vector< double > *times) const
Populates a vector with authored sample times in interval.
TfType represents a dynamic runtime type.
Definition: type.h:70
bool Set(T const &value, UsdTimeCode time=UsdTimeCode::Default()) const
Set the attribute value of the XformOp at time.
Definition: xformOp.h:379
USD_API const UsdAttribute & GetAttribute() const
Return the attribute associated with this query.
Rotation about the X-axis, in degrees.
Definition: xformOp.h:120
Half-float precision.
Definition: xformOp.h:143
Set of 3 canonical Euler rotations in XYZ order.
Definition: xformOp.h:123
Base class for all transformable prims, which allows arbitrary sequences of component affine transfor...
Definition: xformable.h:252
USD_API SdfValueTypeName GetTypeName() const
Return the &quot;scene description&quot; value type name for this attribute.
Type GetOpType() const
Return the operation type of this op, one of UsdGeomXformOp::Type.
Definition: xformOp.h:221
UsdAttribute const & GetAttr() const
Explicit UsdAttribute extractor.
Definition: xformOp.h:330
bool IsEmpty() const
Returns true iff this value is empty.
Definition: value.h:990
Provides a container which may hold any type, and provides introspection and iteration over array typ...
Definition: value.h:182
USD_API TfToken GetBaseName() const
Return this property&#39;s name with all namespace prefixes removed, i.e.
USD_API size_t GetNumTimeSamples() const
Returns the number of time samples that have been authored.