HDK
 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 
27 /// \file usdGeom/xformOp.h
28 
29 #include "pxr/pxr.h"
30 #include "pxr/usd/usdGeom/api.h"
31 #include "pxr/usd/usd/attribute.h"
33 #include "pxr/usd/usdGeom/tokens.h"
34 
35 #include <string>
36 #include <vector>
37 #include <typeinfo>
38 
39 #include <hboost/variant.hpp>
40 
42 
44 
45 
46 /// \hideinitializer
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 
63 /// \anchor UsdGeomXformOpTypes
64 /// Provides TfToken's for use in conjunction with UsdGeomXformable::Add
65 /// XformOp() and UsdGeomXformOp::GetOpType(), to establish op type.
66 ///
67 /// The component operation names and their meanings are:
68 /// \li <b>translate</b> - XYZ translation
69 /// \li <b>scale</b> - XYZ scale
70 /// \li <b>rotateX</b> - rotation about the X axis, <b>in degrees</b>
71 /// \li <b>rotateY</b> - rotation about the Y axis, <b>in degrees</b>
72 /// \li <b>rotateZ</b> - rotation about the Z axis, <b>in degrees</b>
73 /// \li <b>rotateXYZ, rotateXZY, rotateYXZ, rotateYZX, rotateZXY, rotateZYX</b>
74 /// - a set of three canonical Euler rotations, packed into a single
75 /// Vec3, for conciseness and efficiency of reading. The \\em first
76 /// axis named is the most local, so a single rotateXYZ is equivalent to
77 /// the ordered ops "rotateZ rotateY rotateX". See also
78 /// \ref usdGeom_rotationPackingOrder "note on rotation packing order."
79 /// \li <b>orient</b> - arbitrary axis/angle rotation, expressed as a quaternion
80 /// \li <b>transform</b> - 4x4 matrix transformation
81 /// \li <b>resetXformStack</b> - when appearing as the first op, instructs
82 /// client that the transform stack should be cleared of any inherited
83 /// transformation prior to processing the rest of the prims ops. It is
84 /// an error for resetXformStack to appear anywhere other than as the
85 /// first element in \em xformOpOrder.
87 
88 /// \class UsdGeomXformOp
89 ///
90 /// Schema wrapper for UsdAttribute for authoring and computing
91 /// transformation operations, as consumed by UsdGeomXformable schema.
92 ///
93 /// The semantics of an op are determined primarily by its name, which allows
94 /// us to decode an op very efficiently. All ops are independent attributes,
95 /// which must live in the "xformOp" property namespace. The op's primary name
96 /// within the namespace must be one of \ref UsdGeomXformOpTypes, which
97 /// determines the type of transformation operation, and its secondary name
98 /// (or suffix) within the namespace (which is not required to exist), can be
99 /// any name that distinguishes it from other ops of the same type. Suffixes
100 /// are generally imposed by higer level xform API schemas.
101 ///
102 /// \anchor usdGeom_rotationPackingOrder
103 /// \note
104 /// <b>On packing order of rotateABC triples</b><br>
105 /// The order in which the axis rotations are recorded in a Vec3* for the
106 /// six \em rotateABC Euler triples <b>is always the same:</b> vec[0] = X,
107 /// vec[1] = Y, vec[2] = Z . The \em A, \em B, \em C in the op name dictate
108 /// the order in which their corresponding elements are consumed by the
109 /// rotation, not how they are laid out.
110 ///
112 {
113 public:
114 
115  /// Enumerates the set of all transformation operation types.
116  enum Type {
117  TypeInvalid, ///< Represents an invalid xformOp.
118  TypeTranslate, ///< XYZ translation.
119  TypeScale, ///< XYZ scale.
120  TypeRotateX, ///< Rotation about the X-axis, <b>in degrees</b>.
121  TypeRotateY, ///< Rotation about the Y-axis, <b>in degrees</b>.
122  TypeRotateZ, ///< Rotation about the Z-axis, <b>in degrees</b>.
123  TypeRotateXYZ, ///< Set of 3 canonical Euler rotations
124  /// \ref usdGeom_rotationPackingOrder "in XYZ order"
125  TypeRotateXZY, ///< Set of 3 canonical Euler rotations
126  /// \ref usdGeom_rotationPackingOrder "in XZY order"
127  TypeRotateYXZ, ///< Set of 3 canonical Euler rotations
128  /// \ref usdGeom_rotationPackingOrder "in YXZ order"
129  TypeRotateYZX, ///< Set of 3 canonical Euler rotations
130  /// \ref usdGeom_rotationPackingOrder "in YZX order"
131  TypeRotateZXY, ///< Set of 3 canonical Euler rotations
132  /// \ref usdGeom_rotationPackingOrder "in ZXY order"
133  TypeRotateZYX, ///< Set of 3 canonical Euler rotations
134  /// \ref usdGeom_rotationPackingOrder "in ZYX order"
135  TypeOrient, ///< Arbitrary axis/angle rotation, expressed as a quaternion.
136  TypeTransform ///< A 4x4 matrix transformation.
137  };
138 
139  /// Precision with which the value of the tranformation operation is encoded.
140  enum Precision {
141  PrecisionDouble, ///< Double precision
142  PrecisionFloat, ///< Floating-point precision
143  PrecisionHalf ///< Half-float precision
144  };
145 
146  // Default constructor returns an invalid XformOp. Exists for
147  // container classes
149  {
150  /* NOTHING */
151  }
152 
153  /// Speculative constructor that will produce a valid UsdGeomXformOp when
154  /// \p attr already represents an attribute that is XformOp, and
155  /// produces an \em invalid XformOp otherwise (i.e.
156  /// explicit-bool conversion operator will return false).
157  ///
158  /// Calling \c UsdGeomXformOp::IsXformOp(attr) will return the same truth
159  /// value as this constructor, but if you plan to subsequently use the
160  /// XformOp anyways, just use this constructor.
161  ///
162  /// \p isInverseOp is set to true to indicate an inverse transformation
163  /// op.
164  ///
165  /// This constructor exists mainly for internal use. Clients should use
166  /// AddXformOp API (or one of Add*Op convenience API) to create and retain
167  /// a copy of an UsdGeomXformOp object.
168  ///
170  explicit UsdGeomXformOp(const UsdAttribute &attr, bool isInverseOp=false);
171 
172  // -------------------------------------------------------
173  /// \name Static Helper API
174  // -------------------------------------------------------
175 
176  /// Test whether a given UsdAttribute represents valid XformOp, which
177  /// implies that creating a UsdGeomXformOp from the attribute will succeed.
178  ///
179  /// Success implies that \c attr.IsDefined() is true.
181  static bool IsXformOp(const UsdAttribute &attr);
182 
183  /// Test whether a given attrbute name represents a valid XformOp, which
184  /// implies that creating a UsdGeomXformOp from the corresponding
185  /// UsdAttribute will succeed.
186  ///
188  static bool IsXformOp(const TfToken &attrName);
189 
190  /// Returns the TfToken used to encode the given \p opType.
192  static TfToken const &GetOpTypeToken(Type const opType);
193 
194  /// Returns the Type enum associated with the given \p opTypeToken.
196  static Type GetOpTypeEnum(TfToken const &opTypeToken);
197 
198  /// Returns the precision corresponding to the given value typeName.
201 
202  /// Returns the value typeName token that corresponds to the given
203  /// combination of \p opType and \p precision.
205  static const SdfValueTypeName &GetValueTypeName(const Type opType,
206  const Precision precision);
207 
208  /// Returns the xformOp's name as it appears in xformOpOrder, given
209  /// the opType, the (optional) suffix and whether it is an inverse
210  /// operation.
212  static TfToken GetOpName(const Type opType,
213  const TfToken &opSuffix=TfToken(),
214  bool inverse=false);
215 
216  // -------------------------------------------------------
217  /// \name Data Encoding Queries
218  // -------------------------------------------------------
219 
220  /// Return the operation type of this op, one of \ref UsdGeomXformOp::Type
221  Type GetOpType() const {
222  return _opType;
223  }
224 
225  /// Returns the precision level of the xform op.
227  Precision GetPrecision() const;
228 
229  /// Returns whether the xformOp represents an inverse operation.
230  bool IsInverseOp() const {
231  return _isInverseOp;
232  }
233 
234  /// Returns the opName as it appears in the xformOpOrder attribute.
235  ///
236  /// This will begin with "!invert!:xformOp:" if it is an inverse xform
237  /// operation. If it is not an inverse xformOp, it will begin with 'xformOp:'.
238  ///
239  /// This will be empty for an invalid xformOp.
240  ///
242  TfToken GetOpName() const;
243 
244  /// Does this op have the given suffix in its name.
246  bool HasSuffix(TfToken const &suffix) const;
247 
248  // ---------------------------------------------------------------
249  /// \name Computing with Ops
250  // ---------------------------------------------------------------
251 
252  /// We allow ops to be encoded with varying degrees of precision,
253  /// depending on the clients needs and constraints. GetAs() will
254  /// attempt to convert the stored data to the requested datatype.
255  ///
256  /// Note this accessor incurs some overhead beyond Get()'ing the
257  /// value as a VtValue and dealing with the results yourself.
258  ///
259  /// \return true if a value was successfully read \em and converted
260  /// to the requested datatype (see \ref VtValue::Cast()), false
261  /// otherwise. A problem reading or failure to convert will cause
262  /// an error to be emitted.
263  ///
264  /// \note the requested type \p T must be constructable by assignment
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 
284  /// Return the 4x4 matrix that applies the transformation encoded
285  /// by op \p opType and data value \p opVal.
286  ///
287  /// If \p isInverseOp is true, then the inverse of the tranformation
288  /// represented by the op/value pair is returned.
289  ///
290  /// An error will be issued if \p opType is not one of the values in the enum
291  /// \ref UsdGeomXformOp::Type or if \p opVal cannot be converted
292  /// to a suitable input to \p opType
294  static GfMatrix4d GetOpTransform(Type const opType,
295  VtValue const &opVal,
296  bool isInverseOp=false);
297 
298 
299  /// Return the 4x4 matrix that applies the transformation encoded
300  /// in this op at \p time.
301  ///
302  /// Returns the identity matrix and issues a coding error if the op is
303  /// invalid.
304  ///
305  /// If the op is valid, but has no authored value, the identity
306  /// matrix is returned and no error is issued.
307  ///
310 
311  /// Determine whether there is any possibility that this op's value
312  /// may vary over time.
313  ///
314  /// The determination is based on a snapshot of the authored state of the
315  /// op, and may become invalid in the face of further authoring.
316  bool MightBeTimeVarying() const {
317  return hboost::apply_visitor(_GetMightBeTimeVarying(), _attr);
318  }
319 
320  // ---------------------------------------------------------------
321  /// \name UsdAttribute API
322  // ---------------------------------------------------------------
323 
324  /// Allow UsdGeomXformOp to auto-convert to UsdAttribute, so you can
325  /// pass a UsdGeomXformOp to any function that accepts a UsdAttribute or
326  /// const-ref thereto.
327  operator UsdAttribute const& () const { return GetAttr(); }
328 
329  /// Explicit UsdAttribute extractor
330  UsdAttribute const &GetAttr() const {
331  return hboost::apply_visitor(_GetAttr(), _attr);
332  }
333 
334  /// Return true if the wrapped UsdAttribute::IsDefined(), and in
335  /// addition the attribute is identified as a XformOp.
336  bool IsDefined() const { return IsXformOp(GetAttr()); }
337 
338 public:
339  /// \anchor UsdGeomXformOp_explicit_bool
340  /// Explicit bool conversion operator. An XformOp object converts to
341  /// \c true iff it is valid for querying and authoring values and metadata,
342  /// (which is identically equivalent to IsDefined()), and converts to
343  /// \c false otherwise.
344  explicit operator bool() const {
345  return IsDefined();
346  }
347 
348  /// \sa UsdAttribute::GetName()
349  TfToken const &GetName() const { return GetAttr().GetName(); }
350 
351  /// \sa UsdAttribute::GetBaseName()
352  TfToken GetBaseName() const { return GetAttr().GetBaseName(); }
353 
354  /// \sa UsdAttribute::GetNamespace()
355  TfToken GetNamespace() const { return GetAttr().GetNamespace(); }
356 
357  /// \sa UsdAttribute::SplitName()
358  std::vector<std::string> SplitName() const { return GetAttr().SplitName(); };
359 
360  /// \sa UsdAttribute::GetTypeName()
362 
363  /// Get the attribute value of the XformOp at \p time.
364  ///
365  /// \note For inverted ops, this returns the raw, uninverted value.
366  ///
367  template <typename T>
369  return hboost::apply_visitor(_Get<T>(value, time), _attr);
370  }
371 
372  /// Set the attribute value of the XformOp at \p time
373  ///
374  /// \note This only works on non-inverse operations. If invoked on
375  /// an inverse xform operation, a coding error is issued and no value is
376  /// authored.
377  ///
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 
392  /// Populates the list of time samples at which the associated attribute
393  /// is authored.
394  bool GetTimeSamples(std::vector<double> *times) const {
395  return hboost::apply_visitor(_GetTimeSamples(times), _attr);
396  }
397 
398  /// Populates the list of time samples within the given \p interval,
399  /// at which the associated attribute is authored.
400  bool GetTimeSamplesInInterval(const GfInterval &interval,
401  std::vector<double> *times) const {
402  return hboost::apply_visitor(
403  _GetTimeSamplesInInterval(interval, times), _attr);
404  }
405 
406  /// Returns the number of time samples authored for this xformOp.
407  size_t GetNumTimeSamples() const {
408  return hboost::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.
418  UsdGeomXformOp(const UsdAttribute &attr, bool isInverseOp,
419  _ValidAttributeTagType);
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 hboost::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 hboost::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;
501  };
502 
503  // Visitor for getting a const-reference to the UsdAttribute.
504  struct _GetAttr : public hboost::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 hboost::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 hboost::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 hboost::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 hboost::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 
596 
597 #endif // USD_XFORMOP_H
static USDGEOM_API Precision GetPrecisionFromValueTypeName(const SdfValueTypeName &typeName)
Returns the precision corresponding to the given value typeName.
Arbitrary axis/angle rotation, expressed as a quaternion.
Definition: xformOp.h:135
static USDGEOM_API bool IsXformOp(const UsdAttribute &attr)
T const & UncheckedGet() const
Definition: value.h:836
bool Get(T *value, UsdTimeCode time=UsdTimeCode::Default()) const
Double precision.
Definition: xformOp.h:141
static constexpr UsdTimeCode Default()
Definition: timeCode.h:113
bool Get(T *value, UsdTimeCode time=UsdTimeCode::Default()) const
Definition: attribute.h:435
USD_API TfToken GetBaseName() const
A 4x4 matrix transformation.
Definition: xformOp.h:136
GT_API const UT_StringHolder time
static USDGEOM_API TfToken const & GetOpTypeToken(Type const opType)
Returns the TfToken used to encode the given opType.
static TF_API std::string GetCanonicalTypeName(const std::type_info &)
bool IsDefined() const
Definition: xformOp.h:336
TF_DECLARE_PUBLIC_TOKENS(UsdGeomXformOpTypes, USDGEOM_API, USDGEOM_XFORM_OP_TYPES)
TfToken const & GetName() const
Definition: xformOp.h:349
USD_API size_t GetNumTimeSamples() const
Represents an invalid xformOp.
Definition: xformOp.h:117
#define TF_CODING_ERROR
bool MightBeTimeVarying() const
Definition: xformOp.h:316
USD_API SdfValueTypeName GetTypeName() const
Return the "scene description" value type name for this attribute.
GLenum query
Definition: glew.h:5704
Half-float precision.
Definition: xformOp.h:143
const GLdouble * v
Definition: glew.h:1391
Rotation about the Y-axis, in degrees.
Definition: xformOp.h:121
bool IsEmpty() const
Returns true iff this value is empty.
Definition: value.h:990
Rotation about the X-axis, in degrees.
Definition: xformOp.h:120
static USDGEOM_API const SdfValueTypeName & GetValueTypeName(const Type opType, const Precision precision)
Definition: token.h:89
Type GetOpType() const
Return the operation type of this op, one of UsdGeomXformOp::Type.
Definition: xformOp.h:221
USD_API bool ValueMightBeTimeVarying() const
USD_API std::vector< std::string > SplitName() const
TfToken GetBaseName() const
Definition: xformOp.h:352
static USDGEOM_API GfMatrix4d GetOpTransform(Type const opType, VtValue const &opVal, bool isInverseOp=false)
#define USDGEOM_XFORM_OP_TYPES
Definition: xformOp.h:47
USD_API bool GetTimeSamples(std::vector< double > *times) const
USD_API size_t GetNumTimeSamples() const
TfToken GetNamespace() const
Definition: xformOp.h:355
Floating-point precision.
Definition: xformOp.h:142
Definition: prim.h:131
bool GetTimeSamplesInInterval(const GfInterval &interval, std::vector< double > *times) const
Definition: xformOp.h:400
bool Get(T *value, UsdTimeCode time=UsdTimeCode::Default()) const
Definition: xformOp.h:368
std::vector< std::string > SplitName() const
Definition: xformOp.h:358
USD_API TfToken GetNamespace() const
bool Set(const T &value, UsdTimeCode time=UsdTimeCode::Default()) const
Definition: attribute.h:466
const TfToken & GetName() const
Definition: object.h:228
bool IsInverseOp() const
Returns whether the xformOp represents an inverse operation.
Definition: xformOp.h:230
bool GetAs(T *value, UsdTimeCode time) const
Definition: xformOp.h:266
USD_API bool GetTimeSamples(std::vector< double > *times) const
bool Set(T const &value, UsdTimeCode time=UsdTimeCode::Default()) const
Definition: xformOp.h:379
Rotation about the Z-axis, in degrees.
Definition: xformOp.h:122
bool GetTimeSamples(std::vector< double > *times) const
Definition: xformOp.h:394
USD_API bool GetTimeSamplesInInterval(const GfInterval &interval, std::vector< double > *times) const
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1245
XYZ translation.
Definition: xformOp.h:118
static VtValue Cast(VtValue const &val)
Definition: value.h:898
TF_API const std::string & GetTypeName() const
size_t GetNumTimeSamples() const
Returns the number of time samples authored for this xformOp.
Definition: xformOp.h:407
static USDGEOM_API Type GetOpTypeEnum(TfToken const &opTypeToken)
Returns the Type enum associated with the given opTypeToken.
UsdAttribute const & GetAttr() const
Explicit UsdAttribute extractor.
Definition: xformOp.h:330
SdfValueTypeName GetTypeName() const
Definition: xformOp.h:361
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:83
Definition: type.h:70
USD_API bool GetTimeSamplesInInterval(const GfInterval &interval, std::vector< double > *times) const
Type
Enumerates the set of all transformation operation types.
Definition: xformOp.h:116
USD_API const UsdAttribute & GetAttribute() const
Return the attribute associated with this query.
#define USDGEOM_API
Definition: api.h:40
SDF_API const TfType & GetType() const
Returns the TfType of the type.
USD_API bool ValueMightBeTimeVarying() const
GLenum GLint GLint * precision
Definition: glew.h:3500
GLsizei const GLfloat * value
Definition: glew.h:1849
Definition: value.h:182
USDGEOM_API TfToken GetOpName() const
USDGEOM_API bool HasSuffix(TfToken const &suffix) const
Does this op have the given suffix in its name.
Precision
Precision with which the value of the tranformation operation is encoded.
Definition: xformOp.h:140
USDGEOM_API Precision GetPrecision() const
Returns the precision level of the xform op.
GLenum GLsizei len
Definition: glew.h:7752