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 USDCONTRIVED_GENERATED_BASE_H 25 #define USDCONTRIVED_GENERATED_BASE_H 26 27 /// \file usdContrived/base.h 28 29 #include "pxr/pxr.h" 30 #include "pxr/usd/usdContrived/api.h" 31 #include "pxr/usd/usd/typed.h" 32 #include "pxr/usd/usd/prim.h" 33 #include "pxr/usd/usd/stage.h" 34 #include "pxr/usd/usdContrived/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 45 PXR_NAMESPACE_OPEN_SCOPE 46 47 class SdfAssetPath; 48 49 // -------------------------------------------------------------------------- // 50 // BASE // 51 // -------------------------------------------------------------------------- // 52 53 /// \class UsdContrivedBase 54 /// 55 /// This doc should only exist on the "Base" class. 56 /// 57 /// For any described attribute \em Fallback \em Value or \em Allowed \em Values below 58 /// that are text/tokens, the actual token is published and defined in \ref UsdContrivedTokens. 59 /// So to set an attribute to the value "rightHanded", use UsdContrivedTokens->rightHanded 60 /// as the value. 61 /// 62 class UsdContrivedBase : public UsdTyped 63 { 64 public: 65 /// Compile time constant representing what kind of schema this class is. 66 /// 67 /// \sa UsdSchemaKind 68 static const UsdSchemaKind schemaKind = UsdSchemaKind::AbstractTyped; 69 70 /// Construct a UsdContrivedBase on UsdPrim \p prim . 71 /// Equivalent to UsdContrivedBase::Get(prim.GetStage(), prim.GetPath()) 72 /// for a \em valid \p prim, but will not immediately throw an error for 73 /// an invalid \p prim 74 explicit UsdContrivedBase(const UsdPrim& prim=UsdPrim()) UsdTyped(prim)75 : UsdTyped(prim) 76 { 77 } 78 79 /// Construct a UsdContrivedBase on the prim held by \p schemaObj . 80 /// Should be preferred over UsdContrivedBase(schemaObj.GetPrim()), 81 /// as it preserves SchemaBase state. UsdContrivedBase(const UsdSchemaBase & schemaObj)82 explicit UsdContrivedBase(const UsdSchemaBase& schemaObj) 83 : UsdTyped(schemaObj) 84 { 85 } 86 87 /// Destructor. 88 USDCONTRIVED_API 89 virtual ~UsdContrivedBase(); 90 91 /// Return a vector of names of all pre-declared attributes for this schema 92 /// class and all its ancestor classes. Does not include attributes that 93 /// may be authored by custom/extended methods of the schemas involved. 94 USDCONTRIVED_API 95 static const TfTokenVector & 96 GetSchemaAttributeNames(bool includeInherited=true); 97 98 /// Return a UsdContrivedBase holding the prim adhering to this 99 /// schema at \p path on \p stage. If no prim exists at \p path on 100 /// \p stage, or if the prim at that path does not adhere to this schema, 101 /// return an invalid schema object. This is shorthand for the following: 102 /// 103 /// \code 104 /// UsdContrivedBase(stage->GetPrimAtPath(path)); 105 /// \endcode 106 /// 107 USDCONTRIVED_API 108 static UsdContrivedBase 109 Get(const UsdStagePtr &stage, const SdfPath &path); 110 111 112 protected: 113 /// Returns the kind of schema this class belongs to. 114 /// 115 /// \sa UsdSchemaKind 116 USDCONTRIVED_API 117 UsdSchemaKind _GetSchemaKind() const override; 118 119 private: 120 // needs to invoke _GetStaticTfType. 121 friend class UsdSchemaRegistry; 122 USDCONTRIVED_API 123 static const TfType &_GetStaticTfType(); 124 125 static bool _IsTypedSchema(); 126 127 // override SchemaBase virtuals. 128 USDCONTRIVED_API 129 const TfType &_GetTfType() const override; 130 131 public: 132 // --------------------------------------------------------------------- // 133 // MYVARYINGTOKEN 134 // --------------------------------------------------------------------- // 135 /// VariableToken attribute docs. 136 /// 137 /// | || 138 /// | -- | -- | 139 /// | Declaration | `token myVaryingToken = "VariableTokenDefault"` | 140 /// | C++ Type | TfToken | 141 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token | 142 /// | \ref UsdContrivedTokens "Allowed Values" | VariableTokenAllowed1, VariableTokenAllowed2, VariableTokenAllowed<3>, "" | 143 USDCONTRIVED_API 144 UsdAttribute GetMyVaryingTokenAttr() const; 145 146 /// See GetMyVaryingTokenAttr(), and also 147 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 148 /// If specified, author \p defaultValue as the attribute's default, 149 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 150 /// the default for \p writeSparsely is \c false. 151 USDCONTRIVED_API 152 UsdAttribute CreateMyVaryingTokenAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 153 154 public: 155 // --------------------------------------------------------------------- // 156 // MYVARYINGTOKENARRAY 157 // --------------------------------------------------------------------- // 158 /// VariableTokenArray attribute docs. 159 /// 160 /// | || 161 /// | -- | -- | 162 /// | Declaration | `uniform token[] myVaryingTokenArray = ["VariableTokenArrayAllowed1", ""]` | 163 /// | C++ Type | VtArray<TfToken> | 164 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->TokenArray | 165 /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | 166 /// | \ref UsdContrivedTokens "Allowed Values" | VariableTokenArrayAllowed1, VariableTokenArrayAllowed2, VariableTokenArrayAllowed<3>, "" | 167 USDCONTRIVED_API 168 UsdAttribute GetMyVaryingTokenArrayAttr() const; 169 170 /// See GetMyVaryingTokenArrayAttr(), and also 171 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 172 /// If specified, author \p defaultValue as the attribute's default, 173 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 174 /// the default for \p writeSparsely is \c false. 175 USDCONTRIVED_API 176 UsdAttribute CreateMyVaryingTokenArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 177 178 public: 179 // --------------------------------------------------------------------- // 180 // MYUNIFORMBOOL 181 // --------------------------------------------------------------------- // 182 /// Uniform bool, default false 183 /// 184 /// | || 185 /// | -- | -- | 186 /// | Declaration | `uniform bool myUniformBool = 0` | 187 /// | C++ Type | bool | 188 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | 189 /// | \ref SdfVariability "Variability" | SdfVariabilityUniform | 190 USDCONTRIVED_API 191 UsdAttribute GetMyUniformBoolAttr() const; 192 193 /// See GetMyUniformBoolAttr(), and also 194 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 195 /// If specified, author \p defaultValue as the attribute's default, 196 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 197 /// the default for \p writeSparsely is \c false. 198 USDCONTRIVED_API 199 UsdAttribute CreateMyUniformBoolAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 200 201 public: 202 // --------------------------------------------------------------------- // 203 // MYDOUBLE 204 // --------------------------------------------------------------------- // 205 /// 206 /// 207 /// | || 208 /// | -- | -- | 209 /// | Declaration | `double myDouble` | 210 /// | C++ Type | double | 211 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | 212 USDCONTRIVED_API 213 UsdAttribute GetMyDoubleAttr() const; 214 215 /// See GetMyDoubleAttr(), and also 216 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 217 /// If specified, author \p defaultValue as the attribute's default, 218 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 219 /// the default for \p writeSparsely is \c false. 220 USDCONTRIVED_API 221 UsdAttribute CreateMyDoubleAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 222 223 public: 224 // --------------------------------------------------------------------- // 225 // BOOL 226 // --------------------------------------------------------------------- // 227 /// 228 /// 229 /// | || 230 /// | -- | -- | 231 /// | Declaration | `bool bool = 1` | 232 /// | C++ Type | bool | 233 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool | 234 USDCONTRIVED_API 235 UsdAttribute GetBoolAttr() const; 236 237 /// See GetBoolAttr(), and also 238 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 239 /// If specified, author \p defaultValue as the attribute's default, 240 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 241 /// the default for \p writeSparsely is \c false. 242 USDCONTRIVED_API 243 UsdAttribute CreateBoolAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 244 245 public: 246 // --------------------------------------------------------------------- // 247 // UCHAR 248 // --------------------------------------------------------------------- // 249 /// 250 /// 251 /// | || 252 /// | -- | -- | 253 /// | Declaration | `uchar uchar = 0` | 254 /// | C++ Type | unsigned char | 255 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UChar | 256 USDCONTRIVED_API 257 UsdAttribute GetUcharAttr() const; 258 259 /// See GetUcharAttr(), and also 260 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 261 /// If specified, author \p defaultValue as the attribute's default, 262 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 263 /// the default for \p writeSparsely is \c false. 264 USDCONTRIVED_API 265 UsdAttribute CreateUcharAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 266 267 public: 268 // --------------------------------------------------------------------- // 269 // INT 270 // --------------------------------------------------------------------- // 271 /// 272 /// 273 /// | || 274 /// | -- | -- | 275 /// | Declaration | `int int = 0` | 276 /// | C++ Type | int | 277 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int | 278 USDCONTRIVED_API 279 UsdAttribute GetIntAttr() const; 280 281 /// See GetIntAttr(), and also 282 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 283 /// If specified, author \p defaultValue as the attribute's default, 284 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 285 /// the default for \p writeSparsely is \c false. 286 USDCONTRIVED_API 287 UsdAttribute CreateIntAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 288 289 public: 290 // --------------------------------------------------------------------- // 291 // UINT 292 // --------------------------------------------------------------------- // 293 /// 294 /// 295 /// | || 296 /// | -- | -- | 297 /// | Declaration | `uint uint = 0` | 298 /// | C++ Type | unsigned int | 299 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UInt | 300 USDCONTRIVED_API 301 UsdAttribute GetUintAttr() const; 302 303 /// See GetUintAttr(), and also 304 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 305 /// If specified, author \p defaultValue as the attribute's default, 306 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 307 /// the default for \p writeSparsely is \c false. 308 USDCONTRIVED_API 309 UsdAttribute CreateUintAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 310 311 public: 312 // --------------------------------------------------------------------- // 313 // INT64 314 // --------------------------------------------------------------------- // 315 /// 316 /// 317 /// | || 318 /// | -- | -- | 319 /// | Declaration | `int64 int64 = 0` | 320 /// | C++ Type | int64_t | 321 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int64 | 322 USDCONTRIVED_API 323 UsdAttribute GetInt64Attr() const; 324 325 /// See GetInt64Attr(), and also 326 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 327 /// If specified, author \p defaultValue as the attribute's default, 328 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 329 /// the default for \p writeSparsely is \c false. 330 USDCONTRIVED_API 331 UsdAttribute CreateInt64Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 332 333 public: 334 // --------------------------------------------------------------------- // 335 // UINT64 336 // --------------------------------------------------------------------- // 337 /// 338 /// 339 /// | || 340 /// | -- | -- | 341 /// | Declaration | `uint64 uint64 = 0` | 342 /// | C++ Type | uint64_t | 343 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UInt64 | 344 USDCONTRIVED_API 345 UsdAttribute GetUint64Attr() const; 346 347 /// See GetUint64Attr(), and also 348 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 349 /// If specified, author \p defaultValue as the attribute's default, 350 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 351 /// the default for \p writeSparsely is \c false. 352 USDCONTRIVED_API 353 UsdAttribute CreateUint64Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 354 355 public: 356 // --------------------------------------------------------------------- // 357 // HALF 358 // --------------------------------------------------------------------- // 359 /// 360 /// 361 /// | || 362 /// | -- | -- | 363 /// | Declaration | `half half = 0` | 364 /// | C++ Type | GfHalf | 365 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half | 366 USDCONTRIVED_API 367 UsdAttribute GetHalfAttr() const; 368 369 /// See GetHalfAttr(), and also 370 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 371 /// If specified, author \p defaultValue as the attribute's default, 372 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 373 /// the default for \p writeSparsely is \c false. 374 USDCONTRIVED_API 375 UsdAttribute CreateHalfAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 376 377 public: 378 // --------------------------------------------------------------------- // 379 // FLOAT 380 // --------------------------------------------------------------------- // 381 /// 382 /// 383 /// | || 384 /// | -- | -- | 385 /// | Declaration | `float float = 0` | 386 /// | C++ Type | float | 387 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float | 388 USDCONTRIVED_API 389 UsdAttribute GetFloatAttr() const; 390 391 /// See GetFloatAttr(), and also 392 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 393 /// If specified, author \p defaultValue as the attribute's default, 394 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 395 /// the default for \p writeSparsely is \c false. 396 USDCONTRIVED_API 397 UsdAttribute CreateFloatAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 398 399 public: 400 // --------------------------------------------------------------------- // 401 // DOUBLE 402 // --------------------------------------------------------------------- // 403 /// 404 /// 405 /// | || 406 /// | -- | -- | 407 /// | Declaration | `double double = 0` | 408 /// | C++ Type | double | 409 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double | 410 USDCONTRIVED_API 411 UsdAttribute GetDoubleAttr() const; 412 413 /// See GetDoubleAttr(), and also 414 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 415 /// If specified, author \p defaultValue as the attribute's default, 416 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 417 /// the default for \p writeSparsely is \c false. 418 USDCONTRIVED_API 419 UsdAttribute CreateDoubleAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 420 421 public: 422 // --------------------------------------------------------------------- // 423 // STRING 424 // --------------------------------------------------------------------- // 425 /// 426 /// 427 /// | || 428 /// | -- | -- | 429 /// | Declaration | `string string = "string"` | 430 /// | C++ Type | std::string | 431 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->String | 432 USDCONTRIVED_API 433 UsdAttribute GetStringAttr() const; 434 435 /// See GetStringAttr(), and also 436 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 437 /// If specified, author \p defaultValue as the attribute's default, 438 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 439 /// the default for \p writeSparsely is \c false. 440 USDCONTRIVED_API 441 UsdAttribute CreateStringAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 442 443 public: 444 // --------------------------------------------------------------------- // 445 // TOKEN 446 // --------------------------------------------------------------------- // 447 /// 448 /// 449 /// | || 450 /// | -- | -- | 451 /// | Declaration | `token token = "token"` | 452 /// | C++ Type | TfToken | 453 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token | 454 USDCONTRIVED_API 455 UsdAttribute GetTokenAttr() const; 456 457 /// See GetTokenAttr(), and also 458 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 459 /// If specified, author \p defaultValue as the attribute's default, 460 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 461 /// the default for \p writeSparsely is \c false. 462 USDCONTRIVED_API 463 UsdAttribute CreateTokenAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 464 465 public: 466 // --------------------------------------------------------------------- // 467 // ASSET 468 // --------------------------------------------------------------------- // 469 /// 470 /// 471 /// | || 472 /// | -- | -- | 473 /// | Declaration | `asset asset = @asset@` | 474 /// | C++ Type | SdfAssetPath | 475 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Asset | 476 USDCONTRIVED_API 477 UsdAttribute GetAssetAttr() const; 478 479 /// See GetAssetAttr(), and also 480 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 481 /// If specified, author \p defaultValue as the attribute's default, 482 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 483 /// the default for \p writeSparsely is \c false. 484 USDCONTRIVED_API 485 UsdAttribute CreateAssetAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 486 487 public: 488 // --------------------------------------------------------------------- // 489 // INT2 490 // --------------------------------------------------------------------- // 491 /// 492 /// 493 /// | || 494 /// | -- | -- | 495 /// | Declaration | `int2 int2 = (0, 0)` | 496 /// | C++ Type | GfVec2i | 497 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int2 | 498 USDCONTRIVED_API 499 UsdAttribute GetInt2Attr() const; 500 501 /// See GetInt2Attr(), and also 502 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 503 /// If specified, author \p defaultValue as the attribute's default, 504 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 505 /// the default for \p writeSparsely is \c false. 506 USDCONTRIVED_API 507 UsdAttribute CreateInt2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 508 509 public: 510 // --------------------------------------------------------------------- // 511 // INT3 512 // --------------------------------------------------------------------- // 513 /// 514 /// 515 /// | || 516 /// | -- | -- | 517 /// | Declaration | `int3 int3 = (0, 0, 0)` | 518 /// | C++ Type | GfVec3i | 519 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int3 | 520 USDCONTRIVED_API 521 UsdAttribute GetInt3Attr() const; 522 523 /// See GetInt3Attr(), and also 524 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 525 /// If specified, author \p defaultValue as the attribute's default, 526 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 527 /// the default for \p writeSparsely is \c false. 528 USDCONTRIVED_API 529 UsdAttribute CreateInt3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 530 531 public: 532 // --------------------------------------------------------------------- // 533 // INT4 534 // --------------------------------------------------------------------- // 535 /// 536 /// 537 /// | || 538 /// | -- | -- | 539 /// | Declaration | `int4 int4 = (0, 0, 0, 0)` | 540 /// | C++ Type | GfVec4i | 541 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int4 | 542 USDCONTRIVED_API 543 UsdAttribute GetInt4Attr() const; 544 545 /// See GetInt4Attr(), and also 546 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 547 /// If specified, author \p defaultValue as the attribute's default, 548 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 549 /// the default for \p writeSparsely is \c false. 550 USDCONTRIVED_API 551 UsdAttribute CreateInt4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 552 553 public: 554 // --------------------------------------------------------------------- // 555 // HALF2 556 // --------------------------------------------------------------------- // 557 /// 558 /// 559 /// | || 560 /// | -- | -- | 561 /// | Declaration | `half2 half2 = (0, 0)` | 562 /// | C++ Type | GfVec2h | 563 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half2 | 564 USDCONTRIVED_API 565 UsdAttribute GetHalf2Attr() const; 566 567 /// See GetHalf2Attr(), and also 568 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 569 /// If specified, author \p defaultValue as the attribute's default, 570 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 571 /// the default for \p writeSparsely is \c false. 572 USDCONTRIVED_API 573 UsdAttribute CreateHalf2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 574 575 public: 576 // --------------------------------------------------------------------- // 577 // HALF3 578 // --------------------------------------------------------------------- // 579 /// 580 /// 581 /// | || 582 /// | -- | -- | 583 /// | Declaration | `half3 half3 = (0, 0, 0)` | 584 /// | C++ Type | GfVec3h | 585 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half3 | 586 USDCONTRIVED_API 587 UsdAttribute GetHalf3Attr() const; 588 589 /// See GetHalf3Attr(), and also 590 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 591 /// If specified, author \p defaultValue as the attribute's default, 592 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 593 /// the default for \p writeSparsely is \c false. 594 USDCONTRIVED_API 595 UsdAttribute CreateHalf3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 596 597 public: 598 // --------------------------------------------------------------------- // 599 // HALF4 600 // --------------------------------------------------------------------- // 601 /// 602 /// 603 /// | || 604 /// | -- | -- | 605 /// | Declaration | `half4 half4 = (0, 0, 0, 0)` | 606 /// | C++ Type | GfVec4h | 607 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half4 | 608 USDCONTRIVED_API 609 UsdAttribute GetHalf4Attr() const; 610 611 /// See GetHalf4Attr(), and also 612 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 613 /// If specified, author \p defaultValue as the attribute's default, 614 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 615 /// the default for \p writeSparsely is \c false. 616 USDCONTRIVED_API 617 UsdAttribute CreateHalf4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 618 619 public: 620 // --------------------------------------------------------------------- // 621 // FLOAT2 622 // --------------------------------------------------------------------- // 623 /// 624 /// 625 /// | || 626 /// | -- | -- | 627 /// | Declaration | `float2 float2 = (0, 0)` | 628 /// | C++ Type | GfVec2f | 629 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float2 | 630 USDCONTRIVED_API 631 UsdAttribute GetFloat2Attr() const; 632 633 /// See GetFloat2Attr(), and also 634 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 635 /// If specified, author \p defaultValue as the attribute's default, 636 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 637 /// the default for \p writeSparsely is \c false. 638 USDCONTRIVED_API 639 UsdAttribute CreateFloat2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 640 641 public: 642 // --------------------------------------------------------------------- // 643 // FLOAT3 644 // --------------------------------------------------------------------- // 645 /// 646 /// 647 /// | || 648 /// | -- | -- | 649 /// | Declaration | `float3 float3 = (0, 0, 0)` | 650 /// | C++ Type | GfVec3f | 651 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float3 | 652 USDCONTRIVED_API 653 UsdAttribute GetFloat3Attr() const; 654 655 /// See GetFloat3Attr(), and also 656 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 657 /// If specified, author \p defaultValue as the attribute's default, 658 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 659 /// the default for \p writeSparsely is \c false. 660 USDCONTRIVED_API 661 UsdAttribute CreateFloat3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 662 663 public: 664 // --------------------------------------------------------------------- // 665 // FLOAT4 666 // --------------------------------------------------------------------- // 667 /// 668 /// 669 /// | || 670 /// | -- | -- | 671 /// | Declaration | `float4 float4 = (0, 0, 0, 0)` | 672 /// | C++ Type | GfVec4f | 673 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float4 | 674 USDCONTRIVED_API 675 UsdAttribute GetFloat4Attr() const; 676 677 /// See GetFloat4Attr(), and also 678 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 679 /// If specified, author \p defaultValue as the attribute's default, 680 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 681 /// the default for \p writeSparsely is \c false. 682 USDCONTRIVED_API 683 UsdAttribute CreateFloat4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 684 685 public: 686 // --------------------------------------------------------------------- // 687 // DOUBLE2 688 // --------------------------------------------------------------------- // 689 /// 690 /// 691 /// | || 692 /// | -- | -- | 693 /// | Declaration | `double2 double2 = (0, 0)` | 694 /// | C++ Type | GfVec2d | 695 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double2 | 696 USDCONTRIVED_API 697 UsdAttribute GetDouble2Attr() const; 698 699 /// See GetDouble2Attr(), and also 700 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 701 /// If specified, author \p defaultValue as the attribute's default, 702 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 703 /// the default for \p writeSparsely is \c false. 704 USDCONTRIVED_API 705 UsdAttribute CreateDouble2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 706 707 public: 708 // --------------------------------------------------------------------- // 709 // DOUBLE3 710 // --------------------------------------------------------------------- // 711 /// 712 /// 713 /// | || 714 /// | -- | -- | 715 /// | Declaration | `double3 double3 = (0, 0, 0)` | 716 /// | C++ Type | GfVec3d | 717 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double3 | 718 USDCONTRIVED_API 719 UsdAttribute GetDouble3Attr() const; 720 721 /// See GetDouble3Attr(), and also 722 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 723 /// If specified, author \p defaultValue as the attribute's default, 724 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 725 /// the default for \p writeSparsely is \c false. 726 USDCONTRIVED_API 727 UsdAttribute CreateDouble3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 728 729 public: 730 // --------------------------------------------------------------------- // 731 // DOUBLE4 732 // --------------------------------------------------------------------- // 733 /// 734 /// 735 /// | || 736 /// | -- | -- | 737 /// | Declaration | `double4 double4 = (0, 0, 0, 0)` | 738 /// | C++ Type | GfVec4d | 739 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double4 | 740 USDCONTRIVED_API 741 UsdAttribute GetDouble4Attr() const; 742 743 /// See GetDouble4Attr(), and also 744 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 745 /// If specified, author \p defaultValue as the attribute's default, 746 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 747 /// the default for \p writeSparsely is \c false. 748 USDCONTRIVED_API 749 UsdAttribute CreateDouble4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 750 751 public: 752 // --------------------------------------------------------------------- // 753 // POINT3H 754 // --------------------------------------------------------------------- // 755 /// 756 /// 757 /// | || 758 /// | -- | -- | 759 /// | Declaration | `point3h point3h = (0, 0, 0)` | 760 /// | C++ Type | GfVec3h | 761 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3h | 762 USDCONTRIVED_API 763 UsdAttribute GetPoint3hAttr() const; 764 765 /// See GetPoint3hAttr(), and also 766 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 767 /// If specified, author \p defaultValue as the attribute's default, 768 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 769 /// the default for \p writeSparsely is \c false. 770 USDCONTRIVED_API 771 UsdAttribute CreatePoint3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 772 773 public: 774 // --------------------------------------------------------------------- // 775 // POINT3F 776 // --------------------------------------------------------------------- // 777 /// 778 /// 779 /// | || 780 /// | -- | -- | 781 /// | Declaration | `point3f point3f = (0, 0, 0)` | 782 /// | C++ Type | GfVec3f | 783 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3f | 784 USDCONTRIVED_API 785 UsdAttribute GetPoint3fAttr() const; 786 787 /// See GetPoint3fAttr(), and also 788 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 789 /// If specified, author \p defaultValue as the attribute's default, 790 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 791 /// the default for \p writeSparsely is \c false. 792 USDCONTRIVED_API 793 UsdAttribute CreatePoint3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 794 795 public: 796 // --------------------------------------------------------------------- // 797 // POINT3D 798 // --------------------------------------------------------------------- // 799 /// 800 /// 801 /// | || 802 /// | -- | -- | 803 /// | Declaration | `point3d point3d = (0, 0, 0)` | 804 /// | C++ Type | GfVec3d | 805 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3d | 806 USDCONTRIVED_API 807 UsdAttribute GetPoint3dAttr() const; 808 809 /// See GetPoint3dAttr(), and also 810 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 811 /// If specified, author \p defaultValue as the attribute's default, 812 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 813 /// the default for \p writeSparsely is \c false. 814 USDCONTRIVED_API 815 UsdAttribute CreatePoint3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 816 817 public: 818 // --------------------------------------------------------------------- // 819 // VECTOR3D 820 // --------------------------------------------------------------------- // 821 /// 822 /// 823 /// | || 824 /// | -- | -- | 825 /// | Declaration | `vector3d vector3d = (0, 0, 0)` | 826 /// | C++ Type | GfVec3d | 827 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3d | 828 USDCONTRIVED_API 829 UsdAttribute GetVector3dAttr() const; 830 831 /// See GetVector3dAttr(), and also 832 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 833 /// If specified, author \p defaultValue as the attribute's default, 834 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 835 /// the default for \p writeSparsely is \c false. 836 USDCONTRIVED_API 837 UsdAttribute CreateVector3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 838 839 public: 840 // --------------------------------------------------------------------- // 841 // VECTOR3F 842 // --------------------------------------------------------------------- // 843 /// 844 /// 845 /// | || 846 /// | -- | -- | 847 /// | Declaration | `vector3f vector3f = (0, 0, 0)` | 848 /// | C++ Type | GfVec3f | 849 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3f | 850 USDCONTRIVED_API 851 UsdAttribute GetVector3fAttr() const; 852 853 /// See GetVector3fAttr(), and also 854 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 855 /// If specified, author \p defaultValue as the attribute's default, 856 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 857 /// the default for \p writeSparsely is \c false. 858 USDCONTRIVED_API 859 UsdAttribute CreateVector3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 860 861 public: 862 // --------------------------------------------------------------------- // 863 // VECTOR3H 864 // --------------------------------------------------------------------- // 865 /// 866 /// 867 /// | || 868 /// | -- | -- | 869 /// | Declaration | `vector3h vector3h = (0, 0, 0)` | 870 /// | C++ Type | GfVec3h | 871 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3h | 872 USDCONTRIVED_API 873 UsdAttribute GetVector3hAttr() const; 874 875 /// See GetVector3hAttr(), and also 876 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 877 /// If specified, author \p defaultValue as the attribute's default, 878 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 879 /// the default for \p writeSparsely is \c false. 880 USDCONTRIVED_API 881 UsdAttribute CreateVector3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 882 883 public: 884 // --------------------------------------------------------------------- // 885 // NORMAL3D 886 // --------------------------------------------------------------------- // 887 /// 888 /// 889 /// | || 890 /// | -- | -- | 891 /// | Declaration | `normal3d normal3d = (0, 0, 0)` | 892 /// | C++ Type | GfVec3d | 893 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3d | 894 USDCONTRIVED_API 895 UsdAttribute GetNormal3dAttr() const; 896 897 /// See GetNormal3dAttr(), and also 898 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 899 /// If specified, author \p defaultValue as the attribute's default, 900 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 901 /// the default for \p writeSparsely is \c false. 902 USDCONTRIVED_API 903 UsdAttribute CreateNormal3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 904 905 public: 906 // --------------------------------------------------------------------- // 907 // NORMAL3F 908 // --------------------------------------------------------------------- // 909 /// 910 /// 911 /// | || 912 /// | -- | -- | 913 /// | Declaration | `normal3f normal3f = (0, 0, 0)` | 914 /// | C++ Type | GfVec3f | 915 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3f | 916 USDCONTRIVED_API 917 UsdAttribute GetNormal3fAttr() const; 918 919 /// See GetNormal3fAttr(), and also 920 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 921 /// If specified, author \p defaultValue as the attribute's default, 922 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 923 /// the default for \p writeSparsely is \c false. 924 USDCONTRIVED_API 925 UsdAttribute CreateNormal3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 926 927 public: 928 // --------------------------------------------------------------------- // 929 // NORMAL3H 930 // --------------------------------------------------------------------- // 931 /// 932 /// 933 /// | || 934 /// | -- | -- | 935 /// | Declaration | `normal3h normal3h = (0, 0, 0)` | 936 /// | C++ Type | GfVec3h | 937 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3h | 938 USDCONTRIVED_API 939 UsdAttribute GetNormal3hAttr() const; 940 941 /// See GetNormal3hAttr(), and also 942 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 943 /// If specified, author \p defaultValue as the attribute's default, 944 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 945 /// the default for \p writeSparsely is \c false. 946 USDCONTRIVED_API 947 UsdAttribute CreateNormal3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 948 949 public: 950 // --------------------------------------------------------------------- // 951 // COLOR3D 952 // --------------------------------------------------------------------- // 953 /// 954 /// 955 /// | || 956 /// | -- | -- | 957 /// | Declaration | `color3d color3d = (0, 0, 0)` | 958 /// | C++ Type | GfVec3d | 959 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3d | 960 USDCONTRIVED_API 961 UsdAttribute GetColor3dAttr() const; 962 963 /// See GetColor3dAttr(), and also 964 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 965 /// If specified, author \p defaultValue as the attribute's default, 966 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 967 /// the default for \p writeSparsely is \c false. 968 USDCONTRIVED_API 969 UsdAttribute CreateColor3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 970 971 public: 972 // --------------------------------------------------------------------- // 973 // COLOR3F 974 // --------------------------------------------------------------------- // 975 /// 976 /// 977 /// | || 978 /// | -- | -- | 979 /// | Declaration | `color3f color3f = (0, 0, 0)` | 980 /// | C++ Type | GfVec3f | 981 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3f | 982 USDCONTRIVED_API 983 UsdAttribute GetColor3fAttr() const; 984 985 /// See GetColor3fAttr(), and also 986 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 987 /// If specified, author \p defaultValue as the attribute's default, 988 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 989 /// the default for \p writeSparsely is \c false. 990 USDCONTRIVED_API 991 UsdAttribute CreateColor3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 992 993 public: 994 // --------------------------------------------------------------------- // 995 // COLOR3H 996 // --------------------------------------------------------------------- // 997 /// 998 /// 999 /// | || 1000 /// | -- | -- | 1001 /// | Declaration | `color3h color3h = (0, 0, 0)` | 1002 /// | C++ Type | GfVec3h | 1003 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3h | 1004 USDCONTRIVED_API 1005 UsdAttribute GetColor3hAttr() const; 1006 1007 /// See GetColor3hAttr(), and also 1008 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1009 /// If specified, author \p defaultValue as the attribute's default, 1010 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1011 /// the default for \p writeSparsely is \c false. 1012 USDCONTRIVED_API 1013 UsdAttribute CreateColor3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1014 1015 public: 1016 // --------------------------------------------------------------------- // 1017 // COLOR4D 1018 // --------------------------------------------------------------------- // 1019 /// 1020 /// 1021 /// | || 1022 /// | -- | -- | 1023 /// | Declaration | `color4d color4d = (0, 0, 0, 0)` | 1024 /// | C++ Type | GfVec4d | 1025 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4d | 1026 USDCONTRIVED_API 1027 UsdAttribute GetColor4dAttr() const; 1028 1029 /// See GetColor4dAttr(), and also 1030 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1031 /// If specified, author \p defaultValue as the attribute's default, 1032 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1033 /// the default for \p writeSparsely is \c false. 1034 USDCONTRIVED_API 1035 UsdAttribute CreateColor4dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1036 1037 public: 1038 // --------------------------------------------------------------------- // 1039 // COLOR4F 1040 // --------------------------------------------------------------------- // 1041 /// 1042 /// 1043 /// | || 1044 /// | -- | -- | 1045 /// | Declaration | `color4f color4f = (0, 0, 0, 0)` | 1046 /// | C++ Type | GfVec4f | 1047 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4f | 1048 USDCONTRIVED_API 1049 UsdAttribute GetColor4fAttr() const; 1050 1051 /// See GetColor4fAttr(), and also 1052 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1053 /// If specified, author \p defaultValue as the attribute's default, 1054 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1055 /// the default for \p writeSparsely is \c false. 1056 USDCONTRIVED_API 1057 UsdAttribute CreateColor4fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1058 1059 public: 1060 // --------------------------------------------------------------------- // 1061 // COLOR4H 1062 // --------------------------------------------------------------------- // 1063 /// 1064 /// 1065 /// | || 1066 /// | -- | -- | 1067 /// | Declaration | `color4h color4h = (0, 0, 0, 0)` | 1068 /// | C++ Type | GfVec4h | 1069 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4h | 1070 USDCONTRIVED_API 1071 UsdAttribute GetColor4hAttr() const; 1072 1073 /// See GetColor4hAttr(), and also 1074 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1075 /// If specified, author \p defaultValue as the attribute's default, 1076 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1077 /// the default for \p writeSparsely is \c false. 1078 USDCONTRIVED_API 1079 UsdAttribute CreateColor4hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1080 1081 public: 1082 // --------------------------------------------------------------------- // 1083 // QUATD 1084 // --------------------------------------------------------------------- // 1085 /// 1086 /// 1087 /// | || 1088 /// | -- | -- | 1089 /// | Declaration | `quatd quatd = (1, 0, 0, 0)` | 1090 /// | C++ Type | GfQuatd | 1091 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Quatd | 1092 USDCONTRIVED_API 1093 UsdAttribute GetQuatdAttr() const; 1094 1095 /// See GetQuatdAttr(), and also 1096 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1097 /// If specified, author \p defaultValue as the attribute's default, 1098 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1099 /// the default for \p writeSparsely is \c false. 1100 USDCONTRIVED_API 1101 UsdAttribute CreateQuatdAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1102 1103 public: 1104 // --------------------------------------------------------------------- // 1105 // QUATF 1106 // --------------------------------------------------------------------- // 1107 /// 1108 /// 1109 /// | || 1110 /// | -- | -- | 1111 /// | Declaration | `quatf quatf = (1, 0, 0, 0)` | 1112 /// | C++ Type | GfQuatf | 1113 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Quatf | 1114 USDCONTRIVED_API 1115 UsdAttribute GetQuatfAttr() const; 1116 1117 /// See GetQuatfAttr(), and also 1118 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1119 /// If specified, author \p defaultValue as the attribute's default, 1120 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1121 /// the default for \p writeSparsely is \c false. 1122 USDCONTRIVED_API 1123 UsdAttribute CreateQuatfAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1124 1125 public: 1126 // --------------------------------------------------------------------- // 1127 // QUATH 1128 // --------------------------------------------------------------------- // 1129 /// 1130 /// 1131 /// | || 1132 /// | -- | -- | 1133 /// | Declaration | `quath quath = (1, 0, 0, 0)` | 1134 /// | C++ Type | GfQuath | 1135 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Quath | 1136 USDCONTRIVED_API 1137 UsdAttribute GetQuathAttr() const; 1138 1139 /// See GetQuathAttr(), and also 1140 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1141 /// If specified, author \p defaultValue as the attribute's default, 1142 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1143 /// the default for \p writeSparsely is \c false. 1144 USDCONTRIVED_API 1145 UsdAttribute CreateQuathAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1146 1147 public: 1148 // --------------------------------------------------------------------- // 1149 // MATRIX2D 1150 // --------------------------------------------------------------------- // 1151 /// 1152 /// 1153 /// | || 1154 /// | -- | -- | 1155 /// | Declaration | `matrix2d matrix2d = ( (1, 0), (0, 1) )` | 1156 /// | C++ Type | GfMatrix2d | 1157 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix2d | 1158 USDCONTRIVED_API 1159 UsdAttribute GetMatrix2dAttr() const; 1160 1161 /// See GetMatrix2dAttr(), and also 1162 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1163 /// If specified, author \p defaultValue as the attribute's default, 1164 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1165 /// the default for \p writeSparsely is \c false. 1166 USDCONTRIVED_API 1167 UsdAttribute CreateMatrix2dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1168 1169 public: 1170 // --------------------------------------------------------------------- // 1171 // MATRIX3D 1172 // --------------------------------------------------------------------- // 1173 /// 1174 /// 1175 /// | || 1176 /// | -- | -- | 1177 /// | Declaration | `matrix3d matrix3d = ( (1, 0, 0), (0, 1, 0), (0, 0, 1) )` | 1178 /// | C++ Type | GfMatrix3d | 1179 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix3d | 1180 USDCONTRIVED_API 1181 UsdAttribute GetMatrix3dAttr() const; 1182 1183 /// See GetMatrix3dAttr(), and also 1184 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1185 /// If specified, author \p defaultValue as the attribute's default, 1186 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1187 /// the default for \p writeSparsely is \c false. 1188 USDCONTRIVED_API 1189 UsdAttribute CreateMatrix3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1190 1191 public: 1192 // --------------------------------------------------------------------- // 1193 // MATRIX4D 1194 // --------------------------------------------------------------------- // 1195 /// 1196 /// 1197 /// | || 1198 /// | -- | -- | 1199 /// | Declaration | `matrix4d matrix4d = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) )` | 1200 /// | C++ Type | GfMatrix4d | 1201 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix4d | 1202 USDCONTRIVED_API 1203 UsdAttribute GetMatrix4dAttr() const; 1204 1205 /// See GetMatrix4dAttr(), and also 1206 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1207 /// If specified, author \p defaultValue as the attribute's default, 1208 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1209 /// the default for \p writeSparsely is \c false. 1210 USDCONTRIVED_API 1211 UsdAttribute CreateMatrix4dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1212 1213 public: 1214 // --------------------------------------------------------------------- // 1215 // FRAME4D 1216 // --------------------------------------------------------------------- // 1217 /// 1218 /// 1219 /// | || 1220 /// | -- | -- | 1221 /// | Declaration | `frame4d frame4d = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) )` | 1222 /// | C++ Type | GfMatrix4d | 1223 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Frame4d | 1224 USDCONTRIVED_API 1225 UsdAttribute GetFrame4dAttr() const; 1226 1227 /// See GetFrame4dAttr(), and also 1228 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1229 /// If specified, author \p defaultValue as the attribute's default, 1230 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1231 /// the default for \p writeSparsely is \c false. 1232 USDCONTRIVED_API 1233 UsdAttribute CreateFrame4dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1234 1235 public: 1236 // --------------------------------------------------------------------- // 1237 // BOOLARRAY 1238 // --------------------------------------------------------------------- // 1239 /// 1240 /// 1241 /// | || 1242 /// | -- | -- | 1243 /// | Declaration | `bool[] boolArray` | 1244 /// | C++ Type | VtArray<bool> | 1245 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->BoolArray | 1246 USDCONTRIVED_API 1247 UsdAttribute GetBoolArrayAttr() const; 1248 1249 /// See GetBoolArrayAttr(), and also 1250 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1251 /// If specified, author \p defaultValue as the attribute's default, 1252 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1253 /// the default for \p writeSparsely is \c false. 1254 USDCONTRIVED_API 1255 UsdAttribute CreateBoolArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1256 1257 public: 1258 // --------------------------------------------------------------------- // 1259 // UCHARARRAY 1260 // --------------------------------------------------------------------- // 1261 /// 1262 /// 1263 /// | || 1264 /// | -- | -- | 1265 /// | Declaration | `uchar[] ucharArray` | 1266 /// | C++ Type | VtArray<unsigned char> | 1267 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UCharArray | 1268 USDCONTRIVED_API 1269 UsdAttribute GetUcharArrayAttr() const; 1270 1271 /// See GetUcharArrayAttr(), and also 1272 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1273 /// If specified, author \p defaultValue as the attribute's default, 1274 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1275 /// the default for \p writeSparsely is \c false. 1276 USDCONTRIVED_API 1277 UsdAttribute CreateUcharArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1278 1279 public: 1280 // --------------------------------------------------------------------- // 1281 // INTARRAY 1282 // --------------------------------------------------------------------- // 1283 /// 1284 /// 1285 /// | || 1286 /// | -- | -- | 1287 /// | Declaration | `int[] intArray` | 1288 /// | C++ Type | VtArray<int> | 1289 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->IntArray | 1290 USDCONTRIVED_API 1291 UsdAttribute GetIntArrayAttr() const; 1292 1293 /// See GetIntArrayAttr(), and also 1294 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1295 /// If specified, author \p defaultValue as the attribute's default, 1296 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1297 /// the default for \p writeSparsely is \c false. 1298 USDCONTRIVED_API 1299 UsdAttribute CreateIntArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1300 1301 public: 1302 // --------------------------------------------------------------------- // 1303 // UINTARRAY 1304 // --------------------------------------------------------------------- // 1305 /// 1306 /// 1307 /// | || 1308 /// | -- | -- | 1309 /// | Declaration | `uint[] uintArray` | 1310 /// | C++ Type | VtArray<unsigned int> | 1311 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UIntArray | 1312 USDCONTRIVED_API 1313 UsdAttribute GetUintArrayAttr() const; 1314 1315 /// See GetUintArrayAttr(), and also 1316 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1317 /// If specified, author \p defaultValue as the attribute's default, 1318 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1319 /// the default for \p writeSparsely is \c false. 1320 USDCONTRIVED_API 1321 UsdAttribute CreateUintArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1322 1323 public: 1324 // --------------------------------------------------------------------- // 1325 // INT64ARRAY 1326 // --------------------------------------------------------------------- // 1327 /// 1328 /// 1329 /// | || 1330 /// | -- | -- | 1331 /// | Declaration | `int64[] int64Array` | 1332 /// | C++ Type | VtArray<int64_t> | 1333 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int64Array | 1334 USDCONTRIVED_API 1335 UsdAttribute GetInt64ArrayAttr() const; 1336 1337 /// See GetInt64ArrayAttr(), and also 1338 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1339 /// If specified, author \p defaultValue as the attribute's default, 1340 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1341 /// the default for \p writeSparsely is \c false. 1342 USDCONTRIVED_API 1343 UsdAttribute CreateInt64ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1344 1345 public: 1346 // --------------------------------------------------------------------- // 1347 // UINT64ARRAY 1348 // --------------------------------------------------------------------- // 1349 /// 1350 /// 1351 /// | || 1352 /// | -- | -- | 1353 /// | Declaration | `uint64[] uint64Array` | 1354 /// | C++ Type | VtArray<uint64_t> | 1355 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UInt64Array | 1356 USDCONTRIVED_API 1357 UsdAttribute GetUint64ArrayAttr() const; 1358 1359 /// See GetUint64ArrayAttr(), and also 1360 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1361 /// If specified, author \p defaultValue as the attribute's default, 1362 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1363 /// the default for \p writeSparsely is \c false. 1364 USDCONTRIVED_API 1365 UsdAttribute CreateUint64ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1366 1367 public: 1368 // --------------------------------------------------------------------- // 1369 // HALFARRAY 1370 // --------------------------------------------------------------------- // 1371 /// 1372 /// 1373 /// | || 1374 /// | -- | -- | 1375 /// | Declaration | `half[] halfArray` | 1376 /// | C++ Type | VtArray<GfHalf> | 1377 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->HalfArray | 1378 USDCONTRIVED_API 1379 UsdAttribute GetHalfArrayAttr() const; 1380 1381 /// See GetHalfArrayAttr(), and also 1382 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1383 /// If specified, author \p defaultValue as the attribute's default, 1384 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1385 /// the default for \p writeSparsely is \c false. 1386 USDCONTRIVED_API 1387 UsdAttribute CreateHalfArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1388 1389 public: 1390 // --------------------------------------------------------------------- // 1391 // FLOATARRAY 1392 // --------------------------------------------------------------------- // 1393 /// 1394 /// 1395 /// | || 1396 /// | -- | -- | 1397 /// | Declaration | `float[] floatArray` | 1398 /// | C++ Type | VtArray<float> | 1399 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->FloatArray | 1400 USDCONTRIVED_API 1401 UsdAttribute GetFloatArrayAttr() const; 1402 1403 /// See GetFloatArrayAttr(), and also 1404 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1405 /// If specified, author \p defaultValue as the attribute's default, 1406 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1407 /// the default for \p writeSparsely is \c false. 1408 USDCONTRIVED_API 1409 UsdAttribute CreateFloatArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1410 1411 public: 1412 // --------------------------------------------------------------------- // 1413 // DOUBLEARRAY 1414 // --------------------------------------------------------------------- // 1415 /// 1416 /// 1417 /// | || 1418 /// | -- | -- | 1419 /// | Declaration | `double[] doubleArray` | 1420 /// | C++ Type | VtArray<double> | 1421 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->DoubleArray | 1422 USDCONTRIVED_API 1423 UsdAttribute GetDoubleArrayAttr() const; 1424 1425 /// See GetDoubleArrayAttr(), and also 1426 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1427 /// If specified, author \p defaultValue as the attribute's default, 1428 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1429 /// the default for \p writeSparsely is \c false. 1430 USDCONTRIVED_API 1431 UsdAttribute CreateDoubleArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1432 1433 public: 1434 // --------------------------------------------------------------------- // 1435 // STRINGARRAY 1436 // --------------------------------------------------------------------- // 1437 /// 1438 /// 1439 /// | || 1440 /// | -- | -- | 1441 /// | Declaration | `string[] stringArray` | 1442 /// | C++ Type | VtArray<std::string> | 1443 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->StringArray | 1444 USDCONTRIVED_API 1445 UsdAttribute GetStringArrayAttr() const; 1446 1447 /// See GetStringArrayAttr(), and also 1448 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1449 /// If specified, author \p defaultValue as the attribute's default, 1450 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1451 /// the default for \p writeSparsely is \c false. 1452 USDCONTRIVED_API 1453 UsdAttribute CreateStringArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1454 1455 public: 1456 // --------------------------------------------------------------------- // 1457 // TOKENARRAY 1458 // --------------------------------------------------------------------- // 1459 /// 1460 /// 1461 /// | || 1462 /// | -- | -- | 1463 /// | Declaration | `token[] tokenArray` | 1464 /// | C++ Type | VtArray<TfToken> | 1465 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->TokenArray | 1466 USDCONTRIVED_API 1467 UsdAttribute GetTokenArrayAttr() const; 1468 1469 /// See GetTokenArrayAttr(), and also 1470 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1471 /// If specified, author \p defaultValue as the attribute's default, 1472 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1473 /// the default for \p writeSparsely is \c false. 1474 USDCONTRIVED_API 1475 UsdAttribute CreateTokenArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1476 1477 public: 1478 // --------------------------------------------------------------------- // 1479 // ASSETARRAY 1480 // --------------------------------------------------------------------- // 1481 /// 1482 /// 1483 /// | || 1484 /// | -- | -- | 1485 /// | Declaration | `asset[] assetArray` | 1486 /// | C++ Type | VtArray<SdfAssetPath> | 1487 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->AssetArray | 1488 USDCONTRIVED_API 1489 UsdAttribute GetAssetArrayAttr() const; 1490 1491 /// See GetAssetArrayAttr(), and also 1492 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1493 /// If specified, author \p defaultValue as the attribute's default, 1494 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1495 /// the default for \p writeSparsely is \c false. 1496 USDCONTRIVED_API 1497 UsdAttribute CreateAssetArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1498 1499 public: 1500 // --------------------------------------------------------------------- // 1501 // INT2ARRAY 1502 // --------------------------------------------------------------------- // 1503 /// 1504 /// 1505 /// | || 1506 /// | -- | -- | 1507 /// | Declaration | `int2[] int2Array` | 1508 /// | C++ Type | VtArray<GfVec2i> | 1509 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int2Array | 1510 USDCONTRIVED_API 1511 UsdAttribute GetInt2ArrayAttr() const; 1512 1513 /// See GetInt2ArrayAttr(), and also 1514 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1515 /// If specified, author \p defaultValue as the attribute's default, 1516 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1517 /// the default for \p writeSparsely is \c false. 1518 USDCONTRIVED_API 1519 UsdAttribute CreateInt2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1520 1521 public: 1522 // --------------------------------------------------------------------- // 1523 // INT3ARRAY 1524 // --------------------------------------------------------------------- // 1525 /// 1526 /// 1527 /// | || 1528 /// | -- | -- | 1529 /// | Declaration | `int3[] int3Array` | 1530 /// | C++ Type | VtArray<GfVec3i> | 1531 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int3Array | 1532 USDCONTRIVED_API 1533 UsdAttribute GetInt3ArrayAttr() const; 1534 1535 /// See GetInt3ArrayAttr(), and also 1536 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1537 /// If specified, author \p defaultValue as the attribute's default, 1538 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1539 /// the default for \p writeSparsely is \c false. 1540 USDCONTRIVED_API 1541 UsdAttribute CreateInt3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1542 1543 public: 1544 // --------------------------------------------------------------------- // 1545 // INT4ARRAY 1546 // --------------------------------------------------------------------- // 1547 /// 1548 /// 1549 /// | || 1550 /// | -- | -- | 1551 /// | Declaration | `int4[] int4Array` | 1552 /// | C++ Type | VtArray<GfVec4i> | 1553 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int4Array | 1554 USDCONTRIVED_API 1555 UsdAttribute GetInt4ArrayAttr() const; 1556 1557 /// See GetInt4ArrayAttr(), and also 1558 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1559 /// If specified, author \p defaultValue as the attribute's default, 1560 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1561 /// the default for \p writeSparsely is \c false. 1562 USDCONTRIVED_API 1563 UsdAttribute CreateInt4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1564 1565 public: 1566 // --------------------------------------------------------------------- // 1567 // HALF2ARRAY 1568 // --------------------------------------------------------------------- // 1569 /// 1570 /// 1571 /// | || 1572 /// | -- | -- | 1573 /// | Declaration | `half2[] half2Array` | 1574 /// | C++ Type | VtArray<GfVec2h> | 1575 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half2Array | 1576 USDCONTRIVED_API 1577 UsdAttribute GetHalf2ArrayAttr() const; 1578 1579 /// See GetHalf2ArrayAttr(), and also 1580 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1581 /// If specified, author \p defaultValue as the attribute's default, 1582 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1583 /// the default for \p writeSparsely is \c false. 1584 USDCONTRIVED_API 1585 UsdAttribute CreateHalf2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1586 1587 public: 1588 // --------------------------------------------------------------------- // 1589 // HALF3ARRAY 1590 // --------------------------------------------------------------------- // 1591 /// 1592 /// 1593 /// | || 1594 /// | -- | -- | 1595 /// | Declaration | `half3[] half3Array` | 1596 /// | C++ Type | VtArray<GfVec3h> | 1597 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half3Array | 1598 USDCONTRIVED_API 1599 UsdAttribute GetHalf3ArrayAttr() const; 1600 1601 /// See GetHalf3ArrayAttr(), and also 1602 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1603 /// If specified, author \p defaultValue as the attribute's default, 1604 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1605 /// the default for \p writeSparsely is \c false. 1606 USDCONTRIVED_API 1607 UsdAttribute CreateHalf3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1608 1609 public: 1610 // --------------------------------------------------------------------- // 1611 // HALF4ARRAY 1612 // --------------------------------------------------------------------- // 1613 /// 1614 /// 1615 /// | || 1616 /// | -- | -- | 1617 /// | Declaration | `half4[] half4Array` | 1618 /// | C++ Type | VtArray<GfVec4h> | 1619 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half4Array | 1620 USDCONTRIVED_API 1621 UsdAttribute GetHalf4ArrayAttr() const; 1622 1623 /// See GetHalf4ArrayAttr(), and also 1624 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1625 /// If specified, author \p defaultValue as the attribute's default, 1626 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1627 /// the default for \p writeSparsely is \c false. 1628 USDCONTRIVED_API 1629 UsdAttribute CreateHalf4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1630 1631 public: 1632 // --------------------------------------------------------------------- // 1633 // FLOAT2ARRAY 1634 // --------------------------------------------------------------------- // 1635 /// 1636 /// 1637 /// | || 1638 /// | -- | -- | 1639 /// | Declaration | `float2[] float2Array` | 1640 /// | C++ Type | VtArray<GfVec2f> | 1641 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float2Array | 1642 USDCONTRIVED_API 1643 UsdAttribute GetFloat2ArrayAttr() const; 1644 1645 /// See GetFloat2ArrayAttr(), and also 1646 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1647 /// If specified, author \p defaultValue as the attribute's default, 1648 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1649 /// the default for \p writeSparsely is \c false. 1650 USDCONTRIVED_API 1651 UsdAttribute CreateFloat2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1652 1653 public: 1654 // --------------------------------------------------------------------- // 1655 // FLOAT3ARRAY 1656 // --------------------------------------------------------------------- // 1657 /// 1658 /// 1659 /// | || 1660 /// | -- | -- | 1661 /// | Declaration | `float3[] float3Array` | 1662 /// | C++ Type | VtArray<GfVec3f> | 1663 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float3Array | 1664 USDCONTRIVED_API 1665 UsdAttribute GetFloat3ArrayAttr() const; 1666 1667 /// See GetFloat3ArrayAttr(), and also 1668 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1669 /// If specified, author \p defaultValue as the attribute's default, 1670 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1671 /// the default for \p writeSparsely is \c false. 1672 USDCONTRIVED_API 1673 UsdAttribute CreateFloat3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1674 1675 public: 1676 // --------------------------------------------------------------------- // 1677 // FLOAT4ARRAY 1678 // --------------------------------------------------------------------- // 1679 /// 1680 /// 1681 /// | || 1682 /// | -- | -- | 1683 /// | Declaration | `float4[] float4Array` | 1684 /// | C++ Type | VtArray<GfVec4f> | 1685 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float4Array | 1686 USDCONTRIVED_API 1687 UsdAttribute GetFloat4ArrayAttr() const; 1688 1689 /// See GetFloat4ArrayAttr(), and also 1690 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1691 /// If specified, author \p defaultValue as the attribute's default, 1692 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1693 /// the default for \p writeSparsely is \c false. 1694 USDCONTRIVED_API 1695 UsdAttribute CreateFloat4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1696 1697 public: 1698 // --------------------------------------------------------------------- // 1699 // DOUBLE2ARRAY 1700 // --------------------------------------------------------------------- // 1701 /// 1702 /// 1703 /// | || 1704 /// | -- | -- | 1705 /// | Declaration | `double2[] double2Array` | 1706 /// | C++ Type | VtArray<GfVec2d> | 1707 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double2Array | 1708 USDCONTRIVED_API 1709 UsdAttribute GetDouble2ArrayAttr() const; 1710 1711 /// See GetDouble2ArrayAttr(), and also 1712 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1713 /// If specified, author \p defaultValue as the attribute's default, 1714 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1715 /// the default for \p writeSparsely is \c false. 1716 USDCONTRIVED_API 1717 UsdAttribute CreateDouble2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1718 1719 public: 1720 // --------------------------------------------------------------------- // 1721 // DOUBLE3ARRAY 1722 // --------------------------------------------------------------------- // 1723 /// 1724 /// 1725 /// | || 1726 /// | -- | -- | 1727 /// | Declaration | `double3[] double3Array` | 1728 /// | C++ Type | VtArray<GfVec3d> | 1729 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double3Array | 1730 USDCONTRIVED_API 1731 UsdAttribute GetDouble3ArrayAttr() const; 1732 1733 /// See GetDouble3ArrayAttr(), and also 1734 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1735 /// If specified, author \p defaultValue as the attribute's default, 1736 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1737 /// the default for \p writeSparsely is \c false. 1738 USDCONTRIVED_API 1739 UsdAttribute CreateDouble3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1740 1741 public: 1742 // --------------------------------------------------------------------- // 1743 // DOUBLE4ARRAY 1744 // --------------------------------------------------------------------- // 1745 /// 1746 /// 1747 /// | || 1748 /// | -- | -- | 1749 /// | Declaration | `double4[] double4Array` | 1750 /// | C++ Type | VtArray<GfVec4d> | 1751 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double4Array | 1752 USDCONTRIVED_API 1753 UsdAttribute GetDouble4ArrayAttr() const; 1754 1755 /// See GetDouble4ArrayAttr(), and also 1756 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1757 /// If specified, author \p defaultValue as the attribute's default, 1758 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1759 /// the default for \p writeSparsely is \c false. 1760 USDCONTRIVED_API 1761 UsdAttribute CreateDouble4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1762 1763 public: 1764 // --------------------------------------------------------------------- // 1765 // POINT3HARRAY 1766 // --------------------------------------------------------------------- // 1767 /// 1768 /// 1769 /// | || 1770 /// | -- | -- | 1771 /// | Declaration | `point3h[] point3hArray` | 1772 /// | C++ Type | VtArray<GfVec3h> | 1773 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3hArray | 1774 USDCONTRIVED_API 1775 UsdAttribute GetPoint3hArrayAttr() const; 1776 1777 /// See GetPoint3hArrayAttr(), and also 1778 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1779 /// If specified, author \p defaultValue as the attribute's default, 1780 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1781 /// the default for \p writeSparsely is \c false. 1782 USDCONTRIVED_API 1783 UsdAttribute CreatePoint3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1784 1785 public: 1786 // --------------------------------------------------------------------- // 1787 // POINT3FARRAY 1788 // --------------------------------------------------------------------- // 1789 /// 1790 /// 1791 /// | || 1792 /// | -- | -- | 1793 /// | Declaration | `point3f[] point3fArray` | 1794 /// | C++ Type | VtArray<GfVec3f> | 1795 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3fArray | 1796 USDCONTRIVED_API 1797 UsdAttribute GetPoint3fArrayAttr() const; 1798 1799 /// See GetPoint3fArrayAttr(), and also 1800 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1801 /// If specified, author \p defaultValue as the attribute's default, 1802 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1803 /// the default for \p writeSparsely is \c false. 1804 USDCONTRIVED_API 1805 UsdAttribute CreatePoint3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1806 1807 public: 1808 // --------------------------------------------------------------------- // 1809 // POINT3DARRAY 1810 // --------------------------------------------------------------------- // 1811 /// 1812 /// 1813 /// | || 1814 /// | -- | -- | 1815 /// | Declaration | `point3d[] point3dArray` | 1816 /// | C++ Type | VtArray<GfVec3d> | 1817 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3dArray | 1818 USDCONTRIVED_API 1819 UsdAttribute GetPoint3dArrayAttr() const; 1820 1821 /// See GetPoint3dArrayAttr(), and also 1822 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1823 /// If specified, author \p defaultValue as the attribute's default, 1824 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1825 /// the default for \p writeSparsely is \c false. 1826 USDCONTRIVED_API 1827 UsdAttribute CreatePoint3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1828 1829 public: 1830 // --------------------------------------------------------------------- // 1831 // VECTOR3HARRAY 1832 // --------------------------------------------------------------------- // 1833 /// 1834 /// 1835 /// | || 1836 /// | -- | -- | 1837 /// | Declaration | `vector3h[] vector3hArray` | 1838 /// | C++ Type | VtArray<GfVec3h> | 1839 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3hArray | 1840 USDCONTRIVED_API 1841 UsdAttribute GetVector3hArrayAttr() const; 1842 1843 /// See GetVector3hArrayAttr(), and also 1844 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1845 /// If specified, author \p defaultValue as the attribute's default, 1846 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1847 /// the default for \p writeSparsely is \c false. 1848 USDCONTRIVED_API 1849 UsdAttribute CreateVector3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1850 1851 public: 1852 // --------------------------------------------------------------------- // 1853 // VECTOR3FARRAY 1854 // --------------------------------------------------------------------- // 1855 /// 1856 /// 1857 /// | || 1858 /// | -- | -- | 1859 /// | Declaration | `vector3f[] vector3fArray` | 1860 /// | C++ Type | VtArray<GfVec3f> | 1861 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3fArray | 1862 USDCONTRIVED_API 1863 UsdAttribute GetVector3fArrayAttr() const; 1864 1865 /// See GetVector3fArrayAttr(), and also 1866 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1867 /// If specified, author \p defaultValue as the attribute's default, 1868 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1869 /// the default for \p writeSparsely is \c false. 1870 USDCONTRIVED_API 1871 UsdAttribute CreateVector3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1872 1873 public: 1874 // --------------------------------------------------------------------- // 1875 // VECTOR3DARRAY 1876 // --------------------------------------------------------------------- // 1877 /// 1878 /// 1879 /// | || 1880 /// | -- | -- | 1881 /// | Declaration | `vector3d[] vector3dArray` | 1882 /// | C++ Type | VtArray<GfVec3d> | 1883 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3dArray | 1884 USDCONTRIVED_API 1885 UsdAttribute GetVector3dArrayAttr() const; 1886 1887 /// See GetVector3dArrayAttr(), and also 1888 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1889 /// If specified, author \p defaultValue as the attribute's default, 1890 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1891 /// the default for \p writeSparsely is \c false. 1892 USDCONTRIVED_API 1893 UsdAttribute CreateVector3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1894 1895 public: 1896 // --------------------------------------------------------------------- // 1897 // NORMAL3HARRAY 1898 // --------------------------------------------------------------------- // 1899 /// 1900 /// 1901 /// | || 1902 /// | -- | -- | 1903 /// | Declaration | `normal3h[] normal3hArray` | 1904 /// | C++ Type | VtArray<GfVec3h> | 1905 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3hArray | 1906 USDCONTRIVED_API 1907 UsdAttribute GetNormal3hArrayAttr() const; 1908 1909 /// See GetNormal3hArrayAttr(), and also 1910 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1911 /// If specified, author \p defaultValue as the attribute's default, 1912 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1913 /// the default for \p writeSparsely is \c false. 1914 USDCONTRIVED_API 1915 UsdAttribute CreateNormal3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1916 1917 public: 1918 // --------------------------------------------------------------------- // 1919 // NORMAL3FARRAY 1920 // --------------------------------------------------------------------- // 1921 /// 1922 /// 1923 /// | || 1924 /// | -- | -- | 1925 /// | Declaration | `normal3f[] normal3fArray` | 1926 /// | C++ Type | VtArray<GfVec3f> | 1927 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3fArray | 1928 USDCONTRIVED_API 1929 UsdAttribute GetNormal3fArrayAttr() const; 1930 1931 /// See GetNormal3fArrayAttr(), and also 1932 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1933 /// If specified, author \p defaultValue as the attribute's default, 1934 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1935 /// the default for \p writeSparsely is \c false. 1936 USDCONTRIVED_API 1937 UsdAttribute CreateNormal3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1938 1939 public: 1940 // --------------------------------------------------------------------- // 1941 // NORMAL3DARRAY 1942 // --------------------------------------------------------------------- // 1943 /// 1944 /// 1945 /// | || 1946 /// | -- | -- | 1947 /// | Declaration | `normal3d[] normal3dArray` | 1948 /// | C++ Type | VtArray<GfVec3d> | 1949 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3dArray | 1950 USDCONTRIVED_API 1951 UsdAttribute GetNormal3dArrayAttr() const; 1952 1953 /// See GetNormal3dArrayAttr(), and also 1954 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1955 /// If specified, author \p defaultValue as the attribute's default, 1956 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1957 /// the default for \p writeSparsely is \c false. 1958 USDCONTRIVED_API 1959 UsdAttribute CreateNormal3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1960 1961 public: 1962 // --------------------------------------------------------------------- // 1963 // COLOR3HARRAY 1964 // --------------------------------------------------------------------- // 1965 /// 1966 /// 1967 /// | || 1968 /// | -- | -- | 1969 /// | Declaration | `color3h[] color3hArray` | 1970 /// | C++ Type | VtArray<GfVec3h> | 1971 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3hArray | 1972 USDCONTRIVED_API 1973 UsdAttribute GetColor3hArrayAttr() const; 1974 1975 /// See GetColor3hArrayAttr(), and also 1976 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1977 /// If specified, author \p defaultValue as the attribute's default, 1978 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 1979 /// the default for \p writeSparsely is \c false. 1980 USDCONTRIVED_API 1981 UsdAttribute CreateColor3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 1982 1983 public: 1984 // --------------------------------------------------------------------- // 1985 // COLOR3FARRAY 1986 // --------------------------------------------------------------------- // 1987 /// 1988 /// 1989 /// | || 1990 /// | -- | -- | 1991 /// | Declaration | `color3f[] color3fArray` | 1992 /// | C++ Type | VtArray<GfVec3f> | 1993 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3fArray | 1994 USDCONTRIVED_API 1995 UsdAttribute GetColor3fArrayAttr() const; 1996 1997 /// See GetColor3fArrayAttr(), and also 1998 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 1999 /// If specified, author \p defaultValue as the attribute's default, 2000 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2001 /// the default for \p writeSparsely is \c false. 2002 USDCONTRIVED_API 2003 UsdAttribute CreateColor3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2004 2005 public: 2006 // --------------------------------------------------------------------- // 2007 // COLOR3DARRAY 2008 // --------------------------------------------------------------------- // 2009 /// 2010 /// 2011 /// | || 2012 /// | -- | -- | 2013 /// | Declaration | `color3d[] color3dArray` | 2014 /// | C++ Type | VtArray<GfVec3d> | 2015 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3dArray | 2016 USDCONTRIVED_API 2017 UsdAttribute GetColor3dArrayAttr() const; 2018 2019 /// See GetColor3dArrayAttr(), and also 2020 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2021 /// If specified, author \p defaultValue as the attribute's default, 2022 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2023 /// the default for \p writeSparsely is \c false. 2024 USDCONTRIVED_API 2025 UsdAttribute CreateColor3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2026 2027 public: 2028 // --------------------------------------------------------------------- // 2029 // COLOR4HARRAY 2030 // --------------------------------------------------------------------- // 2031 /// 2032 /// 2033 /// | || 2034 /// | -- | -- | 2035 /// | Declaration | `color4h[] color4hArray` | 2036 /// | C++ Type | VtArray<GfVec4h> | 2037 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4hArray | 2038 USDCONTRIVED_API 2039 UsdAttribute GetColor4hArrayAttr() const; 2040 2041 /// See GetColor4hArrayAttr(), and also 2042 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2043 /// If specified, author \p defaultValue as the attribute's default, 2044 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2045 /// the default for \p writeSparsely is \c false. 2046 USDCONTRIVED_API 2047 UsdAttribute CreateColor4hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2048 2049 public: 2050 // --------------------------------------------------------------------- // 2051 // COLOR4FARRAY 2052 // --------------------------------------------------------------------- // 2053 /// 2054 /// 2055 /// | || 2056 /// | -- | -- | 2057 /// | Declaration | `color4f[] color4fArray` | 2058 /// | C++ Type | VtArray<GfVec4f> | 2059 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4fArray | 2060 USDCONTRIVED_API 2061 UsdAttribute GetColor4fArrayAttr() const; 2062 2063 /// See GetColor4fArrayAttr(), and also 2064 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2065 /// If specified, author \p defaultValue as the attribute's default, 2066 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2067 /// the default for \p writeSparsely is \c false. 2068 USDCONTRIVED_API 2069 UsdAttribute CreateColor4fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2070 2071 public: 2072 // --------------------------------------------------------------------- // 2073 // COLOR4DARRAY 2074 // --------------------------------------------------------------------- // 2075 /// 2076 /// 2077 /// | || 2078 /// | -- | -- | 2079 /// | Declaration | `color4d[] color4dArray` | 2080 /// | C++ Type | VtArray<GfVec4d> | 2081 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4dArray | 2082 USDCONTRIVED_API 2083 UsdAttribute GetColor4dArrayAttr() const; 2084 2085 /// See GetColor4dArrayAttr(), and also 2086 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2087 /// If specified, author \p defaultValue as the attribute's default, 2088 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2089 /// the default for \p writeSparsely is \c false. 2090 USDCONTRIVED_API 2091 UsdAttribute CreateColor4dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2092 2093 public: 2094 // --------------------------------------------------------------------- // 2095 // QUATHARRAY 2096 // --------------------------------------------------------------------- // 2097 /// 2098 /// 2099 /// | || 2100 /// | -- | -- | 2101 /// | Declaration | `quath[] quathArray` | 2102 /// | C++ Type | VtArray<GfQuath> | 2103 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->QuathArray | 2104 USDCONTRIVED_API 2105 UsdAttribute GetQuathArrayAttr() const; 2106 2107 /// See GetQuathArrayAttr(), and also 2108 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2109 /// If specified, author \p defaultValue as the attribute's default, 2110 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2111 /// the default for \p writeSparsely is \c false. 2112 USDCONTRIVED_API 2113 UsdAttribute CreateQuathArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2114 2115 public: 2116 // --------------------------------------------------------------------- // 2117 // QUATFARRAY 2118 // --------------------------------------------------------------------- // 2119 /// 2120 /// 2121 /// | || 2122 /// | -- | -- | 2123 /// | Declaration | `quatf[] quatfArray` | 2124 /// | C++ Type | VtArray<GfQuatf> | 2125 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->QuatfArray | 2126 USDCONTRIVED_API 2127 UsdAttribute GetQuatfArrayAttr() const; 2128 2129 /// See GetQuatfArrayAttr(), and also 2130 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2131 /// If specified, author \p defaultValue as the attribute's default, 2132 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2133 /// the default for \p writeSparsely is \c false. 2134 USDCONTRIVED_API 2135 UsdAttribute CreateQuatfArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2136 2137 public: 2138 // --------------------------------------------------------------------- // 2139 // QUATDARRAY 2140 // --------------------------------------------------------------------- // 2141 /// 2142 /// 2143 /// | || 2144 /// | -- | -- | 2145 /// | Declaration | `quatd[] quatdArray` | 2146 /// | C++ Type | VtArray<GfQuatd> | 2147 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->QuatdArray | 2148 USDCONTRIVED_API 2149 UsdAttribute GetQuatdArrayAttr() const; 2150 2151 /// See GetQuatdArrayAttr(), and also 2152 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2153 /// If specified, author \p defaultValue as the attribute's default, 2154 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2155 /// the default for \p writeSparsely is \c false. 2156 USDCONTRIVED_API 2157 UsdAttribute CreateQuatdArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2158 2159 public: 2160 // --------------------------------------------------------------------- // 2161 // MATRIX2DARRAY 2162 // --------------------------------------------------------------------- // 2163 /// 2164 /// 2165 /// | || 2166 /// | -- | -- | 2167 /// | Declaration | `matrix2d[] matrix2dArray` | 2168 /// | C++ Type | VtArray<GfMatrix2d> | 2169 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix2dArray | 2170 USDCONTRIVED_API 2171 UsdAttribute GetMatrix2dArrayAttr() const; 2172 2173 /// See GetMatrix2dArrayAttr(), and also 2174 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2175 /// If specified, author \p defaultValue as the attribute's default, 2176 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2177 /// the default for \p writeSparsely is \c false. 2178 USDCONTRIVED_API 2179 UsdAttribute CreateMatrix2dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2180 2181 public: 2182 // --------------------------------------------------------------------- // 2183 // MATRIX3DARRAY 2184 // --------------------------------------------------------------------- // 2185 /// 2186 /// 2187 /// | || 2188 /// | -- | -- | 2189 /// | Declaration | `matrix3d[] matrix3dArray` | 2190 /// | C++ Type | VtArray<GfMatrix3d> | 2191 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix3dArray | 2192 USDCONTRIVED_API 2193 UsdAttribute GetMatrix3dArrayAttr() const; 2194 2195 /// See GetMatrix3dArrayAttr(), and also 2196 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2197 /// If specified, author \p defaultValue as the attribute's default, 2198 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2199 /// the default for \p writeSparsely is \c false. 2200 USDCONTRIVED_API 2201 UsdAttribute CreateMatrix3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2202 2203 public: 2204 // --------------------------------------------------------------------- // 2205 // MATRIX4DARRAY 2206 // --------------------------------------------------------------------- // 2207 /// 2208 /// 2209 /// | || 2210 /// | -- | -- | 2211 /// | Declaration | `matrix4d[] matrix4dArray` | 2212 /// | C++ Type | VtArray<GfMatrix4d> | 2213 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix4dArray | 2214 USDCONTRIVED_API 2215 UsdAttribute GetMatrix4dArrayAttr() const; 2216 2217 /// See GetMatrix4dArrayAttr(), and also 2218 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2219 /// If specified, author \p defaultValue as the attribute's default, 2220 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2221 /// the default for \p writeSparsely is \c false. 2222 USDCONTRIVED_API 2223 UsdAttribute CreateMatrix4dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2224 2225 public: 2226 // --------------------------------------------------------------------- // 2227 // FRAME4DARRAY 2228 // --------------------------------------------------------------------- // 2229 /// 2230 /// 2231 /// | || 2232 /// | -- | -- | 2233 /// | Declaration | `frame4d[] frame4dArray` | 2234 /// | C++ Type | VtArray<GfMatrix4d> | 2235 /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Frame4dArray | 2236 USDCONTRIVED_API 2237 UsdAttribute GetFrame4dArrayAttr() const; 2238 2239 /// See GetFrame4dArrayAttr(), and also 2240 /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create. 2241 /// If specified, author \p defaultValue as the attribute's default, 2242 /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true - 2243 /// the default for \p writeSparsely is \c false. 2244 USDCONTRIVED_API 2245 UsdAttribute CreateFrame4dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const; 2246 2247 public: 2248 // ===================================================================== // 2249 // Feel free to add custom code below this line, it will be preserved by 2250 // the code generator. 2251 // 2252 // Just remember to: 2253 // - Close the class declaration with }; 2254 // - Close the namespace with PXR_NAMESPACE_CLOSE_SCOPE 2255 // - Close the include guard with #endif 2256 // ===================================================================== // 2257 // --(BEGIN CUSTOM CODE)-- 2258 }; 2259 2260 PXR_NAMESPACE_CLOSE_SCOPE 2261 2262 #endif 2263