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