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_annotate_type_common_h__ 10 #define __domFx_annotate_type_common_h__ 11 12 #include <dae/daeDocument.h> 13 #include <dom/domTypes.h> 14 #include <dom/domElements.h> 15 16 class DAE; 17 18 /** 19 * A group that specifies the allowable types for an annotation. 20 */ 21 class domFx_annotate_type_common : public daeElement 22 { 23 public: 24 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FX_ANNOTATE_TYPE_COMMON; } 25 static daeInt ID() { return 171; } 26 virtual daeInt typeID() const { return ID(); } 27 public: 28 class domBool; 29 30 typedef daeSmartRef<domBool> domBoolRef; 31 typedef daeTArray<domBoolRef> domBool_Array; 32 33 class domBool : public daeElement 34 { 35 public: 36 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL; } 37 static daeInt ID() { return 172; } 38 virtual daeInt typeID() const { return ID(); } 39 40 protected: // Value 41 /** 42 * The ::domBool value of the text data of this element. 43 */ 44 ::domBool _value; 45 46 public: //Accessors and Mutators 47 /** 48 * Gets the value of this element. 49 * @return a ::domBool of the value. 50 */ 51 ::domBool getValue() const { return _value; } 52 /** 53 * Sets the _value of this element. 54 * @param val The new value for this element. 55 */ 56 void setValue( ::domBool val ) { _value = val; } 57 58 protected: 59 /** 60 * Constructor 61 */ 62 domBool(DAE& dae) : daeElement(dae), _value() {} 63 /** 64 * Destructor 65 */ 66 virtual ~domBool() {} 67 /** 68 * Overloaded assignment operator 69 */ 70 virtual domBool &operator=( const domBool &cpy ) { (void)cpy; return *this; } 71 72 public: // STATIC METHODS 73 /** 74 * Creates an instance of this class and returns a daeElementRef referencing it. 75 * @return a daeElementRef referencing an instance of this object. 76 */ 77 static DLLSPEC daeElementRef create(DAE& dae); 78 /** 79 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 80 * If a daeMetaElement already exists it will return that instead of creating a new one. 81 * @return A daeMetaElement describing this COLLADA element. 82 */ 83 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 84 }; 85 86 class domBool2; 87 88 typedef daeSmartRef<domBool2> domBool2Ref; 89 typedef daeTArray<domBool2Ref> domBool2_Array; 90 91 class domBool2 : public daeElement 92 { 93 public: 94 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2; } 95 static daeInt ID() { return 173; } 96 virtual daeInt typeID() const { return ID(); } 97 98 protected: // Value 99 /** 100 * The ::domBool2 value of the text data of this element. 101 */ 102 ::domBool2 _value; 103 104 public: //Accessors and Mutators 105 /** 106 * Gets the _value array. 107 * @return Returns a ::domBool2 reference of the _value array. 108 */ 109 ::domBool2 &getValue() { return _value; } 110 /** 111 * Gets the _value array. 112 * @return Returns a constant ::domBool2 reference of the _value array. 113 */ 114 const ::domBool2 &getValue() const { return _value; } 115 /** 116 * Sets the _value array. 117 * @param val The new value for the _value array. 118 */ 119 void setValue( const ::domBool2 &val ) { _value = val; } 120 121 protected: 122 /** 123 * Constructor 124 */ 125 domBool2(DAE& dae) : daeElement(dae), _value() {} 126 /** 127 * Destructor 128 */ 129 virtual ~domBool2() {} 130 /** 131 * Overloaded assignment operator 132 */ 133 virtual domBool2 &operator=( const domBool2 &cpy ) { (void)cpy; return *this; } 134 135 public: // STATIC METHODS 136 /** 137 * Creates an instance of this class and returns a daeElementRef referencing it. 138 * @return a daeElementRef referencing an instance of this object. 139 */ 140 static DLLSPEC daeElementRef create(DAE& dae); 141 /** 142 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 143 * If a daeMetaElement already exists it will return that instead of creating a new one. 144 * @return A daeMetaElement describing this COLLADA element. 145 */ 146 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 147 }; 148 149 class domBool3; 150 151 typedef daeSmartRef<domBool3> domBool3Ref; 152 typedef daeTArray<domBool3Ref> domBool3_Array; 153 154 class domBool3 : public daeElement 155 { 156 public: 157 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3; } 158 static daeInt ID() { return 174; } 159 virtual daeInt typeID() const { return ID(); } 160 161 protected: // Value 162 /** 163 * The ::domBool3 value of the text data of this element. 164 */ 165 ::domBool3 _value; 166 167 public: //Accessors and Mutators 168 /** 169 * Gets the _value array. 170 * @return Returns a ::domBool3 reference of the _value array. 171 */ 172 ::domBool3 &getValue() { return _value; } 173 /** 174 * Gets the _value array. 175 * @return Returns a constant ::domBool3 reference of the _value array. 176 */ 177 const ::domBool3 &getValue() const { return _value; } 178 /** 179 * Sets the _value array. 180 * @param val The new value for the _value array. 181 */ 182 void setValue( const ::domBool3 &val ) { _value = val; } 183 184 protected: 185 /** 186 * Constructor 187 */ 188 domBool3(DAE& dae) : daeElement(dae), _value() {} 189 /** 190 * Destructor 191 */ 192 virtual ~domBool3() {} 193 /** 194 * Overloaded assignment operator 195 */ 196 virtual domBool3 &operator=( const domBool3 &cpy ) { (void)cpy; return *this; } 197 198 public: // STATIC METHODS 199 /** 200 * Creates an instance of this class and returns a daeElementRef referencing it. 201 * @return a daeElementRef referencing an instance of this object. 202 */ 203 static DLLSPEC daeElementRef create(DAE& dae); 204 /** 205 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 206 * If a daeMetaElement already exists it will return that instead of creating a new one. 207 * @return A daeMetaElement describing this COLLADA element. 208 */ 209 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 210 }; 211 212 class domBool4; 213 214 typedef daeSmartRef<domBool4> domBool4Ref; 215 typedef daeTArray<domBool4Ref> domBool4_Array; 216 217 class domBool4 : public daeElement 218 { 219 public: 220 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4; } 221 static daeInt ID() { return 175; } 222 virtual daeInt typeID() const { return ID(); } 223 224 protected: // Value 225 /** 226 * The ::domBool4 value of the text data of this element. 227 */ 228 ::domBool4 _value; 229 230 public: //Accessors and Mutators 231 /** 232 * Gets the _value array. 233 * @return Returns a ::domBool4 reference of the _value array. 234 */ 235 ::domBool4 &getValue() { return _value; } 236 /** 237 * Gets the _value array. 238 * @return Returns a constant ::domBool4 reference of the _value array. 239 */ 240 const ::domBool4 &getValue() const { return _value; } 241 /** 242 * Sets the _value array. 243 * @param val The new value for the _value array. 244 */ 245 void setValue( const ::domBool4 &val ) { _value = val; } 246 247 protected: 248 /** 249 * Constructor 250 */ 251 domBool4(DAE& dae) : daeElement(dae), _value() {} 252 /** 253 * Destructor 254 */ 255 virtual ~domBool4() {} 256 /** 257 * Overloaded assignment operator 258 */ 259 virtual domBool4 &operator=( const domBool4 &cpy ) { (void)cpy; return *this; } 260 261 public: // STATIC METHODS 262 /** 263 * Creates an instance of this class and returns a daeElementRef referencing it. 264 * @return a daeElementRef referencing an instance of this object. 265 */ 266 static DLLSPEC daeElementRef create(DAE& dae); 267 /** 268 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 269 * If a daeMetaElement already exists it will return that instead of creating a new one. 270 * @return A daeMetaElement describing this COLLADA element. 271 */ 272 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 273 }; 274 275 class domInt; 276 277 typedef daeSmartRef<domInt> domIntRef; 278 typedef daeTArray<domIntRef> domInt_Array; 279 280 class domInt : public daeElement 281 { 282 public: 283 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT; } 284 static daeInt ID() { return 176; } 285 virtual daeInt typeID() const { return ID(); } 286 287 protected: // Value 288 /** 289 * The ::domInt value of the text data of this element. 290 */ 291 ::domInt _value; 292 293 public: //Accessors and Mutators 294 /** 295 * Gets the value of this element. 296 * @return a ::domInt of the value. 297 */ 298 ::domInt getValue() const { return _value; } 299 /** 300 * Sets the _value of this element. 301 * @param val The new value for this element. 302 */ 303 void setValue( ::domInt val ) { _value = val; } 304 305 protected: 306 /** 307 * Constructor 308 */ 309 domInt(DAE& dae) : daeElement(dae), _value() {} 310 /** 311 * Destructor 312 */ 313 virtual ~domInt() {} 314 /** 315 * Overloaded assignment operator 316 */ 317 virtual domInt &operator=( const domInt &cpy ) { (void)cpy; return *this; } 318 319 public: // STATIC METHODS 320 /** 321 * Creates an instance of this class and returns a daeElementRef referencing it. 322 * @return a daeElementRef referencing an instance of this object. 323 */ 324 static DLLSPEC daeElementRef create(DAE& dae); 325 /** 326 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 327 * If a daeMetaElement already exists it will return that instead of creating a new one. 328 * @return A daeMetaElement describing this COLLADA element. 329 */ 330 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 331 }; 332 333 class domInt2; 334 335 typedef daeSmartRef<domInt2> domInt2Ref; 336 typedef daeTArray<domInt2Ref> domInt2_Array; 337 338 class domInt2 : public daeElement 339 { 340 public: 341 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2; } 342 static daeInt ID() { return 177; } 343 virtual daeInt typeID() const { return ID(); } 344 345 protected: // Value 346 /** 347 * The ::domInt2 value of the text data of this element. 348 */ 349 ::domInt2 _value; 350 351 public: //Accessors and Mutators 352 /** 353 * Gets the _value array. 354 * @return Returns a ::domInt2 reference of the _value array. 355 */ 356 ::domInt2 &getValue() { return _value; } 357 /** 358 * Gets the _value array. 359 * @return Returns a constant ::domInt2 reference of the _value array. 360 */ 361 const ::domInt2 &getValue() const { return _value; } 362 /** 363 * Sets the _value array. 364 * @param val The new value for the _value array. 365 */ 366 void setValue( const ::domInt2 &val ) { _value = val; } 367 368 protected: 369 /** 370 * Constructor 371 */ 372 domInt2(DAE& dae) : daeElement(dae), _value() {} 373 /** 374 * Destructor 375 */ 376 virtual ~domInt2() {} 377 /** 378 * Overloaded assignment operator 379 */ 380 virtual domInt2 &operator=( const domInt2 &cpy ) { (void)cpy; return *this; } 381 382 public: // STATIC METHODS 383 /** 384 * Creates an instance of this class and returns a daeElementRef referencing it. 385 * @return a daeElementRef referencing an instance of this object. 386 */ 387 static DLLSPEC daeElementRef create(DAE& dae); 388 /** 389 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 390 * If a daeMetaElement already exists it will return that instead of creating a new one. 391 * @return A daeMetaElement describing this COLLADA element. 392 */ 393 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 394 }; 395 396 class domInt3; 397 398 typedef daeSmartRef<domInt3> domInt3Ref; 399 typedef daeTArray<domInt3Ref> domInt3_Array; 400 401 class domInt3 : public daeElement 402 { 403 public: 404 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3; } 405 static daeInt ID() { return 178; } 406 virtual daeInt typeID() const { return ID(); } 407 408 protected: // Value 409 /** 410 * The ::domInt3 value of the text data of this element. 411 */ 412 ::domInt3 _value; 413 414 public: //Accessors and Mutators 415 /** 416 * Gets the _value array. 417 * @return Returns a ::domInt3 reference of the _value array. 418 */ 419 ::domInt3 &getValue() { return _value; } 420 /** 421 * Gets the _value array. 422 * @return Returns a constant ::domInt3 reference of the _value array. 423 */ 424 const ::domInt3 &getValue() const { return _value; } 425 /** 426 * Sets the _value array. 427 * @param val The new value for the _value array. 428 */ 429 void setValue( const ::domInt3 &val ) { _value = val; } 430 431 protected: 432 /** 433 * Constructor 434 */ 435 domInt3(DAE& dae) : daeElement(dae), _value() {} 436 /** 437 * Destructor 438 */ 439 virtual ~domInt3() {} 440 /** 441 * Overloaded assignment operator 442 */ 443 virtual domInt3 &operator=( const domInt3 &cpy ) { (void)cpy; return *this; } 444 445 public: // STATIC METHODS 446 /** 447 * Creates an instance of this class and returns a daeElementRef referencing it. 448 * @return a daeElementRef referencing an instance of this object. 449 */ 450 static DLLSPEC daeElementRef create(DAE& dae); 451 /** 452 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 453 * If a daeMetaElement already exists it will return that instead of creating a new one. 454 * @return A daeMetaElement describing this COLLADA element. 455 */ 456 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 457 }; 458 459 class domInt4; 460 461 typedef daeSmartRef<domInt4> domInt4Ref; 462 typedef daeTArray<domInt4Ref> domInt4_Array; 463 464 class domInt4 : public daeElement 465 { 466 public: 467 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4; } 468 static daeInt ID() { return 179; } 469 virtual daeInt typeID() const { return ID(); } 470 471 protected: // Value 472 /** 473 * The ::domInt4 value of the text data of this element. 474 */ 475 ::domInt4 _value; 476 477 public: //Accessors and Mutators 478 /** 479 * Gets the _value array. 480 * @return Returns a ::domInt4 reference of the _value array. 481 */ 482 ::domInt4 &getValue() { return _value; } 483 /** 484 * Gets the _value array. 485 * @return Returns a constant ::domInt4 reference of the _value array. 486 */ 487 const ::domInt4 &getValue() const { return _value; } 488 /** 489 * Sets the _value array. 490 * @param val The new value for the _value array. 491 */ 492 void setValue( const ::domInt4 &val ) { _value = val; } 493 494 protected: 495 /** 496 * Constructor 497 */ 498 domInt4(DAE& dae) : daeElement(dae), _value() {} 499 /** 500 * Destructor 501 */ 502 virtual ~domInt4() {} 503 /** 504 * Overloaded assignment operator 505 */ 506 virtual domInt4 &operator=( const domInt4 &cpy ) { (void)cpy; return *this; } 507 508 public: // STATIC METHODS 509 /** 510 * Creates an instance of this class and returns a daeElementRef referencing it. 511 * @return a daeElementRef referencing an instance of this object. 512 */ 513 static DLLSPEC daeElementRef create(DAE& dae); 514 /** 515 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 516 * If a daeMetaElement already exists it will return that instead of creating a new one. 517 * @return A daeMetaElement describing this COLLADA element. 518 */ 519 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 520 }; 521 522 class domFloat; 523 524 typedef daeSmartRef<domFloat> domFloatRef; 525 typedef daeTArray<domFloatRef> domFloat_Array; 526 527 class domFloat : public daeElement 528 { 529 public: 530 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT; } 531 static daeInt ID() { return 180; } 532 virtual daeInt typeID() const { return ID(); } 533 534 protected: // Value 535 /** 536 * The ::domFloat value of the text data of this element. 537 */ 538 ::domFloat _value; 539 540 public: //Accessors and Mutators 541 /** 542 * Gets the value of this element. 543 * @return a ::domFloat of the value. 544 */ 545 ::domFloat getValue() const { return _value; } 546 /** 547 * Sets the _value of this element. 548 * @param val The new value for this element. 549 */ 550 void setValue( ::domFloat val ) { _value = val; } 551 552 protected: 553 /** 554 * Constructor 555 */ 556 domFloat(DAE& dae) : daeElement(dae), _value() {} 557 /** 558 * Destructor 559 */ 560 virtual ~domFloat() {} 561 /** 562 * Overloaded assignment operator 563 */ 564 virtual domFloat &operator=( const domFloat &cpy ) { (void)cpy; return *this; } 565 566 public: // STATIC METHODS 567 /** 568 * Creates an instance of this class and returns a daeElementRef referencing it. 569 * @return a daeElementRef referencing an instance of this object. 570 */ 571 static DLLSPEC daeElementRef create(DAE& dae); 572 /** 573 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 574 * If a daeMetaElement already exists it will return that instead of creating a new one. 575 * @return A daeMetaElement describing this COLLADA element. 576 */ 577 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 578 }; 579 580 class domFloat2; 581 582 typedef daeSmartRef<domFloat2> domFloat2Ref; 583 typedef daeTArray<domFloat2Ref> domFloat2_Array; 584 585 class domFloat2 : public daeElement 586 { 587 public: 588 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2; } 589 static daeInt ID() { return 181; } 590 virtual daeInt typeID() const { return ID(); } 591 592 protected: // Value 593 /** 594 * The ::domFloat2 value of the text data of this element. 595 */ 596 ::domFloat2 _value; 597 598 public: //Accessors and Mutators 599 /** 600 * Gets the _value array. 601 * @return Returns a ::domFloat2 reference of the _value array. 602 */ 603 ::domFloat2 &getValue() { return _value; } 604 /** 605 * Gets the _value array. 606 * @return Returns a constant ::domFloat2 reference of the _value array. 607 */ 608 const ::domFloat2 &getValue() const { return _value; } 609 /** 610 * Sets the _value array. 611 * @param val The new value for the _value array. 612 */ 613 void setValue( const ::domFloat2 &val ) { _value = val; } 614 615 protected: 616 /** 617 * Constructor 618 */ 619 domFloat2(DAE& dae) : daeElement(dae), _value() {} 620 /** 621 * Destructor 622 */ 623 virtual ~domFloat2() {} 624 /** 625 * Overloaded assignment operator 626 */ 627 virtual domFloat2 &operator=( const domFloat2 &cpy ) { (void)cpy; return *this; } 628 629 public: // STATIC METHODS 630 /** 631 * Creates an instance of this class and returns a daeElementRef referencing it. 632 * @return a daeElementRef referencing an instance of this object. 633 */ 634 static DLLSPEC daeElementRef create(DAE& dae); 635 /** 636 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 637 * If a daeMetaElement already exists it will return that instead of creating a new one. 638 * @return A daeMetaElement describing this COLLADA element. 639 */ 640 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 641 }; 642 643 class domFloat3; 644 645 typedef daeSmartRef<domFloat3> domFloat3Ref; 646 typedef daeTArray<domFloat3Ref> domFloat3_Array; 647 648 class domFloat3 : public daeElement 649 { 650 public: 651 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3; } 652 static daeInt ID() { return 182; } 653 virtual daeInt typeID() const { return ID(); } 654 655 protected: // Value 656 /** 657 * The ::domFloat3 value of the text data of this element. 658 */ 659 ::domFloat3 _value; 660 661 public: //Accessors and Mutators 662 /** 663 * Gets the _value array. 664 * @return Returns a ::domFloat3 reference of the _value array. 665 */ 666 ::domFloat3 &getValue() { return _value; } 667 /** 668 * Gets the _value array. 669 * @return Returns a constant ::domFloat3 reference of the _value array. 670 */ 671 const ::domFloat3 &getValue() const { return _value; } 672 /** 673 * Sets the _value array. 674 * @param val The new value for the _value array. 675 */ 676 void setValue( const ::domFloat3 &val ) { _value = val; } 677 678 protected: 679 /** 680 * Constructor 681 */ 682 domFloat3(DAE& dae) : daeElement(dae), _value() {} 683 /** 684 * Destructor 685 */ 686 virtual ~domFloat3() {} 687 /** 688 * Overloaded assignment operator 689 */ 690 virtual domFloat3 &operator=( const domFloat3 &cpy ) { (void)cpy; return *this; } 691 692 public: // STATIC METHODS 693 /** 694 * Creates an instance of this class and returns a daeElementRef referencing it. 695 * @return a daeElementRef referencing an instance of this object. 696 */ 697 static DLLSPEC daeElementRef create(DAE& dae); 698 /** 699 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 700 * If a daeMetaElement already exists it will return that instead of creating a new one. 701 * @return A daeMetaElement describing this COLLADA element. 702 */ 703 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 704 }; 705 706 class domFloat4; 707 708 typedef daeSmartRef<domFloat4> domFloat4Ref; 709 typedef daeTArray<domFloat4Ref> domFloat4_Array; 710 711 class domFloat4 : public daeElement 712 { 713 public: 714 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4; } 715 static daeInt ID() { return 183; } 716 virtual daeInt typeID() const { return ID(); } 717 718 protected: // Value 719 /** 720 * The ::domFloat4 value of the text data of this element. 721 */ 722 ::domFloat4 _value; 723 724 public: //Accessors and Mutators 725 /** 726 * Gets the _value array. 727 * @return Returns a ::domFloat4 reference of the _value array. 728 */ 729 ::domFloat4 &getValue() { return _value; } 730 /** 731 * Gets the _value array. 732 * @return Returns a constant ::domFloat4 reference of the _value array. 733 */ 734 const ::domFloat4 &getValue() const { return _value; } 735 /** 736 * Sets the _value array. 737 * @param val The new value for the _value array. 738 */ 739 void setValue( const ::domFloat4 &val ) { _value = val; } 740 741 protected: 742 /** 743 * Constructor 744 */ 745 domFloat4(DAE& dae) : daeElement(dae), _value() {} 746 /** 747 * Destructor 748 */ 749 virtual ~domFloat4() {} 750 /** 751 * Overloaded assignment operator 752 */ 753 virtual domFloat4 &operator=( const domFloat4 &cpy ) { (void)cpy; return *this; } 754 755 public: // STATIC METHODS 756 /** 757 * Creates an instance of this class and returns a daeElementRef referencing it. 758 * @return a daeElementRef referencing an instance of this object. 759 */ 760 static DLLSPEC daeElementRef create(DAE& dae); 761 /** 762 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 763 * If a daeMetaElement already exists it will return that instead of creating a new one. 764 * @return A daeMetaElement describing this COLLADA element. 765 */ 766 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 767 }; 768 769 class domFloat2x2; 770 771 typedef daeSmartRef<domFloat2x2> domFloat2x2Ref; 772 typedef daeTArray<domFloat2x2Ref> domFloat2x2_Array; 773 774 class domFloat2x2 : public daeElement 775 { 776 public: 777 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X2; } 778 static daeInt ID() { return 184; } 779 virtual daeInt typeID() const { return ID(); } 780 781 protected: // Value 782 /** 783 * The ::domFloat2x2 value of the text data of this element. 784 */ 785 ::domFloat2x2 _value; 786 787 public: //Accessors and Mutators 788 /** 789 * Gets the _value array. 790 * @return Returns a ::domFloat2x2 reference of the _value array. 791 */ 792 ::domFloat2x2 &getValue() { return _value; } 793 /** 794 * Gets the _value array. 795 * @return Returns a constant ::domFloat2x2 reference of the _value array. 796 */ 797 const ::domFloat2x2 &getValue() const { return _value; } 798 /** 799 * Sets the _value array. 800 * @param val The new value for the _value array. 801 */ 802 void setValue( const ::domFloat2x2 &val ) { _value = val; } 803 804 protected: 805 /** 806 * Constructor 807 */ 808 domFloat2x2(DAE& dae) : daeElement(dae), _value() {} 809 /** 810 * Destructor 811 */ 812 virtual ~domFloat2x2() {} 813 /** 814 * Overloaded assignment operator 815 */ 816 virtual domFloat2x2 &operator=( const domFloat2x2 &cpy ) { (void)cpy; return *this; } 817 818 public: // STATIC METHODS 819 /** 820 * Creates an instance of this class and returns a daeElementRef referencing it. 821 * @return a daeElementRef referencing an instance of this object. 822 */ 823 static DLLSPEC daeElementRef create(DAE& dae); 824 /** 825 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 826 * If a daeMetaElement already exists it will return that instead of creating a new one. 827 * @return A daeMetaElement describing this COLLADA element. 828 */ 829 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 830 }; 831 832 class domFloat3x3; 833 834 typedef daeSmartRef<domFloat3x3> domFloat3x3Ref; 835 typedef daeTArray<domFloat3x3Ref> domFloat3x3_Array; 836 837 class domFloat3x3 : public daeElement 838 { 839 public: 840 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X3; } 841 static daeInt ID() { return 185; } 842 virtual daeInt typeID() const { return ID(); } 843 844 protected: // Value 845 /** 846 * The ::domFloat3x3 value of the text data of this element. 847 */ 848 ::domFloat3x3 _value; 849 850 public: //Accessors and Mutators 851 /** 852 * Gets the _value array. 853 * @return Returns a ::domFloat3x3 reference of the _value array. 854 */ 855 ::domFloat3x3 &getValue() { return _value; } 856 /** 857 * Gets the _value array. 858 * @return Returns a constant ::domFloat3x3 reference of the _value array. 859 */ 860 const ::domFloat3x3 &getValue() const { return _value; } 861 /** 862 * Sets the _value array. 863 * @param val The new value for the _value array. 864 */ 865 void setValue( const ::domFloat3x3 &val ) { _value = val; } 866 867 protected: 868 /** 869 * Constructor 870 */ 871 domFloat3x3(DAE& dae) : daeElement(dae), _value() {} 872 /** 873 * Destructor 874 */ 875 virtual ~domFloat3x3() {} 876 /** 877 * Overloaded assignment operator 878 */ 879 virtual domFloat3x3 &operator=( const domFloat3x3 &cpy ) { (void)cpy; return *this; } 880 881 public: // STATIC METHODS 882 /** 883 * Creates an instance of this class and returns a daeElementRef referencing it. 884 * @return a daeElementRef referencing an instance of this object. 885 */ 886 static DLLSPEC daeElementRef create(DAE& dae); 887 /** 888 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 889 * If a daeMetaElement already exists it will return that instead of creating a new one. 890 * @return A daeMetaElement describing this COLLADA element. 891 */ 892 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 893 }; 894 895 class domFloat4x4; 896 897 typedef daeSmartRef<domFloat4x4> domFloat4x4Ref; 898 typedef daeTArray<domFloat4x4Ref> domFloat4x4_Array; 899 900 class domFloat4x4 : public daeElement 901 { 902 public: 903 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X4; } 904 static daeInt ID() { return 186; } 905 virtual daeInt typeID() const { return ID(); } 906 907 protected: // Value 908 /** 909 * The ::domFloat4x4 value of the text data of this element. 910 */ 911 ::domFloat4x4 _value; 912 913 public: //Accessors and Mutators 914 /** 915 * Gets the _value array. 916 * @return Returns a ::domFloat4x4 reference of the _value array. 917 */ 918 ::domFloat4x4 &getValue() { return _value; } 919 /** 920 * Gets the _value array. 921 * @return Returns a constant ::domFloat4x4 reference of the _value array. 922 */ 923 const ::domFloat4x4 &getValue() const { return _value; } 924 /** 925 * Sets the _value array. 926 * @param val The new value for the _value array. 927 */ 928 void setValue( const ::domFloat4x4 &val ) { _value = val; } 929 930 protected: 931 /** 932 * Constructor 933 */ 934 domFloat4x4(DAE& dae) : daeElement(dae), _value() {} 935 /** 936 * Destructor 937 */ 938 virtual ~domFloat4x4() {} 939 /** 940 * Overloaded assignment operator 941 */ 942 virtual domFloat4x4 &operator=( const domFloat4x4 &cpy ) { (void)cpy; return *this; } 943 944 public: // STATIC METHODS 945 /** 946 * Creates an instance of this class and returns a daeElementRef referencing it. 947 * @return a daeElementRef referencing an instance of this object. 948 */ 949 static DLLSPEC daeElementRef create(DAE& dae); 950 /** 951 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 952 * If a daeMetaElement already exists it will return that instead of creating a new one. 953 * @return A daeMetaElement describing this COLLADA element. 954 */ 955 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 956 }; 957 958 class domString; 959 960 typedef daeSmartRef<domString> domStringRef; 961 typedef daeTArray<domStringRef> domString_Array; 962 963 class domString : public daeElement 964 { 965 public: 966 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STRING; } 967 static daeInt ID() { return 187; } 968 virtual daeInt typeID() const { return ID(); } 969 970 protected: // Value 971 /** 972 * The ::xsString value of the text data of this element. 973 */ 974 ::xsString _value; 975 976 public: //Accessors and Mutators 977 /** 978 * Gets the value of this element. 979 * @return Returns a ::xsString of the value. 980 */ 981 ::xsString getValue() const { return _value; } 982 /** 983 * Sets the _value of this element. 984 * @param val The new value for this element. 985 */ 986 void setValue( ::xsString val ) { *(daeStringRef*)&_value = val; } 987 988 protected: 989 /** 990 * Constructor 991 */ 992 domString(DAE& dae) : daeElement(dae), _value() {} 993 /** 994 * Destructor 995 */ 996 virtual ~domString() {} 997 /** 998 * Overloaded assignment operator 999 */ 1000 virtual domString &operator=( const domString &cpy ) { (void)cpy; return *this; } 1001 1002 public: // STATIC METHODS 1003 /** 1004 * Creates an instance of this class and returns a daeElementRef referencing it. 1005 * @return a daeElementRef referencing an instance of this object. 1006 */ 1007 static DLLSPEC daeElementRef create(DAE& dae); 1008 /** 1009 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1010 * If a daeMetaElement already exists it will return that instead of creating a new one. 1011 * @return A daeMetaElement describing this COLLADA element. 1012 */ 1013 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1014 }; 1015 1016 1017 1018 protected: // Elements 1019 domBoolRef elemBool; 1020 domBool2Ref elemBool2; 1021 domBool3Ref elemBool3; 1022 domBool4Ref elemBool4; 1023 domIntRef elemInt; 1024 domInt2Ref elemInt2; 1025 domInt3Ref elemInt3; 1026 domInt4Ref elemInt4; 1027 domFloatRef elemFloat; 1028 domFloat2Ref elemFloat2; 1029 domFloat3Ref elemFloat3; 1030 domFloat4Ref elemFloat4; 1031 domFloat2x2Ref elemFloat2x2; 1032 domFloat3x3Ref elemFloat3x3; 1033 domFloat4x4Ref elemFloat4x4; 1034 domStringRef elemString; 1035 /** 1036 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 1037 */ 1038 daeElementRefArray _contents; 1039 /** 1040 * Used to preserve order in elements that have a complex content model. 1041 */ 1042 daeUIntArray _contentsOrder; 1043 1044 /** 1045 * Used to store information needed for some content model objects. 1046 */ 1047 daeTArray< daeCharArray * > _CMData; 1048 1049 1050 public: //Accessors and Mutators 1051 /** 1052 * Gets the bool element. 1053 * @return a daeSmartRef to the bool element. 1054 */ 1055 const domBoolRef getBool() const { return elemBool; } 1056 /** 1057 * Gets the bool2 element. 1058 * @return a daeSmartRef to the bool2 element. 1059 */ 1060 const domBool2Ref getBool2() const { return elemBool2; } 1061 /** 1062 * Gets the bool3 element. 1063 * @return a daeSmartRef to the bool3 element. 1064 */ 1065 const domBool3Ref getBool3() const { return elemBool3; } 1066 /** 1067 * Gets the bool4 element. 1068 * @return a daeSmartRef to the bool4 element. 1069 */ 1070 const domBool4Ref getBool4() const { return elemBool4; } 1071 /** 1072 * Gets the int element. 1073 * @return a daeSmartRef to the int element. 1074 */ 1075 const domIntRef getInt() const { return elemInt; } 1076 /** 1077 * Gets the int2 element. 1078 * @return a daeSmartRef to the int2 element. 1079 */ 1080 const domInt2Ref getInt2() const { return elemInt2; } 1081 /** 1082 * Gets the int3 element. 1083 * @return a daeSmartRef to the int3 element. 1084 */ 1085 const domInt3Ref getInt3() const { return elemInt3; } 1086 /** 1087 * Gets the int4 element. 1088 * @return a daeSmartRef to the int4 element. 1089 */ 1090 const domInt4Ref getInt4() const { return elemInt4; } 1091 /** 1092 * Gets the float element. 1093 * @return a daeSmartRef to the float element. 1094 */ 1095 const domFloatRef getFloat() const { return elemFloat; } 1096 /** 1097 * Gets the float2 element. 1098 * @return a daeSmartRef to the float2 element. 1099 */ 1100 const domFloat2Ref getFloat2() const { return elemFloat2; } 1101 /** 1102 * Gets the float3 element. 1103 * @return a daeSmartRef to the float3 element. 1104 */ 1105 const domFloat3Ref getFloat3() const { return elemFloat3; } 1106 /** 1107 * Gets the float4 element. 1108 * @return a daeSmartRef to the float4 element. 1109 */ 1110 const domFloat4Ref getFloat4() const { return elemFloat4; } 1111 /** 1112 * Gets the float2x2 element. 1113 * @return a daeSmartRef to the float2x2 element. 1114 */ 1115 const domFloat2x2Ref getFloat2x2() const { return elemFloat2x2; } 1116 /** 1117 * Gets the float3x3 element. 1118 * @return a daeSmartRef to the float3x3 element. 1119 */ 1120 const domFloat3x3Ref getFloat3x3() const { return elemFloat3x3; } 1121 /** 1122 * Gets the float4x4 element. 1123 * @return a daeSmartRef to the float4x4 element. 1124 */ 1125 const domFloat4x4Ref getFloat4x4() const { return elemFloat4x4; } 1126 /** 1127 * Gets the string element. 1128 * @return a daeSmartRef to the string element. 1129 */ 1130 const domStringRef getString() const { return elemString; } 1131 /** 1132 * Gets the _contents array. 1133 * @return Returns a reference to the _contents element array. 1134 */ 1135 daeElementRefArray &getContents() { return _contents; } 1136 /** 1137 * Gets the _contents array. 1138 * @return Returns a constant reference to the _contents element array. 1139 */ 1140 const daeElementRefArray &getContents() const { return _contents; } 1141 1142 protected: 1143 /** 1144 * Constructor 1145 */ 1146 domFx_annotate_type_common(DAE& dae) : daeElement(dae), elemBool(), elemBool2(), elemBool3(), elemBool4(), elemInt(), elemInt2(), elemInt3(), elemInt4(), elemFloat(), elemFloat2(), elemFloat3(), elemFloat4(), elemFloat2x2(), elemFloat3x3(), elemFloat4x4(), elemString() {} 1147 /** 1148 * Destructor 1149 */ 1150 virtual ~domFx_annotate_type_common() { daeElement::deleteCMDataArray(_CMData); } 1151 /** 1152 * Overloaded assignment operator 1153 */ 1154 virtual domFx_annotate_type_common &operator=( const domFx_annotate_type_common &cpy ) { (void)cpy; return *this; } 1155 1156 public: // STATIC METHODS 1157 /** 1158 * Creates an instance of this class and returns a daeElementRef referencing it. 1159 * @return a daeElementRef referencing an instance of this object. 1160 */ 1161 static DLLSPEC daeElementRef create(DAE& dae); 1162 /** 1163 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1164 * If a daeMetaElement already exists it will return that instead of creating a new one. 1165 * @return A daeMetaElement describing this COLLADA element. 1166 */ 1167 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1168 }; 1169 1170 1171 #endif 1172
