HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
basisCurves.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_GENERATED_BASISCURVES_H
25 #define USDGEOM_GENERATED_BASISCURVES_H
26 
27 /// \file usdGeom/basisCurves.h
28 
29 #include "pxr/pxr.h"
30 #include "pxr/usd/usdGeom/api.h"
31 #include "pxr/usd/usdGeom/curves.h"
32 #include "pxr/usd/usd/prim.h"
33 #include "pxr/usd/usd/stage.h"
34 #include "pxr/usd/usdGeom/tokens.h"
35 
36 #include "pxr/base/vt/value.h"
37 
38 #include "pxr/base/gf/vec3d.h"
39 #include "pxr/base/gf/vec3f.h"
40 #include "pxr/base/gf/matrix4d.h"
41 
42 #include "pxr/base/tf/token.h"
43 #include "pxr/base/tf/type.h"
44 
46 
47 class SdfAssetPath;
48 
49 // -------------------------------------------------------------------------- //
50 // BASISCURVES //
51 // -------------------------------------------------------------------------- //
52 
53 /// \class UsdGeomBasisCurves
54 ///
55 /// BasisCurves are a batched curve representation analogous to the
56 /// classic RIB definition via Basis and Curves statements. BasisCurves are
57 /// often used to render dense aggregate geometry like hair or grass.
58 ///
59 /// A 'matrix' and 'vstep' associated with the \em basis are used to
60 /// interpolate the vertices of a cubic BasisCurves. (The basis attribute
61 /// is unused for linear BasisCurves.)
62 ///
63 /// A single prim may have many curves whose count is determined implicitly by
64 /// the length of the \em curveVertexCounts vector. Each individual curve is
65 /// composed of one or more segments. Each segment is defined by four vertices
66 /// for cubic curves and two vertices for linear curves. See the next section
67 /// for more information on how to map curve vertex counts to segment counts.
68 ///
69 /// \section UsdGeomBasisCurves_Segment Segment Indexing
70 /// Interpolating a curve requires knowing how to decompose it into its
71 /// individual segments.
72 ///
73 /// The segments of a cubic curve are determined by the vertex count,
74 /// the \em wrap (periodicity), and the vstep of the basis. For linear
75 /// curves, the basis token is ignored and only the vertex count and
76 /// wrap are needed.
77 ///
78 /// cubic basis | vstep
79 /// ------------- | ------
80 /// bezier | 3
81 /// catmullRom | 1
82 /// bspline | 1
83 ///
84 /// The first segment of a cubic (nonperiodic) curve is always defined by its
85 /// first four points. The vstep is the increment used to determine what
86 /// vertex indices define the next segment. For a two segment (nonperiodic)
87 /// bspline basis curve (vstep = 1), the first segment will be defined by
88 /// interpolating vertices [0, 1, 2, 3] and the second segment will be defined
89 /// by [1, 2, 3, 4]. For a two segment bezier basis curve (vstep = 3), the
90 /// first segment will be defined by interpolating vertices [0, 1, 2, 3] and
91 /// the second segment will be defined by [3, 4, 5, 6]. If the vstep is not
92 /// one, then you must take special care to make sure that the number of cvs
93 /// properly divides by your vstep. (The indices described are relative to
94 /// the initial vertex index for a batched curve.)
95 ///
96 /// For periodic curves, at least one of the curve's initial vertices are
97 /// repeated to close the curve. For cubic curves, the number of vertices
98 /// repeated is '4 - vstep'. For linear curves, only one vertex is repeated
99 /// to close the loop.
100 ///
101 /// Pinned curves are a special case of nonperiodic curves that only affects
102 /// the behavior of cubic Bspline and Catmull-Rom curves. To evaluate or render
103 /// pinned curves, a client must effectively add 'phantom points' at the
104 /// beginning and end of every curve in a batch. These phantom points
105 /// are injected to ensure that the inteprolated curve begins at P[0] and
106 /// ends at P[n-1].
107 ///
108 /// For a curve with initial point P[0] and last point P[n-1], the phantom
109 /// points are defined as.
110 /// P[-1] = 2 * P[0] - P[1]
111 /// P[n] = 2 * P[n-1] - P[n-2]
112 ///
113 /// Pinned cubic curves will (usually) have to be unpacked into the standard
114 /// nonperiodic representation before rendering. This unpacking can add some
115 /// additional overhead. However, using pinned curves reduces the amount of
116 /// data recorded in a scene and (more importantly) better records the
117 /// authors' intent for interchange.
118 ///
119 /// \note The additional phantom points mean that the minimum curve vertex
120 /// count for cubic bspline and catmullRom curves is 2.
121 ///
122 /// Linear curve segments are defined by two vertices.
123 /// A two segment linear curve's first segment would be defined by
124 /// interpolating vertices [0, 1]. The second segment would be defined by
125 /// vertices [1, 2]. (Again, for a batched curve, indices are relative to
126 /// the initial vertex index.)
127 ///
128 /// When validating curve topology, each renderable entry in the
129 /// curveVertexCounts vector must pass this check.
130 ///
131 /// type | wrap | validitity
132 /// ------- | --------------------------- | ----------------
133 /// linear | nonperiodic | curveVertexCounts[i] > 2
134 /// linear | periodic | curveVertexCounts[i] > 3
135 /// cubic | nonperiodic | (curveVertexCounts[i] - 4) % vstep == 0
136 /// cubic | periodic | (curveVertexCounts[i]) % vstep == 0
137 /// cubic | pinned (catmullRom/bspline) | (curveVertexCounts[i] - 2) >= 0
138 ///
139 /// \section UsdGeomBasisCurves_BasisMatrix Cubic Vertex Interpolation
140 ///
141 /// \image html USDCurveBasisMatrix.png width=750
142 ///
143 /// \section UsdGeomBasisCurves_Linear Linear Vertex Interpolation
144 ///
145 /// Linear interpolation is always used on curves of type linear.
146 /// 't' with domain [0, 1], the curve is defined by the equation
147 /// P0 * (1-t) + P1 * t. t at 0 describes the first point and t at 1 describes
148 /// the end point.
149 ///
150 /// \section UsdGeomBasisCurves_PrimvarInterpolation Primvar Interpolation
151 ///
152 /// For cubic curves, primvar data can be either interpolated cubically between
153 /// vertices or linearly across segments. The corresponding token
154 /// for cubic interpolation is 'vertex' and for linear interpolation is
155 /// 'varying'. Per vertex data should be the same size as the number
156 /// of vertices in your curve. Segment varying data is dependent on the
157 /// wrap (periodicity) and number of segments in your curve. For linear curves,
158 /// varying and vertex data would be interpolated the same way. By convention
159 /// varying is the preferred interpolation because of the association of
160 /// varying with linear interpolation.
161 ///
162 /// \image html USDCurvePrimvars.png
163 ///
164 /// To convert an entry in the curveVertexCounts vector into a segment count
165 /// for an individual curve, apply these rules. Sum up all the results in
166 /// order to compute how many total segments all curves have.
167 ///
168 /// The following tables describe the expected segment count for the 'i'th
169 /// curve in a curve batch as well as the entire batch. Python syntax
170 /// like '[:]' (to describe all members of an array) and 'len(...)'
171 /// (to describe the length of an array) are used.
172 ///
173 /// type | wrap | curve segment count | batch segment count
174 /// ------- | --------------------------- | -------------------------------------- | --------------------------
175 /// linear | nonperiodic | curveVertexCounts[i] - 1 | sum(curveVertexCounts[:]) - len(curveVertexCounts)
176 /// linear | periodic | curveVertexCounts[i] | sum(curveVertexCounts[:])
177 /// cubic | nonperiodic | (curveVertexCounts[i] - 4) / vstep + 1 | sum(curveVertexCounts[:] - 4) / vstep + len(curveVertexCounts)
178 /// cubic | periodic | curveVertexCounts[i] / vstep | sum(curveVertexCounts[:]) / vstep
179 /// cubic | pinned (catmullRom/bspline) | (curveVertexCounts[i] - 2) + 1 | sum(curveVertexCounts[:] - 2) + len(curveVertexCounts)
180 ///
181 /// The following table descrives the expected size of varying
182 /// (linearly interpolated) data, derived from the segment counts computed
183 /// above.
184 ///
185 /// wrap | curve varying count | batch varying count
186 /// ------------------- | ---------------------------- | ------------------------------------------------
187 /// nonperiodic/pinned | segmentCounts[i] + 1 | sum(segmentCounts[:]) + len(curveVertexCounts)
188 /// periodic | segmentCounts[i] | sum(segmentCounts[:])
189 ///
190 /// Both curve types additionally define 'constant' interpolation for the
191 /// entire prim and 'uniform' interpolation as per curve data.
192 ///
193 ///
194 /// \note Take care when providing support for linearly interpolated data for
195 /// cubic curves. Its shape doesn't provide a one to one mapping with either
196 /// the number of curves (like 'uniform') or the number of vertices (like
197 /// 'vertex') and so it is often overlooked. This is the only primitive in
198 /// UsdGeom (as of this writing) where this is true. For meshes, while they
199 /// use different interpolation methods, 'varying' and 'vertex' are both
200 /// specified per point. It's common to assume that curves follow a similar
201 /// pattern and build in structures and language for per primitive, per
202 /// element, and per point data only to come upon these arrays that don't
203 /// quite fit into either of those categories. It is
204 /// also common to conflate 'varying' with being per segment data and use the
205 /// segmentCount rules table instead of its neighboring varying data table
206 /// rules. We suspect that this is because for the common case of
207 /// nonperiodic cubic curves, both the provided segment count and varying data
208 /// size formula end with '+ 1'. While debugging, users may look at the double
209 /// '+ 1' as a mistake and try to remove it. We take this time to enumerate
210 /// these issues because we've fallen into them before and hope that we save
211 /// others time in their own implementations.
212 ///
213 /// As an example of deriving per curve segment and varying primvar data counts from
214 /// the wrap, type, basis, and curveVertexCount, the following table is provided.
215 ///
216 /// wrap | type | basis | curveVertexCount | curveSegmentCount | varyingDataCount
217 /// ------------- | ------- | ------- | ----------------- | ------------------ | -------------------------
218 /// nonperiodic | linear | N/A | [2 3 2 5] | [1 2 1 4] | [2 3 2 5]
219 /// nonperiodic | cubic | bezier | [4 7 10 4 7] | [1 2 3 1 2] | [2 3 4 2 3]
220 /// nonperiodic | cubic | bspline | [5 4 6 7] | [2 1 3 4] | [3 2 4 5]
221 /// periodic | cubic | bezier | [6 9 6] | [2 3 2] | [2 3 2]
222 /// periodic | linear | N/A | [3 7] | [3 7] | [3 7]
223 ///
224 /// \section UsdGeomBasisCurves_TubesAndRibbons Tubes and Ribbons
225 ///
226 /// The strictest definition of a curve as an infinitely thin wire is not
227 /// particularly useful for describing production scenes. The additional
228 /// \em widths and \em normals attributes can be used to describe cylindrical
229 /// tubes and or flat oriented ribbons.
230 ///
231 /// Curves with only widths defined are imaged as tubes with radius
232 /// 'width / 2'. Curves with both widths and normals are imaged as ribbons
233 /// oriented in the direction of the interpolated normal vectors.
234 ///
235 /// While not technically UsdGeomPrimvars, widths and normals
236 /// also have interpolation metadata. It's common for authored widths to have
237 /// constant, varying, or vertex interpolation
238 /// (see UsdGeomCurves::GetWidthsInterpolation()). It's common for
239 /// authored normals to have varying interpolation
240 /// (see UsdGeomPointBased::GetNormalsInterpolation()).
241 ///
242 /// \image html USDCurveHydra.png
243 ///
244 /// The file used to generate these curves can be found in
245 /// pxr/extras/examples/usdGeomExamples/basisCurves.usda. It's provided
246 /// as a reference on how to properly image both tubes and ribbons. The first
247 /// row of curves are linear; the second are cubic bezier. (We aim in future
248 /// releases of HdSt to fix the discontinuity seen with broken tangents to
249 /// better match offline renderers like RenderMan.) The yellow and violet
250 /// cubic curves represent cubic vertex width interpolation for which there is
251 /// no equivalent for linear curves.
252 ///
253 /// \note How did this prim type get its name? This prim is a portmanteau of
254 /// two different statements in the original RenderMan specification:
255 /// 'Basis' and 'Curves'.
256 ///
257 ///
258 /// For any described attribute \em Fallback \em Value or \em Allowed \em Values below
259 /// that are text/tokens, the actual token is published and defined in \ref UsdGeomTokens.
260 /// So to set an attribute to the value "rightHanded", use UsdGeomTokens->rightHanded
261 /// as the value.
262 ///
264 {
265 public:
266  /// Compile time constant representing what kind of schema this class is.
267  ///
268  /// \sa UsdSchemaType
270 
271  /// Construct a UsdGeomBasisCurves on UsdPrim \p prim .
272  /// Equivalent to UsdGeomBasisCurves::Get(prim.GetStage(), prim.GetPath())
273  /// for a \em valid \p prim, but will not immediately throw an error for
274  /// an invalid \p prim
275  explicit UsdGeomBasisCurves(const UsdPrim& prim=UsdPrim())
276  : UsdGeomCurves(prim)
277  {
278  }
279 
280  /// Construct a UsdGeomBasisCurves on the prim held by \p schemaObj .
281  /// Should be preferred over UsdGeomBasisCurves(schemaObj.GetPrim()),
282  /// as it preserves SchemaBase state.
283  explicit UsdGeomBasisCurves(const UsdSchemaBase& schemaObj)
284  : UsdGeomCurves(schemaObj)
285  {
286  }
287 
288  /// Destructor.
290  virtual ~UsdGeomBasisCurves();
291 
292  /// Return a vector of names of all pre-declared attributes for this schema
293  /// class and all its ancestor classes. Does not include attributes that
294  /// may be authored by custom/extended methods of the schemas involved.
296  static const TfTokenVector &
297  GetSchemaAttributeNames(bool includeInherited=true);
298 
299  /// Return a UsdGeomBasisCurves holding the prim adhering to this
300  /// schema at \p path on \p stage. If no prim exists at \p path on
301  /// \p stage, or if the prim at that path does not adhere to this schema,
302  /// return an invalid schema object. This is shorthand for the following:
303  ///
304  /// \code
305  /// UsdGeomBasisCurves(stage->GetPrimAtPath(path));
306  /// \endcode
307  ///
309  static UsdGeomBasisCurves
310  Get(const UsdStagePtr &stage, const SdfPath &path);
311 
312  /// Attempt to ensure a \a UsdPrim adhering to this schema at \p path
313  /// is defined (according to UsdPrim::IsDefined()) on this stage.
314  ///
315  /// If a prim adhering to this schema at \p path is already defined on this
316  /// stage, return that prim. Otherwise author an \a SdfPrimSpec with
317  /// \a specifier == \a SdfSpecifierDef and this schema's prim type name for
318  /// the prim at \p path at the current EditTarget. Author \a SdfPrimSpec s
319  /// with \p specifier == \a SdfSpecifierDef and empty typeName at the
320  /// current EditTarget for any nonexistent, or existing but not \a Defined
321  /// ancestors.
322  ///
323  /// The given \a path must be an absolute prim path that does not contain
324  /// any variant selections.
325  ///
326  /// If it is impossible to author any of the necessary PrimSpecs, (for
327  /// example, in case \a path cannot map to the current UsdEditTarget's
328  /// namespace) issue an error and return an invalid \a UsdPrim.
329  ///
330  /// Note that this method may return a defined prim whose typeName does not
331  /// specify this schema class, in case a stronger typeName opinion overrides
332  /// the opinion at the current EditTarget.
333  ///
335  static UsdGeomBasisCurves
336  Define(const UsdStagePtr &stage, const SdfPath &path);
337 
338 protected:
339  /// Returns the type of schema this class belongs to.
340  ///
341  /// \sa UsdSchemaType
343  UsdSchemaType _GetSchemaType() const override;
344 
345 private:
346  // needs to invoke _GetStaticTfType.
347  friend class UsdSchemaRegistry;
349  static const TfType &_GetStaticTfType();
350 
351  static bool _IsTypedSchema();
352 
353  // override SchemaBase virtuals.
355  const TfType &_GetTfType() const override;
356 
357 public:
358  // --------------------------------------------------------------------- //
359  // TYPE
360  // --------------------------------------------------------------------- //
361  /// Linear curves interpolate linearly between two vertices.
362  /// Cubic curves use a basis matrix with four vertices to interpolate a segment.
363  ///
364  /// \n C++ Type: TfToken
365  /// \n Usd Type: SdfValueTypeNames->Token
366  /// \n Variability: SdfVariabilityUniform
367  /// \n Fallback Value: cubic
368  /// \n \ref UsdGeomTokens "Allowed Values": [linear, cubic]
370  UsdAttribute GetTypeAttr() const;
371 
372  /// See GetTypeAttr(), and also
373  /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
374  /// If specified, author \p defaultValue as the attribute's default,
375  /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
376  /// the default for \p writeSparsely is \c false.
378  UsdAttribute CreateTypeAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
379 
380 public:
381  // --------------------------------------------------------------------- //
382  // BASIS
383  // --------------------------------------------------------------------- //
384  /// The basis specifies the vstep and matrix used for cubic interpolation.
385  ///
386  /// \n C++ Type: TfToken
387  /// \n Usd Type: SdfValueTypeNames->Token
388  /// \n Variability: SdfVariabilityUniform
389  /// \n Fallback Value: bezier
390  /// \n \ref UsdGeomTokens "Allowed Values": [bezier, bspline, catmullRom, hermite, power]
392  UsdAttribute GetBasisAttr() const;
393 
394  /// See GetBasisAttr(), and also
395  /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
396  /// If specified, author \p defaultValue as the attribute's default,
397  /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
398  /// the default for \p writeSparsely is \c false.
400  UsdAttribute CreateBasisAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
401 
402 public:
403  // --------------------------------------------------------------------- //
404  // WRAP
405  // --------------------------------------------------------------------- //
406  /// If wrap is set to periodic, the curve when rendered will
407  /// repeat the initial vertices (dependent on the vstep) to close the
408  /// curve. If wrap is set to 'pinned', phantom points may be created
409  /// to ensure that the curve interpolation starts at P[0] and ends at P[n-1].
410  ///
411  ///
412  /// \n C++ Type: TfToken
413  /// \n Usd Type: SdfValueTypeNames->Token
414  /// \n Variability: SdfVariabilityUniform
415  /// \n Fallback Value: nonperiodic
416  /// \n \ref UsdGeomTokens "Allowed Values": [nonperiodic, periodic, pinned]
418  UsdAttribute GetWrapAttr() const;
419 
420  /// See GetWrapAttr(), and also
421  /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
422  /// If specified, author \p defaultValue as the attribute's default,
423  /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
424  /// the default for \p writeSparsely is \c false.
426  UsdAttribute CreateWrapAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
427 
428 public:
429  // ===================================================================== //
430  // Feel free to add custom code below this line, it will be preserved by
431  // the code generator.
432  //
433  // Just remember to:
434  // - Close the class declaration with };
435  // - Close the namespace with PXR_NAMESPACE_CLOSE_SCOPE
436  // - Close the include guard with #endif
437  // ===================================================================== //
438  // --(BEGIN CUSTOM CODE)--
439 
440  /// \name Helper functions for working with UsdGeomCurves
441  /// \{
442 
443  typedef std::vector< std::pair<TfToken, size_t> > ComputeInterpolationInfo;
444 
445  /// Computes interpolation token for \p n.
446  ///
447  /// If this returns an empty token and \p info was non-NULL, it'll contain
448  /// the expected value for each token.
449  ///
450  /// The topology is determined using \p timeCode.
453  const UsdTimeCode& timeCode,
454  ComputeInterpolationInfo* info=NULL) const;
455 
456  /// Computes the expected size for data with "uniform" interpolation.
457  ///
458  /// If you're trying to determine what interpolation to use, it is more
459  /// efficient to use \c ComputeInterpolationForSize
461  size_t ComputeUniformDataSize(const UsdTimeCode& timeCode) const;
462 
463  /// Computes the expected size for data with "varying" interpolation.
464  ///
465  /// If you're trying to determine what interpolation to use, it is more
466  /// efficient to use \c ComputeInterpolationForSize
468  size_t ComputeVaryingDataSize(const UsdTimeCode& timeCode) const;
469 
470  /// Computes the expected size for data with "vertex" interpolation.
471  ///
472  /// If you're trying to determine what interpolation to use, it is more
473  /// efficient to use \c ComputeInterpolationForSize
475  size_t ComputeVertexDataSize(const UsdTimeCode& timeCode) const;
476 
477  /// \}
478 };
479 
481 
482 #endif
std::vector< std::pair< TfToken, size_t > > ComputeInterpolationInfo
Definition: basisCurves.h:443
static const UsdSchemaType schemaType
Definition: basisCurves.h:269
static USDGEOM_API UsdGeomBasisCurves Define(const UsdStagePtr &stage, const SdfPath &path)
UsdGeomBasisCurves(const UsdPrim &prim=UsdPrim())
Definition: basisCurves.h:275
USDGEOM_API size_t ComputeVertexDataSize(const UsdTimeCode &timeCode) const
Represents a concrete typed schema.
USDGEOM_API UsdAttribute GetBasisAttr() const
Definition: token.h:89
UsdGeomBasisCurves(const UsdSchemaBase &schemaObj)
Definition: basisCurves.h:283
static USDGEOM_API const TfTokenVector & GetSchemaAttributeNames(bool includeInherited=true)
GLsizei n
Definition: glew.h:4040
USDGEOM_API size_t ComputeUniformDataSize(const UsdTimeCode &timeCode) const
USDGEOM_API TfToken ComputeInterpolationForSize(size_t n, const UsdTimeCode &timeCode, ComputeInterpolationInfo *info=NULL) const
UsdSchemaType
Definition: common.h:149
Definition: prim.h:131
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:438
Definition: path.h:287
static USDGEOM_API UsdGeomBasisCurves Get(const UsdStagePtr &stage, const SdfPath &path)
USDGEOM_API UsdSchemaType _GetSchemaType() const override
GLsizei const GLchar *const * path
Definition: glew.h:6461
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1245
virtual USDGEOM_API ~UsdGeomBasisCurves()
Destructor.
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:83
USDGEOM_API size_t ComputeVaryingDataSize(const UsdTimeCode &timeCode) const
Definition: type.h:70
USDGEOM_API UsdAttribute GetWrapAttr() const
#define USDGEOM_API
Definition: api.h:40
USDGEOM_API UsdAttribute CreateTypeAttr(VtValue const &defaultValue=VtValue(), bool writeSparsely=false) const
USDGEOM_API UsdAttribute CreateWrapAttr(VtValue const &defaultValue=VtValue(), bool writeSparsely=false) const
USDGEOM_API UsdAttribute CreateBasisAttr(VtValue const &defaultValue=VtValue(), bool writeSparsely=false) const
Definition: value.h:182
USDGEOM_API UsdAttribute GetTypeAttr() const