1 #ifndef __dom150Gles_param_h__ 2 #define __dom150Gles_param_h__ 3 4 #include <dae/daeDocument.h> 5 #include <1.5/dom/domTypes.h> 6 #include <1.5/dom/domElements.h> 7 8 #include <1.5/dom/domGles_sampler.h> 9 10 class DAE; 11 namespace ColladaDOM150 { 12 13 /** 14 * A group that defines the available variable types for GLES parameters. 15 */ 16 class domGles_param : public daeElement 17 { 18 public: getElementType()19 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::GLES_PARAM; } ID()20 static daeInt ID() { return 935; } typeID()21 virtual daeInt typeID() const { return ID(); } 22 public: 23 class domBool; 24 25 typedef daeSmartRef<domBool> domBoolRef; 26 typedef daeTArray<domBoolRef> domBool_Array; 27 28 class domBool : public daeElement 29 { 30 public: getElementType()31 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL; } ID()32 static daeInt ID() { return 936; } typeID()33 virtual daeInt typeID() const { return ID(); } 34 35 36 public: //Accessors and Mutators 37 /** 38 * Gets the value of this element. 39 * @return a xsBoolean of the value. 40 */ getValue()41 xsBoolean& getValue() { return _value; } 42 /** 43 * Sets the _value of this element. 44 * @param val The new value for this element. 45 */ setValue(const xsBoolean & val)46 void setValue( const xsBoolean& val ) { _value = val; } 47 48 protected: // Value 49 /** 50 * The xsBoolean value of the text data of this element. 51 */ 52 xsBoolean _value; 53 protected: 54 /** 55 * Constructor 56 */ domBool(DAE & dae)57 domBool(DAE& dae) : daeElement(dae), _value() {} 58 /** 59 * Destructor 60 */ ~domBool()61 virtual ~domBool() {} 62 /** 63 * Overloaded assignment operator 64 */ 65 virtual domBool &operator=( const domBool &cpy ) { (void)cpy; return *this; } 66 67 public: // STATIC METHODS 68 /** 69 * Creates an instance of this class and returns a daeElementRef referencing it. 70 * @return a daeElementRef referencing an instance of this object. 71 */ 72 static DLLSPEC daeElementRef create(DAE& dae); 73 /** 74 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 75 * If a daeMetaElement already exists it will return that instead of creating a new one. 76 * @return A daeMetaElement describing this COLLADA element. 77 */ 78 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 79 }; 80 81 class domBool2; 82 83 typedef daeSmartRef<domBool2> domBool2Ref; 84 typedef daeTArray<domBool2Ref> domBool2_Array; 85 86 class domBool2 : public daeElement 87 { 88 public: getElementType()89 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2; } ID()90 static daeInt ID() { return 937; } typeID()91 virtual daeInt typeID() const { return ID(); } 92 93 94 public: //Accessors and Mutators 95 /** 96 * Gets the value of this element. 97 * @return a ColladaDOM150::domBool2 of the value. 98 */ getValue()99 ColladaDOM150::domBool2& getValue() { return _value; } 100 /** 101 * Sets the _value of this element. 102 * @param val The new value for this element. 103 */ setValue(const ColladaDOM150::domBool2 & val)104 void setValue( const ColladaDOM150::domBool2& val ) { _value = val; } 105 106 protected: // Value 107 /** 108 * The ColladaDOM150::domBool2 value of the text data of this element. 109 */ 110 ColladaDOM150::domBool2 _value; 111 protected: 112 /** 113 * Constructor 114 */ domBool2(DAE & dae)115 domBool2(DAE& dae) : daeElement(dae), _value() {} 116 /** 117 * Destructor 118 */ ~domBool2()119 virtual ~domBool2() {} 120 /** 121 * Overloaded assignment operator 122 */ 123 virtual domBool2 &operator=( const domBool2 &cpy ) { (void)cpy; return *this; } 124 125 public: // STATIC METHODS 126 /** 127 * Creates an instance of this class and returns a daeElementRef referencing it. 128 * @return a daeElementRef referencing an instance of this object. 129 */ 130 static DLLSPEC daeElementRef create(DAE& dae); 131 /** 132 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 133 * If a daeMetaElement already exists it will return that instead of creating a new one. 134 * @return A daeMetaElement describing this COLLADA element. 135 */ 136 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 137 }; 138 139 class domBool3; 140 141 typedef daeSmartRef<domBool3> domBool3Ref; 142 typedef daeTArray<domBool3Ref> domBool3_Array; 143 144 class domBool3 : public daeElement 145 { 146 public: getElementType()147 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3; } ID()148 static daeInt ID() { return 938; } typeID()149 virtual daeInt typeID() const { return ID(); } 150 151 152 public: //Accessors and Mutators 153 /** 154 * Gets the value of this element. 155 * @return a ColladaDOM150::domBool3 of the value. 156 */ getValue()157 ColladaDOM150::domBool3& getValue() { return _value; } 158 /** 159 * Sets the _value of this element. 160 * @param val The new value for this element. 161 */ setValue(const ColladaDOM150::domBool3 & val)162 void setValue( const ColladaDOM150::domBool3& val ) { _value = val; } 163 164 protected: // Value 165 /** 166 * The ColladaDOM150::domBool3 value of the text data of this element. 167 */ 168 ColladaDOM150::domBool3 _value; 169 protected: 170 /** 171 * Constructor 172 */ domBool3(DAE & dae)173 domBool3(DAE& dae) : daeElement(dae), _value() {} 174 /** 175 * Destructor 176 */ ~domBool3()177 virtual ~domBool3() {} 178 /** 179 * Overloaded assignment operator 180 */ 181 virtual domBool3 &operator=( const domBool3 &cpy ) { (void)cpy; return *this; } 182 183 public: // STATIC METHODS 184 /** 185 * Creates an instance of this class and returns a daeElementRef referencing it. 186 * @return a daeElementRef referencing an instance of this object. 187 */ 188 static DLLSPEC daeElementRef create(DAE& dae); 189 /** 190 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 191 * If a daeMetaElement already exists it will return that instead of creating a new one. 192 * @return A daeMetaElement describing this COLLADA element. 193 */ 194 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 195 }; 196 197 class domBool4; 198 199 typedef daeSmartRef<domBool4> domBool4Ref; 200 typedef daeTArray<domBool4Ref> domBool4_Array; 201 202 class domBool4 : public daeElement 203 { 204 public: getElementType()205 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4; } ID()206 static daeInt ID() { return 939; } typeID()207 virtual daeInt typeID() const { return ID(); } 208 209 210 public: //Accessors and Mutators 211 /** 212 * Gets the value of this element. 213 * @return a ColladaDOM150::domBool4 of the value. 214 */ getValue()215 ColladaDOM150::domBool4& getValue() { return _value; } 216 /** 217 * Sets the _value of this element. 218 * @param val The new value for this element. 219 */ setValue(const ColladaDOM150::domBool4 & val)220 void setValue( const ColladaDOM150::domBool4& val ) { _value = val; } 221 222 protected: // Value 223 /** 224 * The ColladaDOM150::domBool4 value of the text data of this element. 225 */ 226 ColladaDOM150::domBool4 _value; 227 protected: 228 /** 229 * Constructor 230 */ domBool4(DAE & dae)231 domBool4(DAE& dae) : daeElement(dae), _value() {} 232 /** 233 * Destructor 234 */ ~domBool4()235 virtual ~domBool4() {} 236 /** 237 * Overloaded assignment operator 238 */ 239 virtual domBool4 &operator=( const domBool4 &cpy ) { (void)cpy; return *this; } 240 241 public: // STATIC METHODS 242 /** 243 * Creates an instance of this class and returns a daeElementRef referencing it. 244 * @return a daeElementRef referencing an instance of this object. 245 */ 246 static DLLSPEC daeElementRef create(DAE& dae); 247 /** 248 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 249 * If a daeMetaElement already exists it will return that instead of creating a new one. 250 * @return A daeMetaElement describing this COLLADA element. 251 */ 252 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 253 }; 254 255 class domInt; 256 257 typedef daeSmartRef<domInt> domIntRef; 258 typedef daeTArray<domIntRef> domInt_Array; 259 260 class domInt : public daeElement 261 { 262 public: getElementType()263 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT; } ID()264 static daeInt ID() { return 940; } typeID()265 virtual daeInt typeID() const { return ID(); } 266 267 268 public: //Accessors and Mutators 269 /** 270 * Gets the value of this element. 271 * @return a ColladaDOM150::domInt of the value. 272 */ getValue()273 ColladaDOM150::domInt& getValue() { return _value; } 274 /** 275 * Sets the _value of this element. 276 * @param val The new value for this element. 277 */ setValue(const ColladaDOM150::domInt & val)278 void setValue( const ColladaDOM150::domInt& val ) { _value = val; } 279 280 protected: // Value 281 /** 282 * The ColladaDOM150::domInt value of the text data of this element. 283 */ 284 ColladaDOM150::domInt _value; 285 protected: 286 /** 287 * Constructor 288 */ domInt(DAE & dae)289 domInt(DAE& dae) : daeElement(dae), _value() {} 290 /** 291 * Destructor 292 */ ~domInt()293 virtual ~domInt() {} 294 /** 295 * Overloaded assignment operator 296 */ 297 virtual domInt &operator=( const domInt &cpy ) { (void)cpy; return *this; } 298 299 public: // STATIC METHODS 300 /** 301 * Creates an instance of this class and returns a daeElementRef referencing it. 302 * @return a daeElementRef referencing an instance of this object. 303 */ 304 static DLLSPEC daeElementRef create(DAE& dae); 305 /** 306 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 307 * If a daeMetaElement already exists it will return that instead of creating a new one. 308 * @return A daeMetaElement describing this COLLADA element. 309 */ 310 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 311 }; 312 313 class domInt2; 314 315 typedef daeSmartRef<domInt2> domInt2Ref; 316 typedef daeTArray<domInt2Ref> domInt2_Array; 317 318 class domInt2 : public daeElement 319 { 320 public: getElementType()321 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2; } ID()322 static daeInt ID() { return 941; } typeID()323 virtual daeInt typeID() const { return ID(); } 324 325 326 public: //Accessors and Mutators 327 /** 328 * Gets the value of this element. 329 * @return a ColladaDOM150::domInt2 of the value. 330 */ getValue()331 ColladaDOM150::domInt2& getValue() { return _value; } 332 /** 333 * Sets the _value of this element. 334 * @param val The new value for this element. 335 */ setValue(const ColladaDOM150::domInt2 & val)336 void setValue( const ColladaDOM150::domInt2& val ) { _value = val; } 337 338 protected: // Value 339 /** 340 * The ColladaDOM150::domInt2 value of the text data of this element. 341 */ 342 ColladaDOM150::domInt2 _value; 343 protected: 344 /** 345 * Constructor 346 */ domInt2(DAE & dae)347 domInt2(DAE& dae) : daeElement(dae), _value() {} 348 /** 349 * Destructor 350 */ ~domInt2()351 virtual ~domInt2() {} 352 /** 353 * Overloaded assignment operator 354 */ 355 virtual domInt2 &operator=( const domInt2 &cpy ) { (void)cpy; return *this; } 356 357 public: // STATIC METHODS 358 /** 359 * Creates an instance of this class and returns a daeElementRef referencing it. 360 * @return a daeElementRef referencing an instance of this object. 361 */ 362 static DLLSPEC daeElementRef create(DAE& dae); 363 /** 364 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 365 * If a daeMetaElement already exists it will return that instead of creating a new one. 366 * @return A daeMetaElement describing this COLLADA element. 367 */ 368 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 369 }; 370 371 class domInt3; 372 373 typedef daeSmartRef<domInt3> domInt3Ref; 374 typedef daeTArray<domInt3Ref> domInt3_Array; 375 376 class domInt3 : public daeElement 377 { 378 public: getElementType()379 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3; } ID()380 static daeInt ID() { return 942; } typeID()381 virtual daeInt typeID() const { return ID(); } 382 383 384 public: //Accessors and Mutators 385 /** 386 * Gets the value of this element. 387 * @return a ColladaDOM150::domInt3 of the value. 388 */ getValue()389 ColladaDOM150::domInt3& getValue() { return _value; } 390 /** 391 * Sets the _value of this element. 392 * @param val The new value for this element. 393 */ setValue(const ColladaDOM150::domInt3 & val)394 void setValue( const ColladaDOM150::domInt3& val ) { _value = val; } 395 396 protected: // Value 397 /** 398 * The ColladaDOM150::domInt3 value of the text data of this element. 399 */ 400 ColladaDOM150::domInt3 _value; 401 protected: 402 /** 403 * Constructor 404 */ domInt3(DAE & dae)405 domInt3(DAE& dae) : daeElement(dae), _value() {} 406 /** 407 * Destructor 408 */ ~domInt3()409 virtual ~domInt3() {} 410 /** 411 * Overloaded assignment operator 412 */ 413 virtual domInt3 &operator=( const domInt3 &cpy ) { (void)cpy; return *this; } 414 415 public: // STATIC METHODS 416 /** 417 * Creates an instance of this class and returns a daeElementRef referencing it. 418 * @return a daeElementRef referencing an instance of this object. 419 */ 420 static DLLSPEC daeElementRef create(DAE& dae); 421 /** 422 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 423 * If a daeMetaElement already exists it will return that instead of creating a new one. 424 * @return A daeMetaElement describing this COLLADA element. 425 */ 426 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 427 }; 428 429 class domInt4; 430 431 typedef daeSmartRef<domInt4> domInt4Ref; 432 typedef daeTArray<domInt4Ref> domInt4_Array; 433 434 class domInt4 : public daeElement 435 { 436 public: getElementType()437 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4; } ID()438 static daeInt ID() { return 943; } typeID()439 virtual daeInt typeID() const { return ID(); } 440 441 442 public: //Accessors and Mutators 443 /** 444 * Gets the value of this element. 445 * @return a ColladaDOM150::domInt4 of the value. 446 */ getValue()447 ColladaDOM150::domInt4& getValue() { return _value; } 448 /** 449 * Sets the _value of this element. 450 * @param val The new value for this element. 451 */ setValue(const ColladaDOM150::domInt4 & val)452 void setValue( const ColladaDOM150::domInt4& val ) { _value = val; } 453 454 protected: // Value 455 /** 456 * The ColladaDOM150::domInt4 value of the text data of this element. 457 */ 458 ColladaDOM150::domInt4 _value; 459 protected: 460 /** 461 * Constructor 462 */ domInt4(DAE & dae)463 domInt4(DAE& dae) : daeElement(dae), _value() {} 464 /** 465 * Destructor 466 */ ~domInt4()467 virtual ~domInt4() {} 468 /** 469 * Overloaded assignment operator 470 */ 471 virtual domInt4 &operator=( const domInt4 &cpy ) { (void)cpy; return *this; } 472 473 public: // STATIC METHODS 474 /** 475 * Creates an instance of this class and returns a daeElementRef referencing it. 476 * @return a daeElementRef referencing an instance of this object. 477 */ 478 static DLLSPEC daeElementRef create(DAE& dae); 479 /** 480 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 481 * If a daeMetaElement already exists it will return that instead of creating a new one. 482 * @return A daeMetaElement describing this COLLADA element. 483 */ 484 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 485 }; 486 487 class domFloat; 488 489 typedef daeSmartRef<domFloat> domFloatRef; 490 typedef daeTArray<domFloatRef> domFloat_Array; 491 492 class domFloat : public daeElement 493 { 494 public: getElementType()495 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT; } ID()496 static daeInt ID() { return 944; } typeID()497 virtual daeInt typeID() const { return ID(); } 498 499 500 public: //Accessors and Mutators 501 /** 502 * Gets the value of this element. 503 * @return a ColladaDOM150::domFloat of the value. 504 */ getValue()505 ColladaDOM150::domFloat& getValue() { return _value; } 506 /** 507 * Sets the _value of this element. 508 * @param val The new value for this element. 509 */ setValue(const ColladaDOM150::domFloat & val)510 void setValue( const ColladaDOM150::domFloat& val ) { _value = val; } 511 512 protected: // Value 513 /** 514 * The ColladaDOM150::domFloat value of the text data of this element. 515 */ 516 ColladaDOM150::domFloat _value; 517 protected: 518 /** 519 * Constructor 520 */ domFloat(DAE & dae)521 domFloat(DAE& dae) : daeElement(dae), _value() {} 522 /** 523 * Destructor 524 */ ~domFloat()525 virtual ~domFloat() {} 526 /** 527 * Overloaded assignment operator 528 */ 529 virtual domFloat &operator=( const domFloat &cpy ) { (void)cpy; return *this; } 530 531 public: // STATIC METHODS 532 /** 533 * Creates an instance of this class and returns a daeElementRef referencing it. 534 * @return a daeElementRef referencing an instance of this object. 535 */ 536 static DLLSPEC daeElementRef create(DAE& dae); 537 /** 538 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 539 * If a daeMetaElement already exists it will return that instead of creating a new one. 540 * @return A daeMetaElement describing this COLLADA element. 541 */ 542 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 543 }; 544 545 class domFloat2; 546 547 typedef daeSmartRef<domFloat2> domFloat2Ref; 548 typedef daeTArray<domFloat2Ref> domFloat2_Array; 549 550 class domFloat2 : public daeElement 551 { 552 public: getElementType()553 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2; } ID()554 static daeInt ID() { return 945; } typeID()555 virtual daeInt typeID() const { return ID(); } 556 557 558 public: //Accessors and Mutators 559 /** 560 * Gets the value of this element. 561 * @return a ColladaDOM150::domFloat2 of the value. 562 */ getValue()563 ColladaDOM150::domFloat2& getValue() { return _value; } 564 /** 565 * Sets the _value of this element. 566 * @param val The new value for this element. 567 */ setValue(const ColladaDOM150::domFloat2 & val)568 void setValue( const ColladaDOM150::domFloat2& val ) { _value = val; } 569 570 protected: // Value 571 /** 572 * The ColladaDOM150::domFloat2 value of the text data of this element. 573 */ 574 ColladaDOM150::domFloat2 _value; 575 protected: 576 /** 577 * Constructor 578 */ domFloat2(DAE & dae)579 domFloat2(DAE& dae) : daeElement(dae), _value() {} 580 /** 581 * Destructor 582 */ ~domFloat2()583 virtual ~domFloat2() {} 584 /** 585 * Overloaded assignment operator 586 */ 587 virtual domFloat2 &operator=( const domFloat2 &cpy ) { (void)cpy; return *this; } 588 589 public: // STATIC METHODS 590 /** 591 * Creates an instance of this class and returns a daeElementRef referencing it. 592 * @return a daeElementRef referencing an instance of this object. 593 */ 594 static DLLSPEC daeElementRef create(DAE& dae); 595 /** 596 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 597 * If a daeMetaElement already exists it will return that instead of creating a new one. 598 * @return A daeMetaElement describing this COLLADA element. 599 */ 600 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 601 }; 602 603 class domFloat3; 604 605 typedef daeSmartRef<domFloat3> domFloat3Ref; 606 typedef daeTArray<domFloat3Ref> domFloat3_Array; 607 608 class domFloat3 : public daeElement 609 { 610 public: getElementType()611 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3; } ID()612 static daeInt ID() { return 946; } typeID()613 virtual daeInt typeID() const { return ID(); } 614 615 616 public: //Accessors and Mutators 617 /** 618 * Gets the value of this element. 619 * @return a ColladaDOM150::domFloat3 of the value. 620 */ getValue()621 ColladaDOM150::domFloat3& getValue() { return _value; } 622 /** 623 * Sets the _value of this element. 624 * @param val The new value for this element. 625 */ setValue(const ColladaDOM150::domFloat3 & val)626 void setValue( const ColladaDOM150::domFloat3& val ) { _value = val; } 627 628 protected: // Value 629 /** 630 * The ColladaDOM150::domFloat3 value of the text data of this element. 631 */ 632 ColladaDOM150::domFloat3 _value; 633 protected: 634 /** 635 * Constructor 636 */ domFloat3(DAE & dae)637 domFloat3(DAE& dae) : daeElement(dae), _value() {} 638 /** 639 * Destructor 640 */ ~domFloat3()641 virtual ~domFloat3() {} 642 /** 643 * Overloaded assignment operator 644 */ 645 virtual domFloat3 &operator=( const domFloat3 &cpy ) { (void)cpy; return *this; } 646 647 public: // STATIC METHODS 648 /** 649 * Creates an instance of this class and returns a daeElementRef referencing it. 650 * @return a daeElementRef referencing an instance of this object. 651 */ 652 static DLLSPEC daeElementRef create(DAE& dae); 653 /** 654 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 655 * If a daeMetaElement already exists it will return that instead of creating a new one. 656 * @return A daeMetaElement describing this COLLADA element. 657 */ 658 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 659 }; 660 661 class domFloat4; 662 663 typedef daeSmartRef<domFloat4> domFloat4Ref; 664 typedef daeTArray<domFloat4Ref> domFloat4_Array; 665 666 class domFloat4 : public daeElement 667 { 668 public: getElementType()669 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4; } ID()670 static daeInt ID() { return 947; } typeID()671 virtual daeInt typeID() const { return ID(); } 672 673 674 public: //Accessors and Mutators 675 /** 676 * Gets the value of this element. 677 * @return a ColladaDOM150::domFloat4 of the value. 678 */ getValue()679 ColladaDOM150::domFloat4& getValue() { return _value; } 680 /** 681 * Sets the _value of this element. 682 * @param val The new value for this element. 683 */ setValue(const ColladaDOM150::domFloat4 & val)684 void setValue( const ColladaDOM150::domFloat4& val ) { _value = val; } 685 686 protected: // Value 687 /** 688 * The ColladaDOM150::domFloat4 value of the text data of this element. 689 */ 690 ColladaDOM150::domFloat4 _value; 691 protected: 692 /** 693 * Constructor 694 */ domFloat4(DAE & dae)695 domFloat4(DAE& dae) : daeElement(dae), _value() {} 696 /** 697 * Destructor 698 */ ~domFloat4()699 virtual ~domFloat4() {} 700 /** 701 * Overloaded assignment operator 702 */ 703 virtual domFloat4 &operator=( const domFloat4 &cpy ) { (void)cpy; return *this; } 704 705 public: // STATIC METHODS 706 /** 707 * Creates an instance of this class and returns a daeElementRef referencing it. 708 * @return a daeElementRef referencing an instance of this object. 709 */ 710 static DLLSPEC daeElementRef create(DAE& dae); 711 /** 712 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 713 * If a daeMetaElement already exists it will return that instead of creating a new one. 714 * @return A daeMetaElement describing this COLLADA element. 715 */ 716 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 717 }; 718 719 class domFloat1x1; 720 721 typedef daeSmartRef<domFloat1x1> domFloat1x1Ref; 722 typedef daeTArray<domFloat1x1Ref> domFloat1x1_Array; 723 724 class domFloat1x1 : public daeElement 725 { 726 public: getElementType()727 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X1; } ID()728 static daeInt ID() { return 948; } typeID()729 virtual daeInt typeID() const { return ID(); } 730 731 732 public: //Accessors and Mutators 733 /** 734 * Gets the value of this element. 735 * @return a ColladaDOM150::domFloat of the value. 736 */ getValue()737 ColladaDOM150::domFloat& getValue() { return _value; } 738 /** 739 * Sets the _value of this element. 740 * @param val The new value for this element. 741 */ setValue(const ColladaDOM150::domFloat & val)742 void setValue( const ColladaDOM150::domFloat& val ) { _value = val; } 743 744 protected: // Value 745 /** 746 * The ColladaDOM150::domFloat value of the text data of this element. 747 */ 748 ColladaDOM150::domFloat _value; 749 protected: 750 /** 751 * Constructor 752 */ domFloat1x1(DAE & dae)753 domFloat1x1(DAE& dae) : daeElement(dae), _value() {} 754 /** 755 * Destructor 756 */ ~domFloat1x1()757 virtual ~domFloat1x1() {} 758 /** 759 * Overloaded assignment operator 760 */ 761 virtual domFloat1x1 &operator=( const domFloat1x1 &cpy ) { (void)cpy; return *this; } 762 763 public: // STATIC METHODS 764 /** 765 * Creates an instance of this class and returns a daeElementRef referencing it. 766 * @return a daeElementRef referencing an instance of this object. 767 */ 768 static DLLSPEC daeElementRef create(DAE& dae); 769 /** 770 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 771 * If a daeMetaElement already exists it will return that instead of creating a new one. 772 * @return A daeMetaElement describing this COLLADA element. 773 */ 774 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 775 }; 776 777 class domFloat1x2; 778 779 typedef daeSmartRef<domFloat1x2> domFloat1x2Ref; 780 typedef daeTArray<domFloat1x2Ref> domFloat1x2_Array; 781 782 class domFloat1x2 : public daeElement 783 { 784 public: getElementType()785 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X2; } ID()786 static daeInt ID() { return 949; } typeID()787 virtual daeInt typeID() const { return ID(); } 788 789 790 public: //Accessors and Mutators 791 /** 792 * Gets the value of this element. 793 * @return a ColladaDOM150::domFloat2 of the value. 794 */ getValue()795 ColladaDOM150::domFloat2& getValue() { return _value; } 796 /** 797 * Sets the _value of this element. 798 * @param val The new value for this element. 799 */ setValue(const ColladaDOM150::domFloat2 & val)800 void setValue( const ColladaDOM150::domFloat2& val ) { _value = val; } 801 802 protected: // Value 803 /** 804 * The ColladaDOM150::domFloat2 value of the text data of this element. 805 */ 806 ColladaDOM150::domFloat2 _value; 807 protected: 808 /** 809 * Constructor 810 */ domFloat1x2(DAE & dae)811 domFloat1x2(DAE& dae) : daeElement(dae), _value() {} 812 /** 813 * Destructor 814 */ ~domFloat1x2()815 virtual ~domFloat1x2() {} 816 /** 817 * Overloaded assignment operator 818 */ 819 virtual domFloat1x2 &operator=( const domFloat1x2 &cpy ) { (void)cpy; return *this; } 820 821 public: // STATIC METHODS 822 /** 823 * Creates an instance of this class and returns a daeElementRef referencing it. 824 * @return a daeElementRef referencing an instance of this object. 825 */ 826 static DLLSPEC daeElementRef create(DAE& dae); 827 /** 828 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 829 * If a daeMetaElement already exists it will return that instead of creating a new one. 830 * @return A daeMetaElement describing this COLLADA element. 831 */ 832 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 833 }; 834 835 class domFloat1x3; 836 837 typedef daeSmartRef<domFloat1x3> domFloat1x3Ref; 838 typedef daeTArray<domFloat1x3Ref> domFloat1x3_Array; 839 840 class domFloat1x3 : public daeElement 841 { 842 public: getElementType()843 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X3; } ID()844 static daeInt ID() { return 950; } typeID()845 virtual daeInt typeID() const { return ID(); } 846 847 848 public: //Accessors and Mutators 849 /** 850 * Gets the value of this element. 851 * @return a ColladaDOM150::domFloat3 of the value. 852 */ getValue()853 ColladaDOM150::domFloat3& getValue() { return _value; } 854 /** 855 * Sets the _value of this element. 856 * @param val The new value for this element. 857 */ setValue(const ColladaDOM150::domFloat3 & val)858 void setValue( const ColladaDOM150::domFloat3& val ) { _value = val; } 859 860 protected: // Value 861 /** 862 * The ColladaDOM150::domFloat3 value of the text data of this element. 863 */ 864 ColladaDOM150::domFloat3 _value; 865 protected: 866 /** 867 * Constructor 868 */ domFloat1x3(DAE & dae)869 domFloat1x3(DAE& dae) : daeElement(dae), _value() {} 870 /** 871 * Destructor 872 */ ~domFloat1x3()873 virtual ~domFloat1x3() {} 874 /** 875 * Overloaded assignment operator 876 */ 877 virtual domFloat1x3 &operator=( const domFloat1x3 &cpy ) { (void)cpy; return *this; } 878 879 public: // STATIC METHODS 880 /** 881 * Creates an instance of this class and returns a daeElementRef referencing it. 882 * @return a daeElementRef referencing an instance of this object. 883 */ 884 static DLLSPEC daeElementRef create(DAE& dae); 885 /** 886 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 887 * If a daeMetaElement already exists it will return that instead of creating a new one. 888 * @return A daeMetaElement describing this COLLADA element. 889 */ 890 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 891 }; 892 893 class domFloat1x4; 894 895 typedef daeSmartRef<domFloat1x4> domFloat1x4Ref; 896 typedef daeTArray<domFloat1x4Ref> domFloat1x4_Array; 897 898 class domFloat1x4 : public daeElement 899 { 900 public: getElementType()901 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X4; } ID()902 static daeInt ID() { return 951; } typeID()903 virtual daeInt typeID() const { return ID(); } 904 905 906 public: //Accessors and Mutators 907 /** 908 * Gets the value of this element. 909 * @return a ColladaDOM150::domFloat4 of the value. 910 */ getValue()911 ColladaDOM150::domFloat4& getValue() { return _value; } 912 /** 913 * Sets the _value of this element. 914 * @param val The new value for this element. 915 */ setValue(const ColladaDOM150::domFloat4 & val)916 void setValue( const ColladaDOM150::domFloat4& val ) { _value = val; } 917 918 protected: // Value 919 /** 920 * The ColladaDOM150::domFloat4 value of the text data of this element. 921 */ 922 ColladaDOM150::domFloat4 _value; 923 protected: 924 /** 925 * Constructor 926 */ domFloat1x4(DAE & dae)927 domFloat1x4(DAE& dae) : daeElement(dae), _value() {} 928 /** 929 * Destructor 930 */ ~domFloat1x4()931 virtual ~domFloat1x4() {} 932 /** 933 * Overloaded assignment operator 934 */ 935 virtual domFloat1x4 &operator=( const domFloat1x4 &cpy ) { (void)cpy; return *this; } 936 937 public: // STATIC METHODS 938 /** 939 * Creates an instance of this class and returns a daeElementRef referencing it. 940 * @return a daeElementRef referencing an instance of this object. 941 */ 942 static DLLSPEC daeElementRef create(DAE& dae); 943 /** 944 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 945 * If a daeMetaElement already exists it will return that instead of creating a new one. 946 * @return A daeMetaElement describing this COLLADA element. 947 */ 948 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 949 }; 950 951 class domFloat2x1; 952 953 typedef daeSmartRef<domFloat2x1> domFloat2x1Ref; 954 typedef daeTArray<domFloat2x1Ref> domFloat2x1_Array; 955 956 class domFloat2x1 : public daeElement 957 { 958 public: getElementType()959 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X1; } ID()960 static daeInt ID() { return 952; } typeID()961 virtual daeInt typeID() const { return ID(); } 962 963 964 public: //Accessors and Mutators 965 /** 966 * Gets the value of this element. 967 * @return a ColladaDOM150::domFloat2 of the value. 968 */ getValue()969 ColladaDOM150::domFloat2& getValue() { return _value; } 970 /** 971 * Sets the _value of this element. 972 * @param val The new value for this element. 973 */ setValue(const ColladaDOM150::domFloat2 & val)974 void setValue( const ColladaDOM150::domFloat2& val ) { _value = val; } 975 976 protected: // Value 977 /** 978 * The ColladaDOM150::domFloat2 value of the text data of this element. 979 */ 980 ColladaDOM150::domFloat2 _value; 981 protected: 982 /** 983 * Constructor 984 */ domFloat2x1(DAE & dae)985 domFloat2x1(DAE& dae) : daeElement(dae), _value() {} 986 /** 987 * Destructor 988 */ ~domFloat2x1()989 virtual ~domFloat2x1() {} 990 /** 991 * Overloaded assignment operator 992 */ 993 virtual domFloat2x1 &operator=( const domFloat2x1 &cpy ) { (void)cpy; return *this; } 994 995 public: // STATIC METHODS 996 /** 997 * Creates an instance of this class and returns a daeElementRef referencing it. 998 * @return a daeElementRef referencing an instance of this object. 999 */ 1000 static DLLSPEC daeElementRef create(DAE& dae); 1001 /** 1002 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1003 * If a daeMetaElement already exists it will return that instead of creating a new one. 1004 * @return A daeMetaElement describing this COLLADA element. 1005 */ 1006 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1007 }; 1008 1009 class domFloat2x2; 1010 1011 typedef daeSmartRef<domFloat2x2> domFloat2x2Ref; 1012 typedef daeTArray<domFloat2x2Ref> domFloat2x2_Array; 1013 1014 class domFloat2x2 : public daeElement 1015 { 1016 public: getElementType()1017 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X2; } ID()1018 static daeInt ID() { return 953; } typeID()1019 virtual daeInt typeID() const { return ID(); } 1020 1021 1022 public: //Accessors and Mutators 1023 /** 1024 * Gets the value of this element. 1025 * @return a ColladaDOM150::domFloat2x2 of the value. 1026 */ getValue()1027 ColladaDOM150::domFloat2x2& getValue() { return _value; } 1028 /** 1029 * Sets the _value of this element. 1030 * @param val The new value for this element. 1031 */ setValue(const ColladaDOM150::domFloat2x2 & val)1032 void setValue( const ColladaDOM150::domFloat2x2& val ) { _value = val; } 1033 1034 protected: // Value 1035 /** 1036 * The ColladaDOM150::domFloat2x2 value of the text data of this element. 1037 */ 1038 ColladaDOM150::domFloat2x2 _value; 1039 protected: 1040 /** 1041 * Constructor 1042 */ domFloat2x2(DAE & dae)1043 domFloat2x2(DAE& dae) : daeElement(dae), _value() {} 1044 /** 1045 * Destructor 1046 */ ~domFloat2x2()1047 virtual ~domFloat2x2() {} 1048 /** 1049 * Overloaded assignment operator 1050 */ 1051 virtual domFloat2x2 &operator=( const domFloat2x2 &cpy ) { (void)cpy; return *this; } 1052 1053 public: // STATIC METHODS 1054 /** 1055 * Creates an instance of this class and returns a daeElementRef referencing it. 1056 * @return a daeElementRef referencing an instance of this object. 1057 */ 1058 static DLLSPEC daeElementRef create(DAE& dae); 1059 /** 1060 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1061 * If a daeMetaElement already exists it will return that instead of creating a new one. 1062 * @return A daeMetaElement describing this COLLADA element. 1063 */ 1064 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1065 }; 1066 1067 class domFloat2x3; 1068 1069 typedef daeSmartRef<domFloat2x3> domFloat2x3Ref; 1070 typedef daeTArray<domFloat2x3Ref> domFloat2x3_Array; 1071 1072 class domFloat2x3 : public daeElement 1073 { 1074 public: getElementType()1075 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X3; } ID()1076 static daeInt ID() { return 954; } typeID()1077 virtual daeInt typeID() const { return ID(); } 1078 1079 1080 public: //Accessors and Mutators 1081 /** 1082 * Gets the value of this element. 1083 * @return a ColladaDOM150::domFloat2x3 of the value. 1084 */ getValue()1085 ColladaDOM150::domFloat2x3& getValue() { return _value; } 1086 /** 1087 * Sets the _value of this element. 1088 * @param val The new value for this element. 1089 */ setValue(const ColladaDOM150::domFloat2x3 & val)1090 void setValue( const ColladaDOM150::domFloat2x3& val ) { _value = val; } 1091 1092 protected: // Value 1093 /** 1094 * The ColladaDOM150::domFloat2x3 value of the text data of this element. 1095 */ 1096 ColladaDOM150::domFloat2x3 _value; 1097 protected: 1098 /** 1099 * Constructor 1100 */ domFloat2x3(DAE & dae)1101 domFloat2x3(DAE& dae) : daeElement(dae), _value() {} 1102 /** 1103 * Destructor 1104 */ ~domFloat2x3()1105 virtual ~domFloat2x3() {} 1106 /** 1107 * Overloaded assignment operator 1108 */ 1109 virtual domFloat2x3 &operator=( const domFloat2x3 &cpy ) { (void)cpy; return *this; } 1110 1111 public: // STATIC METHODS 1112 /** 1113 * Creates an instance of this class and returns a daeElementRef referencing it. 1114 * @return a daeElementRef referencing an instance of this object. 1115 */ 1116 static DLLSPEC daeElementRef create(DAE& dae); 1117 /** 1118 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1119 * If a daeMetaElement already exists it will return that instead of creating a new one. 1120 * @return A daeMetaElement describing this COLLADA element. 1121 */ 1122 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1123 }; 1124 1125 class domFloat2x4; 1126 1127 typedef daeSmartRef<domFloat2x4> domFloat2x4Ref; 1128 typedef daeTArray<domFloat2x4Ref> domFloat2x4_Array; 1129 1130 class domFloat2x4 : public daeElement 1131 { 1132 public: getElementType()1133 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X4; } ID()1134 static daeInt ID() { return 955; } typeID()1135 virtual daeInt typeID() const { return ID(); } 1136 1137 1138 public: //Accessors and Mutators 1139 /** 1140 * Gets the value of this element. 1141 * @return a ColladaDOM150::domFloat2x4 of the value. 1142 */ getValue()1143 ColladaDOM150::domFloat2x4& getValue() { return _value; } 1144 /** 1145 * Sets the _value of this element. 1146 * @param val The new value for this element. 1147 */ setValue(const ColladaDOM150::domFloat2x4 & val)1148 void setValue( const ColladaDOM150::domFloat2x4& val ) { _value = val; } 1149 1150 protected: // Value 1151 /** 1152 * The ColladaDOM150::domFloat2x4 value of the text data of this element. 1153 */ 1154 ColladaDOM150::domFloat2x4 _value; 1155 protected: 1156 /** 1157 * Constructor 1158 */ domFloat2x4(DAE & dae)1159 domFloat2x4(DAE& dae) : daeElement(dae), _value() {} 1160 /** 1161 * Destructor 1162 */ ~domFloat2x4()1163 virtual ~domFloat2x4() {} 1164 /** 1165 * Overloaded assignment operator 1166 */ 1167 virtual domFloat2x4 &operator=( const domFloat2x4 &cpy ) { (void)cpy; return *this; } 1168 1169 public: // STATIC METHODS 1170 /** 1171 * Creates an instance of this class and returns a daeElementRef referencing it. 1172 * @return a daeElementRef referencing an instance of this object. 1173 */ 1174 static DLLSPEC daeElementRef create(DAE& dae); 1175 /** 1176 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1177 * If a daeMetaElement already exists it will return that instead of creating a new one. 1178 * @return A daeMetaElement describing this COLLADA element. 1179 */ 1180 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1181 }; 1182 1183 class domFloat3x1; 1184 1185 typedef daeSmartRef<domFloat3x1> domFloat3x1Ref; 1186 typedef daeTArray<domFloat3x1Ref> domFloat3x1_Array; 1187 1188 class domFloat3x1 : public daeElement 1189 { 1190 public: getElementType()1191 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X1; } ID()1192 static daeInt ID() { return 956; } typeID()1193 virtual daeInt typeID() const { return ID(); } 1194 1195 1196 public: //Accessors and Mutators 1197 /** 1198 * Gets the value of this element. 1199 * @return a ColladaDOM150::domFloat3 of the value. 1200 */ getValue()1201 ColladaDOM150::domFloat3& getValue() { return _value; } 1202 /** 1203 * Sets the _value of this element. 1204 * @param val The new value for this element. 1205 */ setValue(const ColladaDOM150::domFloat3 & val)1206 void setValue( const ColladaDOM150::domFloat3& val ) { _value = val; } 1207 1208 protected: // Value 1209 /** 1210 * The ColladaDOM150::domFloat3 value of the text data of this element. 1211 */ 1212 ColladaDOM150::domFloat3 _value; 1213 protected: 1214 /** 1215 * Constructor 1216 */ domFloat3x1(DAE & dae)1217 domFloat3x1(DAE& dae) : daeElement(dae), _value() {} 1218 /** 1219 * Destructor 1220 */ ~domFloat3x1()1221 virtual ~domFloat3x1() {} 1222 /** 1223 * Overloaded assignment operator 1224 */ 1225 virtual domFloat3x1 &operator=( const domFloat3x1 &cpy ) { (void)cpy; return *this; } 1226 1227 public: // STATIC METHODS 1228 /** 1229 * Creates an instance of this class and returns a daeElementRef referencing it. 1230 * @return a daeElementRef referencing an instance of this object. 1231 */ 1232 static DLLSPEC daeElementRef create(DAE& dae); 1233 /** 1234 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1235 * If a daeMetaElement already exists it will return that instead of creating a new one. 1236 * @return A daeMetaElement describing this COLLADA element. 1237 */ 1238 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1239 }; 1240 1241 class domFloat3x2; 1242 1243 typedef daeSmartRef<domFloat3x2> domFloat3x2Ref; 1244 typedef daeTArray<domFloat3x2Ref> domFloat3x2_Array; 1245 1246 class domFloat3x2 : public daeElement 1247 { 1248 public: getElementType()1249 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X2; } ID()1250 static daeInt ID() { return 957; } typeID()1251 virtual daeInt typeID() const { return ID(); } 1252 1253 1254 public: //Accessors and Mutators 1255 /** 1256 * Gets the value of this element. 1257 * @return a ColladaDOM150::domFloat3x2 of the value. 1258 */ getValue()1259 ColladaDOM150::domFloat3x2& getValue() { return _value; } 1260 /** 1261 * Sets the _value of this element. 1262 * @param val The new value for this element. 1263 */ setValue(const ColladaDOM150::domFloat3x2 & val)1264 void setValue( const ColladaDOM150::domFloat3x2& val ) { _value = val; } 1265 1266 protected: // Value 1267 /** 1268 * The ColladaDOM150::domFloat3x2 value of the text data of this element. 1269 */ 1270 ColladaDOM150::domFloat3x2 _value; 1271 protected: 1272 /** 1273 * Constructor 1274 */ domFloat3x2(DAE & dae)1275 domFloat3x2(DAE& dae) : daeElement(dae), _value() {} 1276 /** 1277 * Destructor 1278 */ ~domFloat3x2()1279 virtual ~domFloat3x2() {} 1280 /** 1281 * Overloaded assignment operator 1282 */ 1283 virtual domFloat3x2 &operator=( const domFloat3x2 &cpy ) { (void)cpy; return *this; } 1284 1285 public: // STATIC METHODS 1286 /** 1287 * Creates an instance of this class and returns a daeElementRef referencing it. 1288 * @return a daeElementRef referencing an instance of this object. 1289 */ 1290 static DLLSPEC daeElementRef create(DAE& dae); 1291 /** 1292 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1293 * If a daeMetaElement already exists it will return that instead of creating a new one. 1294 * @return A daeMetaElement describing this COLLADA element. 1295 */ 1296 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1297 }; 1298 1299 class domFloat3x3; 1300 1301 typedef daeSmartRef<domFloat3x3> domFloat3x3Ref; 1302 typedef daeTArray<domFloat3x3Ref> domFloat3x3_Array; 1303 1304 class domFloat3x3 : public daeElement 1305 { 1306 public: getElementType()1307 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X3; } ID()1308 static daeInt ID() { return 958; } typeID()1309 virtual daeInt typeID() const { return ID(); } 1310 1311 1312 public: //Accessors and Mutators 1313 /** 1314 * Gets the value of this element. 1315 * @return a ColladaDOM150::domFloat3x3 of the value. 1316 */ getValue()1317 ColladaDOM150::domFloat3x3& getValue() { return _value; } 1318 /** 1319 * Sets the _value of this element. 1320 * @param val The new value for this element. 1321 */ setValue(const ColladaDOM150::domFloat3x3 & val)1322 void setValue( const ColladaDOM150::domFloat3x3& val ) { _value = val; } 1323 1324 protected: // Value 1325 /** 1326 * The ColladaDOM150::domFloat3x3 value of the text data of this element. 1327 */ 1328 ColladaDOM150::domFloat3x3 _value; 1329 protected: 1330 /** 1331 * Constructor 1332 */ domFloat3x3(DAE & dae)1333 domFloat3x3(DAE& dae) : daeElement(dae), _value() {} 1334 /** 1335 * Destructor 1336 */ ~domFloat3x3()1337 virtual ~domFloat3x3() {} 1338 /** 1339 * Overloaded assignment operator 1340 */ 1341 virtual domFloat3x3 &operator=( const domFloat3x3 &cpy ) { (void)cpy; return *this; } 1342 1343 public: // STATIC METHODS 1344 /** 1345 * Creates an instance of this class and returns a daeElementRef referencing it. 1346 * @return a daeElementRef referencing an instance of this object. 1347 */ 1348 static DLLSPEC daeElementRef create(DAE& dae); 1349 /** 1350 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1351 * If a daeMetaElement already exists it will return that instead of creating a new one. 1352 * @return A daeMetaElement describing this COLLADA element. 1353 */ 1354 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1355 }; 1356 1357 class domFloat3x4; 1358 1359 typedef daeSmartRef<domFloat3x4> domFloat3x4Ref; 1360 typedef daeTArray<domFloat3x4Ref> domFloat3x4_Array; 1361 1362 class domFloat3x4 : public daeElement 1363 { 1364 public: getElementType()1365 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X4; } ID()1366 static daeInt ID() { return 959; } typeID()1367 virtual daeInt typeID() const { return ID(); } 1368 1369 1370 public: //Accessors and Mutators 1371 /** 1372 * Gets the value of this element. 1373 * @return a ColladaDOM150::domFloat3x4 of the value. 1374 */ getValue()1375 ColladaDOM150::domFloat3x4& getValue() { return _value; } 1376 /** 1377 * Sets the _value of this element. 1378 * @param val The new value for this element. 1379 */ setValue(const ColladaDOM150::domFloat3x4 & val)1380 void setValue( const ColladaDOM150::domFloat3x4& val ) { _value = val; } 1381 1382 protected: // Value 1383 /** 1384 * The ColladaDOM150::domFloat3x4 value of the text data of this element. 1385 */ 1386 ColladaDOM150::domFloat3x4 _value; 1387 protected: 1388 /** 1389 * Constructor 1390 */ domFloat3x4(DAE & dae)1391 domFloat3x4(DAE& dae) : daeElement(dae), _value() {} 1392 /** 1393 * Destructor 1394 */ ~domFloat3x4()1395 virtual ~domFloat3x4() {} 1396 /** 1397 * Overloaded assignment operator 1398 */ 1399 virtual domFloat3x4 &operator=( const domFloat3x4 &cpy ) { (void)cpy; return *this; } 1400 1401 public: // STATIC METHODS 1402 /** 1403 * Creates an instance of this class and returns a daeElementRef referencing it. 1404 * @return a daeElementRef referencing an instance of this object. 1405 */ 1406 static DLLSPEC daeElementRef create(DAE& dae); 1407 /** 1408 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1409 * If a daeMetaElement already exists it will return that instead of creating a new one. 1410 * @return A daeMetaElement describing this COLLADA element. 1411 */ 1412 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1413 }; 1414 1415 class domFloat4x1; 1416 1417 typedef daeSmartRef<domFloat4x1> domFloat4x1Ref; 1418 typedef daeTArray<domFloat4x1Ref> domFloat4x1_Array; 1419 1420 class domFloat4x1 : public daeElement 1421 { 1422 public: getElementType()1423 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X1; } ID()1424 static daeInt ID() { return 960; } typeID()1425 virtual daeInt typeID() const { return ID(); } 1426 1427 1428 public: //Accessors and Mutators 1429 /** 1430 * Gets the value of this element. 1431 * @return a ColladaDOM150::domFloat4 of the value. 1432 */ getValue()1433 ColladaDOM150::domFloat4& getValue() { return _value; } 1434 /** 1435 * Sets the _value of this element. 1436 * @param val The new value for this element. 1437 */ setValue(const ColladaDOM150::domFloat4 & val)1438 void setValue( const ColladaDOM150::domFloat4& val ) { _value = val; } 1439 1440 protected: // Value 1441 /** 1442 * The ColladaDOM150::domFloat4 value of the text data of this element. 1443 */ 1444 ColladaDOM150::domFloat4 _value; 1445 protected: 1446 /** 1447 * Constructor 1448 */ domFloat4x1(DAE & dae)1449 domFloat4x1(DAE& dae) : daeElement(dae), _value() {} 1450 /** 1451 * Destructor 1452 */ ~domFloat4x1()1453 virtual ~domFloat4x1() {} 1454 /** 1455 * Overloaded assignment operator 1456 */ 1457 virtual domFloat4x1 &operator=( const domFloat4x1 &cpy ) { (void)cpy; return *this; } 1458 1459 public: // STATIC METHODS 1460 /** 1461 * Creates an instance of this class and returns a daeElementRef referencing it. 1462 * @return a daeElementRef referencing an instance of this object. 1463 */ 1464 static DLLSPEC daeElementRef create(DAE& dae); 1465 /** 1466 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1467 * If a daeMetaElement already exists it will return that instead of creating a new one. 1468 * @return A daeMetaElement describing this COLLADA element. 1469 */ 1470 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1471 }; 1472 1473 class domFloat4x2; 1474 1475 typedef daeSmartRef<domFloat4x2> domFloat4x2Ref; 1476 typedef daeTArray<domFloat4x2Ref> domFloat4x2_Array; 1477 1478 class domFloat4x2 : public daeElement 1479 { 1480 public: getElementType()1481 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X2; } ID()1482 static daeInt ID() { return 961; } typeID()1483 virtual daeInt typeID() const { return ID(); } 1484 1485 1486 public: //Accessors and Mutators 1487 /** 1488 * Gets the value of this element. 1489 * @return a ColladaDOM150::domFloat4x2 of the value. 1490 */ getValue()1491 ColladaDOM150::domFloat4x2& getValue() { return _value; } 1492 /** 1493 * Sets the _value of this element. 1494 * @param val The new value for this element. 1495 */ setValue(const ColladaDOM150::domFloat4x2 & val)1496 void setValue( const ColladaDOM150::domFloat4x2& val ) { _value = val; } 1497 1498 protected: // Value 1499 /** 1500 * The ColladaDOM150::domFloat4x2 value of the text data of this element. 1501 */ 1502 ColladaDOM150::domFloat4x2 _value; 1503 protected: 1504 /** 1505 * Constructor 1506 */ domFloat4x2(DAE & dae)1507 domFloat4x2(DAE& dae) : daeElement(dae), _value() {} 1508 /** 1509 * Destructor 1510 */ ~domFloat4x2()1511 virtual ~domFloat4x2() {} 1512 /** 1513 * Overloaded assignment operator 1514 */ 1515 virtual domFloat4x2 &operator=( const domFloat4x2 &cpy ) { (void)cpy; return *this; } 1516 1517 public: // STATIC METHODS 1518 /** 1519 * Creates an instance of this class and returns a daeElementRef referencing it. 1520 * @return a daeElementRef referencing an instance of this object. 1521 */ 1522 static DLLSPEC daeElementRef create(DAE& dae); 1523 /** 1524 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1525 * If a daeMetaElement already exists it will return that instead of creating a new one. 1526 * @return A daeMetaElement describing this COLLADA element. 1527 */ 1528 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1529 }; 1530 1531 class domFloat4x3; 1532 1533 typedef daeSmartRef<domFloat4x3> domFloat4x3Ref; 1534 typedef daeTArray<domFloat4x3Ref> domFloat4x3_Array; 1535 1536 class domFloat4x3 : public daeElement 1537 { 1538 public: getElementType()1539 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X3; } ID()1540 static daeInt ID() { return 962; } typeID()1541 virtual daeInt typeID() const { return ID(); } 1542 1543 1544 public: //Accessors and Mutators 1545 /** 1546 * Gets the value of this element. 1547 * @return a ColladaDOM150::domFloat4x3 of the value. 1548 */ getValue()1549 ColladaDOM150::domFloat4x3& getValue() { return _value; } 1550 /** 1551 * Sets the _value of this element. 1552 * @param val The new value for this element. 1553 */ setValue(const ColladaDOM150::domFloat4x3 & val)1554 void setValue( const ColladaDOM150::domFloat4x3& val ) { _value = val; } 1555 1556 protected: // Value 1557 /** 1558 * The ColladaDOM150::domFloat4x3 value of the text data of this element. 1559 */ 1560 ColladaDOM150::domFloat4x3 _value; 1561 protected: 1562 /** 1563 * Constructor 1564 */ domFloat4x3(DAE & dae)1565 domFloat4x3(DAE& dae) : daeElement(dae), _value() {} 1566 /** 1567 * Destructor 1568 */ ~domFloat4x3()1569 virtual ~domFloat4x3() {} 1570 /** 1571 * Overloaded assignment operator 1572 */ 1573 virtual domFloat4x3 &operator=( const domFloat4x3 &cpy ) { (void)cpy; return *this; } 1574 1575 public: // STATIC METHODS 1576 /** 1577 * Creates an instance of this class and returns a daeElementRef referencing it. 1578 * @return a daeElementRef referencing an instance of this object. 1579 */ 1580 static DLLSPEC daeElementRef create(DAE& dae); 1581 /** 1582 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1583 * If a daeMetaElement already exists it will return that instead of creating a new one. 1584 * @return A daeMetaElement describing this COLLADA element. 1585 */ 1586 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1587 }; 1588 1589 class domFloat4x4; 1590 1591 typedef daeSmartRef<domFloat4x4> domFloat4x4Ref; 1592 typedef daeTArray<domFloat4x4Ref> domFloat4x4_Array; 1593 1594 class domFloat4x4 : public daeElement 1595 { 1596 public: getElementType()1597 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X4; } ID()1598 static daeInt ID() { return 963; } typeID()1599 virtual daeInt typeID() const { return ID(); } 1600 1601 1602 public: //Accessors and Mutators 1603 /** 1604 * Gets the value of this element. 1605 * @return a ColladaDOM150::domFloat4x4 of the value. 1606 */ getValue()1607 ColladaDOM150::domFloat4x4& getValue() { return _value; } 1608 /** 1609 * Sets the _value of this element. 1610 * @param val The new value for this element. 1611 */ setValue(const ColladaDOM150::domFloat4x4 & val)1612 void setValue( const ColladaDOM150::domFloat4x4& val ) { _value = val; } 1613 1614 protected: // Value 1615 /** 1616 * The ColladaDOM150::domFloat4x4 value of the text data of this element. 1617 */ 1618 ColladaDOM150::domFloat4x4 _value; 1619 protected: 1620 /** 1621 * Constructor 1622 */ domFloat4x4(DAE & dae)1623 domFloat4x4(DAE& dae) : daeElement(dae), _value() {} 1624 /** 1625 * Destructor 1626 */ ~domFloat4x4()1627 virtual ~domFloat4x4() {} 1628 /** 1629 * Overloaded assignment operator 1630 */ 1631 virtual domFloat4x4 &operator=( const domFloat4x4 &cpy ) { (void)cpy; return *this; } 1632 1633 public: // STATIC METHODS 1634 /** 1635 * Creates an instance of this class and returns a daeElementRef referencing it. 1636 * @return a daeElementRef referencing an instance of this object. 1637 */ 1638 static DLLSPEC daeElementRef create(DAE& dae); 1639 /** 1640 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1641 * If a daeMetaElement already exists it will return that instead of creating a new one. 1642 * @return A daeMetaElement describing this COLLADA element. 1643 */ 1644 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1645 }; 1646 1647 class domEnum; 1648 1649 typedef daeSmartRef<domEnum> domEnumRef; 1650 typedef daeTArray<domEnumRef> domEnum_Array; 1651 1652 class domEnum : public daeElement 1653 { 1654 public: getElementType()1655 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ENUM; } ID()1656 static daeInt ID() { return 964; } typeID()1657 virtual daeInt typeID() const { return ID(); } 1658 1659 1660 public: //Accessors and Mutators 1661 /** 1662 * Gets the value of this element. 1663 * @return a domGles_enumeration of the value. 1664 */ getValue()1665 domGles_enumeration& getValue() { return _value; } 1666 /** 1667 * Sets the _value of this element. 1668 * @param val The new value for this element. 1669 */ setValue(const domGles_enumeration & val)1670 void setValue( const domGles_enumeration& val ) { _value = val; } 1671 1672 protected: // Value 1673 /** 1674 * The domGles_enumeration value of the text data of this element. 1675 */ 1676 domGles_enumeration _value; 1677 protected: 1678 /** 1679 * Constructor 1680 */ domEnum(DAE & dae)1681 domEnum(DAE& dae) : daeElement(dae), _value() {} 1682 /** 1683 * Destructor 1684 */ ~domEnum()1685 virtual ~domEnum() {} 1686 /** 1687 * Overloaded assignment operator 1688 */ 1689 virtual domEnum &operator=( const domEnum &cpy ) { (void)cpy; return *this; } 1690 1691 public: // STATIC METHODS 1692 /** 1693 * Creates an instance of this class and returns a daeElementRef referencing it. 1694 * @return a daeElementRef referencing an instance of this object. 1695 */ 1696 static DLLSPEC daeElementRef create(DAE& dae); 1697 /** 1698 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1699 * If a daeMetaElement already exists it will return that instead of creating a new one. 1700 * @return A daeMetaElement describing this COLLADA element. 1701 */ 1702 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1703 }; 1704 1705 1706 1707 protected: // Elements 1708 domBoolRef elemBool; 1709 domBool2Ref elemBool2; 1710 domBool3Ref elemBool3; 1711 domBool4Ref elemBool4; 1712 domIntRef elemInt; 1713 domInt2Ref elemInt2; 1714 domInt3Ref elemInt3; 1715 domInt4Ref elemInt4; 1716 domFloatRef elemFloat; 1717 domFloat2Ref elemFloat2; 1718 domFloat3Ref elemFloat3; 1719 domFloat4Ref elemFloat4; 1720 domFloat1x1Ref elemFloat1x1; 1721 domFloat1x2Ref elemFloat1x2; 1722 domFloat1x3Ref elemFloat1x3; 1723 domFloat1x4Ref elemFloat1x4; 1724 domFloat2x1Ref elemFloat2x1; 1725 domFloat2x2Ref elemFloat2x2; 1726 domFloat2x3Ref elemFloat2x3; 1727 domFloat2x4Ref elemFloat2x4; 1728 domFloat3x1Ref elemFloat3x1; 1729 domFloat3x2Ref elemFloat3x2; 1730 domFloat3x3Ref elemFloat3x3; 1731 domFloat3x4Ref elemFloat3x4; 1732 domFloat4x1Ref elemFloat4x1; 1733 domFloat4x2Ref elemFloat4x2; 1734 domFloat4x3Ref elemFloat4x3; 1735 domFloat4x4Ref elemFloat4x4; 1736 domGles_samplerRef elemSampler2D; 1737 domEnumRef elemEnum; 1738 /** 1739 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 1740 */ 1741 daeElementRefArray _contents; 1742 /** 1743 * Used to preserve order in elements that have a complex content model. 1744 */ 1745 daeUIntArray _contentsOrder; 1746 1747 /** 1748 * Used to store information needed for some content model objects. 1749 */ 1750 daeTArray< daeCharArray * > _CMData; 1751 1752 1753 public: //Accessors and Mutators 1754 /** 1755 * Gets the bool element. 1756 * @return a daeSmartRef to the bool element. 1757 */ getBool()1758 const domBoolRef getBool() const { return elemBool; } 1759 /** 1760 * Gets the bool2 element. 1761 * @return a daeSmartRef to the bool2 element. 1762 */ getBool2()1763 const domBool2Ref getBool2() const { return elemBool2; } 1764 /** 1765 * Gets the bool3 element. 1766 * @return a daeSmartRef to the bool3 element. 1767 */ getBool3()1768 const domBool3Ref getBool3() const { return elemBool3; } 1769 /** 1770 * Gets the bool4 element. 1771 * @return a daeSmartRef to the bool4 element. 1772 */ getBool4()1773 const domBool4Ref getBool4() const { return elemBool4; } 1774 /** 1775 * Gets the int element. 1776 * @return a daeSmartRef to the int element. 1777 */ getInt()1778 const domIntRef getInt() const { return elemInt; } 1779 /** 1780 * Gets the int2 element. 1781 * @return a daeSmartRef to the int2 element. 1782 */ getInt2()1783 const domInt2Ref getInt2() const { return elemInt2; } 1784 /** 1785 * Gets the int3 element. 1786 * @return a daeSmartRef to the int3 element. 1787 */ getInt3()1788 const domInt3Ref getInt3() const { return elemInt3; } 1789 /** 1790 * Gets the int4 element. 1791 * @return a daeSmartRef to the int4 element. 1792 */ getInt4()1793 const domInt4Ref getInt4() const { return elemInt4; } 1794 /** 1795 * Gets the float element. 1796 * @return a daeSmartRef to the float element. 1797 */ getFloat()1798 const domFloatRef getFloat() const { return elemFloat; } 1799 /** 1800 * Gets the float2 element. 1801 * @return a daeSmartRef to the float2 element. 1802 */ getFloat2()1803 const domFloat2Ref getFloat2() const { return elemFloat2; } 1804 /** 1805 * Gets the float3 element. 1806 * @return a daeSmartRef to the float3 element. 1807 */ getFloat3()1808 const domFloat3Ref getFloat3() const { return elemFloat3; } 1809 /** 1810 * Gets the float4 element. 1811 * @return a daeSmartRef to the float4 element. 1812 */ getFloat4()1813 const domFloat4Ref getFloat4() const { return elemFloat4; } 1814 /** 1815 * Gets the float1x1 element. 1816 * @return a daeSmartRef to the float1x1 element. 1817 */ getFloat1x1()1818 const domFloat1x1Ref getFloat1x1() const { return elemFloat1x1; } 1819 /** 1820 * Gets the float1x2 element. 1821 * @return a daeSmartRef to the float1x2 element. 1822 */ getFloat1x2()1823 const domFloat1x2Ref getFloat1x2() const { return elemFloat1x2; } 1824 /** 1825 * Gets the float1x3 element. 1826 * @return a daeSmartRef to the float1x3 element. 1827 */ getFloat1x3()1828 const domFloat1x3Ref getFloat1x3() const { return elemFloat1x3; } 1829 /** 1830 * Gets the float1x4 element. 1831 * @return a daeSmartRef to the float1x4 element. 1832 */ getFloat1x4()1833 const domFloat1x4Ref getFloat1x4() const { return elemFloat1x4; } 1834 /** 1835 * Gets the float2x1 element. 1836 * @return a daeSmartRef to the float2x1 element. 1837 */ getFloat2x1()1838 const domFloat2x1Ref getFloat2x1() const { return elemFloat2x1; } 1839 /** 1840 * Gets the float2x2 element. 1841 * @return a daeSmartRef to the float2x2 element. 1842 */ getFloat2x2()1843 const domFloat2x2Ref getFloat2x2() const { return elemFloat2x2; } 1844 /** 1845 * Gets the float2x3 element. 1846 * @return a daeSmartRef to the float2x3 element. 1847 */ getFloat2x3()1848 const domFloat2x3Ref getFloat2x3() const { return elemFloat2x3; } 1849 /** 1850 * Gets the float2x4 element. 1851 * @return a daeSmartRef to the float2x4 element. 1852 */ getFloat2x4()1853 const domFloat2x4Ref getFloat2x4() const { return elemFloat2x4; } 1854 /** 1855 * Gets the float3x1 element. 1856 * @return a daeSmartRef to the float3x1 element. 1857 */ getFloat3x1()1858 const domFloat3x1Ref getFloat3x1() const { return elemFloat3x1; } 1859 /** 1860 * Gets the float3x2 element. 1861 * @return a daeSmartRef to the float3x2 element. 1862 */ getFloat3x2()1863 const domFloat3x2Ref getFloat3x2() const { return elemFloat3x2; } 1864 /** 1865 * Gets the float3x3 element. 1866 * @return a daeSmartRef to the float3x3 element. 1867 */ getFloat3x3()1868 const domFloat3x3Ref getFloat3x3() const { return elemFloat3x3; } 1869 /** 1870 * Gets the float3x4 element. 1871 * @return a daeSmartRef to the float3x4 element. 1872 */ getFloat3x4()1873 const domFloat3x4Ref getFloat3x4() const { return elemFloat3x4; } 1874 /** 1875 * Gets the float4x1 element. 1876 * @return a daeSmartRef to the float4x1 element. 1877 */ getFloat4x1()1878 const domFloat4x1Ref getFloat4x1() const { return elemFloat4x1; } 1879 /** 1880 * Gets the float4x2 element. 1881 * @return a daeSmartRef to the float4x2 element. 1882 */ getFloat4x2()1883 const domFloat4x2Ref getFloat4x2() const { return elemFloat4x2; } 1884 /** 1885 * Gets the float4x3 element. 1886 * @return a daeSmartRef to the float4x3 element. 1887 */ getFloat4x3()1888 const domFloat4x3Ref getFloat4x3() const { return elemFloat4x3; } 1889 /** 1890 * Gets the float4x4 element. 1891 * @return a daeSmartRef to the float4x4 element. 1892 */ getFloat4x4()1893 const domFloat4x4Ref getFloat4x4() const { return elemFloat4x4; } 1894 /** 1895 * Gets the sampler2D element. 1896 * @return a daeSmartRef to the sampler2D element. 1897 */ getSampler2D()1898 const domGles_samplerRef getSampler2D() const { return elemSampler2D; } 1899 /** 1900 * Gets the enum element. 1901 * @return a daeSmartRef to the enum element. 1902 */ getEnum()1903 const domEnumRef getEnum() const { return elemEnum; } 1904 /** 1905 * Gets the _contents array. 1906 * @return Returns a reference to the _contents element array. 1907 */ getContents()1908 daeElementRefArray &getContents() { return _contents; } 1909 /** 1910 * Gets the _contents array. 1911 * @return Returns a constant reference to the _contents element array. 1912 */ getContents()1913 const daeElementRefArray &getContents() const { return _contents; } 1914 1915 protected: 1916 /** 1917 * Constructor 1918 */ domGles_param(DAE & dae)1919 domGles_param(DAE& dae) : daeElement(dae), elemBool(), elemBool2(), elemBool3(), elemBool4(), elemInt(), elemInt2(), elemInt3(), elemInt4(), elemFloat(), elemFloat2(), elemFloat3(), elemFloat4(), elemFloat1x1(), elemFloat1x2(), elemFloat1x3(), elemFloat1x4(), elemFloat2x1(), elemFloat2x2(), elemFloat2x3(), elemFloat2x4(), elemFloat3x1(), elemFloat3x2(), elemFloat3x3(), elemFloat3x4(), elemFloat4x1(), elemFloat4x2(), elemFloat4x3(), elemFloat4x4(), elemSampler2D(), elemEnum() {} 1920 /** 1921 * Destructor 1922 */ ~domGles_param()1923 virtual ~domGles_param() { daeElement::deleteCMDataArray(_CMData); } 1924 /** 1925 * Overloaded assignment operator 1926 */ 1927 virtual domGles_param &operator=( const domGles_param &cpy ) { (void)cpy; return *this; } 1928 1929 public: // STATIC METHODS 1930 /** 1931 * Creates an instance of this class and returns a daeElementRef referencing it. 1932 * @return a daeElementRef referencing an instance of this object. 1933 */ 1934 static DLLSPEC daeElementRef create(DAE& dae); 1935 /** 1936 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1937 * If a daeMetaElement already exists it will return that instead of creating a new one. 1938 * @return A daeMetaElement describing this COLLADA element. 1939 */ 1940 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1941 }; 1942 1943 1944 } // ColladaDOM150 1945 #endif 1946