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