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 __domCg_param_type_h__ 10 #define __domCg_param_type_h__ 11 12 #include <dae/daeDocument.h> 13 #include <dom/domTypes.h> 14 #include <dom/domElements.h> 15 16 #include <dom/domCg_surface_type.h> 17 #include <dom/domCg_sampler1D.h> 18 #include <dom/domCg_sampler2D.h> 19 #include <dom/domCg_sampler3D.h> 20 #include <dom/domCg_samplerRECT.h> 21 #include <dom/domCg_samplerCUBE.h> 22 #include <dom/domCg_samplerDEPTH.h> 23 class DAE; 24 25 /** 26 * A group that specifies the allowable types for CG profile parameters. 27 */ 28 class domCg_param_type : public daeElement 29 { 30 public: 31 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CG_PARAM_TYPE; } 32 static daeInt ID() { return 380; } 33 virtual daeInt typeID() const { return ID(); } 34 public: 35 class domBool; 36 37 typedef daeSmartRef<domBool> domBoolRef; 38 typedef daeTArray<domBoolRef> domBool_Array; 39 40 class domBool : public daeElement 41 { 42 public: 43 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL; } 44 static daeInt ID() { return 381; } 45 virtual daeInt typeID() const { return ID(); } 46 47 protected: // Value 48 /** 49 * The domCg_bool value of the text data of this element. 50 */ 51 domCg_bool _value; 52 53 public: //Accessors and Mutators 54 /** 55 * Gets the value of this element. 56 * @return a domCg_bool of the value. 57 */ 58 domCg_bool getValue() const { return _value; } 59 /** 60 * Sets the _value of this element. 61 * @param val The new value for this element. 62 */ 63 void setValue( domCg_bool val ) { _value = val; } 64 65 protected: 66 /** 67 * Constructor 68 */ 69 domBool(DAE& dae) : daeElement(dae), _value() {} 70 /** 71 * Destructor 72 */ 73 virtual ~domBool() {} 74 /** 75 * Overloaded assignment operator 76 */ 77 virtual domBool &operator=( const domBool &cpy ) { (void)cpy; return *this; } 78 79 public: // STATIC METHODS 80 /** 81 * Creates an instance of this class and returns a daeElementRef referencing it. 82 * @return a daeElementRef referencing an instance of this object. 83 */ 84 static DLLSPEC daeElementRef create(DAE& dae); 85 /** 86 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 87 * If a daeMetaElement already exists it will return that instead of creating a new one. 88 * @return A daeMetaElement describing this COLLADA element. 89 */ 90 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 91 }; 92 93 class domBool1; 94 95 typedef daeSmartRef<domBool1> domBool1Ref; 96 typedef daeTArray<domBool1Ref> domBool1_Array; 97 98 class domBool1 : public daeElement 99 { 100 public: 101 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL1; } 102 static daeInt ID() { return 382; } 103 virtual daeInt typeID() const { return ID(); } 104 105 protected: // Value 106 /** 107 * The domCg_bool1 value of the text data of this element. 108 */ 109 domCg_bool1 _value; 110 111 public: //Accessors and Mutators 112 /** 113 * Gets the value of this element. 114 * @return a domCg_bool1 of the value. 115 */ 116 domCg_bool1 getValue() const { return _value; } 117 /** 118 * Sets the _value of this element. 119 * @param val The new value for this element. 120 */ 121 void setValue( domCg_bool1 val ) { _value = val; } 122 123 protected: 124 /** 125 * Constructor 126 */ 127 domBool1(DAE& dae) : daeElement(dae), _value() {} 128 /** 129 * Destructor 130 */ 131 virtual ~domBool1() {} 132 /** 133 * Overloaded assignment operator 134 */ 135 virtual domBool1 &operator=( const domBool1 &cpy ) { (void)cpy; return *this; } 136 137 public: // STATIC METHODS 138 /** 139 * Creates an instance of this class and returns a daeElementRef referencing it. 140 * @return a daeElementRef referencing an instance of this object. 141 */ 142 static DLLSPEC daeElementRef create(DAE& dae); 143 /** 144 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 145 * If a daeMetaElement already exists it will return that instead of creating a new one. 146 * @return A daeMetaElement describing this COLLADA element. 147 */ 148 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 149 }; 150 151 class domBool2; 152 153 typedef daeSmartRef<domBool2> domBool2Ref; 154 typedef daeTArray<domBool2Ref> domBool2_Array; 155 156 class domBool2 : public daeElement 157 { 158 public: 159 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2; } 160 static daeInt ID() { return 383; } 161 virtual daeInt typeID() const { return ID(); } 162 163 protected: // Value 164 /** 165 * The domCg_bool2 value of the text data of this element. 166 */ 167 domCg_bool2 _value; 168 169 public: //Accessors and Mutators 170 /** 171 * Gets the _value array. 172 * @return Returns a domCg_bool2 reference of the _value array. 173 */ 174 domCg_bool2 &getValue() { return _value; } 175 /** 176 * Gets the _value array. 177 * @return Returns a constant domCg_bool2 reference of the _value array. 178 */ 179 const domCg_bool2 &getValue() const { return _value; } 180 /** 181 * Sets the _value array. 182 * @param val The new value for the _value array. 183 */ 184 void setValue( const domCg_bool2 &val ) { _value = val; } 185 186 protected: 187 /** 188 * Constructor 189 */ 190 domBool2(DAE& dae) : daeElement(dae), _value() {} 191 /** 192 * Destructor 193 */ 194 virtual ~domBool2() {} 195 /** 196 * Overloaded assignment operator 197 */ 198 virtual domBool2 &operator=( const domBool2 &cpy ) { (void)cpy; return *this; } 199 200 public: // STATIC METHODS 201 /** 202 * Creates an instance of this class and returns a daeElementRef referencing it. 203 * @return a daeElementRef referencing an instance of this object. 204 */ 205 static DLLSPEC daeElementRef create(DAE& dae); 206 /** 207 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 208 * If a daeMetaElement already exists it will return that instead of creating a new one. 209 * @return A daeMetaElement describing this COLLADA element. 210 */ 211 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 212 }; 213 214 class domBool3; 215 216 typedef daeSmartRef<domBool3> domBool3Ref; 217 typedef daeTArray<domBool3Ref> domBool3_Array; 218 219 class domBool3 : public daeElement 220 { 221 public: 222 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3; } 223 static daeInt ID() { return 384; } 224 virtual daeInt typeID() const { return ID(); } 225 226 protected: // Value 227 /** 228 * The domCg_bool3 value of the text data of this element. 229 */ 230 domCg_bool3 _value; 231 232 public: //Accessors and Mutators 233 /** 234 * Gets the _value array. 235 * @return Returns a domCg_bool3 reference of the _value array. 236 */ 237 domCg_bool3 &getValue() { return _value; } 238 /** 239 * Gets the _value array. 240 * @return Returns a constant domCg_bool3 reference of the _value array. 241 */ 242 const domCg_bool3 &getValue() const { return _value; } 243 /** 244 * Sets the _value array. 245 * @param val The new value for the _value array. 246 */ 247 void setValue( const domCg_bool3 &val ) { _value = val; } 248 249 protected: 250 /** 251 * Constructor 252 */ 253 domBool3(DAE& dae) : daeElement(dae), _value() {} 254 /** 255 * Destructor 256 */ 257 virtual ~domBool3() {} 258 /** 259 * Overloaded assignment operator 260 */ 261 virtual domBool3 &operator=( const domBool3 &cpy ) { (void)cpy; return *this; } 262 263 public: // STATIC METHODS 264 /** 265 * Creates an instance of this class and returns a daeElementRef referencing it. 266 * @return a daeElementRef referencing an instance of this object. 267 */ 268 static DLLSPEC daeElementRef create(DAE& dae); 269 /** 270 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 271 * If a daeMetaElement already exists it will return that instead of creating a new one. 272 * @return A daeMetaElement describing this COLLADA element. 273 */ 274 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 275 }; 276 277 class domBool4; 278 279 typedef daeSmartRef<domBool4> domBool4Ref; 280 typedef daeTArray<domBool4Ref> domBool4_Array; 281 282 class domBool4 : public daeElement 283 { 284 public: 285 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4; } 286 static daeInt ID() { return 385; } 287 virtual daeInt typeID() const { return ID(); } 288 289 protected: // Value 290 /** 291 * The domCg_bool4 value of the text data of this element. 292 */ 293 domCg_bool4 _value; 294 295 public: //Accessors and Mutators 296 /** 297 * Gets the _value array. 298 * @return Returns a domCg_bool4 reference of the _value array. 299 */ 300 domCg_bool4 &getValue() { return _value; } 301 /** 302 * Gets the _value array. 303 * @return Returns a constant domCg_bool4 reference of the _value array. 304 */ 305 const domCg_bool4 &getValue() const { return _value; } 306 /** 307 * Sets the _value array. 308 * @param val The new value for the _value array. 309 */ 310 void setValue( const domCg_bool4 &val ) { _value = val; } 311 312 protected: 313 /** 314 * Constructor 315 */ 316 domBool4(DAE& dae) : daeElement(dae), _value() {} 317 /** 318 * Destructor 319 */ 320 virtual ~domBool4() {} 321 /** 322 * Overloaded assignment operator 323 */ 324 virtual domBool4 &operator=( const domBool4 &cpy ) { (void)cpy; return *this; } 325 326 public: // STATIC METHODS 327 /** 328 * Creates an instance of this class and returns a daeElementRef referencing it. 329 * @return a daeElementRef referencing an instance of this object. 330 */ 331 static DLLSPEC daeElementRef create(DAE& dae); 332 /** 333 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 334 * If a daeMetaElement already exists it will return that instead of creating a new one. 335 * @return A daeMetaElement describing this COLLADA element. 336 */ 337 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 338 }; 339 340 class domBool1x1; 341 342 typedef daeSmartRef<domBool1x1> domBool1x1Ref; 343 typedef daeTArray<domBool1x1Ref> domBool1x1_Array; 344 345 class domBool1x1 : public daeElement 346 { 347 public: 348 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL1X1; } 349 static daeInt ID() { return 386; } 350 virtual daeInt typeID() const { return ID(); } 351 352 protected: // Value 353 /** 354 * The domCg_bool1x1 value of the text data of this element. 355 */ 356 domCg_bool1x1 _value; 357 358 public: //Accessors and Mutators 359 /** 360 * Gets the _value array. 361 * @return Returns a domCg_bool1x1 reference of the _value array. 362 */ 363 domCg_bool1x1 &getValue() { return _value; } 364 /** 365 * Gets the _value array. 366 * @return Returns a constant domCg_bool1x1 reference of the _value array. 367 */ 368 const domCg_bool1x1 &getValue() const { return _value; } 369 /** 370 * Sets the _value array. 371 * @param val The new value for the _value array. 372 */ 373 void setValue( const domCg_bool1x1 &val ) { _value = val; } 374 375 protected: 376 /** 377 * Constructor 378 */ 379 domBool1x1(DAE& dae) : daeElement(dae), _value() {} 380 /** 381 * Destructor 382 */ 383 virtual ~domBool1x1() {} 384 /** 385 * Overloaded assignment operator 386 */ 387 virtual domBool1x1 &operator=( const domBool1x1 &cpy ) { (void)cpy; return *this; } 388 389 public: // STATIC METHODS 390 /** 391 * Creates an instance of this class and returns a daeElementRef referencing it. 392 * @return a daeElementRef referencing an instance of this object. 393 */ 394 static DLLSPEC daeElementRef create(DAE& dae); 395 /** 396 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 397 * If a daeMetaElement already exists it will return that instead of creating a new one. 398 * @return A daeMetaElement describing this COLLADA element. 399 */ 400 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 401 }; 402 403 class domBool1x2; 404 405 typedef daeSmartRef<domBool1x2> domBool1x2Ref; 406 typedef daeTArray<domBool1x2Ref> domBool1x2_Array; 407 408 class domBool1x2 : public daeElement 409 { 410 public: 411 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL1X2; } 412 static daeInt ID() { return 387; } 413 virtual daeInt typeID() const { return ID(); } 414 415 protected: // Value 416 /** 417 * The domCg_bool1x2 value of the text data of this element. 418 */ 419 domCg_bool1x2 _value; 420 421 public: //Accessors and Mutators 422 /** 423 * Gets the _value array. 424 * @return Returns a domCg_bool1x2 reference of the _value array. 425 */ 426 domCg_bool1x2 &getValue() { return _value; } 427 /** 428 * Gets the _value array. 429 * @return Returns a constant domCg_bool1x2 reference of the _value array. 430 */ 431 const domCg_bool1x2 &getValue() const { return _value; } 432 /** 433 * Sets the _value array. 434 * @param val The new value for the _value array. 435 */ 436 void setValue( const domCg_bool1x2 &val ) { _value = val; } 437 438 protected: 439 /** 440 * Constructor 441 */ 442 domBool1x2(DAE& dae) : daeElement(dae), _value() {} 443 /** 444 * Destructor 445 */ 446 virtual ~domBool1x2() {} 447 /** 448 * Overloaded assignment operator 449 */ 450 virtual domBool1x2 &operator=( const domBool1x2 &cpy ) { (void)cpy; return *this; } 451 452 public: // STATIC METHODS 453 /** 454 * Creates an instance of this class and returns a daeElementRef referencing it. 455 * @return a daeElementRef referencing an instance of this object. 456 */ 457 static DLLSPEC daeElementRef create(DAE& dae); 458 /** 459 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 460 * If a daeMetaElement already exists it will return that instead of creating a new one. 461 * @return A daeMetaElement describing this COLLADA element. 462 */ 463 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 464 }; 465 466 class domBool1x3; 467 468 typedef daeSmartRef<domBool1x3> domBool1x3Ref; 469 typedef daeTArray<domBool1x3Ref> domBool1x3_Array; 470 471 class domBool1x3 : public daeElement 472 { 473 public: 474 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL1X3; } 475 static daeInt ID() { return 388; } 476 virtual daeInt typeID() const { return ID(); } 477 478 protected: // Value 479 /** 480 * The domCg_bool1x3 value of the text data of this element. 481 */ 482 domCg_bool1x3 _value; 483 484 public: //Accessors and Mutators 485 /** 486 * Gets the _value array. 487 * @return Returns a domCg_bool1x3 reference of the _value array. 488 */ 489 domCg_bool1x3 &getValue() { return _value; } 490 /** 491 * Gets the _value array. 492 * @return Returns a constant domCg_bool1x3 reference of the _value array. 493 */ 494 const domCg_bool1x3 &getValue() const { return _value; } 495 /** 496 * Sets the _value array. 497 * @param val The new value for the _value array. 498 */ 499 void setValue( const domCg_bool1x3 &val ) { _value = val; } 500 501 protected: 502 /** 503 * Constructor 504 */ 505 domBool1x3(DAE& dae) : daeElement(dae), _value() {} 506 /** 507 * Destructor 508 */ 509 virtual ~domBool1x3() {} 510 /** 511 * Overloaded assignment operator 512 */ 513 virtual domBool1x3 &operator=( const domBool1x3 &cpy ) { (void)cpy; return *this; } 514 515 public: // STATIC METHODS 516 /** 517 * Creates an instance of this class and returns a daeElementRef referencing it. 518 * @return a daeElementRef referencing an instance of this object. 519 */ 520 static DLLSPEC daeElementRef create(DAE& dae); 521 /** 522 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 523 * If a daeMetaElement already exists it will return that instead of creating a new one. 524 * @return A daeMetaElement describing this COLLADA element. 525 */ 526 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 527 }; 528 529 class domBool1x4; 530 531 typedef daeSmartRef<domBool1x4> domBool1x4Ref; 532 typedef daeTArray<domBool1x4Ref> domBool1x4_Array; 533 534 class domBool1x4 : public daeElement 535 { 536 public: 537 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL1X4; } 538 static daeInt ID() { return 389; } 539 virtual daeInt typeID() const { return ID(); } 540 541 protected: // Value 542 /** 543 * The domCg_bool1x4 value of the text data of this element. 544 */ 545 domCg_bool1x4 _value; 546 547 public: //Accessors and Mutators 548 /** 549 * Gets the _value array. 550 * @return Returns a domCg_bool1x4 reference of the _value array. 551 */ 552 domCg_bool1x4 &getValue() { return _value; } 553 /** 554 * Gets the _value array. 555 * @return Returns a constant domCg_bool1x4 reference of the _value array. 556 */ 557 const domCg_bool1x4 &getValue() const { return _value; } 558 /** 559 * Sets the _value array. 560 * @param val The new value for the _value array. 561 */ 562 void setValue( const domCg_bool1x4 &val ) { _value = val; } 563 564 protected: 565 /** 566 * Constructor 567 */ 568 domBool1x4(DAE& dae) : daeElement(dae), _value() {} 569 /** 570 * Destructor 571 */ 572 virtual ~domBool1x4() {} 573 /** 574 * Overloaded assignment operator 575 */ 576 virtual domBool1x4 &operator=( const domBool1x4 &cpy ) { (void)cpy; return *this; } 577 578 public: // STATIC METHODS 579 /** 580 * Creates an instance of this class and returns a daeElementRef referencing it. 581 * @return a daeElementRef referencing an instance of this object. 582 */ 583 static DLLSPEC daeElementRef create(DAE& dae); 584 /** 585 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 586 * If a daeMetaElement already exists it will return that instead of creating a new one. 587 * @return A daeMetaElement describing this COLLADA element. 588 */ 589 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 590 }; 591 592 class domBool2x1; 593 594 typedef daeSmartRef<domBool2x1> domBool2x1Ref; 595 typedef daeTArray<domBool2x1Ref> domBool2x1_Array; 596 597 class domBool2x1 : public daeElement 598 { 599 public: 600 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2X1; } 601 static daeInt ID() { return 390; } 602 virtual daeInt typeID() const { return ID(); } 603 604 protected: // Value 605 /** 606 * The domCg_bool2x1 value of the text data of this element. 607 */ 608 domCg_bool2x1 _value; 609 610 public: //Accessors and Mutators 611 /** 612 * Gets the _value array. 613 * @return Returns a domCg_bool2x1 reference of the _value array. 614 */ 615 domCg_bool2x1 &getValue() { return _value; } 616 /** 617 * Gets the _value array. 618 * @return Returns a constant domCg_bool2x1 reference of the _value array. 619 */ 620 const domCg_bool2x1 &getValue() const { return _value; } 621 /** 622 * Sets the _value array. 623 * @param val The new value for the _value array. 624 */ 625 void setValue( const domCg_bool2x1 &val ) { _value = val; } 626 627 protected: 628 /** 629 * Constructor 630 */ 631 domBool2x1(DAE& dae) : daeElement(dae), _value() {} 632 /** 633 * Destructor 634 */ 635 virtual ~domBool2x1() {} 636 /** 637 * Overloaded assignment operator 638 */ 639 virtual domBool2x1 &operator=( const domBool2x1 &cpy ) { (void)cpy; return *this; } 640 641 public: // STATIC METHODS 642 /** 643 * Creates an instance of this class and returns a daeElementRef referencing it. 644 * @return a daeElementRef referencing an instance of this object. 645 */ 646 static DLLSPEC daeElementRef create(DAE& dae); 647 /** 648 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 649 * If a daeMetaElement already exists it will return that instead of creating a new one. 650 * @return A daeMetaElement describing this COLLADA element. 651 */ 652 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 653 }; 654 655 class domBool2x2; 656 657 typedef daeSmartRef<domBool2x2> domBool2x2Ref; 658 typedef daeTArray<domBool2x2Ref> domBool2x2_Array; 659 660 class domBool2x2 : public daeElement 661 { 662 public: 663 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2X2; } 664 static daeInt ID() { return 391; } 665 virtual daeInt typeID() const { return ID(); } 666 667 protected: // Value 668 /** 669 * The domCg_bool2x2 value of the text data of this element. 670 */ 671 domCg_bool2x2 _value; 672 673 public: //Accessors and Mutators 674 /** 675 * Gets the _value array. 676 * @return Returns a domCg_bool2x2 reference of the _value array. 677 */ 678 domCg_bool2x2 &getValue() { return _value; } 679 /** 680 * Gets the _value array. 681 * @return Returns a constant domCg_bool2x2 reference of the _value array. 682 */ 683 const domCg_bool2x2 &getValue() const { return _value; } 684 /** 685 * Sets the _value array. 686 * @param val The new value for the _value array. 687 */ 688 void setValue( const domCg_bool2x2 &val ) { _value = val; } 689 690 protected: 691 /** 692 * Constructor 693 */ 694 domBool2x2(DAE& dae) : daeElement(dae), _value() {} 695 /** 696 * Destructor 697 */ 698 virtual ~domBool2x2() {} 699 /** 700 * Overloaded assignment operator 701 */ 702 virtual domBool2x2 &operator=( const domBool2x2 &cpy ) { (void)cpy; return *this; } 703 704 public: // STATIC METHODS 705 /** 706 * Creates an instance of this class and returns a daeElementRef referencing it. 707 * @return a daeElementRef referencing an instance of this object. 708 */ 709 static DLLSPEC daeElementRef create(DAE& dae); 710 /** 711 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 712 * If a daeMetaElement already exists it will return that instead of creating a new one. 713 * @return A daeMetaElement describing this COLLADA element. 714 */ 715 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 716 }; 717 718 class domBool2x3; 719 720 typedef daeSmartRef<domBool2x3> domBool2x3Ref; 721 typedef daeTArray<domBool2x3Ref> domBool2x3_Array; 722 723 class domBool2x3 : public daeElement 724 { 725 public: 726 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2X3; } 727 static daeInt ID() { return 392; } 728 virtual daeInt typeID() const { return ID(); } 729 730 protected: // Value 731 /** 732 * The domCg_bool2x3 value of the text data of this element. 733 */ 734 domCg_bool2x3 _value; 735 736 public: //Accessors and Mutators 737 /** 738 * Gets the _value array. 739 * @return Returns a domCg_bool2x3 reference of the _value array. 740 */ 741 domCg_bool2x3 &getValue() { return _value; } 742 /** 743 * Gets the _value array. 744 * @return Returns a constant domCg_bool2x3 reference of the _value array. 745 */ 746 const domCg_bool2x3 &getValue() const { return _value; } 747 /** 748 * Sets the _value array. 749 * @param val The new value for the _value array. 750 */ 751 void setValue( const domCg_bool2x3 &val ) { _value = val; } 752 753 protected: 754 /** 755 * Constructor 756 */ 757 domBool2x3(DAE& dae) : daeElement(dae), _value() {} 758 /** 759 * Destructor 760 */ 761 virtual ~domBool2x3() {} 762 /** 763 * Overloaded assignment operator 764 */ 765 virtual domBool2x3 &operator=( const domBool2x3 &cpy ) { (void)cpy; return *this; } 766 767 public: // STATIC METHODS 768 /** 769 * Creates an instance of this class and returns a daeElementRef referencing it. 770 * @return a daeElementRef referencing an instance of this object. 771 */ 772 static DLLSPEC daeElementRef create(DAE& dae); 773 /** 774 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 775 * If a daeMetaElement already exists it will return that instead of creating a new one. 776 * @return A daeMetaElement describing this COLLADA element. 777 */ 778 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 779 }; 780 781 class domBool2x4; 782 783 typedef daeSmartRef<domBool2x4> domBool2x4Ref; 784 typedef daeTArray<domBool2x4Ref> domBool2x4_Array; 785 786 class domBool2x4 : public daeElement 787 { 788 public: 789 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL2X4; } 790 static daeInt ID() { return 393; } 791 virtual daeInt typeID() const { return ID(); } 792 793 protected: // Value 794 /** 795 * The domCg_bool2x4 value of the text data of this element. 796 */ 797 domCg_bool2x4 _value; 798 799 public: //Accessors and Mutators 800 /** 801 * Gets the _value array. 802 * @return Returns a domCg_bool2x4 reference of the _value array. 803 */ 804 domCg_bool2x4 &getValue() { return _value; } 805 /** 806 * Gets the _value array. 807 * @return Returns a constant domCg_bool2x4 reference of the _value array. 808 */ 809 const domCg_bool2x4 &getValue() const { return _value; } 810 /** 811 * Sets the _value array. 812 * @param val The new value for the _value array. 813 */ 814 void setValue( const domCg_bool2x4 &val ) { _value = val; } 815 816 protected: 817 /** 818 * Constructor 819 */ 820 domBool2x4(DAE& dae) : daeElement(dae), _value() {} 821 /** 822 * Destructor 823 */ 824 virtual ~domBool2x4() {} 825 /** 826 * Overloaded assignment operator 827 */ 828 virtual domBool2x4 &operator=( const domBool2x4 &cpy ) { (void)cpy; return *this; } 829 830 public: // STATIC METHODS 831 /** 832 * Creates an instance of this class and returns a daeElementRef referencing it. 833 * @return a daeElementRef referencing an instance of this object. 834 */ 835 static DLLSPEC daeElementRef create(DAE& dae); 836 /** 837 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 838 * If a daeMetaElement already exists it will return that instead of creating a new one. 839 * @return A daeMetaElement describing this COLLADA element. 840 */ 841 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 842 }; 843 844 class domBool3x1; 845 846 typedef daeSmartRef<domBool3x1> domBool3x1Ref; 847 typedef daeTArray<domBool3x1Ref> domBool3x1_Array; 848 849 class domBool3x1 : public daeElement 850 { 851 public: 852 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3X1; } 853 static daeInt ID() { return 394; } 854 virtual daeInt typeID() const { return ID(); } 855 856 protected: // Value 857 /** 858 * The domCg_bool3x1 value of the text data of this element. 859 */ 860 domCg_bool3x1 _value; 861 862 public: //Accessors and Mutators 863 /** 864 * Gets the _value array. 865 * @return Returns a domCg_bool3x1 reference of the _value array. 866 */ 867 domCg_bool3x1 &getValue() { return _value; } 868 /** 869 * Gets the _value array. 870 * @return Returns a constant domCg_bool3x1 reference of the _value array. 871 */ 872 const domCg_bool3x1 &getValue() const { return _value; } 873 /** 874 * Sets the _value array. 875 * @param val The new value for the _value array. 876 */ 877 void setValue( const domCg_bool3x1 &val ) { _value = val; } 878 879 protected: 880 /** 881 * Constructor 882 */ 883 domBool3x1(DAE& dae) : daeElement(dae), _value() {} 884 /** 885 * Destructor 886 */ 887 virtual ~domBool3x1() {} 888 /** 889 * Overloaded assignment operator 890 */ 891 virtual domBool3x1 &operator=( const domBool3x1 &cpy ) { (void)cpy; return *this; } 892 893 public: // STATIC METHODS 894 /** 895 * Creates an instance of this class and returns a daeElementRef referencing it. 896 * @return a daeElementRef referencing an instance of this object. 897 */ 898 static DLLSPEC daeElementRef create(DAE& dae); 899 /** 900 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 901 * If a daeMetaElement already exists it will return that instead of creating a new one. 902 * @return A daeMetaElement describing this COLLADA element. 903 */ 904 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 905 }; 906 907 class domBool3x2; 908 909 typedef daeSmartRef<domBool3x2> domBool3x2Ref; 910 typedef daeTArray<domBool3x2Ref> domBool3x2_Array; 911 912 class domBool3x2 : public daeElement 913 { 914 public: 915 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3X2; } 916 static daeInt ID() { return 395; } 917 virtual daeInt typeID() const { return ID(); } 918 919 protected: // Value 920 /** 921 * The domCg_bool3x2 value of the text data of this element. 922 */ 923 domCg_bool3x2 _value; 924 925 public: //Accessors and Mutators 926 /** 927 * Gets the _value array. 928 * @return Returns a domCg_bool3x2 reference of the _value array. 929 */ 930 domCg_bool3x2 &getValue() { return _value; } 931 /** 932 * Gets the _value array. 933 * @return Returns a constant domCg_bool3x2 reference of the _value array. 934 */ 935 const domCg_bool3x2 &getValue() const { return _value; } 936 /** 937 * Sets the _value array. 938 * @param val The new value for the _value array. 939 */ 940 void setValue( const domCg_bool3x2 &val ) { _value = val; } 941 942 protected: 943 /** 944 * Constructor 945 */ 946 domBool3x2(DAE& dae) : daeElement(dae), _value() {} 947 /** 948 * Destructor 949 */ 950 virtual ~domBool3x2() {} 951 /** 952 * Overloaded assignment operator 953 */ 954 virtual domBool3x2 &operator=( const domBool3x2 &cpy ) { (void)cpy; return *this; } 955 956 public: // STATIC METHODS 957 /** 958 * Creates an instance of this class and returns a daeElementRef referencing it. 959 * @return a daeElementRef referencing an instance of this object. 960 */ 961 static DLLSPEC daeElementRef create(DAE& dae); 962 /** 963 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 964 * If a daeMetaElement already exists it will return that instead of creating a new one. 965 * @return A daeMetaElement describing this COLLADA element. 966 */ 967 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 968 }; 969 970 class domBool3x3; 971 972 typedef daeSmartRef<domBool3x3> domBool3x3Ref; 973 typedef daeTArray<domBool3x3Ref> domBool3x3_Array; 974 975 class domBool3x3 : public daeElement 976 { 977 public: 978 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3X3; } 979 static daeInt ID() { return 396; } 980 virtual daeInt typeID() const { return ID(); } 981 982 protected: // Value 983 /** 984 * The domCg_bool3x3 value of the text data of this element. 985 */ 986 domCg_bool3x3 _value; 987 988 public: //Accessors and Mutators 989 /** 990 * Gets the _value array. 991 * @return Returns a domCg_bool3x3 reference of the _value array. 992 */ 993 domCg_bool3x3 &getValue() { return _value; } 994 /** 995 * Gets the _value array. 996 * @return Returns a constant domCg_bool3x3 reference of the _value array. 997 */ 998 const domCg_bool3x3 &getValue() const { return _value; } 999 /** 1000 * Sets the _value array. 1001 * @param val The new value for the _value array. 1002 */ 1003 void setValue( const domCg_bool3x3 &val ) { _value = val; } 1004 1005 protected: 1006 /** 1007 * Constructor 1008 */ 1009 domBool3x3(DAE& dae) : daeElement(dae), _value() {} 1010 /** 1011 * Destructor 1012 */ 1013 virtual ~domBool3x3() {} 1014 /** 1015 * Overloaded assignment operator 1016 */ 1017 virtual domBool3x3 &operator=( const domBool3x3 &cpy ) { (void)cpy; return *this; } 1018 1019 public: // STATIC METHODS 1020 /** 1021 * Creates an instance of this class and returns a daeElementRef referencing it. 1022 * @return a daeElementRef referencing an instance of this object. 1023 */ 1024 static DLLSPEC daeElementRef create(DAE& dae); 1025 /** 1026 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1027 * If a daeMetaElement already exists it will return that instead of creating a new one. 1028 * @return A daeMetaElement describing this COLLADA element. 1029 */ 1030 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1031 }; 1032 1033 class domBool3x4; 1034 1035 typedef daeSmartRef<domBool3x4> domBool3x4Ref; 1036 typedef daeTArray<domBool3x4Ref> domBool3x4_Array; 1037 1038 class domBool3x4 : public daeElement 1039 { 1040 public: 1041 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL3X4; } 1042 static daeInt ID() { return 397; } 1043 virtual daeInt typeID() const { return ID(); } 1044 1045 protected: // Value 1046 /** 1047 * The domCg_bool3x4 value of the text data of this element. 1048 */ 1049 domCg_bool3x4 _value; 1050 1051 public: //Accessors and Mutators 1052 /** 1053 * Gets the _value array. 1054 * @return Returns a domCg_bool3x4 reference of the _value array. 1055 */ 1056 domCg_bool3x4 &getValue() { return _value; } 1057 /** 1058 * Gets the _value array. 1059 * @return Returns a constant domCg_bool3x4 reference of the _value array. 1060 */ 1061 const domCg_bool3x4 &getValue() const { return _value; } 1062 /** 1063 * Sets the _value array. 1064 * @param val The new value for the _value array. 1065 */ 1066 void setValue( const domCg_bool3x4 &val ) { _value = val; } 1067 1068 protected: 1069 /** 1070 * Constructor 1071 */ 1072 domBool3x4(DAE& dae) : daeElement(dae), _value() {} 1073 /** 1074 * Destructor 1075 */ 1076 virtual ~domBool3x4() {} 1077 /** 1078 * Overloaded assignment operator 1079 */ 1080 virtual domBool3x4 &operator=( const domBool3x4 &cpy ) { (void)cpy; return *this; } 1081 1082 public: // STATIC METHODS 1083 /** 1084 * Creates an instance of this class and returns a daeElementRef referencing it. 1085 * @return a daeElementRef referencing an instance of this object. 1086 */ 1087 static DLLSPEC daeElementRef create(DAE& dae); 1088 /** 1089 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1090 * If a daeMetaElement already exists it will return that instead of creating a new one. 1091 * @return A daeMetaElement describing this COLLADA element. 1092 */ 1093 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1094 }; 1095 1096 class domBool4x1; 1097 1098 typedef daeSmartRef<domBool4x1> domBool4x1Ref; 1099 typedef daeTArray<domBool4x1Ref> domBool4x1_Array; 1100 1101 class domBool4x1 : public daeElement 1102 { 1103 public: 1104 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4X1; } 1105 static daeInt ID() { return 398; } 1106 virtual daeInt typeID() const { return ID(); } 1107 1108 protected: // Value 1109 /** 1110 * The domCg_bool4x1 value of the text data of this element. 1111 */ 1112 domCg_bool4x1 _value; 1113 1114 public: //Accessors and Mutators 1115 /** 1116 * Gets the _value array. 1117 * @return Returns a domCg_bool4x1 reference of the _value array. 1118 */ 1119 domCg_bool4x1 &getValue() { return _value; } 1120 /** 1121 * Gets the _value array. 1122 * @return Returns a constant domCg_bool4x1 reference of the _value array. 1123 */ 1124 const domCg_bool4x1 &getValue() const { return _value; } 1125 /** 1126 * Sets the _value array. 1127 * @param val The new value for the _value array. 1128 */ 1129 void setValue( const domCg_bool4x1 &val ) { _value = val; } 1130 1131 protected: 1132 /** 1133 * Constructor 1134 */ 1135 domBool4x1(DAE& dae) : daeElement(dae), _value() {} 1136 /** 1137 * Destructor 1138 */ 1139 virtual ~domBool4x1() {} 1140 /** 1141 * Overloaded assignment operator 1142 */ 1143 virtual domBool4x1 &operator=( const domBool4x1 &cpy ) { (void)cpy; return *this; } 1144 1145 public: // STATIC METHODS 1146 /** 1147 * Creates an instance of this class and returns a daeElementRef referencing it. 1148 * @return a daeElementRef referencing an instance of this object. 1149 */ 1150 static DLLSPEC daeElementRef create(DAE& dae); 1151 /** 1152 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1153 * If a daeMetaElement already exists it will return that instead of creating a new one. 1154 * @return A daeMetaElement describing this COLLADA element. 1155 */ 1156 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1157 }; 1158 1159 class domBool4x2; 1160 1161 typedef daeSmartRef<domBool4x2> domBool4x2Ref; 1162 typedef daeTArray<domBool4x2Ref> domBool4x2_Array; 1163 1164 class domBool4x2 : public daeElement 1165 { 1166 public: 1167 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4X2; } 1168 static daeInt ID() { return 399; } 1169 virtual daeInt typeID() const { return ID(); } 1170 1171 protected: // Value 1172 /** 1173 * The domCg_bool4x2 value of the text data of this element. 1174 */ 1175 domCg_bool4x2 _value; 1176 1177 public: //Accessors and Mutators 1178 /** 1179 * Gets the _value array. 1180 * @return Returns a domCg_bool4x2 reference of the _value array. 1181 */ 1182 domCg_bool4x2 &getValue() { return _value; } 1183 /** 1184 * Gets the _value array. 1185 * @return Returns a constant domCg_bool4x2 reference of the _value array. 1186 */ 1187 const domCg_bool4x2 &getValue() const { return _value; } 1188 /** 1189 * Sets the _value array. 1190 * @param val The new value for the _value array. 1191 */ 1192 void setValue( const domCg_bool4x2 &val ) { _value = val; } 1193 1194 protected: 1195 /** 1196 * Constructor 1197 */ 1198 domBool4x2(DAE& dae) : daeElement(dae), _value() {} 1199 /** 1200 * Destructor 1201 */ 1202 virtual ~domBool4x2() {} 1203 /** 1204 * Overloaded assignment operator 1205 */ 1206 virtual domBool4x2 &operator=( const domBool4x2 &cpy ) { (void)cpy; return *this; } 1207 1208 public: // STATIC METHODS 1209 /** 1210 * Creates an instance of this class and returns a daeElementRef referencing it. 1211 * @return a daeElementRef referencing an instance of this object. 1212 */ 1213 static DLLSPEC daeElementRef create(DAE& dae); 1214 /** 1215 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1216 * If a daeMetaElement already exists it will return that instead of creating a new one. 1217 * @return A daeMetaElement describing this COLLADA element. 1218 */ 1219 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1220 }; 1221 1222 class domBool4x3; 1223 1224 typedef daeSmartRef<domBool4x3> domBool4x3Ref; 1225 typedef daeTArray<domBool4x3Ref> domBool4x3_Array; 1226 1227 class domBool4x3 : public daeElement 1228 { 1229 public: 1230 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4X3; } 1231 static daeInt ID() { return 400; } 1232 virtual daeInt typeID() const { return ID(); } 1233 1234 protected: // Value 1235 /** 1236 * The domCg_bool4x3 value of the text data of this element. 1237 */ 1238 domCg_bool4x3 _value; 1239 1240 public: //Accessors and Mutators 1241 /** 1242 * Gets the _value array. 1243 * @return Returns a domCg_bool4x3 reference of the _value array. 1244 */ 1245 domCg_bool4x3 &getValue() { return _value; } 1246 /** 1247 * Gets the _value array. 1248 * @return Returns a constant domCg_bool4x3 reference of the _value array. 1249 */ 1250 const domCg_bool4x3 &getValue() const { return _value; } 1251 /** 1252 * Sets the _value array. 1253 * @param val The new value for the _value array. 1254 */ 1255 void setValue( const domCg_bool4x3 &val ) { _value = val; } 1256 1257 protected: 1258 /** 1259 * Constructor 1260 */ 1261 domBool4x3(DAE& dae) : daeElement(dae), _value() {} 1262 /** 1263 * Destructor 1264 */ 1265 virtual ~domBool4x3() {} 1266 /** 1267 * Overloaded assignment operator 1268 */ 1269 virtual domBool4x3 &operator=( const domBool4x3 &cpy ) { (void)cpy; return *this; } 1270 1271 public: // STATIC METHODS 1272 /** 1273 * Creates an instance of this class and returns a daeElementRef referencing it. 1274 * @return a daeElementRef referencing an instance of this object. 1275 */ 1276 static DLLSPEC daeElementRef create(DAE& dae); 1277 /** 1278 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1279 * If a daeMetaElement already exists it will return that instead of creating a new one. 1280 * @return A daeMetaElement describing this COLLADA element. 1281 */ 1282 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1283 }; 1284 1285 class domBool4x4; 1286 1287 typedef daeSmartRef<domBool4x4> domBool4x4Ref; 1288 typedef daeTArray<domBool4x4Ref> domBool4x4_Array; 1289 1290 class domBool4x4 : public daeElement 1291 { 1292 public: 1293 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BOOL4X4; } 1294 static daeInt ID() { return 401; } 1295 virtual daeInt typeID() const { return ID(); } 1296 1297 protected: // Value 1298 /** 1299 * The domCg_bool4x4 value of the text data of this element. 1300 */ 1301 domCg_bool4x4 _value; 1302 1303 public: //Accessors and Mutators 1304 /** 1305 * Gets the _value array. 1306 * @return Returns a domCg_bool4x4 reference of the _value array. 1307 */ 1308 domCg_bool4x4 &getValue() { return _value; } 1309 /** 1310 * Gets the _value array. 1311 * @return Returns a constant domCg_bool4x4 reference of the _value array. 1312 */ 1313 const domCg_bool4x4 &getValue() const { return _value; } 1314 /** 1315 * Sets the _value array. 1316 * @param val The new value for the _value array. 1317 */ 1318 void setValue( const domCg_bool4x4 &val ) { _value = val; } 1319 1320 protected: 1321 /** 1322 * Constructor 1323 */ 1324 domBool4x4(DAE& dae) : daeElement(dae), _value() {} 1325 /** 1326 * Destructor 1327 */ 1328 virtual ~domBool4x4() {} 1329 /** 1330 * Overloaded assignment operator 1331 */ 1332 virtual domBool4x4 &operator=( const domBool4x4 &cpy ) { (void)cpy; return *this; } 1333 1334 public: // STATIC METHODS 1335 /** 1336 * Creates an instance of this class and returns a daeElementRef referencing it. 1337 * @return a daeElementRef referencing an instance of this object. 1338 */ 1339 static DLLSPEC daeElementRef create(DAE& dae); 1340 /** 1341 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1342 * If a daeMetaElement already exists it will return that instead of creating a new one. 1343 * @return A daeMetaElement describing this COLLADA element. 1344 */ 1345 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1346 }; 1347 1348 class domFloat; 1349 1350 typedef daeSmartRef<domFloat> domFloatRef; 1351 typedef daeTArray<domFloatRef> domFloat_Array; 1352 1353 class domFloat : public daeElement 1354 { 1355 public: 1356 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT; } 1357 static daeInt ID() { return 402; } 1358 virtual daeInt typeID() const { return ID(); } 1359 1360 protected: // Value 1361 /** 1362 * The domCg_float value of the text data of this element. 1363 */ 1364 domCg_float _value; 1365 1366 public: //Accessors and Mutators 1367 /** 1368 * Gets the value of this element. 1369 * @return a domCg_float of the value. 1370 */ 1371 domCg_float getValue() const { return _value; } 1372 /** 1373 * Sets the _value of this element. 1374 * @param val The new value for this element. 1375 */ 1376 void setValue( domCg_float val ) { _value = val; } 1377 1378 protected: 1379 /** 1380 * Constructor 1381 */ 1382 domFloat(DAE& dae) : daeElement(dae), _value() {} 1383 /** 1384 * Destructor 1385 */ 1386 virtual ~domFloat() {} 1387 /** 1388 * Overloaded assignment operator 1389 */ 1390 virtual domFloat &operator=( const domFloat &cpy ) { (void)cpy; return *this; } 1391 1392 public: // STATIC METHODS 1393 /** 1394 * Creates an instance of this class and returns a daeElementRef referencing it. 1395 * @return a daeElementRef referencing an instance of this object. 1396 */ 1397 static DLLSPEC daeElementRef create(DAE& dae); 1398 /** 1399 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1400 * If a daeMetaElement already exists it will return that instead of creating a new one. 1401 * @return A daeMetaElement describing this COLLADA element. 1402 */ 1403 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1404 }; 1405 1406 class domFloat1; 1407 1408 typedef daeSmartRef<domFloat1> domFloat1Ref; 1409 typedef daeTArray<domFloat1Ref> domFloat1_Array; 1410 1411 class domFloat1 : public daeElement 1412 { 1413 public: 1414 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1; } 1415 static daeInt ID() { return 403; } 1416 virtual daeInt typeID() const { return ID(); } 1417 1418 protected: // Value 1419 /** 1420 * The domCg_float1 value of the text data of this element. 1421 */ 1422 domCg_float1 _value; 1423 1424 public: //Accessors and Mutators 1425 /** 1426 * Gets the value of this element. 1427 * @return a domCg_float1 of the value. 1428 */ 1429 domCg_float1 getValue() const { return _value; } 1430 /** 1431 * Sets the _value of this element. 1432 * @param val The new value for this element. 1433 */ 1434 void setValue( domCg_float1 val ) { _value = val; } 1435 1436 protected: 1437 /** 1438 * Constructor 1439 */ 1440 domFloat1(DAE& dae) : daeElement(dae), _value() {} 1441 /** 1442 * Destructor 1443 */ 1444 virtual ~domFloat1() {} 1445 /** 1446 * Overloaded assignment operator 1447 */ 1448 virtual domFloat1 &operator=( const domFloat1 &cpy ) { (void)cpy; return *this; } 1449 1450 public: // STATIC METHODS 1451 /** 1452 * Creates an instance of this class and returns a daeElementRef referencing it. 1453 * @return a daeElementRef referencing an instance of this object. 1454 */ 1455 static DLLSPEC daeElementRef create(DAE& dae); 1456 /** 1457 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1458 * If a daeMetaElement already exists it will return that instead of creating a new one. 1459 * @return A daeMetaElement describing this COLLADA element. 1460 */ 1461 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1462 }; 1463 1464 class domFloat2; 1465 1466 typedef daeSmartRef<domFloat2> domFloat2Ref; 1467 typedef daeTArray<domFloat2Ref> domFloat2_Array; 1468 1469 class domFloat2 : public daeElement 1470 { 1471 public: 1472 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2; } 1473 static daeInt ID() { return 404; } 1474 virtual daeInt typeID() const { return ID(); } 1475 1476 protected: // Value 1477 /** 1478 * The domCg_float2 value of the text data of this element. 1479 */ 1480 domCg_float2 _value; 1481 1482 public: //Accessors and Mutators 1483 /** 1484 * Gets the _value array. 1485 * @return Returns a domCg_float2 reference of the _value array. 1486 */ 1487 domCg_float2 &getValue() { return _value; } 1488 /** 1489 * Gets the _value array. 1490 * @return Returns a constant domCg_float2 reference of the _value array. 1491 */ 1492 const domCg_float2 &getValue() const { return _value; } 1493 /** 1494 * Sets the _value array. 1495 * @param val The new value for the _value array. 1496 */ 1497 void setValue( const domCg_float2 &val ) { _value = val; } 1498 1499 protected: 1500 /** 1501 * Constructor 1502 */ 1503 domFloat2(DAE& dae) : daeElement(dae), _value() {} 1504 /** 1505 * Destructor 1506 */ 1507 virtual ~domFloat2() {} 1508 /** 1509 * Overloaded assignment operator 1510 */ 1511 virtual domFloat2 &operator=( const domFloat2 &cpy ) { (void)cpy; return *this; } 1512 1513 public: // STATIC METHODS 1514 /** 1515 * Creates an instance of this class and returns a daeElementRef referencing it. 1516 * @return a daeElementRef referencing an instance of this object. 1517 */ 1518 static DLLSPEC daeElementRef create(DAE& dae); 1519 /** 1520 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1521 * If a daeMetaElement already exists it will return that instead of creating a new one. 1522 * @return A daeMetaElement describing this COLLADA element. 1523 */ 1524 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1525 }; 1526 1527 class domFloat3; 1528 1529 typedef daeSmartRef<domFloat3> domFloat3Ref; 1530 typedef daeTArray<domFloat3Ref> domFloat3_Array; 1531 1532 class domFloat3 : public daeElement 1533 { 1534 public: 1535 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3; } 1536 static daeInt ID() { return 405; } 1537 virtual daeInt typeID() const { return ID(); } 1538 1539 protected: // Value 1540 /** 1541 * The domCg_float3 value of the text data of this element. 1542 */ 1543 domCg_float3 _value; 1544 1545 public: //Accessors and Mutators 1546 /** 1547 * Gets the _value array. 1548 * @return Returns a domCg_float3 reference of the _value array. 1549 */ 1550 domCg_float3 &getValue() { return _value; } 1551 /** 1552 * Gets the _value array. 1553 * @return Returns a constant domCg_float3 reference of the _value array. 1554 */ 1555 const domCg_float3 &getValue() const { return _value; } 1556 /** 1557 * Sets the _value array. 1558 * @param val The new value for the _value array. 1559 */ 1560 void setValue( const domCg_float3 &val ) { _value = val; } 1561 1562 protected: 1563 /** 1564 * Constructor 1565 */ 1566 domFloat3(DAE& dae) : daeElement(dae), _value() {} 1567 /** 1568 * Destructor 1569 */ 1570 virtual ~domFloat3() {} 1571 /** 1572 * Overloaded assignment operator 1573 */ 1574 virtual domFloat3 &operator=( const domFloat3 &cpy ) { (void)cpy; return *this; } 1575 1576 public: // STATIC METHODS 1577 /** 1578 * Creates an instance of this class and returns a daeElementRef referencing it. 1579 * @return a daeElementRef referencing an instance of this object. 1580 */ 1581 static DLLSPEC daeElementRef create(DAE& dae); 1582 /** 1583 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1584 * If a daeMetaElement already exists it will return that instead of creating a new one. 1585 * @return A daeMetaElement describing this COLLADA element. 1586 */ 1587 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1588 }; 1589 1590 class domFloat4; 1591 1592 typedef daeSmartRef<domFloat4> domFloat4Ref; 1593 typedef daeTArray<domFloat4Ref> domFloat4_Array; 1594 1595 class domFloat4 : public daeElement 1596 { 1597 public: 1598 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4; } 1599 static daeInt ID() { return 406; } 1600 virtual daeInt typeID() const { return ID(); } 1601 1602 protected: // Value 1603 /** 1604 * The domCg_float4 value of the text data of this element. 1605 */ 1606 domCg_float4 _value; 1607 1608 public: //Accessors and Mutators 1609 /** 1610 * Gets the _value array. 1611 * @return Returns a domCg_float4 reference of the _value array. 1612 */ 1613 domCg_float4 &getValue() { return _value; } 1614 /** 1615 * Gets the _value array. 1616 * @return Returns a constant domCg_float4 reference of the _value array. 1617 */ 1618 const domCg_float4 &getValue() const { return _value; } 1619 /** 1620 * Sets the _value array. 1621 * @param val The new value for the _value array. 1622 */ 1623 void setValue( const domCg_float4 &val ) { _value = val; } 1624 1625 protected: 1626 /** 1627 * Constructor 1628 */ 1629 domFloat4(DAE& dae) : daeElement(dae), _value() {} 1630 /** 1631 * Destructor 1632 */ 1633 virtual ~domFloat4() {} 1634 /** 1635 * Overloaded assignment operator 1636 */ 1637 virtual domFloat4 &operator=( const domFloat4 &cpy ) { (void)cpy; return *this; } 1638 1639 public: // STATIC METHODS 1640 /** 1641 * Creates an instance of this class and returns a daeElementRef referencing it. 1642 * @return a daeElementRef referencing an instance of this object. 1643 */ 1644 static DLLSPEC daeElementRef create(DAE& dae); 1645 /** 1646 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1647 * If a daeMetaElement already exists it will return that instead of creating a new one. 1648 * @return A daeMetaElement describing this COLLADA element. 1649 */ 1650 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1651 }; 1652 1653 class domFloat1x1; 1654 1655 typedef daeSmartRef<domFloat1x1> domFloat1x1Ref; 1656 typedef daeTArray<domFloat1x1Ref> domFloat1x1_Array; 1657 1658 class domFloat1x1 : public daeElement 1659 { 1660 public: 1661 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X1; } 1662 static daeInt ID() { return 407; } 1663 virtual daeInt typeID() const { return ID(); } 1664 1665 protected: // Value 1666 /** 1667 * The domCg_float1x1 value of the text data of this element. 1668 */ 1669 domCg_float1x1 _value; 1670 1671 public: //Accessors and Mutators 1672 /** 1673 * Gets the _value array. 1674 * @return Returns a domCg_float1x1 reference of the _value array. 1675 */ 1676 domCg_float1x1 &getValue() { return _value; } 1677 /** 1678 * Gets the _value array. 1679 * @return Returns a constant domCg_float1x1 reference of the _value array. 1680 */ 1681 const domCg_float1x1 &getValue() const { return _value; } 1682 /** 1683 * Sets the _value array. 1684 * @param val The new value for the _value array. 1685 */ 1686 void setValue( const domCg_float1x1 &val ) { _value = val; } 1687 1688 protected: 1689 /** 1690 * Constructor 1691 */ 1692 domFloat1x1(DAE& dae) : daeElement(dae), _value() {} 1693 /** 1694 * Destructor 1695 */ 1696 virtual ~domFloat1x1() {} 1697 /** 1698 * Overloaded assignment operator 1699 */ 1700 virtual domFloat1x1 &operator=( const domFloat1x1 &cpy ) { (void)cpy; return *this; } 1701 1702 public: // STATIC METHODS 1703 /** 1704 * Creates an instance of this class and returns a daeElementRef referencing it. 1705 * @return a daeElementRef referencing an instance of this object. 1706 */ 1707 static DLLSPEC daeElementRef create(DAE& dae); 1708 /** 1709 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1710 * If a daeMetaElement already exists it will return that instead of creating a new one. 1711 * @return A daeMetaElement describing this COLLADA element. 1712 */ 1713 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1714 }; 1715 1716 class domFloat1x2; 1717 1718 typedef daeSmartRef<domFloat1x2> domFloat1x2Ref; 1719 typedef daeTArray<domFloat1x2Ref> domFloat1x2_Array; 1720 1721 class domFloat1x2 : public daeElement 1722 { 1723 public: 1724 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X2; } 1725 static daeInt ID() { return 408; } 1726 virtual daeInt typeID() const { return ID(); } 1727 1728 protected: // Value 1729 /** 1730 * The domCg_float1x2 value of the text data of this element. 1731 */ 1732 domCg_float1x2 _value; 1733 1734 public: //Accessors and Mutators 1735 /** 1736 * Gets the _value array. 1737 * @return Returns a domCg_float1x2 reference of the _value array. 1738 */ 1739 domCg_float1x2 &getValue() { return _value; } 1740 /** 1741 * Gets the _value array. 1742 * @return Returns a constant domCg_float1x2 reference of the _value array. 1743 */ 1744 const domCg_float1x2 &getValue() const { return _value; } 1745 /** 1746 * Sets the _value array. 1747 * @param val The new value for the _value array. 1748 */ 1749 void setValue( const domCg_float1x2 &val ) { _value = val; } 1750 1751 protected: 1752 /** 1753 * Constructor 1754 */ 1755 domFloat1x2(DAE& dae) : daeElement(dae), _value() {} 1756 /** 1757 * Destructor 1758 */ 1759 virtual ~domFloat1x2() {} 1760 /** 1761 * Overloaded assignment operator 1762 */ 1763 virtual domFloat1x2 &operator=( const domFloat1x2 &cpy ) { (void)cpy; return *this; } 1764 1765 public: // STATIC METHODS 1766 /** 1767 * Creates an instance of this class and returns a daeElementRef referencing it. 1768 * @return a daeElementRef referencing an instance of this object. 1769 */ 1770 static DLLSPEC daeElementRef create(DAE& dae); 1771 /** 1772 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1773 * If a daeMetaElement already exists it will return that instead of creating a new one. 1774 * @return A daeMetaElement describing this COLLADA element. 1775 */ 1776 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1777 }; 1778 1779 class domFloat1x3; 1780 1781 typedef daeSmartRef<domFloat1x3> domFloat1x3Ref; 1782 typedef daeTArray<domFloat1x3Ref> domFloat1x3_Array; 1783 1784 class domFloat1x3 : public daeElement 1785 { 1786 public: 1787 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X3; } 1788 static daeInt ID() { return 409; } 1789 virtual daeInt typeID() const { return ID(); } 1790 1791 protected: // Value 1792 /** 1793 * The domCg_float1x3 value of the text data of this element. 1794 */ 1795 domCg_float1x3 _value; 1796 1797 public: //Accessors and Mutators 1798 /** 1799 * Gets the _value array. 1800 * @return Returns a domCg_float1x3 reference of the _value array. 1801 */ 1802 domCg_float1x3 &getValue() { return _value; } 1803 /** 1804 * Gets the _value array. 1805 * @return Returns a constant domCg_float1x3 reference of the _value array. 1806 */ 1807 const domCg_float1x3 &getValue() const { return _value; } 1808 /** 1809 * Sets the _value array. 1810 * @param val The new value for the _value array. 1811 */ 1812 void setValue( const domCg_float1x3 &val ) { _value = val; } 1813 1814 protected: 1815 /** 1816 * Constructor 1817 */ 1818 domFloat1x3(DAE& dae) : daeElement(dae), _value() {} 1819 /** 1820 * Destructor 1821 */ 1822 virtual ~domFloat1x3() {} 1823 /** 1824 * Overloaded assignment operator 1825 */ 1826 virtual domFloat1x3 &operator=( const domFloat1x3 &cpy ) { (void)cpy; return *this; } 1827 1828 public: // STATIC METHODS 1829 /** 1830 * Creates an instance of this class and returns a daeElementRef referencing it. 1831 * @return a daeElementRef referencing an instance of this object. 1832 */ 1833 static DLLSPEC daeElementRef create(DAE& dae); 1834 /** 1835 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1836 * If a daeMetaElement already exists it will return that instead of creating a new one. 1837 * @return A daeMetaElement describing this COLLADA element. 1838 */ 1839 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1840 }; 1841 1842 class domFloat1x4; 1843 1844 typedef daeSmartRef<domFloat1x4> domFloat1x4Ref; 1845 typedef daeTArray<domFloat1x4Ref> domFloat1x4_Array; 1846 1847 class domFloat1x4 : public daeElement 1848 { 1849 public: 1850 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT1X4; } 1851 static daeInt ID() { return 410; } 1852 virtual daeInt typeID() const { return ID(); } 1853 1854 protected: // Value 1855 /** 1856 * The domCg_float1x4 value of the text data of this element. 1857 */ 1858 domCg_float1x4 _value; 1859 1860 public: //Accessors and Mutators 1861 /** 1862 * Gets the _value array. 1863 * @return Returns a domCg_float1x4 reference of the _value array. 1864 */ 1865 domCg_float1x4 &getValue() { return _value; } 1866 /** 1867 * Gets the _value array. 1868 * @return Returns a constant domCg_float1x4 reference of the _value array. 1869 */ 1870 const domCg_float1x4 &getValue() const { return _value; } 1871 /** 1872 * Sets the _value array. 1873 * @param val The new value for the _value array. 1874 */ 1875 void setValue( const domCg_float1x4 &val ) { _value = val; } 1876 1877 protected: 1878 /** 1879 * Constructor 1880 */ 1881 domFloat1x4(DAE& dae) : daeElement(dae), _value() {} 1882 /** 1883 * Destructor 1884 */ 1885 virtual ~domFloat1x4() {} 1886 /** 1887 * Overloaded assignment operator 1888 */ 1889 virtual domFloat1x4 &operator=( const domFloat1x4 &cpy ) { (void)cpy; return *this; } 1890 1891 public: // STATIC METHODS 1892 /** 1893 * Creates an instance of this class and returns a daeElementRef referencing it. 1894 * @return a daeElementRef referencing an instance of this object. 1895 */ 1896 static DLLSPEC daeElementRef create(DAE& dae); 1897 /** 1898 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1899 * If a daeMetaElement already exists it will return that instead of creating a new one. 1900 * @return A daeMetaElement describing this COLLADA element. 1901 */ 1902 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1903 }; 1904 1905 class domFloat2x1; 1906 1907 typedef daeSmartRef<domFloat2x1> domFloat2x1Ref; 1908 typedef daeTArray<domFloat2x1Ref> domFloat2x1_Array; 1909 1910 class domFloat2x1 : public daeElement 1911 { 1912 public: 1913 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X1; } 1914 static daeInt ID() { return 411; } 1915 virtual daeInt typeID() const { return ID(); } 1916 1917 protected: // Value 1918 /** 1919 * The domCg_float2x1 value of the text data of this element. 1920 */ 1921 domCg_float2x1 _value; 1922 1923 public: //Accessors and Mutators 1924 /** 1925 * Gets the _value array. 1926 * @return Returns a domCg_float2x1 reference of the _value array. 1927 */ 1928 domCg_float2x1 &getValue() { return _value; } 1929 /** 1930 * Gets the _value array. 1931 * @return Returns a constant domCg_float2x1 reference of the _value array. 1932 */ 1933 const domCg_float2x1 &getValue() const { return _value; } 1934 /** 1935 * Sets the _value array. 1936 * @param val The new value for the _value array. 1937 */ 1938 void setValue( const domCg_float2x1 &val ) { _value = val; } 1939 1940 protected: 1941 /** 1942 * Constructor 1943 */ 1944 domFloat2x1(DAE& dae) : daeElement(dae), _value() {} 1945 /** 1946 * Destructor 1947 */ 1948 virtual ~domFloat2x1() {} 1949 /** 1950 * Overloaded assignment operator 1951 */ 1952 virtual domFloat2x1 &operator=( const domFloat2x1 &cpy ) { (void)cpy; return *this; } 1953 1954 public: // STATIC METHODS 1955 /** 1956 * Creates an instance of this class and returns a daeElementRef referencing it. 1957 * @return a daeElementRef referencing an instance of this object. 1958 */ 1959 static DLLSPEC daeElementRef create(DAE& dae); 1960 /** 1961 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1962 * If a daeMetaElement already exists it will return that instead of creating a new one. 1963 * @return A daeMetaElement describing this COLLADA element. 1964 */ 1965 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1966 }; 1967 1968 class domFloat2x2; 1969 1970 typedef daeSmartRef<domFloat2x2> domFloat2x2Ref; 1971 typedef daeTArray<domFloat2x2Ref> domFloat2x2_Array; 1972 1973 class domFloat2x2 : public daeElement 1974 { 1975 public: 1976 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X2; } 1977 static daeInt ID() { return 412; } 1978 virtual daeInt typeID() const { return ID(); } 1979 1980 protected: // Value 1981 /** 1982 * The domCg_float2x2 value of the text data of this element. 1983 */ 1984 domCg_float2x2 _value; 1985 1986 public: //Accessors and Mutators 1987 /** 1988 * Gets the _value array. 1989 * @return Returns a domCg_float2x2 reference of the _value array. 1990 */ 1991 domCg_float2x2 &getValue() { return _value; } 1992 /** 1993 * Gets the _value array. 1994 * @return Returns a constant domCg_float2x2 reference of the _value array. 1995 */ 1996 const domCg_float2x2 &getValue() const { return _value; } 1997 /** 1998 * Sets the _value array. 1999 * @param val The new value for the _value array. 2000 */ 2001 void setValue( const domCg_float2x2 &val ) { _value = val; } 2002 2003 protected: 2004 /** 2005 * Constructor 2006 */ 2007 domFloat2x2(DAE& dae) : daeElement(dae), _value() {} 2008 /** 2009 * Destructor 2010 */ 2011 virtual ~domFloat2x2() {} 2012 /** 2013 * Overloaded assignment operator 2014 */ 2015 virtual domFloat2x2 &operator=( const domFloat2x2 &cpy ) { (void)cpy; return *this; } 2016 2017 public: // STATIC METHODS 2018 /** 2019 * Creates an instance of this class and returns a daeElementRef referencing it. 2020 * @return a daeElementRef referencing an instance of this object. 2021 */ 2022 static DLLSPEC daeElementRef create(DAE& dae); 2023 /** 2024 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2025 * If a daeMetaElement already exists it will return that instead of creating a new one. 2026 * @return A daeMetaElement describing this COLLADA element. 2027 */ 2028 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2029 }; 2030 2031 class domFloat2x3; 2032 2033 typedef daeSmartRef<domFloat2x3> domFloat2x3Ref; 2034 typedef daeTArray<domFloat2x3Ref> domFloat2x3_Array; 2035 2036 class domFloat2x3 : public daeElement 2037 { 2038 public: 2039 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X3; } 2040 static daeInt ID() { return 413; } 2041 virtual daeInt typeID() const { return ID(); } 2042 2043 protected: // Value 2044 /** 2045 * The domCg_float2x3 value of the text data of this element. 2046 */ 2047 domCg_float2x3 _value; 2048 2049 public: //Accessors and Mutators 2050 /** 2051 * Gets the _value array. 2052 * @return Returns a domCg_float2x3 reference of the _value array. 2053 */ 2054 domCg_float2x3 &getValue() { return _value; } 2055 /** 2056 * Gets the _value array. 2057 * @return Returns a constant domCg_float2x3 reference of the _value array. 2058 */ 2059 const domCg_float2x3 &getValue() const { return _value; } 2060 /** 2061 * Sets the _value array. 2062 * @param val The new value for the _value array. 2063 */ 2064 void setValue( const domCg_float2x3 &val ) { _value = val; } 2065 2066 protected: 2067 /** 2068 * Constructor 2069 */ 2070 domFloat2x3(DAE& dae) : daeElement(dae), _value() {} 2071 /** 2072 * Destructor 2073 */ 2074 virtual ~domFloat2x3() {} 2075 /** 2076 * Overloaded assignment operator 2077 */ 2078 virtual domFloat2x3 &operator=( const domFloat2x3 &cpy ) { (void)cpy; return *this; } 2079 2080 public: // STATIC METHODS 2081 /** 2082 * Creates an instance of this class and returns a daeElementRef referencing it. 2083 * @return a daeElementRef referencing an instance of this object. 2084 */ 2085 static DLLSPEC daeElementRef create(DAE& dae); 2086 /** 2087 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2088 * If a daeMetaElement already exists it will return that instead of creating a new one. 2089 * @return A daeMetaElement describing this COLLADA element. 2090 */ 2091 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2092 }; 2093 2094 class domFloat2x4; 2095 2096 typedef daeSmartRef<domFloat2x4> domFloat2x4Ref; 2097 typedef daeTArray<domFloat2x4Ref> domFloat2x4_Array; 2098 2099 class domFloat2x4 : public daeElement 2100 { 2101 public: 2102 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT2X4; } 2103 static daeInt ID() { return 414; } 2104 virtual daeInt typeID() const { return ID(); } 2105 2106 protected: // Value 2107 /** 2108 * The domCg_float2x4 value of the text data of this element. 2109 */ 2110 domCg_float2x4 _value; 2111 2112 public: //Accessors and Mutators 2113 /** 2114 * Gets the _value array. 2115 * @return Returns a domCg_float2x4 reference of the _value array. 2116 */ 2117 domCg_float2x4 &getValue() { return _value; } 2118 /** 2119 * Gets the _value array. 2120 * @return Returns a constant domCg_float2x4 reference of the _value array. 2121 */ 2122 const domCg_float2x4 &getValue() const { return _value; } 2123 /** 2124 * Sets the _value array. 2125 * @param val The new value for the _value array. 2126 */ 2127 void setValue( const domCg_float2x4 &val ) { _value = val; } 2128 2129 protected: 2130 /** 2131 * Constructor 2132 */ 2133 domFloat2x4(DAE& dae) : daeElement(dae), _value() {} 2134 /** 2135 * Destructor 2136 */ 2137 virtual ~domFloat2x4() {} 2138 /** 2139 * Overloaded assignment operator 2140 */ 2141 virtual domFloat2x4 &operator=( const domFloat2x4 &cpy ) { (void)cpy; return *this; } 2142 2143 public: // STATIC METHODS 2144 /** 2145 * Creates an instance of this class and returns a daeElementRef referencing it. 2146 * @return a daeElementRef referencing an instance of this object. 2147 */ 2148 static DLLSPEC daeElementRef create(DAE& dae); 2149 /** 2150 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2151 * If a daeMetaElement already exists it will return that instead of creating a new one. 2152 * @return A daeMetaElement describing this COLLADA element. 2153 */ 2154 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2155 }; 2156 2157 class domFloat3x1; 2158 2159 typedef daeSmartRef<domFloat3x1> domFloat3x1Ref; 2160 typedef daeTArray<domFloat3x1Ref> domFloat3x1_Array; 2161 2162 class domFloat3x1 : public daeElement 2163 { 2164 public: 2165 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X1; } 2166 static daeInt ID() { return 415; } 2167 virtual daeInt typeID() const { return ID(); } 2168 2169 protected: // Value 2170 /** 2171 * The domCg_float3x1 value of the text data of this element. 2172 */ 2173 domCg_float3x1 _value; 2174 2175 public: //Accessors and Mutators 2176 /** 2177 * Gets the _value array. 2178 * @return Returns a domCg_float3x1 reference of the _value array. 2179 */ 2180 domCg_float3x1 &getValue() { return _value; } 2181 /** 2182 * Gets the _value array. 2183 * @return Returns a constant domCg_float3x1 reference of the _value array. 2184 */ 2185 const domCg_float3x1 &getValue() const { return _value; } 2186 /** 2187 * Sets the _value array. 2188 * @param val The new value for the _value array. 2189 */ 2190 void setValue( const domCg_float3x1 &val ) { _value = val; } 2191 2192 protected: 2193 /** 2194 * Constructor 2195 */ 2196 domFloat3x1(DAE& dae) : daeElement(dae), _value() {} 2197 /** 2198 * Destructor 2199 */ 2200 virtual ~domFloat3x1() {} 2201 /** 2202 * Overloaded assignment operator 2203 */ 2204 virtual domFloat3x1 &operator=( const domFloat3x1 &cpy ) { (void)cpy; return *this; } 2205 2206 public: // STATIC METHODS 2207 /** 2208 * Creates an instance of this class and returns a daeElementRef referencing it. 2209 * @return a daeElementRef referencing an instance of this object. 2210 */ 2211 static DLLSPEC daeElementRef create(DAE& dae); 2212 /** 2213 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2214 * If a daeMetaElement already exists it will return that instead of creating a new one. 2215 * @return A daeMetaElement describing this COLLADA element. 2216 */ 2217 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2218 }; 2219 2220 class domFloat3x2; 2221 2222 typedef daeSmartRef<domFloat3x2> domFloat3x2Ref; 2223 typedef daeTArray<domFloat3x2Ref> domFloat3x2_Array; 2224 2225 class domFloat3x2 : public daeElement 2226 { 2227 public: 2228 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X2; } 2229 static daeInt ID() { return 416; } 2230 virtual daeInt typeID() const { return ID(); } 2231 2232 protected: // Value 2233 /** 2234 * The domCg_float3x2 value of the text data of this element. 2235 */ 2236 domCg_float3x2 _value; 2237 2238 public: //Accessors and Mutators 2239 /** 2240 * Gets the _value array. 2241 * @return Returns a domCg_float3x2 reference of the _value array. 2242 */ 2243 domCg_float3x2 &getValue() { return _value; } 2244 /** 2245 * Gets the _value array. 2246 * @return Returns a constant domCg_float3x2 reference of the _value array. 2247 */ 2248 const domCg_float3x2 &getValue() const { return _value; } 2249 /** 2250 * Sets the _value array. 2251 * @param val The new value for the _value array. 2252 */ 2253 void setValue( const domCg_float3x2 &val ) { _value = val; } 2254 2255 protected: 2256 /** 2257 * Constructor 2258 */ 2259 domFloat3x2(DAE& dae) : daeElement(dae), _value() {} 2260 /** 2261 * Destructor 2262 */ 2263 virtual ~domFloat3x2() {} 2264 /** 2265 * Overloaded assignment operator 2266 */ 2267 virtual domFloat3x2 &operator=( const domFloat3x2 &cpy ) { (void)cpy; return *this; } 2268 2269 public: // STATIC METHODS 2270 /** 2271 * Creates an instance of this class and returns a daeElementRef referencing it. 2272 * @return a daeElementRef referencing an instance of this object. 2273 */ 2274 static DLLSPEC daeElementRef create(DAE& dae); 2275 /** 2276 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2277 * If a daeMetaElement already exists it will return that instead of creating a new one. 2278 * @return A daeMetaElement describing this COLLADA element. 2279 */ 2280 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2281 }; 2282 2283 class domFloat3x3; 2284 2285 typedef daeSmartRef<domFloat3x3> domFloat3x3Ref; 2286 typedef daeTArray<domFloat3x3Ref> domFloat3x3_Array; 2287 2288 class domFloat3x3 : public daeElement 2289 { 2290 public: 2291 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X3; } 2292 static daeInt ID() { return 417; } 2293 virtual daeInt typeID() const { return ID(); } 2294 2295 protected: // Value 2296 /** 2297 * The domCg_float3x3 value of the text data of this element. 2298 */ 2299 domCg_float3x3 _value; 2300 2301 public: //Accessors and Mutators 2302 /** 2303 * Gets the _value array. 2304 * @return Returns a domCg_float3x3 reference of the _value array. 2305 */ 2306 domCg_float3x3 &getValue() { return _value; } 2307 /** 2308 * Gets the _value array. 2309 * @return Returns a constant domCg_float3x3 reference of the _value array. 2310 */ 2311 const domCg_float3x3 &getValue() const { return _value; } 2312 /** 2313 * Sets the _value array. 2314 * @param val The new value for the _value array. 2315 */ 2316 void setValue( const domCg_float3x3 &val ) { _value = val; } 2317 2318 protected: 2319 /** 2320 * Constructor 2321 */ 2322 domFloat3x3(DAE& dae) : daeElement(dae), _value() {} 2323 /** 2324 * Destructor 2325 */ 2326 virtual ~domFloat3x3() {} 2327 /** 2328 * Overloaded assignment operator 2329 */ 2330 virtual domFloat3x3 &operator=( const domFloat3x3 &cpy ) { (void)cpy; return *this; } 2331 2332 public: // STATIC METHODS 2333 /** 2334 * Creates an instance of this class and returns a daeElementRef referencing it. 2335 * @return a daeElementRef referencing an instance of this object. 2336 */ 2337 static DLLSPEC daeElementRef create(DAE& dae); 2338 /** 2339 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2340 * If a daeMetaElement already exists it will return that instead of creating a new one. 2341 * @return A daeMetaElement describing this COLLADA element. 2342 */ 2343 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2344 }; 2345 2346 class domFloat3x4; 2347 2348 typedef daeSmartRef<domFloat3x4> domFloat3x4Ref; 2349 typedef daeTArray<domFloat3x4Ref> domFloat3x4_Array; 2350 2351 class domFloat3x4 : public daeElement 2352 { 2353 public: 2354 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT3X4; } 2355 static daeInt ID() { return 418; } 2356 virtual daeInt typeID() const { return ID(); } 2357 2358 protected: // Value 2359 /** 2360 * The domCg_float3x4 value of the text data of this element. 2361 */ 2362 domCg_float3x4 _value; 2363 2364 public: //Accessors and Mutators 2365 /** 2366 * Gets the _value array. 2367 * @return Returns a domCg_float3x4 reference of the _value array. 2368 */ 2369 domCg_float3x4 &getValue() { return _value; } 2370 /** 2371 * Gets the _value array. 2372 * @return Returns a constant domCg_float3x4 reference of the _value array. 2373 */ 2374 const domCg_float3x4 &getValue() const { return _value; } 2375 /** 2376 * Sets the _value array. 2377 * @param val The new value for the _value array. 2378 */ 2379 void setValue( const domCg_float3x4 &val ) { _value = val; } 2380 2381 protected: 2382 /** 2383 * Constructor 2384 */ 2385 domFloat3x4(DAE& dae) : daeElement(dae), _value() {} 2386 /** 2387 * Destructor 2388 */ 2389 virtual ~domFloat3x4() {} 2390 /** 2391 * Overloaded assignment operator 2392 */ 2393 virtual domFloat3x4 &operator=( const domFloat3x4 &cpy ) { (void)cpy; return *this; } 2394 2395 public: // STATIC METHODS 2396 /** 2397 * Creates an instance of this class and returns a daeElementRef referencing it. 2398 * @return a daeElementRef referencing an instance of this object. 2399 */ 2400 static DLLSPEC daeElementRef create(DAE& dae); 2401 /** 2402 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2403 * If a daeMetaElement already exists it will return that instead of creating a new one. 2404 * @return A daeMetaElement describing this COLLADA element. 2405 */ 2406 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2407 }; 2408 2409 class domFloat4x1; 2410 2411 typedef daeSmartRef<domFloat4x1> domFloat4x1Ref; 2412 typedef daeTArray<domFloat4x1Ref> domFloat4x1_Array; 2413 2414 class domFloat4x1 : public daeElement 2415 { 2416 public: 2417 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X1; } 2418 static daeInt ID() { return 419; } 2419 virtual daeInt typeID() const { return ID(); } 2420 2421 protected: // Value 2422 /** 2423 * The domCg_float4x1 value of the text data of this element. 2424 */ 2425 domCg_float4x1 _value; 2426 2427 public: //Accessors and Mutators 2428 /** 2429 * Gets the _value array. 2430 * @return Returns a domCg_float4x1 reference of the _value array. 2431 */ 2432 domCg_float4x1 &getValue() { return _value; } 2433 /** 2434 * Gets the _value array. 2435 * @return Returns a constant domCg_float4x1 reference of the _value array. 2436 */ 2437 const domCg_float4x1 &getValue() const { return _value; } 2438 /** 2439 * Sets the _value array. 2440 * @param val The new value for the _value array. 2441 */ 2442 void setValue( const domCg_float4x1 &val ) { _value = val; } 2443 2444 protected: 2445 /** 2446 * Constructor 2447 */ 2448 domFloat4x1(DAE& dae) : daeElement(dae), _value() {} 2449 /** 2450 * Destructor 2451 */ 2452 virtual ~domFloat4x1() {} 2453 /** 2454 * Overloaded assignment operator 2455 */ 2456 virtual domFloat4x1 &operator=( const domFloat4x1 &cpy ) { (void)cpy; return *this; } 2457 2458 public: // STATIC METHODS 2459 /** 2460 * Creates an instance of this class and returns a daeElementRef referencing it. 2461 * @return a daeElementRef referencing an instance of this object. 2462 */ 2463 static DLLSPEC daeElementRef create(DAE& dae); 2464 /** 2465 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2466 * If a daeMetaElement already exists it will return that instead of creating a new one. 2467 * @return A daeMetaElement describing this COLLADA element. 2468 */ 2469 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2470 }; 2471 2472 class domFloat4x2; 2473 2474 typedef daeSmartRef<domFloat4x2> domFloat4x2Ref; 2475 typedef daeTArray<domFloat4x2Ref> domFloat4x2_Array; 2476 2477 class domFloat4x2 : public daeElement 2478 { 2479 public: 2480 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X2; } 2481 static daeInt ID() { return 420; } 2482 virtual daeInt typeID() const { return ID(); } 2483 2484 protected: // Value 2485 /** 2486 * The domCg_float4x2 value of the text data of this element. 2487 */ 2488 domCg_float4x2 _value; 2489 2490 public: //Accessors and Mutators 2491 /** 2492 * Gets the _value array. 2493 * @return Returns a domCg_float4x2 reference of the _value array. 2494 */ 2495 domCg_float4x2 &getValue() { return _value; } 2496 /** 2497 * Gets the _value array. 2498 * @return Returns a constant domCg_float4x2 reference of the _value array. 2499 */ 2500 const domCg_float4x2 &getValue() const { return _value; } 2501 /** 2502 * Sets the _value array. 2503 * @param val The new value for the _value array. 2504 */ 2505 void setValue( const domCg_float4x2 &val ) { _value = val; } 2506 2507 protected: 2508 /** 2509 * Constructor 2510 */ 2511 domFloat4x2(DAE& dae) : daeElement(dae), _value() {} 2512 /** 2513 * Destructor 2514 */ 2515 virtual ~domFloat4x2() {} 2516 /** 2517 * Overloaded assignment operator 2518 */ 2519 virtual domFloat4x2 &operator=( const domFloat4x2 &cpy ) { (void)cpy; return *this; } 2520 2521 public: // STATIC METHODS 2522 /** 2523 * Creates an instance of this class and returns a daeElementRef referencing it. 2524 * @return a daeElementRef referencing an instance of this object. 2525 */ 2526 static DLLSPEC daeElementRef create(DAE& dae); 2527 /** 2528 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2529 * If a daeMetaElement already exists it will return that instead of creating a new one. 2530 * @return A daeMetaElement describing this COLLADA element. 2531 */ 2532 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2533 }; 2534 2535 class domFloat4x3; 2536 2537 typedef daeSmartRef<domFloat4x3> domFloat4x3Ref; 2538 typedef daeTArray<domFloat4x3Ref> domFloat4x3_Array; 2539 2540 class domFloat4x3 : public daeElement 2541 { 2542 public: 2543 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X3; } 2544 static daeInt ID() { return 421; } 2545 virtual daeInt typeID() const { return ID(); } 2546 2547 protected: // Value 2548 /** 2549 * The domCg_float4x3 value of the text data of this element. 2550 */ 2551 domCg_float4x3 _value; 2552 2553 public: //Accessors and Mutators 2554 /** 2555 * Gets the _value array. 2556 * @return Returns a domCg_float4x3 reference of the _value array. 2557 */ 2558 domCg_float4x3 &getValue() { return _value; } 2559 /** 2560 * Gets the _value array. 2561 * @return Returns a constant domCg_float4x3 reference of the _value array. 2562 */ 2563 const domCg_float4x3 &getValue() const { return _value; } 2564 /** 2565 * Sets the _value array. 2566 * @param val The new value for the _value array. 2567 */ 2568 void setValue( const domCg_float4x3 &val ) { _value = val; } 2569 2570 protected: 2571 /** 2572 * Constructor 2573 */ 2574 domFloat4x3(DAE& dae) : daeElement(dae), _value() {} 2575 /** 2576 * Destructor 2577 */ 2578 virtual ~domFloat4x3() {} 2579 /** 2580 * Overloaded assignment operator 2581 */ 2582 virtual domFloat4x3 &operator=( const domFloat4x3 &cpy ) { (void)cpy; return *this; } 2583 2584 public: // STATIC METHODS 2585 /** 2586 * Creates an instance of this class and returns a daeElementRef referencing it. 2587 * @return a daeElementRef referencing an instance of this object. 2588 */ 2589 static DLLSPEC daeElementRef create(DAE& dae); 2590 /** 2591 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2592 * If a daeMetaElement already exists it will return that instead of creating a new one. 2593 * @return A daeMetaElement describing this COLLADA element. 2594 */ 2595 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2596 }; 2597 2598 class domFloat4x4; 2599 2600 typedef daeSmartRef<domFloat4x4> domFloat4x4Ref; 2601 typedef daeTArray<domFloat4x4Ref> domFloat4x4_Array; 2602 2603 class domFloat4x4 : public daeElement 2604 { 2605 public: 2606 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FLOAT4X4; } 2607 static daeInt ID() { return 422; } 2608 virtual daeInt typeID() const { return ID(); } 2609 2610 protected: // Value 2611 /** 2612 * The domCg_float4x4 value of the text data of this element. 2613 */ 2614 domCg_float4x4 _value; 2615 2616 public: //Accessors and Mutators 2617 /** 2618 * Gets the _value array. 2619 * @return Returns a domCg_float4x4 reference of the _value array. 2620 */ 2621 domCg_float4x4 &getValue() { return _value; } 2622 /** 2623 * Gets the _value array. 2624 * @return Returns a constant domCg_float4x4 reference of the _value array. 2625 */ 2626 const domCg_float4x4 &getValue() const { return _value; } 2627 /** 2628 * Sets the _value array. 2629 * @param val The new value for the _value array. 2630 */ 2631 void setValue( const domCg_float4x4 &val ) { _value = val; } 2632 2633 protected: 2634 /** 2635 * Constructor 2636 */ 2637 domFloat4x4(DAE& dae) : daeElement(dae), _value() {} 2638 /** 2639 * Destructor 2640 */ 2641 virtual ~domFloat4x4() {} 2642 /** 2643 * Overloaded assignment operator 2644 */ 2645 virtual domFloat4x4 &operator=( const domFloat4x4 &cpy ) { (void)cpy; return *this; } 2646 2647 public: // STATIC METHODS 2648 /** 2649 * Creates an instance of this class and returns a daeElementRef referencing it. 2650 * @return a daeElementRef referencing an instance of this object. 2651 */ 2652 static DLLSPEC daeElementRef create(DAE& dae); 2653 /** 2654 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2655 * If a daeMetaElement already exists it will return that instead of creating a new one. 2656 * @return A daeMetaElement describing this COLLADA element. 2657 */ 2658 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2659 }; 2660 2661 class domInt; 2662 2663 typedef daeSmartRef<domInt> domIntRef; 2664 typedef daeTArray<domIntRef> domInt_Array; 2665 2666 class domInt : public daeElement 2667 { 2668 public: 2669 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT; } 2670 static daeInt ID() { return 423; } 2671 virtual daeInt typeID() const { return ID(); } 2672 2673 protected: // Value 2674 /** 2675 * The domCg_int value of the text data of this element. 2676 */ 2677 domCg_int _value; 2678 2679 public: //Accessors and Mutators 2680 /** 2681 * Gets the value of this element. 2682 * @return a domCg_int of the value. 2683 */ 2684 domCg_int getValue() const { return _value; } 2685 /** 2686 * Sets the _value of this element. 2687 * @param val The new value for this element. 2688 */ 2689 void setValue( domCg_int val ) { _value = val; } 2690 2691 protected: 2692 /** 2693 * Constructor 2694 */ 2695 domInt(DAE& dae) : daeElement(dae), _value() {} 2696 /** 2697 * Destructor 2698 */ 2699 virtual ~domInt() {} 2700 /** 2701 * Overloaded assignment operator 2702 */ 2703 virtual domInt &operator=( const domInt &cpy ) { (void)cpy; return *this; } 2704 2705 public: // STATIC METHODS 2706 /** 2707 * Creates an instance of this class and returns a daeElementRef referencing it. 2708 * @return a daeElementRef referencing an instance of this object. 2709 */ 2710 static DLLSPEC daeElementRef create(DAE& dae); 2711 /** 2712 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2713 * If a daeMetaElement already exists it will return that instead of creating a new one. 2714 * @return A daeMetaElement describing this COLLADA element. 2715 */ 2716 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2717 }; 2718 2719 class domInt1; 2720 2721 typedef daeSmartRef<domInt1> domInt1Ref; 2722 typedef daeTArray<domInt1Ref> domInt1_Array; 2723 2724 class domInt1 : public daeElement 2725 { 2726 public: 2727 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT1; } 2728 static daeInt ID() { return 424; } 2729 virtual daeInt typeID() const { return ID(); } 2730 2731 protected: // Value 2732 /** 2733 * The domCg_int1 value of the text data of this element. 2734 */ 2735 domCg_int1 _value; 2736 2737 public: //Accessors and Mutators 2738 /** 2739 * Gets the value of this element. 2740 * @return a domCg_int1 of the value. 2741 */ 2742 domCg_int1 getValue() const { return _value; } 2743 /** 2744 * Sets the _value of this element. 2745 * @param val The new value for this element. 2746 */ 2747 void setValue( domCg_int1 val ) { _value = val; } 2748 2749 protected: 2750 /** 2751 * Constructor 2752 */ 2753 domInt1(DAE& dae) : daeElement(dae), _value() {} 2754 /** 2755 * Destructor 2756 */ 2757 virtual ~domInt1() {} 2758 /** 2759 * Overloaded assignment operator 2760 */ 2761 virtual domInt1 &operator=( const domInt1 &cpy ) { (void)cpy; return *this; } 2762 2763 public: // STATIC METHODS 2764 /** 2765 * Creates an instance of this class and returns a daeElementRef referencing it. 2766 * @return a daeElementRef referencing an instance of this object. 2767 */ 2768 static DLLSPEC daeElementRef create(DAE& dae); 2769 /** 2770 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2771 * If a daeMetaElement already exists it will return that instead of creating a new one. 2772 * @return A daeMetaElement describing this COLLADA element. 2773 */ 2774 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2775 }; 2776 2777 class domInt2; 2778 2779 typedef daeSmartRef<domInt2> domInt2Ref; 2780 typedef daeTArray<domInt2Ref> domInt2_Array; 2781 2782 class domInt2 : public daeElement 2783 { 2784 public: 2785 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2; } 2786 static daeInt ID() { return 425; } 2787 virtual daeInt typeID() const { return ID(); } 2788 2789 protected: // Value 2790 /** 2791 * The domCg_int2 value of the text data of this element. 2792 */ 2793 domCg_int2 _value; 2794 2795 public: //Accessors and Mutators 2796 /** 2797 * Gets the _value array. 2798 * @return Returns a domCg_int2 reference of the _value array. 2799 */ 2800 domCg_int2 &getValue() { return _value; } 2801 /** 2802 * Gets the _value array. 2803 * @return Returns a constant domCg_int2 reference of the _value array. 2804 */ 2805 const domCg_int2 &getValue() const { return _value; } 2806 /** 2807 * Sets the _value array. 2808 * @param val The new value for the _value array. 2809 */ 2810 void setValue( const domCg_int2 &val ) { _value = val; } 2811 2812 protected: 2813 /** 2814 * Constructor 2815 */ 2816 domInt2(DAE& dae) : daeElement(dae), _value() {} 2817 /** 2818 * Destructor 2819 */ 2820 virtual ~domInt2() {} 2821 /** 2822 * Overloaded assignment operator 2823 */ 2824 virtual domInt2 &operator=( const domInt2 &cpy ) { (void)cpy; return *this; } 2825 2826 public: // STATIC METHODS 2827 /** 2828 * Creates an instance of this class and returns a daeElementRef referencing it. 2829 * @return a daeElementRef referencing an instance of this object. 2830 */ 2831 static DLLSPEC daeElementRef create(DAE& dae); 2832 /** 2833 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2834 * If a daeMetaElement already exists it will return that instead of creating a new one. 2835 * @return A daeMetaElement describing this COLLADA element. 2836 */ 2837 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2838 }; 2839 2840 class domInt3; 2841 2842 typedef daeSmartRef<domInt3> domInt3Ref; 2843 typedef daeTArray<domInt3Ref> domInt3_Array; 2844 2845 class domInt3 : public daeElement 2846 { 2847 public: 2848 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3; } 2849 static daeInt ID() { return 426; } 2850 virtual daeInt typeID() const { return ID(); } 2851 2852 protected: // Value 2853 /** 2854 * The domCg_int3 value of the text data of this element. 2855 */ 2856 domCg_int3 _value; 2857 2858 public: //Accessors and Mutators 2859 /** 2860 * Gets the _value array. 2861 * @return Returns a domCg_int3 reference of the _value array. 2862 */ 2863 domCg_int3 &getValue() { return _value; } 2864 /** 2865 * Gets the _value array. 2866 * @return Returns a constant domCg_int3 reference of the _value array. 2867 */ 2868 const domCg_int3 &getValue() const { return _value; } 2869 /** 2870 * Sets the _value array. 2871 * @param val The new value for the _value array. 2872 */ 2873 void setValue( const domCg_int3 &val ) { _value = val; } 2874 2875 protected: 2876 /** 2877 * Constructor 2878 */ 2879 domInt3(DAE& dae) : daeElement(dae), _value() {} 2880 /** 2881 * Destructor 2882 */ 2883 virtual ~domInt3() {} 2884 /** 2885 * Overloaded assignment operator 2886 */ 2887 virtual domInt3 &operator=( const domInt3 &cpy ) { (void)cpy; return *this; } 2888 2889 public: // STATIC METHODS 2890 /** 2891 * Creates an instance of this class and returns a daeElementRef referencing it. 2892 * @return a daeElementRef referencing an instance of this object. 2893 */ 2894 static DLLSPEC daeElementRef create(DAE& dae); 2895 /** 2896 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2897 * If a daeMetaElement already exists it will return that instead of creating a new one. 2898 * @return A daeMetaElement describing this COLLADA element. 2899 */ 2900 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2901 }; 2902 2903 class domInt4; 2904 2905 typedef daeSmartRef<domInt4> domInt4Ref; 2906 typedef daeTArray<domInt4Ref> domInt4_Array; 2907 2908 class domInt4 : public daeElement 2909 { 2910 public: 2911 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4; } 2912 static daeInt ID() { return 427; } 2913 virtual daeInt typeID() const { return ID(); } 2914 2915 protected: // Value 2916 /** 2917 * The domCg_int4 value of the text data of this element. 2918 */ 2919 domCg_int4 _value; 2920 2921 public: //Accessors and Mutators 2922 /** 2923 * Gets the _value array. 2924 * @return Returns a domCg_int4 reference of the _value array. 2925 */ 2926 domCg_int4 &getValue() { return _value; } 2927 /** 2928 * Gets the _value array. 2929 * @return Returns a constant domCg_int4 reference of the _value array. 2930 */ 2931 const domCg_int4 &getValue() const { return _value; } 2932 /** 2933 * Sets the _value array. 2934 * @param val The new value for the _value array. 2935 */ 2936 void setValue( const domCg_int4 &val ) { _value = val; } 2937 2938 protected: 2939 /** 2940 * Constructor 2941 */ 2942 domInt4(DAE& dae) : daeElement(dae), _value() {} 2943 /** 2944 * Destructor 2945 */ 2946 virtual ~domInt4() {} 2947 /** 2948 * Overloaded assignment operator 2949 */ 2950 virtual domInt4 &operator=( const domInt4 &cpy ) { (void)cpy; return *this; } 2951 2952 public: // STATIC METHODS 2953 /** 2954 * Creates an instance of this class and returns a daeElementRef referencing it. 2955 * @return a daeElementRef referencing an instance of this object. 2956 */ 2957 static DLLSPEC daeElementRef create(DAE& dae); 2958 /** 2959 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2960 * If a daeMetaElement already exists it will return that instead of creating a new one. 2961 * @return A daeMetaElement describing this COLLADA element. 2962 */ 2963 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2964 }; 2965 2966 class domInt1x1; 2967 2968 typedef daeSmartRef<domInt1x1> domInt1x1Ref; 2969 typedef daeTArray<domInt1x1Ref> domInt1x1_Array; 2970 2971 class domInt1x1 : public daeElement 2972 { 2973 public: 2974 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT1X1; } 2975 static daeInt ID() { return 428; } 2976 virtual daeInt typeID() const { return ID(); } 2977 2978 protected: // Value 2979 /** 2980 * The domCg_int1x1 value of the text data of this element. 2981 */ 2982 domCg_int1x1 _value; 2983 2984 public: //Accessors and Mutators 2985 /** 2986 * Gets the _value array. 2987 * @return Returns a domCg_int1x1 reference of the _value array. 2988 */ 2989 domCg_int1x1 &getValue() { return _value; } 2990 /** 2991 * Gets the _value array. 2992 * @return Returns a constant domCg_int1x1 reference of the _value array. 2993 */ 2994 const domCg_int1x1 &getValue() const { return _value; } 2995 /** 2996 * Sets the _value array. 2997 * @param val The new value for the _value array. 2998 */ 2999 void setValue( const domCg_int1x1 &val ) { _value = val; } 3000 3001 protected: 3002 /** 3003 * Constructor 3004 */ 3005 domInt1x1(DAE& dae) : daeElement(dae), _value() {} 3006 /** 3007 * Destructor 3008 */ 3009 virtual ~domInt1x1() {} 3010 /** 3011 * Overloaded assignment operator 3012 */ 3013 virtual domInt1x1 &operator=( const domInt1x1 &cpy ) { (void)cpy; return *this; } 3014 3015 public: // STATIC METHODS 3016 /** 3017 * Creates an instance of this class and returns a daeElementRef referencing it. 3018 * @return a daeElementRef referencing an instance of this object. 3019 */ 3020 static DLLSPEC daeElementRef create(DAE& dae); 3021 /** 3022 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3023 * If a daeMetaElement already exists it will return that instead of creating a new one. 3024 * @return A daeMetaElement describing this COLLADA element. 3025 */ 3026 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3027 }; 3028 3029 class domInt1x2; 3030 3031 typedef daeSmartRef<domInt1x2> domInt1x2Ref; 3032 typedef daeTArray<domInt1x2Ref> domInt1x2_Array; 3033 3034 class domInt1x2 : public daeElement 3035 { 3036 public: 3037 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT1X2; } 3038 static daeInt ID() { return 429; } 3039 virtual daeInt typeID() const { return ID(); } 3040 3041 protected: // Value 3042 /** 3043 * The domCg_int1x2 value of the text data of this element. 3044 */ 3045 domCg_int1x2 _value; 3046 3047 public: //Accessors and Mutators 3048 /** 3049 * Gets the _value array. 3050 * @return Returns a domCg_int1x2 reference of the _value array. 3051 */ 3052 domCg_int1x2 &getValue() { return _value; } 3053 /** 3054 * Gets the _value array. 3055 * @return Returns a constant domCg_int1x2 reference of the _value array. 3056 */ 3057 const domCg_int1x2 &getValue() const { return _value; } 3058 /** 3059 * Sets the _value array. 3060 * @param val The new value for the _value array. 3061 */ 3062 void setValue( const domCg_int1x2 &val ) { _value = val; } 3063 3064 protected: 3065 /** 3066 * Constructor 3067 */ 3068 domInt1x2(DAE& dae) : daeElement(dae), _value() {} 3069 /** 3070 * Destructor 3071 */ 3072 virtual ~domInt1x2() {} 3073 /** 3074 * Overloaded assignment operator 3075 */ 3076 virtual domInt1x2 &operator=( const domInt1x2 &cpy ) { (void)cpy; return *this; } 3077 3078 public: // STATIC METHODS 3079 /** 3080 * Creates an instance of this class and returns a daeElementRef referencing it. 3081 * @return a daeElementRef referencing an instance of this object. 3082 */ 3083 static DLLSPEC daeElementRef create(DAE& dae); 3084 /** 3085 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3086 * If a daeMetaElement already exists it will return that instead of creating a new one. 3087 * @return A daeMetaElement describing this COLLADA element. 3088 */ 3089 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3090 }; 3091 3092 class domInt1x3; 3093 3094 typedef daeSmartRef<domInt1x3> domInt1x3Ref; 3095 typedef daeTArray<domInt1x3Ref> domInt1x3_Array; 3096 3097 class domInt1x3 : public daeElement 3098 { 3099 public: 3100 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT1X3; } 3101 static daeInt ID() { return 430; } 3102 virtual daeInt typeID() const { return ID(); } 3103 3104 protected: // Value 3105 /** 3106 * The domCg_int1x3 value of the text data of this element. 3107 */ 3108 domCg_int1x3 _value; 3109 3110 public: //Accessors and Mutators 3111 /** 3112 * Gets the _value array. 3113 * @return Returns a domCg_int1x3 reference of the _value array. 3114 */ 3115 domCg_int1x3 &getValue() { return _value; } 3116 /** 3117 * Gets the _value array. 3118 * @return Returns a constant domCg_int1x3 reference of the _value array. 3119 */ 3120 const domCg_int1x3 &getValue() const { return _value; } 3121 /** 3122 * Sets the _value array. 3123 * @param val The new value for the _value array. 3124 */ 3125 void setValue( const domCg_int1x3 &val ) { _value = val; } 3126 3127 protected: 3128 /** 3129 * Constructor 3130 */ 3131 domInt1x3(DAE& dae) : daeElement(dae), _value() {} 3132 /** 3133 * Destructor 3134 */ 3135 virtual ~domInt1x3() {} 3136 /** 3137 * Overloaded assignment operator 3138 */ 3139 virtual domInt1x3 &operator=( const domInt1x3 &cpy ) { (void)cpy; return *this; } 3140 3141 public: // STATIC METHODS 3142 /** 3143 * Creates an instance of this class and returns a daeElementRef referencing it. 3144 * @return a daeElementRef referencing an instance of this object. 3145 */ 3146 static DLLSPEC daeElementRef create(DAE& dae); 3147 /** 3148 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3149 * If a daeMetaElement already exists it will return that instead of creating a new one. 3150 * @return A daeMetaElement describing this COLLADA element. 3151 */ 3152 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3153 }; 3154 3155 class domInt1x4; 3156 3157 typedef daeSmartRef<domInt1x4> domInt1x4Ref; 3158 typedef daeTArray<domInt1x4Ref> domInt1x4_Array; 3159 3160 class domInt1x4 : public daeElement 3161 { 3162 public: 3163 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT1X4; } 3164 static daeInt ID() { return 431; } 3165 virtual daeInt typeID() const { return ID(); } 3166 3167 protected: // Value 3168 /** 3169 * The domCg_int1x4 value of the text data of this element. 3170 */ 3171 domCg_int1x4 _value; 3172 3173 public: //Accessors and Mutators 3174 /** 3175 * Gets the _value array. 3176 * @return Returns a domCg_int1x4 reference of the _value array. 3177 */ 3178 domCg_int1x4 &getValue() { return _value; } 3179 /** 3180 * Gets the _value array. 3181 * @return Returns a constant domCg_int1x4 reference of the _value array. 3182 */ 3183 const domCg_int1x4 &getValue() const { return _value; } 3184 /** 3185 * Sets the _value array. 3186 * @param val The new value for the _value array. 3187 */ 3188 void setValue( const domCg_int1x4 &val ) { _value = val; } 3189 3190 protected: 3191 /** 3192 * Constructor 3193 */ 3194 domInt1x4(DAE& dae) : daeElement(dae), _value() {} 3195 /** 3196 * Destructor 3197 */ 3198 virtual ~domInt1x4() {} 3199 /** 3200 * Overloaded assignment operator 3201 */ 3202 virtual domInt1x4 &operator=( const domInt1x4 &cpy ) { (void)cpy; return *this; } 3203 3204 public: // STATIC METHODS 3205 /** 3206 * Creates an instance of this class and returns a daeElementRef referencing it. 3207 * @return a daeElementRef referencing an instance of this object. 3208 */ 3209 static DLLSPEC daeElementRef create(DAE& dae); 3210 /** 3211 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3212 * If a daeMetaElement already exists it will return that instead of creating a new one. 3213 * @return A daeMetaElement describing this COLLADA element. 3214 */ 3215 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3216 }; 3217 3218 class domInt2x1; 3219 3220 typedef daeSmartRef<domInt2x1> domInt2x1Ref; 3221 typedef daeTArray<domInt2x1Ref> domInt2x1_Array; 3222 3223 class domInt2x1 : public daeElement 3224 { 3225 public: 3226 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2X1; } 3227 static daeInt ID() { return 432; } 3228 virtual daeInt typeID() const { return ID(); } 3229 3230 protected: // Value 3231 /** 3232 * The domCg_int2x1 value of the text data of this element. 3233 */ 3234 domCg_int2x1 _value; 3235 3236 public: //Accessors and Mutators 3237 /** 3238 * Gets the _value array. 3239 * @return Returns a domCg_int2x1 reference of the _value array. 3240 */ 3241 domCg_int2x1 &getValue() { return _value; } 3242 /** 3243 * Gets the _value array. 3244 * @return Returns a constant domCg_int2x1 reference of the _value array. 3245 */ 3246 const domCg_int2x1 &getValue() const { return _value; } 3247 /** 3248 * Sets the _value array. 3249 * @param val The new value for the _value array. 3250 */ 3251 void setValue( const domCg_int2x1 &val ) { _value = val; } 3252 3253 protected: 3254 /** 3255 * Constructor 3256 */ 3257 domInt2x1(DAE& dae) : daeElement(dae), _value() {} 3258 /** 3259 * Destructor 3260 */ 3261 virtual ~domInt2x1() {} 3262 /** 3263 * Overloaded assignment operator 3264 */ 3265 virtual domInt2x1 &operator=( const domInt2x1 &cpy ) { (void)cpy; return *this; } 3266 3267 public: // STATIC METHODS 3268 /** 3269 * Creates an instance of this class and returns a daeElementRef referencing it. 3270 * @return a daeElementRef referencing an instance of this object. 3271 */ 3272 static DLLSPEC daeElementRef create(DAE& dae); 3273 /** 3274 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3275 * If a daeMetaElement already exists it will return that instead of creating a new one. 3276 * @return A daeMetaElement describing this COLLADA element. 3277 */ 3278 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3279 }; 3280 3281 class domInt2x2; 3282 3283 typedef daeSmartRef<domInt2x2> domInt2x2Ref; 3284 typedef daeTArray<domInt2x2Ref> domInt2x2_Array; 3285 3286 class domInt2x2 : public daeElement 3287 { 3288 public: 3289 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2X2; } 3290 static daeInt ID() { return 433; } 3291 virtual daeInt typeID() const { return ID(); } 3292 3293 protected: // Value 3294 /** 3295 * The domCg_int2x2 value of the text data of this element. 3296 */ 3297 domCg_int2x2 _value; 3298 3299 public: //Accessors and Mutators 3300 /** 3301 * Gets the _value array. 3302 * @return Returns a domCg_int2x2 reference of the _value array. 3303 */ 3304 domCg_int2x2 &getValue() { return _value; } 3305 /** 3306 * Gets the _value array. 3307 * @return Returns a constant domCg_int2x2 reference of the _value array. 3308 */ 3309 const domCg_int2x2 &getValue() const { return _value; } 3310 /** 3311 * Sets the _value array. 3312 * @param val The new value for the _value array. 3313 */ 3314 void setValue( const domCg_int2x2 &val ) { _value = val; } 3315 3316 protected: 3317 /** 3318 * Constructor 3319 */ 3320 domInt2x2(DAE& dae) : daeElement(dae), _value() {} 3321 /** 3322 * Destructor 3323 */ 3324 virtual ~domInt2x2() {} 3325 /** 3326 * Overloaded assignment operator 3327 */ 3328 virtual domInt2x2 &operator=( const domInt2x2 &cpy ) { (void)cpy; return *this; } 3329 3330 public: // STATIC METHODS 3331 /** 3332 * Creates an instance of this class and returns a daeElementRef referencing it. 3333 * @return a daeElementRef referencing an instance of this object. 3334 */ 3335 static DLLSPEC daeElementRef create(DAE& dae); 3336 /** 3337 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3338 * If a daeMetaElement already exists it will return that instead of creating a new one. 3339 * @return A daeMetaElement describing this COLLADA element. 3340 */ 3341 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3342 }; 3343 3344 class domInt2x3; 3345 3346 typedef daeSmartRef<domInt2x3> domInt2x3Ref; 3347 typedef daeTArray<domInt2x3Ref> domInt2x3_Array; 3348 3349 class domInt2x3 : public daeElement 3350 { 3351 public: 3352 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2X3; } 3353 static daeInt ID() { return 434; } 3354 virtual daeInt typeID() const { return ID(); } 3355 3356 protected: // Value 3357 /** 3358 * The domCg_int2x3 value of the text data of this element. 3359 */ 3360 domCg_int2x3 _value; 3361 3362 public: //Accessors and Mutators 3363 /** 3364 * Gets the _value array. 3365 * @return Returns a domCg_int2x3 reference of the _value array. 3366 */ 3367 domCg_int2x3 &getValue() { return _value; } 3368 /** 3369 * Gets the _value array. 3370 * @return Returns a constant domCg_int2x3 reference of the _value array. 3371 */ 3372 const domCg_int2x3 &getValue() const { return _value; } 3373 /** 3374 * Sets the _value array. 3375 * @param val The new value for the _value array. 3376 */ 3377 void setValue( const domCg_int2x3 &val ) { _value = val; } 3378 3379 protected: 3380 /** 3381 * Constructor 3382 */ 3383 domInt2x3(DAE& dae) : daeElement(dae), _value() {} 3384 /** 3385 * Destructor 3386 */ 3387 virtual ~domInt2x3() {} 3388 /** 3389 * Overloaded assignment operator 3390 */ 3391 virtual domInt2x3 &operator=( const domInt2x3 &cpy ) { (void)cpy; return *this; } 3392 3393 public: // STATIC METHODS 3394 /** 3395 * Creates an instance of this class and returns a daeElementRef referencing it. 3396 * @return a daeElementRef referencing an instance of this object. 3397 */ 3398 static DLLSPEC daeElementRef create(DAE& dae); 3399 /** 3400 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3401 * If a daeMetaElement already exists it will return that instead of creating a new one. 3402 * @return A daeMetaElement describing this COLLADA element. 3403 */ 3404 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3405 }; 3406 3407 class domInt2x4; 3408 3409 typedef daeSmartRef<domInt2x4> domInt2x4Ref; 3410 typedef daeTArray<domInt2x4Ref> domInt2x4_Array; 3411 3412 class domInt2x4 : public daeElement 3413 { 3414 public: 3415 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT2X4; } 3416 static daeInt ID() { return 435; } 3417 virtual daeInt typeID() const { return ID(); } 3418 3419 protected: // Value 3420 /** 3421 * The domCg_int2x4 value of the text data of this element. 3422 */ 3423 domCg_int2x4 _value; 3424 3425 public: //Accessors and Mutators 3426 /** 3427 * Gets the _value array. 3428 * @return Returns a domCg_int2x4 reference of the _value array. 3429 */ 3430 domCg_int2x4 &getValue() { return _value; } 3431 /** 3432 * Gets the _value array. 3433 * @return Returns a constant domCg_int2x4 reference of the _value array. 3434 */ 3435 const domCg_int2x4 &getValue() const { return _value; } 3436 /** 3437 * Sets the _value array. 3438 * @param val The new value for the _value array. 3439 */ 3440 void setValue( const domCg_int2x4 &val ) { _value = val; } 3441 3442 protected: 3443 /** 3444 * Constructor 3445 */ 3446 domInt2x4(DAE& dae) : daeElement(dae), _value() {} 3447 /** 3448 * Destructor 3449 */ 3450 virtual ~domInt2x4() {} 3451 /** 3452 * Overloaded assignment operator 3453 */ 3454 virtual domInt2x4 &operator=( const domInt2x4 &cpy ) { (void)cpy; return *this; } 3455 3456 public: // STATIC METHODS 3457 /** 3458 * Creates an instance of this class and returns a daeElementRef referencing it. 3459 * @return a daeElementRef referencing an instance of this object. 3460 */ 3461 static DLLSPEC daeElementRef create(DAE& dae); 3462 /** 3463 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3464 * If a daeMetaElement already exists it will return that instead of creating a new one. 3465 * @return A daeMetaElement describing this COLLADA element. 3466 */ 3467 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3468 }; 3469 3470 class domInt3x1; 3471 3472 typedef daeSmartRef<domInt3x1> domInt3x1Ref; 3473 typedef daeTArray<domInt3x1Ref> domInt3x1_Array; 3474 3475 class domInt3x1 : public daeElement 3476 { 3477 public: 3478 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3X1; } 3479 static daeInt ID() { return 436; } 3480 virtual daeInt typeID() const { return ID(); } 3481 3482 protected: // Value 3483 /** 3484 * The domCg_int3x1 value of the text data of this element. 3485 */ 3486 domCg_int3x1 _value; 3487 3488 public: //Accessors and Mutators 3489 /** 3490 * Gets the _value array. 3491 * @return Returns a domCg_int3x1 reference of the _value array. 3492 */ 3493 domCg_int3x1 &getValue() { return _value; } 3494 /** 3495 * Gets the _value array. 3496 * @return Returns a constant domCg_int3x1 reference of the _value array. 3497 */ 3498 const domCg_int3x1 &getValue() const { return _value; } 3499 /** 3500 * Sets the _value array. 3501 * @param val The new value for the _value array. 3502 */ 3503 void setValue( const domCg_int3x1 &val ) { _value = val; } 3504 3505 protected: 3506 /** 3507 * Constructor 3508 */ 3509 domInt3x1(DAE& dae) : daeElement(dae), _value() {} 3510 /** 3511 * Destructor 3512 */ 3513 virtual ~domInt3x1() {} 3514 /** 3515 * Overloaded assignment operator 3516 */ 3517 virtual domInt3x1 &operator=( const domInt3x1 &cpy ) { (void)cpy; return *this; } 3518 3519 public: // STATIC METHODS 3520 /** 3521 * Creates an instance of this class and returns a daeElementRef referencing it. 3522 * @return a daeElementRef referencing an instance of this object. 3523 */ 3524 static DLLSPEC daeElementRef create(DAE& dae); 3525 /** 3526 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3527 * If a daeMetaElement already exists it will return that instead of creating a new one. 3528 * @return A daeMetaElement describing this COLLADA element. 3529 */ 3530 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3531 }; 3532 3533 class domInt3x2; 3534 3535 typedef daeSmartRef<domInt3x2> domInt3x2Ref; 3536 typedef daeTArray<domInt3x2Ref> domInt3x2_Array; 3537 3538 class domInt3x2 : public daeElement 3539 { 3540 public: 3541 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3X2; } 3542 static daeInt ID() { return 437; } 3543 virtual daeInt typeID() const { return ID(); } 3544 3545 protected: // Value 3546 /** 3547 * The domCg_int3x2 value of the text data of this element. 3548 */ 3549 domCg_int3x2 _value; 3550 3551 public: //Accessors and Mutators 3552 /** 3553 * Gets the _value array. 3554 * @return Returns a domCg_int3x2 reference of the _value array. 3555 */ 3556 domCg_int3x2 &getValue() { return _value; } 3557 /** 3558 * Gets the _value array. 3559 * @return Returns a constant domCg_int3x2 reference of the _value array. 3560 */ 3561 const domCg_int3x2 &getValue() const { return _value; } 3562 /** 3563 * Sets the _value array. 3564 * @param val The new value for the _value array. 3565 */ 3566 void setValue( const domCg_int3x2 &val ) { _value = val; } 3567 3568 protected: 3569 /** 3570 * Constructor 3571 */ 3572 domInt3x2(DAE& dae) : daeElement(dae), _value() {} 3573 /** 3574 * Destructor 3575 */ 3576 virtual ~domInt3x2() {} 3577 /** 3578 * Overloaded assignment operator 3579 */ 3580 virtual domInt3x2 &operator=( const domInt3x2 &cpy ) { (void)cpy; return *this; } 3581 3582 public: // STATIC METHODS 3583 /** 3584 * Creates an instance of this class and returns a daeElementRef referencing it. 3585 * @return a daeElementRef referencing an instance of this object. 3586 */ 3587 static DLLSPEC daeElementRef create(DAE& dae); 3588 /** 3589 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3590 * If a daeMetaElement already exists it will return that instead of creating a new one. 3591 * @return A daeMetaElement describing this COLLADA element. 3592 */ 3593 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3594 }; 3595 3596 class domInt3x3; 3597 3598 typedef daeSmartRef<domInt3x3> domInt3x3Ref; 3599 typedef daeTArray<domInt3x3Ref> domInt3x3_Array; 3600 3601 class domInt3x3 : public daeElement 3602 { 3603 public: 3604 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3X3; } 3605 static daeInt ID() { return 438; } 3606 virtual daeInt typeID() const { return ID(); } 3607 3608 protected: // Value 3609 /** 3610 * The domCg_int3x3 value of the text data of this element. 3611 */ 3612 domCg_int3x3 _value; 3613 3614 public: //Accessors and Mutators 3615 /** 3616 * Gets the _value array. 3617 * @return Returns a domCg_int3x3 reference of the _value array. 3618 */ 3619 domCg_int3x3 &getValue() { return _value; } 3620 /** 3621 * Gets the _value array. 3622 * @return Returns a constant domCg_int3x3 reference of the _value array. 3623 */ 3624 const domCg_int3x3 &getValue() const { return _value; } 3625 /** 3626 * Sets the _value array. 3627 * @param val The new value for the _value array. 3628 */ 3629 void setValue( const domCg_int3x3 &val ) { _value = val; } 3630 3631 protected: 3632 /** 3633 * Constructor 3634 */ 3635 domInt3x3(DAE& dae) : daeElement(dae), _value() {} 3636 /** 3637 * Destructor 3638 */ 3639 virtual ~domInt3x3() {} 3640 /** 3641 * Overloaded assignment operator 3642 */ 3643 virtual domInt3x3 &operator=( const domInt3x3 &cpy ) { (void)cpy; return *this; } 3644 3645 public: // STATIC METHODS 3646 /** 3647 * Creates an instance of this class and returns a daeElementRef referencing it. 3648 * @return a daeElementRef referencing an instance of this object. 3649 */ 3650 static DLLSPEC daeElementRef create(DAE& dae); 3651 /** 3652 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3653 * If a daeMetaElement already exists it will return that instead of creating a new one. 3654 * @return A daeMetaElement describing this COLLADA element. 3655 */ 3656 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3657 }; 3658 3659 class domInt3x4; 3660 3661 typedef daeSmartRef<domInt3x4> domInt3x4Ref; 3662 typedef daeTArray<domInt3x4Ref> domInt3x4_Array; 3663 3664 class domInt3x4 : public daeElement 3665 { 3666 public: 3667 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT3X4; } 3668 static daeInt ID() { return 439; } 3669 virtual daeInt typeID() const { return ID(); } 3670 3671 protected: // Value 3672 /** 3673 * The domCg_int3x4 value of the text data of this element. 3674 */ 3675 domCg_int3x4 _value; 3676 3677 public: //Accessors and Mutators 3678 /** 3679 * Gets the _value array. 3680 * @return Returns a domCg_int3x4 reference of the _value array. 3681 */ 3682 domCg_int3x4 &getValue() { return _value; } 3683 /** 3684 * Gets the _value array. 3685 * @return Returns a constant domCg_int3x4 reference of the _value array. 3686 */ 3687 const domCg_int3x4 &getValue() const { return _value; } 3688 /** 3689 * Sets the _value array. 3690 * @param val The new value for the _value array. 3691 */ 3692 void setValue( const domCg_int3x4 &val ) { _value = val; } 3693 3694 protected: 3695 /** 3696 * Constructor 3697 */ 3698 domInt3x4(DAE& dae) : daeElement(dae), _value() {} 3699 /** 3700 * Destructor 3701 */ 3702 virtual ~domInt3x4() {} 3703 /** 3704 * Overloaded assignment operator 3705 */ 3706 virtual domInt3x4 &operator=( const domInt3x4 &cpy ) { (void)cpy; return *this; } 3707 3708 public: // STATIC METHODS 3709 /** 3710 * Creates an instance of this class and returns a daeElementRef referencing it. 3711 * @return a daeElementRef referencing an instance of this object. 3712 */ 3713 static DLLSPEC daeElementRef create(DAE& dae); 3714 /** 3715 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3716 * If a daeMetaElement already exists it will return that instead of creating a new one. 3717 * @return A daeMetaElement describing this COLLADA element. 3718 */ 3719 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3720 }; 3721 3722 class domInt4x1; 3723 3724 typedef daeSmartRef<domInt4x1> domInt4x1Ref; 3725 typedef daeTArray<domInt4x1Ref> domInt4x1_Array; 3726 3727 class domInt4x1 : public daeElement 3728 { 3729 public: 3730 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4X1; } 3731 static daeInt ID() { return 440; } 3732 virtual daeInt typeID() const { return ID(); } 3733 3734 protected: // Value 3735 /** 3736 * The domCg_int4x1 value of the text data of this element. 3737 */ 3738 domCg_int4x1 _value; 3739 3740 public: //Accessors and Mutators 3741 /** 3742 * Gets the _value array. 3743 * @return Returns a domCg_int4x1 reference of the _value array. 3744 */ 3745 domCg_int4x1 &getValue() { return _value; } 3746 /** 3747 * Gets the _value array. 3748 * @return Returns a constant domCg_int4x1 reference of the _value array. 3749 */ 3750 const domCg_int4x1 &getValue() const { return _value; } 3751 /** 3752 * Sets the _value array. 3753 * @param val The new value for the _value array. 3754 */ 3755 void setValue( const domCg_int4x1 &val ) { _value = val; } 3756 3757 protected: 3758 /** 3759 * Constructor 3760 */ 3761 domInt4x1(DAE& dae) : daeElement(dae), _value() {} 3762 /** 3763 * Destructor 3764 */ 3765 virtual ~domInt4x1() {} 3766 /** 3767 * Overloaded assignment operator 3768 */ 3769 virtual domInt4x1 &operator=( const domInt4x1 &cpy ) { (void)cpy; return *this; } 3770 3771 public: // STATIC METHODS 3772 /** 3773 * Creates an instance of this class and returns a daeElementRef referencing it. 3774 * @return a daeElementRef referencing an instance of this object. 3775 */ 3776 static DLLSPEC daeElementRef create(DAE& dae); 3777 /** 3778 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3779 * If a daeMetaElement already exists it will return that instead of creating a new one. 3780 * @return A daeMetaElement describing this COLLADA element. 3781 */ 3782 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3783 }; 3784 3785 class domInt4x2; 3786 3787 typedef daeSmartRef<domInt4x2> domInt4x2Ref; 3788 typedef daeTArray<domInt4x2Ref> domInt4x2_Array; 3789 3790 class domInt4x2 : public daeElement 3791 { 3792 public: 3793 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4X2; } 3794 static daeInt ID() { return 441; } 3795 virtual daeInt typeID() const { return ID(); } 3796 3797 protected: // Value 3798 /** 3799 * The domCg_int4x2 value of the text data of this element. 3800 */ 3801 domCg_int4x2 _value; 3802 3803 public: //Accessors and Mutators 3804 /** 3805 * Gets the _value array. 3806 * @return Returns a domCg_int4x2 reference of the _value array. 3807 */ 3808 domCg_int4x2 &getValue() { return _value; } 3809 /** 3810 * Gets the _value array. 3811 * @return Returns a constant domCg_int4x2 reference of the _value array. 3812 */ 3813 const domCg_int4x2 &getValue() const { return _value; } 3814 /** 3815 * Sets the _value array. 3816 * @param val The new value for the _value array. 3817 */ 3818 void setValue( const domCg_int4x2 &val ) { _value = val; } 3819 3820 protected: 3821 /** 3822 * Constructor 3823 */ 3824 domInt4x2(DAE& dae) : daeElement(dae), _value() {} 3825 /** 3826 * Destructor 3827 */ 3828 virtual ~domInt4x2() {} 3829 /** 3830 * Overloaded assignment operator 3831 */ 3832 virtual domInt4x2 &operator=( const domInt4x2 &cpy ) { (void)cpy; return *this; } 3833 3834 public: // STATIC METHODS 3835 /** 3836 * Creates an instance of this class and returns a daeElementRef referencing it. 3837 * @return a daeElementRef referencing an instance of this object. 3838 */ 3839 static DLLSPEC daeElementRef create(DAE& dae); 3840 /** 3841 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3842 * If a daeMetaElement already exists it will return that instead of creating a new one. 3843 * @return A daeMetaElement describing this COLLADA element. 3844 */ 3845 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3846 }; 3847 3848 class domInt4x3; 3849 3850 typedef daeSmartRef<domInt4x3> domInt4x3Ref; 3851 typedef daeTArray<domInt4x3Ref> domInt4x3_Array; 3852 3853 class domInt4x3 : public daeElement 3854 { 3855 public: 3856 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4X3; } 3857 static daeInt ID() { return 442; } 3858 virtual daeInt typeID() const { return ID(); } 3859 3860 protected: // Value 3861 /** 3862 * The domCg_int4x3 value of the text data of this element. 3863 */ 3864 domCg_int4x3 _value; 3865 3866 public: //Accessors and Mutators 3867 /** 3868 * Gets the _value array. 3869 * @return Returns a domCg_int4x3 reference of the _value array. 3870 */ 3871 domCg_int4x3 &getValue() { return _value; } 3872 /** 3873 * Gets the _value array. 3874 * @return Returns a constant domCg_int4x3 reference of the _value array. 3875 */ 3876 const domCg_int4x3 &getValue() const { return _value; } 3877 /** 3878 * Sets the _value array. 3879 * @param val The new value for the _value array. 3880 */ 3881 void setValue( const domCg_int4x3 &val ) { _value = val; } 3882 3883 protected: 3884 /** 3885 * Constructor 3886 */ 3887 domInt4x3(DAE& dae) : daeElement(dae), _value() {} 3888 /** 3889 * Destructor 3890 */ 3891 virtual ~domInt4x3() {} 3892 /** 3893 * Overloaded assignment operator 3894 */ 3895 virtual domInt4x3 &operator=( const domInt4x3 &cpy ) { (void)cpy; return *this; } 3896 3897 public: // STATIC METHODS 3898 /** 3899 * Creates an instance of this class and returns a daeElementRef referencing it. 3900 * @return a daeElementRef referencing an instance of this object. 3901 */ 3902 static DLLSPEC daeElementRef create(DAE& dae); 3903 /** 3904 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3905 * If a daeMetaElement already exists it will return that instead of creating a new one. 3906 * @return A daeMetaElement describing this COLLADA element. 3907 */ 3908 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3909 }; 3910 3911 class domInt4x4; 3912 3913 typedef daeSmartRef<domInt4x4> domInt4x4Ref; 3914 typedef daeTArray<domInt4x4Ref> domInt4x4_Array; 3915 3916 class domInt4x4 : public daeElement 3917 { 3918 public: 3919 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::INT4X4; } 3920 static daeInt ID() { return 443; } 3921 virtual daeInt typeID() const { return ID(); } 3922 3923 protected: // Value 3924 /** 3925 * The domCg_int4x4 value of the text data of this element. 3926 */ 3927 domCg_int4x4 _value; 3928 3929 public: //Accessors and Mutators 3930 /** 3931 * Gets the _value array. 3932 * @return Returns a domCg_int4x4 reference of the _value array. 3933 */ 3934 domCg_int4x4 &getValue() { return _value; } 3935 /** 3936 * Gets the _value array. 3937 * @return Returns a constant domCg_int4x4 reference of the _value array. 3938 */ 3939 const domCg_int4x4 &getValue() const { return _value; } 3940 /** 3941 * Sets the _value array. 3942 * @param val The new value for the _value array. 3943 */ 3944 void setValue( const domCg_int4x4 &val ) { _value = val; } 3945 3946 protected: 3947 /** 3948 * Constructor 3949 */ 3950 domInt4x4(DAE& dae) : daeElement(dae), _value() {} 3951 /** 3952 * Destructor 3953 */ 3954 virtual ~domInt4x4() {} 3955 /** 3956 * Overloaded assignment operator 3957 */ 3958 virtual domInt4x4 &operator=( const domInt4x4 &cpy ) { (void)cpy; return *this; } 3959 3960 public: // STATIC METHODS 3961 /** 3962 * Creates an instance of this class and returns a daeElementRef referencing it. 3963 * @return a daeElementRef referencing an instance of this object. 3964 */ 3965 static DLLSPEC daeElementRef create(DAE& dae); 3966 /** 3967 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3968 * If a daeMetaElement already exists it will return that instead of creating a new one. 3969 * @return A daeMetaElement describing this COLLADA element. 3970 */ 3971 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3972 }; 3973 3974 class domHalf; 3975 3976 typedef daeSmartRef<domHalf> domHalfRef; 3977 typedef daeTArray<domHalfRef> domHalf_Array; 3978 3979 class domHalf : public daeElement 3980 { 3981 public: 3982 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF; } 3983 static daeInt ID() { return 444; } 3984 virtual daeInt typeID() const { return ID(); } 3985 3986 protected: // Value 3987 /** 3988 * The domCg_half value of the text data of this element. 3989 */ 3990 domCg_half _value; 3991 3992 public: //Accessors and Mutators 3993 /** 3994 * Gets the value of this element. 3995 * @return a domCg_half of the value. 3996 */ 3997 domCg_half getValue() const { return _value; } 3998 /** 3999 * Sets the _value of this element. 4000 * @param val The new value for this element. 4001 */ 4002 void setValue( domCg_half val ) { _value = val; } 4003 4004 protected: 4005 /** 4006 * Constructor 4007 */ 4008 domHalf(DAE& dae) : daeElement(dae), _value() {} 4009 /** 4010 * Destructor 4011 */ 4012 virtual ~domHalf() {} 4013 /** 4014 * Overloaded assignment operator 4015 */ 4016 virtual domHalf &operator=( const domHalf &cpy ) { (void)cpy; return *this; } 4017 4018 public: // STATIC METHODS 4019 /** 4020 * Creates an instance of this class and returns a daeElementRef referencing it. 4021 * @return a daeElementRef referencing an instance of this object. 4022 */ 4023 static DLLSPEC daeElementRef create(DAE& dae); 4024 /** 4025 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4026 * If a daeMetaElement already exists it will return that instead of creating a new one. 4027 * @return A daeMetaElement describing this COLLADA element. 4028 */ 4029 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4030 }; 4031 4032 class domHalf1; 4033 4034 typedef daeSmartRef<domHalf1> domHalf1Ref; 4035 typedef daeTArray<domHalf1Ref> domHalf1_Array; 4036 4037 class domHalf1 : public daeElement 4038 { 4039 public: 4040 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF1; } 4041 static daeInt ID() { return 445; } 4042 virtual daeInt typeID() const { return ID(); } 4043 4044 protected: // Value 4045 /** 4046 * The domCg_half1 value of the text data of this element. 4047 */ 4048 domCg_half1 _value; 4049 4050 public: //Accessors and Mutators 4051 /** 4052 * Gets the value of this element. 4053 * @return a domCg_half1 of the value. 4054 */ 4055 domCg_half1 getValue() const { return _value; } 4056 /** 4057 * Sets the _value of this element. 4058 * @param val The new value for this element. 4059 */ 4060 void setValue( domCg_half1 val ) { _value = val; } 4061 4062 protected: 4063 /** 4064 * Constructor 4065 */ 4066 domHalf1(DAE& dae) : daeElement(dae), _value() {} 4067 /** 4068 * Destructor 4069 */ 4070 virtual ~domHalf1() {} 4071 /** 4072 * Overloaded assignment operator 4073 */ 4074 virtual domHalf1 &operator=( const domHalf1 &cpy ) { (void)cpy; return *this; } 4075 4076 public: // STATIC METHODS 4077 /** 4078 * Creates an instance of this class and returns a daeElementRef referencing it. 4079 * @return a daeElementRef referencing an instance of this object. 4080 */ 4081 static DLLSPEC daeElementRef create(DAE& dae); 4082 /** 4083 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4084 * If a daeMetaElement already exists it will return that instead of creating a new one. 4085 * @return A daeMetaElement describing this COLLADA element. 4086 */ 4087 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4088 }; 4089 4090 class domHalf2; 4091 4092 typedef daeSmartRef<domHalf2> domHalf2Ref; 4093 typedef daeTArray<domHalf2Ref> domHalf2_Array; 4094 4095 class domHalf2 : public daeElement 4096 { 4097 public: 4098 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF2; } 4099 static daeInt ID() { return 446; } 4100 virtual daeInt typeID() const { return ID(); } 4101 4102 protected: // Value 4103 /** 4104 * The domCg_half2 value of the text data of this element. 4105 */ 4106 domCg_half2 _value; 4107 4108 public: //Accessors and Mutators 4109 /** 4110 * Gets the _value array. 4111 * @return Returns a domCg_half2 reference of the _value array. 4112 */ 4113 domCg_half2 &getValue() { return _value; } 4114 /** 4115 * Gets the _value array. 4116 * @return Returns a constant domCg_half2 reference of the _value array. 4117 */ 4118 const domCg_half2 &getValue() const { return _value; } 4119 /** 4120 * Sets the _value array. 4121 * @param val The new value for the _value array. 4122 */ 4123 void setValue( const domCg_half2 &val ) { _value = val; } 4124 4125 protected: 4126 /** 4127 * Constructor 4128 */ 4129 domHalf2(DAE& dae) : daeElement(dae), _value() {} 4130 /** 4131 * Destructor 4132 */ 4133 virtual ~domHalf2() {} 4134 /** 4135 * Overloaded assignment operator 4136 */ 4137 virtual domHalf2 &operator=( const domHalf2 &cpy ) { (void)cpy; return *this; } 4138 4139 public: // STATIC METHODS 4140 /** 4141 * Creates an instance of this class and returns a daeElementRef referencing it. 4142 * @return a daeElementRef referencing an instance of this object. 4143 */ 4144 static DLLSPEC daeElementRef create(DAE& dae); 4145 /** 4146 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4147 * If a daeMetaElement already exists it will return that instead of creating a new one. 4148 * @return A daeMetaElement describing this COLLADA element. 4149 */ 4150 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4151 }; 4152 4153 class domHalf3; 4154 4155 typedef daeSmartRef<domHalf3> domHalf3Ref; 4156 typedef daeTArray<domHalf3Ref> domHalf3_Array; 4157 4158 class domHalf3 : public daeElement 4159 { 4160 public: 4161 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF3; } 4162 static daeInt ID() { return 447; } 4163 virtual daeInt typeID() const { return ID(); } 4164 4165 protected: // Value 4166 /** 4167 * The domCg_half3 value of the text data of this element. 4168 */ 4169 domCg_half3 _value; 4170 4171 public: //Accessors and Mutators 4172 /** 4173 * Gets the _value array. 4174 * @return Returns a domCg_half3 reference of the _value array. 4175 */ 4176 domCg_half3 &getValue() { return _value; } 4177 /** 4178 * Gets the _value array. 4179 * @return Returns a constant domCg_half3 reference of the _value array. 4180 */ 4181 const domCg_half3 &getValue() const { return _value; } 4182 /** 4183 * Sets the _value array. 4184 * @param val The new value for the _value array. 4185 */ 4186 void setValue( const domCg_half3 &val ) { _value = val; } 4187 4188 protected: 4189 /** 4190 * Constructor 4191 */ 4192 domHalf3(DAE& dae) : daeElement(dae), _value() {} 4193 /** 4194 * Destructor 4195 */ 4196 virtual ~domHalf3() {} 4197 /** 4198 * Overloaded assignment operator 4199 */ 4200 virtual domHalf3 &operator=( const domHalf3 &cpy ) { (void)cpy; return *this; } 4201 4202 public: // STATIC METHODS 4203 /** 4204 * Creates an instance of this class and returns a daeElementRef referencing it. 4205 * @return a daeElementRef referencing an instance of this object. 4206 */ 4207 static DLLSPEC daeElementRef create(DAE& dae); 4208 /** 4209 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4210 * If a daeMetaElement already exists it will return that instead of creating a new one. 4211 * @return A daeMetaElement describing this COLLADA element. 4212 */ 4213 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4214 }; 4215 4216 class domHalf4; 4217 4218 typedef daeSmartRef<domHalf4> domHalf4Ref; 4219 typedef daeTArray<domHalf4Ref> domHalf4_Array; 4220 4221 class domHalf4 : public daeElement 4222 { 4223 public: 4224 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF4; } 4225 static daeInt ID() { return 448; } 4226 virtual daeInt typeID() const { return ID(); } 4227 4228 protected: // Value 4229 /** 4230 * The domCg_half4 value of the text data of this element. 4231 */ 4232 domCg_half4 _value; 4233 4234 public: //Accessors and Mutators 4235 /** 4236 * Gets the _value array. 4237 * @return Returns a domCg_half4 reference of the _value array. 4238 */ 4239 domCg_half4 &getValue() { return _value; } 4240 /** 4241 * Gets the _value array. 4242 * @return Returns a constant domCg_half4 reference of the _value array. 4243 */ 4244 const domCg_half4 &getValue() const { return _value; } 4245 /** 4246 * Sets the _value array. 4247 * @param val The new value for the _value array. 4248 */ 4249 void setValue( const domCg_half4 &val ) { _value = val; } 4250 4251 protected: 4252 /** 4253 * Constructor 4254 */ 4255 domHalf4(DAE& dae) : daeElement(dae), _value() {} 4256 /** 4257 * Destructor 4258 */ 4259 virtual ~domHalf4() {} 4260 /** 4261 * Overloaded assignment operator 4262 */ 4263 virtual domHalf4 &operator=( const domHalf4 &cpy ) { (void)cpy; return *this; } 4264 4265 public: // STATIC METHODS 4266 /** 4267 * Creates an instance of this class and returns a daeElementRef referencing it. 4268 * @return a daeElementRef referencing an instance of this object. 4269 */ 4270 static DLLSPEC daeElementRef create(DAE& dae); 4271 /** 4272 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4273 * If a daeMetaElement already exists it will return that instead of creating a new one. 4274 * @return A daeMetaElement describing this COLLADA element. 4275 */ 4276 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4277 }; 4278 4279 class domHalf1x1; 4280 4281 typedef daeSmartRef<domHalf1x1> domHalf1x1Ref; 4282 typedef daeTArray<domHalf1x1Ref> domHalf1x1_Array; 4283 4284 class domHalf1x1 : public daeElement 4285 { 4286 public: 4287 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF1X1; } 4288 static daeInt ID() { return 449; } 4289 virtual daeInt typeID() const { return ID(); } 4290 4291 protected: // Value 4292 /** 4293 * The domCg_half1x1 value of the text data of this element. 4294 */ 4295 domCg_half1x1 _value; 4296 4297 public: //Accessors and Mutators 4298 /** 4299 * Gets the _value array. 4300 * @return Returns a domCg_half1x1 reference of the _value array. 4301 */ 4302 domCg_half1x1 &getValue() { return _value; } 4303 /** 4304 * Gets the _value array. 4305 * @return Returns a constant domCg_half1x1 reference of the _value array. 4306 */ 4307 const domCg_half1x1 &getValue() const { return _value; } 4308 /** 4309 * Sets the _value array. 4310 * @param val The new value for the _value array. 4311 */ 4312 void setValue( const domCg_half1x1 &val ) { _value = val; } 4313 4314 protected: 4315 /** 4316 * Constructor 4317 */ 4318 domHalf1x1(DAE& dae) : daeElement(dae), _value() {} 4319 /** 4320 * Destructor 4321 */ 4322 virtual ~domHalf1x1() {} 4323 /** 4324 * Overloaded assignment operator 4325 */ 4326 virtual domHalf1x1 &operator=( const domHalf1x1 &cpy ) { (void)cpy; return *this; } 4327 4328 public: // STATIC METHODS 4329 /** 4330 * Creates an instance of this class and returns a daeElementRef referencing it. 4331 * @return a daeElementRef referencing an instance of this object. 4332 */ 4333 static DLLSPEC daeElementRef create(DAE& dae); 4334 /** 4335 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4336 * If a daeMetaElement already exists it will return that instead of creating a new one. 4337 * @return A daeMetaElement describing this COLLADA element. 4338 */ 4339 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4340 }; 4341 4342 class domHalf1x2; 4343 4344 typedef daeSmartRef<domHalf1x2> domHalf1x2Ref; 4345 typedef daeTArray<domHalf1x2Ref> domHalf1x2_Array; 4346 4347 class domHalf1x2 : public daeElement 4348 { 4349 public: 4350 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF1X2; } 4351 static daeInt ID() { return 450; } 4352 virtual daeInt typeID() const { return ID(); } 4353 4354 protected: // Value 4355 /** 4356 * The domCg_half1x2 value of the text data of this element. 4357 */ 4358 domCg_half1x2 _value; 4359 4360 public: //Accessors and Mutators 4361 /** 4362 * Gets the _value array. 4363 * @return Returns a domCg_half1x2 reference of the _value array. 4364 */ 4365 domCg_half1x2 &getValue() { return _value; } 4366 /** 4367 * Gets the _value array. 4368 * @return Returns a constant domCg_half1x2 reference of the _value array. 4369 */ 4370 const domCg_half1x2 &getValue() const { return _value; } 4371 /** 4372 * Sets the _value array. 4373 * @param val The new value for the _value array. 4374 */ 4375 void setValue( const domCg_half1x2 &val ) { _value = val; } 4376 4377 protected: 4378 /** 4379 * Constructor 4380 */ 4381 domHalf1x2(DAE& dae) : daeElement(dae), _value() {} 4382 /** 4383 * Destructor 4384 */ 4385 virtual ~domHalf1x2() {} 4386 /** 4387 * Overloaded assignment operator 4388 */ 4389 virtual domHalf1x2 &operator=( const domHalf1x2 &cpy ) { (void)cpy; return *this; } 4390 4391 public: // STATIC METHODS 4392 /** 4393 * Creates an instance of this class and returns a daeElementRef referencing it. 4394 * @return a daeElementRef referencing an instance of this object. 4395 */ 4396 static DLLSPEC daeElementRef create(DAE& dae); 4397 /** 4398 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4399 * If a daeMetaElement already exists it will return that instead of creating a new one. 4400 * @return A daeMetaElement describing this COLLADA element. 4401 */ 4402 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4403 }; 4404 4405 class domHalf1x3; 4406 4407 typedef daeSmartRef<domHalf1x3> domHalf1x3Ref; 4408 typedef daeTArray<domHalf1x3Ref> domHalf1x3_Array; 4409 4410 class domHalf1x3 : public daeElement 4411 { 4412 public: 4413 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF1X3; } 4414 static daeInt ID() { return 451; } 4415 virtual daeInt typeID() const { return ID(); } 4416 4417 protected: // Value 4418 /** 4419 * The domCg_half1x3 value of the text data of this element. 4420 */ 4421 domCg_half1x3 _value; 4422 4423 public: //Accessors and Mutators 4424 /** 4425 * Gets the _value array. 4426 * @return Returns a domCg_half1x3 reference of the _value array. 4427 */ 4428 domCg_half1x3 &getValue() { return _value; } 4429 /** 4430 * Gets the _value array. 4431 * @return Returns a constant domCg_half1x3 reference of the _value array. 4432 */ 4433 const domCg_half1x3 &getValue() const { return _value; } 4434 /** 4435 * Sets the _value array. 4436 * @param val The new value for the _value array. 4437 */ 4438 void setValue( const domCg_half1x3 &val ) { _value = val; } 4439 4440 protected: 4441 /** 4442 * Constructor 4443 */ 4444 domHalf1x3(DAE& dae) : daeElement(dae), _value() {} 4445 /** 4446 * Destructor 4447 */ 4448 virtual ~domHalf1x3() {} 4449 /** 4450 * Overloaded assignment operator 4451 */ 4452 virtual domHalf1x3 &operator=( const domHalf1x3 &cpy ) { (void)cpy; return *this; } 4453 4454 public: // STATIC METHODS 4455 /** 4456 * Creates an instance of this class and returns a daeElementRef referencing it. 4457 * @return a daeElementRef referencing an instance of this object. 4458 */ 4459 static DLLSPEC daeElementRef create(DAE& dae); 4460 /** 4461 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4462 * If a daeMetaElement already exists it will return that instead of creating a new one. 4463 * @return A daeMetaElement describing this COLLADA element. 4464 */ 4465 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4466 }; 4467 4468 class domHalf1x4; 4469 4470 typedef daeSmartRef<domHalf1x4> domHalf1x4Ref; 4471 typedef daeTArray<domHalf1x4Ref> domHalf1x4_Array; 4472 4473 class domHalf1x4 : public daeElement 4474 { 4475 public: 4476 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF1X4; } 4477 static daeInt ID() { return 452; } 4478 virtual daeInt typeID() const { return ID(); } 4479 4480 protected: // Value 4481 /** 4482 * The domCg_half1x4 value of the text data of this element. 4483 */ 4484 domCg_half1x4 _value; 4485 4486 public: //Accessors and Mutators 4487 /** 4488 * Gets the _value array. 4489 * @return Returns a domCg_half1x4 reference of the _value array. 4490 */ 4491 domCg_half1x4 &getValue() { return _value; } 4492 /** 4493 * Gets the _value array. 4494 * @return Returns a constant domCg_half1x4 reference of the _value array. 4495 */ 4496 const domCg_half1x4 &getValue() const { return _value; } 4497 /** 4498 * Sets the _value array. 4499 * @param val The new value for the _value array. 4500 */ 4501 void setValue( const domCg_half1x4 &val ) { _value = val; } 4502 4503 protected: 4504 /** 4505 * Constructor 4506 */ 4507 domHalf1x4(DAE& dae) : daeElement(dae), _value() {} 4508 /** 4509 * Destructor 4510 */ 4511 virtual ~domHalf1x4() {} 4512 /** 4513 * Overloaded assignment operator 4514 */ 4515 virtual domHalf1x4 &operator=( const domHalf1x4 &cpy ) { (void)cpy; return *this; } 4516 4517 public: // STATIC METHODS 4518 /** 4519 * Creates an instance of this class and returns a daeElementRef referencing it. 4520 * @return a daeElementRef referencing an instance of this object. 4521 */ 4522 static DLLSPEC daeElementRef create(DAE& dae); 4523 /** 4524 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4525 * If a daeMetaElement already exists it will return that instead of creating a new one. 4526 * @return A daeMetaElement describing this COLLADA element. 4527 */ 4528 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4529 }; 4530 4531 class domHalf2x1; 4532 4533 typedef daeSmartRef<domHalf2x1> domHalf2x1Ref; 4534 typedef daeTArray<domHalf2x1Ref> domHalf2x1_Array; 4535 4536 class domHalf2x1 : public daeElement 4537 { 4538 public: 4539 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF2X1; } 4540 static daeInt ID() { return 453; } 4541 virtual daeInt typeID() const { return ID(); } 4542 4543 protected: // Value 4544 /** 4545 * The domCg_half2x1 value of the text data of this element. 4546 */ 4547 domCg_half2x1 _value; 4548 4549 public: //Accessors and Mutators 4550 /** 4551 * Gets the _value array. 4552 * @return Returns a domCg_half2x1 reference of the _value array. 4553 */ 4554 domCg_half2x1 &getValue() { return _value; } 4555 /** 4556 * Gets the _value array. 4557 * @return Returns a constant domCg_half2x1 reference of the _value array. 4558 */ 4559 const domCg_half2x1 &getValue() const { return _value; } 4560 /** 4561 * Sets the _value array. 4562 * @param val The new value for the _value array. 4563 */ 4564 void setValue( const domCg_half2x1 &val ) { _value = val; } 4565 4566 protected: 4567 /** 4568 * Constructor 4569 */ 4570 domHalf2x1(DAE& dae) : daeElement(dae), _value() {} 4571 /** 4572 * Destructor 4573 */ 4574 virtual ~domHalf2x1() {} 4575 /** 4576 * Overloaded assignment operator 4577 */ 4578 virtual domHalf2x1 &operator=( const domHalf2x1 &cpy ) { (void)cpy; return *this; } 4579 4580 public: // STATIC METHODS 4581 /** 4582 * Creates an instance of this class and returns a daeElementRef referencing it. 4583 * @return a daeElementRef referencing an instance of this object. 4584 */ 4585 static DLLSPEC daeElementRef create(DAE& dae); 4586 /** 4587 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4588 * If a daeMetaElement already exists it will return that instead of creating a new one. 4589 * @return A daeMetaElement describing this COLLADA element. 4590 */ 4591 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4592 }; 4593 4594 class domHalf2x2; 4595 4596 typedef daeSmartRef<domHalf2x2> domHalf2x2Ref; 4597 typedef daeTArray<domHalf2x2Ref> domHalf2x2_Array; 4598 4599 class domHalf2x2 : public daeElement 4600 { 4601 public: 4602 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF2X2; } 4603 static daeInt ID() { return 454; } 4604 virtual daeInt typeID() const { return ID(); } 4605 4606 protected: // Value 4607 /** 4608 * The domCg_half2x2 value of the text data of this element. 4609 */ 4610 domCg_half2x2 _value; 4611 4612 public: //Accessors and Mutators 4613 /** 4614 * Gets the _value array. 4615 * @return Returns a domCg_half2x2 reference of the _value array. 4616 */ 4617 domCg_half2x2 &getValue() { return _value; } 4618 /** 4619 * Gets the _value array. 4620 * @return Returns a constant domCg_half2x2 reference of the _value array. 4621 */ 4622 const domCg_half2x2 &getValue() const { return _value; } 4623 /** 4624 * Sets the _value array. 4625 * @param val The new value for the _value array. 4626 */ 4627 void setValue( const domCg_half2x2 &val ) { _value = val; } 4628 4629 protected: 4630 /** 4631 * Constructor 4632 */ 4633 domHalf2x2(DAE& dae) : daeElement(dae), _value() {} 4634 /** 4635 * Destructor 4636 */ 4637 virtual ~domHalf2x2() {} 4638 /** 4639 * Overloaded assignment operator 4640 */ 4641 virtual domHalf2x2 &operator=( const domHalf2x2 &cpy ) { (void)cpy; return *this; } 4642 4643 public: // STATIC METHODS 4644 /** 4645 * Creates an instance of this class and returns a daeElementRef referencing it. 4646 * @return a daeElementRef referencing an instance of this object. 4647 */ 4648 static DLLSPEC daeElementRef create(DAE& dae); 4649 /** 4650 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4651 * If a daeMetaElement already exists it will return that instead of creating a new one. 4652 * @return A daeMetaElement describing this COLLADA element. 4653 */ 4654 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4655 }; 4656 4657 class domHalf2x3; 4658 4659 typedef daeSmartRef<domHalf2x3> domHalf2x3Ref; 4660 typedef daeTArray<domHalf2x3Ref> domHalf2x3_Array; 4661 4662 class domHalf2x3 : public daeElement 4663 { 4664 public: 4665 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF2X3; } 4666 static daeInt ID() { return 455; } 4667 virtual daeInt typeID() const { return ID(); } 4668 4669 protected: // Value 4670 /** 4671 * The domCg_half2x3 value of the text data of this element. 4672 */ 4673 domCg_half2x3 _value; 4674 4675 public: //Accessors and Mutators 4676 /** 4677 * Gets the _value array. 4678 * @return Returns a domCg_half2x3 reference of the _value array. 4679 */ 4680 domCg_half2x3 &getValue() { return _value; } 4681 /** 4682 * Gets the _value array. 4683 * @return Returns a constant domCg_half2x3 reference of the _value array. 4684 */ 4685 const domCg_half2x3 &getValue() const { return _value; } 4686 /** 4687 * Sets the _value array. 4688 * @param val The new value for the _value array. 4689 */ 4690 void setValue( const domCg_half2x3 &val ) { _value = val; } 4691 4692 protected: 4693 /** 4694 * Constructor 4695 */ 4696 domHalf2x3(DAE& dae) : daeElement(dae), _value() {} 4697 /** 4698 * Destructor 4699 */ 4700 virtual ~domHalf2x3() {} 4701 /** 4702 * Overloaded assignment operator 4703 */ 4704 virtual domHalf2x3 &operator=( const domHalf2x3 &cpy ) { (void)cpy; return *this; } 4705 4706 public: // STATIC METHODS 4707 /** 4708 * Creates an instance of this class and returns a daeElementRef referencing it. 4709 * @return a daeElementRef referencing an instance of this object. 4710 */ 4711 static DLLSPEC daeElementRef create(DAE& dae); 4712 /** 4713 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4714 * If a daeMetaElement already exists it will return that instead of creating a new one. 4715 * @return A daeMetaElement describing this COLLADA element. 4716 */ 4717 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4718 }; 4719 4720 class domHalf2x4; 4721 4722 typedef daeSmartRef<domHalf2x4> domHalf2x4Ref; 4723 typedef daeTArray<domHalf2x4Ref> domHalf2x4_Array; 4724 4725 class domHalf2x4 : public daeElement 4726 { 4727 public: 4728 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF2X4; } 4729 static daeInt ID() { return 456; } 4730 virtual daeInt typeID() const { return ID(); } 4731 4732 protected: // Value 4733 /** 4734 * The domCg_half2x4 value of the text data of this element. 4735 */ 4736 domCg_half2x4 _value; 4737 4738 public: //Accessors and Mutators 4739 /** 4740 * Gets the _value array. 4741 * @return Returns a domCg_half2x4 reference of the _value array. 4742 */ 4743 domCg_half2x4 &getValue() { return _value; } 4744 /** 4745 * Gets the _value array. 4746 * @return Returns a constant domCg_half2x4 reference of the _value array. 4747 */ 4748 const domCg_half2x4 &getValue() const { return _value; } 4749 /** 4750 * Sets the _value array. 4751 * @param val The new value for the _value array. 4752 */ 4753 void setValue( const domCg_half2x4 &val ) { _value = val; } 4754 4755 protected: 4756 /** 4757 * Constructor 4758 */ 4759 domHalf2x4(DAE& dae) : daeElement(dae), _value() {} 4760 /** 4761 * Destructor 4762 */ 4763 virtual ~domHalf2x4() {} 4764 /** 4765 * Overloaded assignment operator 4766 */ 4767 virtual domHalf2x4 &operator=( const domHalf2x4 &cpy ) { (void)cpy; return *this; } 4768 4769 public: // STATIC METHODS 4770 /** 4771 * Creates an instance of this class and returns a daeElementRef referencing it. 4772 * @return a daeElementRef referencing an instance of this object. 4773 */ 4774 static DLLSPEC daeElementRef create(DAE& dae); 4775 /** 4776 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4777 * If a daeMetaElement already exists it will return that instead of creating a new one. 4778 * @return A daeMetaElement describing this COLLADA element. 4779 */ 4780 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4781 }; 4782 4783 class domHalf3x1; 4784 4785 typedef daeSmartRef<domHalf3x1> domHalf3x1Ref; 4786 typedef daeTArray<domHalf3x1Ref> domHalf3x1_Array; 4787 4788 class domHalf3x1 : public daeElement 4789 { 4790 public: 4791 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF3X1; } 4792 static daeInt ID() { return 457; } 4793 virtual daeInt typeID() const { return ID(); } 4794 4795 protected: // Value 4796 /** 4797 * The domCg_half3x1 value of the text data of this element. 4798 */ 4799 domCg_half3x1 _value; 4800 4801 public: //Accessors and Mutators 4802 /** 4803 * Gets the _value array. 4804 * @return Returns a domCg_half3x1 reference of the _value array. 4805 */ 4806 domCg_half3x1 &getValue() { return _value; } 4807 /** 4808 * Gets the _value array. 4809 * @return Returns a constant domCg_half3x1 reference of the _value array. 4810 */ 4811 const domCg_half3x1 &getValue() const { return _value; } 4812 /** 4813 * Sets the _value array. 4814 * @param val The new value for the _value array. 4815 */ 4816 void setValue( const domCg_half3x1 &val ) { _value = val; } 4817 4818 protected: 4819 /** 4820 * Constructor 4821 */ 4822 domHalf3x1(DAE& dae) : daeElement(dae), _value() {} 4823 /** 4824 * Destructor 4825 */ 4826 virtual ~domHalf3x1() {} 4827 /** 4828 * Overloaded assignment operator 4829 */ 4830 virtual domHalf3x1 &operator=( const domHalf3x1 &cpy ) { (void)cpy; return *this; } 4831 4832 public: // STATIC METHODS 4833 /** 4834 * Creates an instance of this class and returns a daeElementRef referencing it. 4835 * @return a daeElementRef referencing an instance of this object. 4836 */ 4837 static DLLSPEC daeElementRef create(DAE& dae); 4838 /** 4839 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4840 * If a daeMetaElement already exists it will return that instead of creating a new one. 4841 * @return A daeMetaElement describing this COLLADA element. 4842 */ 4843 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4844 }; 4845 4846 class domHalf3x2; 4847 4848 typedef daeSmartRef<domHalf3x2> domHalf3x2Ref; 4849 typedef daeTArray<domHalf3x2Ref> domHalf3x2_Array; 4850 4851 class domHalf3x2 : public daeElement 4852 { 4853 public: 4854 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF3X2; } 4855 static daeInt ID() { return 458; } 4856 virtual daeInt typeID() const { return ID(); } 4857 4858 protected: // Value 4859 /** 4860 * The domCg_half3x2 value of the text data of this element. 4861 */ 4862 domCg_half3x2 _value; 4863 4864 public: //Accessors and Mutators 4865 /** 4866 * Gets the _value array. 4867 * @return Returns a domCg_half3x2 reference of the _value array. 4868 */ 4869 domCg_half3x2 &getValue() { return _value; } 4870 /** 4871 * Gets the _value array. 4872 * @return Returns a constant domCg_half3x2 reference of the _value array. 4873 */ 4874 const domCg_half3x2 &getValue() const { return _value; } 4875 /** 4876 * Sets the _value array. 4877 * @param val The new value for the _value array. 4878 */ 4879 void setValue( const domCg_half3x2 &val ) { _value = val; } 4880 4881 protected: 4882 /** 4883 * Constructor 4884 */ 4885 domHalf3x2(DAE& dae) : daeElement(dae), _value() {} 4886 /** 4887 * Destructor 4888 */ 4889 virtual ~domHalf3x2() {} 4890 /** 4891 * Overloaded assignment operator 4892 */ 4893 virtual domHalf3x2 &operator=( const domHalf3x2 &cpy ) { (void)cpy; return *this; } 4894 4895 public: // STATIC METHODS 4896 /** 4897 * Creates an instance of this class and returns a daeElementRef referencing it. 4898 * @return a daeElementRef referencing an instance of this object. 4899 */ 4900 static DLLSPEC daeElementRef create(DAE& dae); 4901 /** 4902 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4903 * If a daeMetaElement already exists it will return that instead of creating a new one. 4904 * @return A daeMetaElement describing this COLLADA element. 4905 */ 4906 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4907 }; 4908 4909 class domHalf3x3; 4910 4911 typedef daeSmartRef<domHalf3x3> domHalf3x3Ref; 4912 typedef daeTArray<domHalf3x3Ref> domHalf3x3_Array; 4913 4914 class domHalf3x3 : public daeElement 4915 { 4916 public: 4917 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF3X3; } 4918 static daeInt ID() { return 459; } 4919 virtual daeInt typeID() const { return ID(); } 4920 4921 protected: // Value 4922 /** 4923 * The domCg_half3x3 value of the text data of this element. 4924 */ 4925 domCg_half3x3 _value; 4926 4927 public: //Accessors and Mutators 4928 /** 4929 * Gets the _value array. 4930 * @return Returns a domCg_half3x3 reference of the _value array. 4931 */ 4932 domCg_half3x3 &getValue() { return _value; } 4933 /** 4934 * Gets the _value array. 4935 * @return Returns a constant domCg_half3x3 reference of the _value array. 4936 */ 4937 const domCg_half3x3 &getValue() const { return _value; } 4938 /** 4939 * Sets the _value array. 4940 * @param val The new value for the _value array. 4941 */ 4942 void setValue( const domCg_half3x3 &val ) { _value = val; } 4943 4944 protected: 4945 /** 4946 * Constructor 4947 */ 4948 domHalf3x3(DAE& dae) : daeElement(dae), _value() {} 4949 /** 4950 * Destructor 4951 */ 4952 virtual ~domHalf3x3() {} 4953 /** 4954 * Overloaded assignment operator 4955 */ 4956 virtual domHalf3x3 &operator=( const domHalf3x3 &cpy ) { (void)cpy; return *this; } 4957 4958 public: // STATIC METHODS 4959 /** 4960 * Creates an instance of this class and returns a daeElementRef referencing it. 4961 * @return a daeElementRef referencing an instance of this object. 4962 */ 4963 static DLLSPEC daeElementRef create(DAE& dae); 4964 /** 4965 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4966 * If a daeMetaElement already exists it will return that instead of creating a new one. 4967 * @return A daeMetaElement describing this COLLADA element. 4968 */ 4969 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4970 }; 4971 4972 class domHalf3x4; 4973 4974 typedef daeSmartRef<domHalf3x4> domHalf3x4Ref; 4975 typedef daeTArray<domHalf3x4Ref> domHalf3x4_Array; 4976 4977 class domHalf3x4 : public daeElement 4978 { 4979 public: 4980 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF3X4; } 4981 static daeInt ID() { return 460; } 4982 virtual daeInt typeID() const { return ID(); } 4983 4984 protected: // Value 4985 /** 4986 * The domCg_half3x4 value of the text data of this element. 4987 */ 4988 domCg_half3x4 _value; 4989 4990 public: //Accessors and Mutators 4991 /** 4992 * Gets the _value array. 4993 * @return Returns a domCg_half3x4 reference of the _value array. 4994 */ 4995 domCg_half3x4 &getValue() { return _value; } 4996 /** 4997 * Gets the _value array. 4998 * @return Returns a constant domCg_half3x4 reference of the _value array. 4999 */ 5000 const domCg_half3x4 &getValue() const { return _value; } 5001 /** 5002 * Sets the _value array. 5003 * @param val The new value for the _value array. 5004 */ 5005 void setValue( const domCg_half3x4 &val ) { _value = val; } 5006 5007 protected: 5008 /** 5009 * Constructor 5010 */ 5011 domHalf3x4(DAE& dae) : daeElement(dae), _value() {} 5012 /** 5013 * Destructor 5014 */ 5015 virtual ~domHalf3x4() {} 5016 /** 5017 * Overloaded assignment operator 5018 */ 5019 virtual domHalf3x4 &operator=( const domHalf3x4 &cpy ) { (void)cpy; return *this; } 5020 5021 public: // STATIC METHODS 5022 /** 5023 * Creates an instance of this class and returns a daeElementRef referencing it. 5024 * @return a daeElementRef referencing an instance of this object. 5025 */ 5026 static DLLSPEC daeElementRef create(DAE& dae); 5027 /** 5028 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5029 * If a daeMetaElement already exists it will return that instead of creating a new one. 5030 * @return A daeMetaElement describing this COLLADA element. 5031 */ 5032 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5033 }; 5034 5035 class domHalf4x1; 5036 5037 typedef daeSmartRef<domHalf4x1> domHalf4x1Ref; 5038 typedef daeTArray<domHalf4x1Ref> domHalf4x1_Array; 5039 5040 class domHalf4x1 : public daeElement 5041 { 5042 public: 5043 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF4X1; } 5044 static daeInt ID() { return 461; } 5045 virtual daeInt typeID() const { return ID(); } 5046 5047 protected: // Value 5048 /** 5049 * The domCg_half4x1 value of the text data of this element. 5050 */ 5051 domCg_half4x1 _value; 5052 5053 public: //Accessors and Mutators 5054 /** 5055 * Gets the _value array. 5056 * @return Returns a domCg_half4x1 reference of the _value array. 5057 */ 5058 domCg_half4x1 &getValue() { return _value; } 5059 /** 5060 * Gets the _value array. 5061 * @return Returns a constant domCg_half4x1 reference of the _value array. 5062 */ 5063 const domCg_half4x1 &getValue() const { return _value; } 5064 /** 5065 * Sets the _value array. 5066 * @param val The new value for the _value array. 5067 */ 5068 void setValue( const domCg_half4x1 &val ) { _value = val; } 5069 5070 protected: 5071 /** 5072 * Constructor 5073 */ 5074 domHalf4x1(DAE& dae) : daeElement(dae), _value() {} 5075 /** 5076 * Destructor 5077 */ 5078 virtual ~domHalf4x1() {} 5079 /** 5080 * Overloaded assignment operator 5081 */ 5082 virtual domHalf4x1 &operator=( const domHalf4x1 &cpy ) { (void)cpy; return *this; } 5083 5084 public: // STATIC METHODS 5085 /** 5086 * Creates an instance of this class and returns a daeElementRef referencing it. 5087 * @return a daeElementRef referencing an instance of this object. 5088 */ 5089 static DLLSPEC daeElementRef create(DAE& dae); 5090 /** 5091 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5092 * If a daeMetaElement already exists it will return that instead of creating a new one. 5093 * @return A daeMetaElement describing this COLLADA element. 5094 */ 5095 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5096 }; 5097 5098 class domHalf4x2; 5099 5100 typedef daeSmartRef<domHalf4x2> domHalf4x2Ref; 5101 typedef daeTArray<domHalf4x2Ref> domHalf4x2_Array; 5102 5103 class domHalf4x2 : public daeElement 5104 { 5105 public: 5106 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF4X2; } 5107 static daeInt ID() { return 462; } 5108 virtual daeInt typeID() const { return ID(); } 5109 5110 protected: // Value 5111 /** 5112 * The domCg_half4x2 value of the text data of this element. 5113 */ 5114 domCg_half4x2 _value; 5115 5116 public: //Accessors and Mutators 5117 /** 5118 * Gets the _value array. 5119 * @return Returns a domCg_half4x2 reference of the _value array. 5120 */ 5121 domCg_half4x2 &getValue() { return _value; } 5122 /** 5123 * Gets the _value array. 5124 * @return Returns a constant domCg_half4x2 reference of the _value array. 5125 */ 5126 const domCg_half4x2 &getValue() const { return _value; } 5127 /** 5128 * Sets the _value array. 5129 * @param val The new value for the _value array. 5130 */ 5131 void setValue( const domCg_half4x2 &val ) { _value = val; } 5132 5133 protected: 5134 /** 5135 * Constructor 5136 */ 5137 domHalf4x2(DAE& dae) : daeElement(dae), _value() {} 5138 /** 5139 * Destructor 5140 */ 5141 virtual ~domHalf4x2() {} 5142 /** 5143 * Overloaded assignment operator 5144 */ 5145 virtual domHalf4x2 &operator=( const domHalf4x2 &cpy ) { (void)cpy; return *this; } 5146 5147 public: // STATIC METHODS 5148 /** 5149 * Creates an instance of this class and returns a daeElementRef referencing it. 5150 * @return a daeElementRef referencing an instance of this object. 5151 */ 5152 static DLLSPEC daeElementRef create(DAE& dae); 5153 /** 5154 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5155 * If a daeMetaElement already exists it will return that instead of creating a new one. 5156 * @return A daeMetaElement describing this COLLADA element. 5157 */ 5158 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5159 }; 5160 5161 class domHalf4x3; 5162 5163 typedef daeSmartRef<domHalf4x3> domHalf4x3Ref; 5164 typedef daeTArray<domHalf4x3Ref> domHalf4x3_Array; 5165 5166 class domHalf4x3 : public daeElement 5167 { 5168 public: 5169 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF4X3; } 5170 static daeInt ID() { return 463; } 5171 virtual daeInt typeID() const { return ID(); } 5172 5173 protected: // Value 5174 /** 5175 * The domCg_half4x3 value of the text data of this element. 5176 */ 5177 domCg_half4x3 _value; 5178 5179 public: //Accessors and Mutators 5180 /** 5181 * Gets the _value array. 5182 * @return Returns a domCg_half4x3 reference of the _value array. 5183 */ 5184 domCg_half4x3 &getValue() { return _value; } 5185 /** 5186 * Gets the _value array. 5187 * @return Returns a constant domCg_half4x3 reference of the _value array. 5188 */ 5189 const domCg_half4x3 &getValue() const { return _value; } 5190 /** 5191 * Sets the _value array. 5192 * @param val The new value for the _value array. 5193 */ 5194 void setValue( const domCg_half4x3 &val ) { _value = val; } 5195 5196 protected: 5197 /** 5198 * Constructor 5199 */ 5200 domHalf4x3(DAE& dae) : daeElement(dae), _value() {} 5201 /** 5202 * Destructor 5203 */ 5204 virtual ~domHalf4x3() {} 5205 /** 5206 * Overloaded assignment operator 5207 */ 5208 virtual domHalf4x3 &operator=( const domHalf4x3 &cpy ) { (void)cpy; return *this; } 5209 5210 public: // STATIC METHODS 5211 /** 5212 * Creates an instance of this class and returns a daeElementRef referencing it. 5213 * @return a daeElementRef referencing an instance of this object. 5214 */ 5215 static DLLSPEC daeElementRef create(DAE& dae); 5216 /** 5217 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5218 * If a daeMetaElement already exists it will return that instead of creating a new one. 5219 * @return A daeMetaElement describing this COLLADA element. 5220 */ 5221 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5222 }; 5223 5224 class domHalf4x4; 5225 5226 typedef daeSmartRef<domHalf4x4> domHalf4x4Ref; 5227 typedef daeTArray<domHalf4x4Ref> domHalf4x4_Array; 5228 5229 class domHalf4x4 : public daeElement 5230 { 5231 public: 5232 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::HALF4X4; } 5233 static daeInt ID() { return 464; } 5234 virtual daeInt typeID() const { return ID(); } 5235 5236 protected: // Value 5237 /** 5238 * The domCg_half4x4 value of the text data of this element. 5239 */ 5240 domCg_half4x4 _value; 5241 5242 public: //Accessors and Mutators 5243 /** 5244 * Gets the _value array. 5245 * @return Returns a domCg_half4x4 reference of the _value array. 5246 */ 5247 domCg_half4x4 &getValue() { return _value; } 5248 /** 5249 * Gets the _value array. 5250 * @return Returns a constant domCg_half4x4 reference of the _value array. 5251 */ 5252 const domCg_half4x4 &getValue() const { return _value; } 5253 /** 5254 * Sets the _value array. 5255 * @param val The new value for the _value array. 5256 */ 5257 void setValue( const domCg_half4x4 &val ) { _value = val; } 5258 5259 protected: 5260 /** 5261 * Constructor 5262 */ 5263 domHalf4x4(DAE& dae) : daeElement(dae), _value() {} 5264 /** 5265 * Destructor 5266 */ 5267 virtual ~domHalf4x4() {} 5268 /** 5269 * Overloaded assignment operator 5270 */ 5271 virtual domHalf4x4 &operator=( const domHalf4x4 &cpy ) { (void)cpy; return *this; } 5272 5273 public: // STATIC METHODS 5274 /** 5275 * Creates an instance of this class and returns a daeElementRef referencing it. 5276 * @return a daeElementRef referencing an instance of this object. 5277 */ 5278 static DLLSPEC daeElementRef create(DAE& dae); 5279 /** 5280 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5281 * If a daeMetaElement already exists it will return that instead of creating a new one. 5282 * @return A daeMetaElement describing this COLLADA element. 5283 */ 5284 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5285 }; 5286 5287 class domFixed; 5288 5289 typedef daeSmartRef<domFixed> domFixedRef; 5290 typedef daeTArray<domFixedRef> domFixed_Array; 5291 5292 class domFixed : public daeElement 5293 { 5294 public: 5295 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED; } 5296 static daeInt ID() { return 465; } 5297 virtual daeInt typeID() const { return ID(); } 5298 5299 protected: // Value 5300 /** 5301 * The domCg_fixed value of the text data of this element. 5302 */ 5303 domCg_fixed _value; 5304 5305 public: //Accessors and Mutators 5306 /** 5307 * Gets the value of this element. 5308 * @return a domCg_fixed of the value. 5309 */ 5310 domCg_fixed getValue() const { return _value; } 5311 /** 5312 * Sets the _value of this element. 5313 * @param val The new value for this element. 5314 */ 5315 void setValue( domCg_fixed val ) { _value = val; } 5316 5317 protected: 5318 /** 5319 * Constructor 5320 */ 5321 domFixed(DAE& dae) : daeElement(dae), _value() {} 5322 /** 5323 * Destructor 5324 */ 5325 virtual ~domFixed() {} 5326 /** 5327 * Overloaded assignment operator 5328 */ 5329 virtual domFixed &operator=( const domFixed &cpy ) { (void)cpy; return *this; } 5330 5331 public: // STATIC METHODS 5332 /** 5333 * Creates an instance of this class and returns a daeElementRef referencing it. 5334 * @return a daeElementRef referencing an instance of this object. 5335 */ 5336 static DLLSPEC daeElementRef create(DAE& dae); 5337 /** 5338 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5339 * If a daeMetaElement already exists it will return that instead of creating a new one. 5340 * @return A daeMetaElement describing this COLLADA element. 5341 */ 5342 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5343 }; 5344 5345 class domFixed1; 5346 5347 typedef daeSmartRef<domFixed1> domFixed1Ref; 5348 typedef daeTArray<domFixed1Ref> domFixed1_Array; 5349 5350 class domFixed1 : public daeElement 5351 { 5352 public: 5353 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED1; } 5354 static daeInt ID() { return 466; } 5355 virtual daeInt typeID() const { return ID(); } 5356 5357 protected: // Value 5358 /** 5359 * The domCg_fixed1 value of the text data of this element. 5360 */ 5361 domCg_fixed1 _value; 5362 5363 public: //Accessors and Mutators 5364 /** 5365 * Gets the value of this element. 5366 * @return a domCg_fixed1 of the value. 5367 */ 5368 domCg_fixed1 getValue() const { return _value; } 5369 /** 5370 * Sets the _value of this element. 5371 * @param val The new value for this element. 5372 */ 5373 void setValue( domCg_fixed1 val ) { _value = val; } 5374 5375 protected: 5376 /** 5377 * Constructor 5378 */ 5379 domFixed1(DAE& dae) : daeElement(dae), _value() {} 5380 /** 5381 * Destructor 5382 */ 5383 virtual ~domFixed1() {} 5384 /** 5385 * Overloaded assignment operator 5386 */ 5387 virtual domFixed1 &operator=( const domFixed1 &cpy ) { (void)cpy; return *this; } 5388 5389 public: // STATIC METHODS 5390 /** 5391 * Creates an instance of this class and returns a daeElementRef referencing it. 5392 * @return a daeElementRef referencing an instance of this object. 5393 */ 5394 static DLLSPEC daeElementRef create(DAE& dae); 5395 /** 5396 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5397 * If a daeMetaElement already exists it will return that instead of creating a new one. 5398 * @return A daeMetaElement describing this COLLADA element. 5399 */ 5400 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5401 }; 5402 5403 class domFixed2; 5404 5405 typedef daeSmartRef<domFixed2> domFixed2Ref; 5406 typedef daeTArray<domFixed2Ref> domFixed2_Array; 5407 5408 class domFixed2 : public daeElement 5409 { 5410 public: 5411 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED2; } 5412 static daeInt ID() { return 467; } 5413 virtual daeInt typeID() const { return ID(); } 5414 5415 protected: // Value 5416 /** 5417 * The domCg_fixed2 value of the text data of this element. 5418 */ 5419 domCg_fixed2 _value; 5420 5421 public: //Accessors and Mutators 5422 /** 5423 * Gets the _value array. 5424 * @return Returns a domCg_fixed2 reference of the _value array. 5425 */ 5426 domCg_fixed2 &getValue() { return _value; } 5427 /** 5428 * Gets the _value array. 5429 * @return Returns a constant domCg_fixed2 reference of the _value array. 5430 */ 5431 const domCg_fixed2 &getValue() const { return _value; } 5432 /** 5433 * Sets the _value array. 5434 * @param val The new value for the _value array. 5435 */ 5436 void setValue( const domCg_fixed2 &val ) { _value = val; } 5437 5438 protected: 5439 /** 5440 * Constructor 5441 */ 5442 domFixed2(DAE& dae) : daeElement(dae), _value() {} 5443 /** 5444 * Destructor 5445 */ 5446 virtual ~domFixed2() {} 5447 /** 5448 * Overloaded assignment operator 5449 */ 5450 virtual domFixed2 &operator=( const domFixed2 &cpy ) { (void)cpy; return *this; } 5451 5452 public: // STATIC METHODS 5453 /** 5454 * Creates an instance of this class and returns a daeElementRef referencing it. 5455 * @return a daeElementRef referencing an instance of this object. 5456 */ 5457 static DLLSPEC daeElementRef create(DAE& dae); 5458 /** 5459 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5460 * If a daeMetaElement already exists it will return that instead of creating a new one. 5461 * @return A daeMetaElement describing this COLLADA element. 5462 */ 5463 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5464 }; 5465 5466 class domFixed3; 5467 5468 typedef daeSmartRef<domFixed3> domFixed3Ref; 5469 typedef daeTArray<domFixed3Ref> domFixed3_Array; 5470 5471 class domFixed3 : public daeElement 5472 { 5473 public: 5474 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED3; } 5475 static daeInt ID() { return 468; } 5476 virtual daeInt typeID() const { return ID(); } 5477 5478 protected: // Value 5479 /** 5480 * The domCg_fixed3 value of the text data of this element. 5481 */ 5482 domCg_fixed3 _value; 5483 5484 public: //Accessors and Mutators 5485 /** 5486 * Gets the _value array. 5487 * @return Returns a domCg_fixed3 reference of the _value array. 5488 */ 5489 domCg_fixed3 &getValue() { return _value; } 5490 /** 5491 * Gets the _value array. 5492 * @return Returns a constant domCg_fixed3 reference of the _value array. 5493 */ 5494 const domCg_fixed3 &getValue() const { return _value; } 5495 /** 5496 * Sets the _value array. 5497 * @param val The new value for the _value array. 5498 */ 5499 void setValue( const domCg_fixed3 &val ) { _value = val; } 5500 5501 protected: 5502 /** 5503 * Constructor 5504 */ 5505 domFixed3(DAE& dae) : daeElement(dae), _value() {} 5506 /** 5507 * Destructor 5508 */ 5509 virtual ~domFixed3() {} 5510 /** 5511 * Overloaded assignment operator 5512 */ 5513 virtual domFixed3 &operator=( const domFixed3 &cpy ) { (void)cpy; return *this; } 5514 5515 public: // STATIC METHODS 5516 /** 5517 * Creates an instance of this class and returns a daeElementRef referencing it. 5518 * @return a daeElementRef referencing an instance of this object. 5519 */ 5520 static DLLSPEC daeElementRef create(DAE& dae); 5521 /** 5522 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5523 * If a daeMetaElement already exists it will return that instead of creating a new one. 5524 * @return A daeMetaElement describing this COLLADA element. 5525 */ 5526 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5527 }; 5528 5529 class domFixed4; 5530 5531 typedef daeSmartRef<domFixed4> domFixed4Ref; 5532 typedef daeTArray<domFixed4Ref> domFixed4_Array; 5533 5534 class domFixed4 : public daeElement 5535 { 5536 public: 5537 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED4; } 5538 static daeInt ID() { return 469; } 5539 virtual daeInt typeID() const { return ID(); } 5540 5541 protected: // Value 5542 /** 5543 * The domCg_fixed4 value of the text data of this element. 5544 */ 5545 domCg_fixed4 _value; 5546 5547 public: //Accessors and Mutators 5548 /** 5549 * Gets the _value array. 5550 * @return Returns a domCg_fixed4 reference of the _value array. 5551 */ 5552 domCg_fixed4 &getValue() { return _value; } 5553 /** 5554 * Gets the _value array. 5555 * @return Returns a constant domCg_fixed4 reference of the _value array. 5556 */ 5557 const domCg_fixed4 &getValue() const { return _value; } 5558 /** 5559 * Sets the _value array. 5560 * @param val The new value for the _value array. 5561 */ 5562 void setValue( const domCg_fixed4 &val ) { _value = val; } 5563 5564 protected: 5565 /** 5566 * Constructor 5567 */ 5568 domFixed4(DAE& dae) : daeElement(dae), _value() {} 5569 /** 5570 * Destructor 5571 */ 5572 virtual ~domFixed4() {} 5573 /** 5574 * Overloaded assignment operator 5575 */ 5576 virtual domFixed4 &operator=( const domFixed4 &cpy ) { (void)cpy; return *this; } 5577 5578 public: // STATIC METHODS 5579 /** 5580 * Creates an instance of this class and returns a daeElementRef referencing it. 5581 * @return a daeElementRef referencing an instance of this object. 5582 */ 5583 static DLLSPEC daeElementRef create(DAE& dae); 5584 /** 5585 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5586 * If a daeMetaElement already exists it will return that instead of creating a new one. 5587 * @return A daeMetaElement describing this COLLADA element. 5588 */ 5589 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5590 }; 5591 5592 class domFixed1x1; 5593 5594 typedef daeSmartRef<domFixed1x1> domFixed1x1Ref; 5595 typedef daeTArray<domFixed1x1Ref> domFixed1x1_Array; 5596 5597 class domFixed1x1 : public daeElement 5598 { 5599 public: 5600 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED1X1; } 5601 static daeInt ID() { return 470; } 5602 virtual daeInt typeID() const { return ID(); } 5603 5604 protected: // Value 5605 /** 5606 * The domCg_fixed1x1 value of the text data of this element. 5607 */ 5608 domCg_fixed1x1 _value; 5609 5610 public: //Accessors and Mutators 5611 /** 5612 * Gets the _value array. 5613 * @return Returns a domCg_fixed1x1 reference of the _value array. 5614 */ 5615 domCg_fixed1x1 &getValue() { return _value; } 5616 /** 5617 * Gets the _value array. 5618 * @return Returns a constant domCg_fixed1x1 reference of the _value array. 5619 */ 5620 const domCg_fixed1x1 &getValue() const { return _value; } 5621 /** 5622 * Sets the _value array. 5623 * @param val The new value for the _value array. 5624 */ 5625 void setValue( const domCg_fixed1x1 &val ) { _value = val; } 5626 5627 protected: 5628 /** 5629 * Constructor 5630 */ 5631 domFixed1x1(DAE& dae) : daeElement(dae), _value() {} 5632 /** 5633 * Destructor 5634 */ 5635 virtual ~domFixed1x1() {} 5636 /** 5637 * Overloaded assignment operator 5638 */ 5639 virtual domFixed1x1 &operator=( const domFixed1x1 &cpy ) { (void)cpy; return *this; } 5640 5641 public: // STATIC METHODS 5642 /** 5643 * Creates an instance of this class and returns a daeElementRef referencing it. 5644 * @return a daeElementRef referencing an instance of this object. 5645 */ 5646 static DLLSPEC daeElementRef create(DAE& dae); 5647 /** 5648 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5649 * If a daeMetaElement already exists it will return that instead of creating a new one. 5650 * @return A daeMetaElement describing this COLLADA element. 5651 */ 5652 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5653 }; 5654 5655 class domFixed1x2; 5656 5657 typedef daeSmartRef<domFixed1x2> domFixed1x2Ref; 5658 typedef daeTArray<domFixed1x2Ref> domFixed1x2_Array; 5659 5660 class domFixed1x2 : public daeElement 5661 { 5662 public: 5663 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED1X2; } 5664 static daeInt ID() { return 471; } 5665 virtual daeInt typeID() const { return ID(); } 5666 5667 protected: // Value 5668 /** 5669 * The domCg_fixed1x2 value of the text data of this element. 5670 */ 5671 domCg_fixed1x2 _value; 5672 5673 public: //Accessors and Mutators 5674 /** 5675 * Gets the _value array. 5676 * @return Returns a domCg_fixed1x2 reference of the _value array. 5677 */ 5678 domCg_fixed1x2 &getValue() { return _value; } 5679 /** 5680 * Gets the _value array. 5681 * @return Returns a constant domCg_fixed1x2 reference of the _value array. 5682 */ 5683 const domCg_fixed1x2 &getValue() const { return _value; } 5684 /** 5685 * Sets the _value array. 5686 * @param val The new value for the _value array. 5687 */ 5688 void setValue( const domCg_fixed1x2 &val ) { _value = val; } 5689 5690 protected: 5691 /** 5692 * Constructor 5693 */ 5694 domFixed1x2(DAE& dae) : daeElement(dae), _value() {} 5695 /** 5696 * Destructor 5697 */ 5698 virtual ~domFixed1x2() {} 5699 /** 5700 * Overloaded assignment operator 5701 */ 5702 virtual domFixed1x2 &operator=( const domFixed1x2 &cpy ) { (void)cpy; return *this; } 5703 5704 public: // STATIC METHODS 5705 /** 5706 * Creates an instance of this class and returns a daeElementRef referencing it. 5707 * @return a daeElementRef referencing an instance of this object. 5708 */ 5709 static DLLSPEC daeElementRef create(DAE& dae); 5710 /** 5711 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5712 * If a daeMetaElement already exists it will return that instead of creating a new one. 5713 * @return A daeMetaElement describing this COLLADA element. 5714 */ 5715 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5716 }; 5717 5718 class domFixed1x3; 5719 5720 typedef daeSmartRef<domFixed1x3> domFixed1x3Ref; 5721 typedef daeTArray<domFixed1x3Ref> domFixed1x3_Array; 5722 5723 class domFixed1x3 : public daeElement 5724 { 5725 public: 5726 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED1X3; } 5727 static daeInt ID() { return 472; } 5728 virtual daeInt typeID() const { return ID(); } 5729 5730 protected: // Value 5731 /** 5732 * The domCg_fixed1x3 value of the text data of this element. 5733 */ 5734 domCg_fixed1x3 _value; 5735 5736 public: //Accessors and Mutators 5737 /** 5738 * Gets the _value array. 5739 * @return Returns a domCg_fixed1x3 reference of the _value array. 5740 */ 5741 domCg_fixed1x3 &getValue() { return _value; } 5742 /** 5743 * Gets the _value array. 5744 * @return Returns a constant domCg_fixed1x3 reference of the _value array. 5745 */ 5746 const domCg_fixed1x3 &getValue() const { return _value; } 5747 /** 5748 * Sets the _value array. 5749 * @param val The new value for the _value array. 5750 */ 5751 void setValue( const domCg_fixed1x3 &val ) { _value = val; } 5752 5753 protected: 5754 /** 5755 * Constructor 5756 */ 5757 domFixed1x3(DAE& dae) : daeElement(dae), _value() {} 5758 /** 5759 * Destructor 5760 */ 5761 virtual ~domFixed1x3() {} 5762 /** 5763 * Overloaded assignment operator 5764 */ 5765 virtual domFixed1x3 &operator=( const domFixed1x3 &cpy ) { (void)cpy; return *this; } 5766 5767 public: // STATIC METHODS 5768 /** 5769 * Creates an instance of this class and returns a daeElementRef referencing it. 5770 * @return a daeElementRef referencing an instance of this object. 5771 */ 5772 static DLLSPEC daeElementRef create(DAE& dae); 5773 /** 5774 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5775 * If a daeMetaElement already exists it will return that instead of creating a new one. 5776 * @return A daeMetaElement describing this COLLADA element. 5777 */ 5778 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5779 }; 5780 5781 class domFixed1x4; 5782 5783 typedef daeSmartRef<domFixed1x4> domFixed1x4Ref; 5784 typedef daeTArray<domFixed1x4Ref> domFixed1x4_Array; 5785 5786 class domFixed1x4 : public daeElement 5787 { 5788 public: 5789 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED1X4; } 5790 static daeInt ID() { return 473; } 5791 virtual daeInt typeID() const { return ID(); } 5792 5793 protected: // Value 5794 /** 5795 * The domCg_fixed1x4 value of the text data of this element. 5796 */ 5797 domCg_fixed1x4 _value; 5798 5799 public: //Accessors and Mutators 5800 /** 5801 * Gets the _value array. 5802 * @return Returns a domCg_fixed1x4 reference of the _value array. 5803 */ 5804 domCg_fixed1x4 &getValue() { return _value; } 5805 /** 5806 * Gets the _value array. 5807 * @return Returns a constant domCg_fixed1x4 reference of the _value array. 5808 */ 5809 const domCg_fixed1x4 &getValue() const { return _value; } 5810 /** 5811 * Sets the _value array. 5812 * @param val The new value for the _value array. 5813 */ 5814 void setValue( const domCg_fixed1x4 &val ) { _value = val; } 5815 5816 protected: 5817 /** 5818 * Constructor 5819 */ 5820 domFixed1x4(DAE& dae) : daeElement(dae), _value() {} 5821 /** 5822 * Destructor 5823 */ 5824 virtual ~domFixed1x4() {} 5825 /** 5826 * Overloaded assignment operator 5827 */ 5828 virtual domFixed1x4 &operator=( const domFixed1x4 &cpy ) { (void)cpy; return *this; } 5829 5830 public: // STATIC METHODS 5831 /** 5832 * Creates an instance of this class and returns a daeElementRef referencing it. 5833 * @return a daeElementRef referencing an instance of this object. 5834 */ 5835 static DLLSPEC daeElementRef create(DAE& dae); 5836 /** 5837 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5838 * If a daeMetaElement already exists it will return that instead of creating a new one. 5839 * @return A daeMetaElement describing this COLLADA element. 5840 */ 5841 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5842 }; 5843 5844 class domFixed2x1; 5845 5846 typedef daeSmartRef<domFixed2x1> domFixed2x1Ref; 5847 typedef daeTArray<domFixed2x1Ref> domFixed2x1_Array; 5848 5849 class domFixed2x1 : public daeElement 5850 { 5851 public: 5852 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED2X1; } 5853 static daeInt ID() { return 474; } 5854 virtual daeInt typeID() const { return ID(); } 5855 5856 protected: // Value 5857 /** 5858 * The domCg_fixed2x1 value of the text data of this element. 5859 */ 5860 domCg_fixed2x1 _value; 5861 5862 public: //Accessors and Mutators 5863 /** 5864 * Gets the _value array. 5865 * @return Returns a domCg_fixed2x1 reference of the _value array. 5866 */ 5867 domCg_fixed2x1 &getValue() { return _value; } 5868 /** 5869 * Gets the _value array. 5870 * @return Returns a constant domCg_fixed2x1 reference of the _value array. 5871 */ 5872 const domCg_fixed2x1 &getValue() const { return _value; } 5873 /** 5874 * Sets the _value array. 5875 * @param val The new value for the _value array. 5876 */ 5877 void setValue( const domCg_fixed2x1 &val ) { _value = val; } 5878 5879 protected: 5880 /** 5881 * Constructor 5882 */ 5883 domFixed2x1(DAE& dae) : daeElement(dae), _value() {} 5884 /** 5885 * Destructor 5886 */ 5887 virtual ~domFixed2x1() {} 5888 /** 5889 * Overloaded assignment operator 5890 */ 5891 virtual domFixed2x1 &operator=( const domFixed2x1 &cpy ) { (void)cpy; return *this; } 5892 5893 public: // STATIC METHODS 5894 /** 5895 * Creates an instance of this class and returns a daeElementRef referencing it. 5896 * @return a daeElementRef referencing an instance of this object. 5897 */ 5898 static DLLSPEC daeElementRef create(DAE& dae); 5899 /** 5900 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5901 * If a daeMetaElement already exists it will return that instead of creating a new one. 5902 * @return A daeMetaElement describing this COLLADA element. 5903 */ 5904 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5905 }; 5906 5907 class domFixed2x2; 5908 5909 typedef daeSmartRef<domFixed2x2> domFixed2x2Ref; 5910 typedef daeTArray<domFixed2x2Ref> domFixed2x2_Array; 5911 5912 class domFixed2x2 : public daeElement 5913 { 5914 public: 5915 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED2X2; } 5916 static daeInt ID() { return 475; } 5917 virtual daeInt typeID() const { return ID(); } 5918 5919 protected: // Value 5920 /** 5921 * The domCg_fixed2x2 value of the text data of this element. 5922 */ 5923 domCg_fixed2x2 _value; 5924 5925 public: //Accessors and Mutators 5926 /** 5927 * Gets the _value array. 5928 * @return Returns a domCg_fixed2x2 reference of the _value array. 5929 */ 5930 domCg_fixed2x2 &getValue() { return _value; } 5931 /** 5932 * Gets the _value array. 5933 * @return Returns a constant domCg_fixed2x2 reference of the _value array. 5934 */ 5935 const domCg_fixed2x2 &getValue() const { return _value; } 5936 /** 5937 * Sets the _value array. 5938 * @param val The new value for the _value array. 5939 */ 5940 void setValue( const domCg_fixed2x2 &val ) { _value = val; } 5941 5942 protected: 5943 /** 5944 * Constructor 5945 */ 5946 domFixed2x2(DAE& dae) : daeElement(dae), _value() {} 5947 /** 5948 * Destructor 5949 */ 5950 virtual ~domFixed2x2() {} 5951 /** 5952 * Overloaded assignment operator 5953 */ 5954 virtual domFixed2x2 &operator=( const domFixed2x2 &cpy ) { (void)cpy; return *this; } 5955 5956 public: // STATIC METHODS 5957 /** 5958 * Creates an instance of this class and returns a daeElementRef referencing it. 5959 * @return a daeElementRef referencing an instance of this object. 5960 */ 5961 static DLLSPEC daeElementRef create(DAE& dae); 5962 /** 5963 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5964 * If a daeMetaElement already exists it will return that instead of creating a new one. 5965 * @return A daeMetaElement describing this COLLADA element. 5966 */ 5967 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5968 }; 5969 5970 class domFixed2x3; 5971 5972 typedef daeSmartRef<domFixed2x3> domFixed2x3Ref; 5973 typedef daeTArray<domFixed2x3Ref> domFixed2x3_Array; 5974 5975 class domFixed2x3 : public daeElement 5976 { 5977 public: 5978 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED2X3; } 5979 static daeInt ID() { return 476; } 5980 virtual daeInt typeID() const { return ID(); } 5981 5982 protected: // Value 5983 /** 5984 * The domCg_fixed2x3 value of the text data of this element. 5985 */ 5986 domCg_fixed2x3 _value; 5987 5988 public: //Accessors and Mutators 5989 /** 5990 * Gets the _value array. 5991 * @return Returns a domCg_fixed2x3 reference of the _value array. 5992 */ 5993 domCg_fixed2x3 &getValue() { return _value; } 5994 /** 5995 * Gets the _value array. 5996 * @return Returns a constant domCg_fixed2x3 reference of the _value array. 5997 */ 5998 const domCg_fixed2x3 &getValue() const { return _value; } 5999 /** 6000 * Sets the _value array. 6001 * @param val The new value for the _value array. 6002 */ 6003 void setValue( const domCg_fixed2x3 &val ) { _value = val; } 6004 6005 protected: 6006 /** 6007 * Constructor 6008 */ 6009 domFixed2x3(DAE& dae) : daeElement(dae), _value() {} 6010 /** 6011 * Destructor 6012 */ 6013 virtual ~domFixed2x3() {} 6014 /** 6015 * Overloaded assignment operator 6016 */ 6017 virtual domFixed2x3 &operator=( const domFixed2x3 &cpy ) { (void)cpy; return *this; } 6018 6019 public: // STATIC METHODS 6020 /** 6021 * Creates an instance of this class and returns a daeElementRef referencing it. 6022 * @return a daeElementRef referencing an instance of this object. 6023 */ 6024 static DLLSPEC daeElementRef create(DAE& dae); 6025 /** 6026 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6027 * If a daeMetaElement already exists it will return that instead of creating a new one. 6028 * @return A daeMetaElement describing this COLLADA element. 6029 */ 6030 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6031 }; 6032 6033 class domFixed2x4; 6034 6035 typedef daeSmartRef<domFixed2x4> domFixed2x4Ref; 6036 typedef daeTArray<domFixed2x4Ref> domFixed2x4_Array; 6037 6038 class domFixed2x4 : public daeElement 6039 { 6040 public: 6041 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED2X4; } 6042 static daeInt ID() { return 477; } 6043 virtual daeInt typeID() const { return ID(); } 6044 6045 protected: // Value 6046 /** 6047 * The domCg_fixed2x4 value of the text data of this element. 6048 */ 6049 domCg_fixed2x4 _value; 6050 6051 public: //Accessors and Mutators 6052 /** 6053 * Gets the _value array. 6054 * @return Returns a domCg_fixed2x4 reference of the _value array. 6055 */ 6056 domCg_fixed2x4 &getValue() { return _value; } 6057 /** 6058 * Gets the _value array. 6059 * @return Returns a constant domCg_fixed2x4 reference of the _value array. 6060 */ 6061 const domCg_fixed2x4 &getValue() const { return _value; } 6062 /** 6063 * Sets the _value array. 6064 * @param val The new value for the _value array. 6065 */ 6066 void setValue( const domCg_fixed2x4 &val ) { _value = val; } 6067 6068 protected: 6069 /** 6070 * Constructor 6071 */ 6072 domFixed2x4(DAE& dae) : daeElement(dae), _value() {} 6073 /** 6074 * Destructor 6075 */ 6076 virtual ~domFixed2x4() {} 6077 /** 6078 * Overloaded assignment operator 6079 */ 6080 virtual domFixed2x4 &operator=( const domFixed2x4 &cpy ) { (void)cpy; return *this; } 6081 6082 public: // STATIC METHODS 6083 /** 6084 * Creates an instance of this class and returns a daeElementRef referencing it. 6085 * @return a daeElementRef referencing an instance of this object. 6086 */ 6087 static DLLSPEC daeElementRef create(DAE& dae); 6088 /** 6089 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6090 * If a daeMetaElement already exists it will return that instead of creating a new one. 6091 * @return A daeMetaElement describing this COLLADA element. 6092 */ 6093 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6094 }; 6095 6096 class domFixed3x1; 6097 6098 typedef daeSmartRef<domFixed3x1> domFixed3x1Ref; 6099 typedef daeTArray<domFixed3x1Ref> domFixed3x1_Array; 6100 6101 class domFixed3x1 : public daeElement 6102 { 6103 public: 6104 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED3X1; } 6105 static daeInt ID() { return 478; } 6106 virtual daeInt typeID() const { return ID(); } 6107 6108 protected: // Value 6109 /** 6110 * The domCg_fixed3x1 value of the text data of this element. 6111 */ 6112 domCg_fixed3x1 _value; 6113 6114 public: //Accessors and Mutators 6115 /** 6116 * Gets the _value array. 6117 * @return Returns a domCg_fixed3x1 reference of the _value array. 6118 */ 6119 domCg_fixed3x1 &getValue() { return _value; } 6120 /** 6121 * Gets the _value array. 6122 * @return Returns a constant domCg_fixed3x1 reference of the _value array. 6123 */ 6124 const domCg_fixed3x1 &getValue() const { return _value; } 6125 /** 6126 * Sets the _value array. 6127 * @param val The new value for the _value array. 6128 */ 6129 void setValue( const domCg_fixed3x1 &val ) { _value = val; } 6130 6131 protected: 6132 /** 6133 * Constructor 6134 */ 6135 domFixed3x1(DAE& dae) : daeElement(dae), _value() {} 6136 /** 6137 * Destructor 6138 */ 6139 virtual ~domFixed3x1() {} 6140 /** 6141 * Overloaded assignment operator 6142 */ 6143 virtual domFixed3x1 &operator=( const domFixed3x1 &cpy ) { (void)cpy; return *this; } 6144 6145 public: // STATIC METHODS 6146 /** 6147 * Creates an instance of this class and returns a daeElementRef referencing it. 6148 * @return a daeElementRef referencing an instance of this object. 6149 */ 6150 static DLLSPEC daeElementRef create(DAE& dae); 6151 /** 6152 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6153 * If a daeMetaElement already exists it will return that instead of creating a new one. 6154 * @return A daeMetaElement describing this COLLADA element. 6155 */ 6156 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6157 }; 6158 6159 class domFixed3x2; 6160 6161 typedef daeSmartRef<domFixed3x2> domFixed3x2Ref; 6162 typedef daeTArray<domFixed3x2Ref> domFixed3x2_Array; 6163 6164 class domFixed3x2 : public daeElement 6165 { 6166 public: 6167 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED3X2; } 6168 static daeInt ID() { return 479; } 6169 virtual daeInt typeID() const { return ID(); } 6170 6171 protected: // Value 6172 /** 6173 * The domCg_fixed3x2 value of the text data of this element. 6174 */ 6175 domCg_fixed3x2 _value; 6176 6177 public: //Accessors and Mutators 6178 /** 6179 * Gets the _value array. 6180 * @return Returns a domCg_fixed3x2 reference of the _value array. 6181 */ 6182 domCg_fixed3x2 &getValue() { return _value; } 6183 /** 6184 * Gets the _value array. 6185 * @return Returns a constant domCg_fixed3x2 reference of the _value array. 6186 */ 6187 const domCg_fixed3x2 &getValue() const { return _value; } 6188 /** 6189 * Sets the _value array. 6190 * @param val The new value for the _value array. 6191 */ 6192 void setValue( const domCg_fixed3x2 &val ) { _value = val; } 6193 6194 protected: 6195 /** 6196 * Constructor 6197 */ 6198 domFixed3x2(DAE& dae) : daeElement(dae), _value() {} 6199 /** 6200 * Destructor 6201 */ 6202 virtual ~domFixed3x2() {} 6203 /** 6204 * Overloaded assignment operator 6205 */ 6206 virtual domFixed3x2 &operator=( const domFixed3x2 &cpy ) { (void)cpy; return *this; } 6207 6208 public: // STATIC METHODS 6209 /** 6210 * Creates an instance of this class and returns a daeElementRef referencing it. 6211 * @return a daeElementRef referencing an instance of this object. 6212 */ 6213 static DLLSPEC daeElementRef create(DAE& dae); 6214 /** 6215 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6216 * If a daeMetaElement already exists it will return that instead of creating a new one. 6217 * @return A daeMetaElement describing this COLLADA element. 6218 */ 6219 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6220 }; 6221 6222 class domFixed3x3; 6223 6224 typedef daeSmartRef<domFixed3x3> domFixed3x3Ref; 6225 typedef daeTArray<domFixed3x3Ref> domFixed3x3_Array; 6226 6227 class domFixed3x3 : public daeElement 6228 { 6229 public: 6230 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED3X3; } 6231 static daeInt ID() { return 480; } 6232 virtual daeInt typeID() const { return ID(); } 6233 6234 protected: // Value 6235 /** 6236 * The domCg_fixed3x3 value of the text data of this element. 6237 */ 6238 domCg_fixed3x3 _value; 6239 6240 public: //Accessors and Mutators 6241 /** 6242 * Gets the _value array. 6243 * @return Returns a domCg_fixed3x3 reference of the _value array. 6244 */ 6245 domCg_fixed3x3 &getValue() { return _value; } 6246 /** 6247 * Gets the _value array. 6248 * @return Returns a constant domCg_fixed3x3 reference of the _value array. 6249 */ 6250 const domCg_fixed3x3 &getValue() const { return _value; } 6251 /** 6252 * Sets the _value array. 6253 * @param val The new value for the _value array. 6254 */ 6255 void setValue( const domCg_fixed3x3 &val ) { _value = val; } 6256 6257 protected: 6258 /** 6259 * Constructor 6260 */ 6261 domFixed3x3(DAE& dae) : daeElement(dae), _value() {} 6262 /** 6263 * Destructor 6264 */ 6265 virtual ~domFixed3x3() {} 6266 /** 6267 * Overloaded assignment operator 6268 */ 6269 virtual domFixed3x3 &operator=( const domFixed3x3 &cpy ) { (void)cpy; return *this; } 6270 6271 public: // STATIC METHODS 6272 /** 6273 * Creates an instance of this class and returns a daeElementRef referencing it. 6274 * @return a daeElementRef referencing an instance of this object. 6275 */ 6276 static DLLSPEC daeElementRef create(DAE& dae); 6277 /** 6278 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6279 * If a daeMetaElement already exists it will return that instead of creating a new one. 6280 * @return A daeMetaElement describing this COLLADA element. 6281 */ 6282 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6283 }; 6284 6285 class domFixed3x4; 6286 6287 typedef daeSmartRef<domFixed3x4> domFixed3x4Ref; 6288 typedef daeTArray<domFixed3x4Ref> domFixed3x4_Array; 6289 6290 class domFixed3x4 : public daeElement 6291 { 6292 public: 6293 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED3X4; } 6294 static daeInt ID() { return 481; } 6295 virtual daeInt typeID() const { return ID(); } 6296 6297 protected: // Value 6298 /** 6299 * The domCg_fixed3x4 value of the text data of this element. 6300 */ 6301 domCg_fixed3x4 _value; 6302 6303 public: //Accessors and Mutators 6304 /** 6305 * Gets the _value array. 6306 * @return Returns a domCg_fixed3x4 reference of the _value array. 6307 */ 6308 domCg_fixed3x4 &getValue() { return _value; } 6309 /** 6310 * Gets the _value array. 6311 * @return Returns a constant domCg_fixed3x4 reference of the _value array. 6312 */ 6313 const domCg_fixed3x4 &getValue() const { return _value; } 6314 /** 6315 * Sets the _value array. 6316 * @param val The new value for the _value array. 6317 */ 6318 void setValue( const domCg_fixed3x4 &val ) { _value = val; } 6319 6320 protected: 6321 /** 6322 * Constructor 6323 */ 6324 domFixed3x4(DAE& dae) : daeElement(dae), _value() {} 6325 /** 6326 * Destructor 6327 */ 6328 virtual ~domFixed3x4() {} 6329 /** 6330 * Overloaded assignment operator 6331 */ 6332 virtual domFixed3x4 &operator=( const domFixed3x4 &cpy ) { (void)cpy; return *this; } 6333 6334 public: // STATIC METHODS 6335 /** 6336 * Creates an instance of this class and returns a daeElementRef referencing it. 6337 * @return a daeElementRef referencing an instance of this object. 6338 */ 6339 static DLLSPEC daeElementRef create(DAE& dae); 6340 /** 6341 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6342 * If a daeMetaElement already exists it will return that instead of creating a new one. 6343 * @return A daeMetaElement describing this COLLADA element. 6344 */ 6345 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6346 }; 6347 6348 class domFixed4x1; 6349 6350 typedef daeSmartRef<domFixed4x1> domFixed4x1Ref; 6351 typedef daeTArray<domFixed4x1Ref> domFixed4x1_Array; 6352 6353 class domFixed4x1 : public daeElement 6354 { 6355 public: 6356 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED4X1; } 6357 static daeInt ID() { return 482; } 6358 virtual daeInt typeID() const { return ID(); } 6359 6360 protected: // Value 6361 /** 6362 * The domCg_fixed4x1 value of the text data of this element. 6363 */ 6364 domCg_fixed4x1 _value; 6365 6366 public: //Accessors and Mutators 6367 /** 6368 * Gets the _value array. 6369 * @return Returns a domCg_fixed4x1 reference of the _value array. 6370 */ 6371 domCg_fixed4x1 &getValue() { return _value; } 6372 /** 6373 * Gets the _value array. 6374 * @return Returns a constant domCg_fixed4x1 reference of the _value array. 6375 */ 6376 const domCg_fixed4x1 &getValue() const { return _value; } 6377 /** 6378 * Sets the _value array. 6379 * @param val The new value for the _value array. 6380 */ 6381 void setValue( const domCg_fixed4x1 &val ) { _value = val; } 6382 6383 protected: 6384 /** 6385 * Constructor 6386 */ 6387 domFixed4x1(DAE& dae) : daeElement(dae), _value() {} 6388 /** 6389 * Destructor 6390 */ 6391 virtual ~domFixed4x1() {} 6392 /** 6393 * Overloaded assignment operator 6394 */ 6395 virtual domFixed4x1 &operator=( const domFixed4x1 &cpy ) { (void)cpy; return *this; } 6396 6397 public: // STATIC METHODS 6398 /** 6399 * Creates an instance of this class and returns a daeElementRef referencing it. 6400 * @return a daeElementRef referencing an instance of this object. 6401 */ 6402 static DLLSPEC daeElementRef create(DAE& dae); 6403 /** 6404 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6405 * If a daeMetaElement already exists it will return that instead of creating a new one. 6406 * @return A daeMetaElement describing this COLLADA element. 6407 */ 6408 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6409 }; 6410 6411 class domFixed4x2; 6412 6413 typedef daeSmartRef<domFixed4x2> domFixed4x2Ref; 6414 typedef daeTArray<domFixed4x2Ref> domFixed4x2_Array; 6415 6416 class domFixed4x2 : public daeElement 6417 { 6418 public: 6419 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED4X2; } 6420 static daeInt ID() { return 483; } 6421 virtual daeInt typeID() const { return ID(); } 6422 6423 protected: // Value 6424 /** 6425 * The domCg_fixed4x2 value of the text data of this element. 6426 */ 6427 domCg_fixed4x2 _value; 6428 6429 public: //Accessors and Mutators 6430 /** 6431 * Gets the _value array. 6432 * @return Returns a domCg_fixed4x2 reference of the _value array. 6433 */ 6434 domCg_fixed4x2 &getValue() { return _value; } 6435 /** 6436 * Gets the _value array. 6437 * @return Returns a constant domCg_fixed4x2 reference of the _value array. 6438 */ 6439 const domCg_fixed4x2 &getValue() const { return _value; } 6440 /** 6441 * Sets the _value array. 6442 * @param val The new value for the _value array. 6443 */ 6444 void setValue( const domCg_fixed4x2 &val ) { _value = val; } 6445 6446 protected: 6447 /** 6448 * Constructor 6449 */ 6450 domFixed4x2(DAE& dae) : daeElement(dae), _value() {} 6451 /** 6452 * Destructor 6453 */ 6454 virtual ~domFixed4x2() {} 6455 /** 6456 * Overloaded assignment operator 6457 */ 6458 virtual domFixed4x2 &operator=( const domFixed4x2 &cpy ) { (void)cpy; return *this; } 6459 6460 public: // STATIC METHODS 6461 /** 6462 * Creates an instance of this class and returns a daeElementRef referencing it. 6463 * @return a daeElementRef referencing an instance of this object. 6464 */ 6465 static DLLSPEC daeElementRef create(DAE& dae); 6466 /** 6467 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6468 * If a daeMetaElement already exists it will return that instead of creating a new one. 6469 * @return A daeMetaElement describing this COLLADA element. 6470 */ 6471 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6472 }; 6473 6474 class domFixed4x3; 6475 6476 typedef daeSmartRef<domFixed4x3> domFixed4x3Ref; 6477 typedef daeTArray<domFixed4x3Ref> domFixed4x3_Array; 6478 6479 class domFixed4x3 : public daeElement 6480 { 6481 public: 6482 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED4X3; } 6483 static daeInt ID() { return 484; } 6484 virtual daeInt typeID() const { return ID(); } 6485 6486 protected: // Value 6487 /** 6488 * The domCg_fixed4x3 value of the text data of this element. 6489 */ 6490 domCg_fixed4x3 _value; 6491 6492 public: //Accessors and Mutators 6493 /** 6494 * Gets the _value array. 6495 * @return Returns a domCg_fixed4x3 reference of the _value array. 6496 */ 6497 domCg_fixed4x3 &getValue() { return _value; } 6498 /** 6499 * Gets the _value array. 6500 * @return Returns a constant domCg_fixed4x3 reference of the _value array. 6501 */ 6502 const domCg_fixed4x3 &getValue() const { return _value; } 6503 /** 6504 * Sets the _value array. 6505 * @param val The new value for the _value array. 6506 */ 6507 void setValue( const domCg_fixed4x3 &val ) { _value = val; } 6508 6509 protected: 6510 /** 6511 * Constructor 6512 */ 6513 domFixed4x3(DAE& dae) : daeElement(dae), _value() {} 6514 /** 6515 * Destructor 6516 */ 6517 virtual ~domFixed4x3() {} 6518 /** 6519 * Overloaded assignment operator 6520 */ 6521 virtual domFixed4x3 &operator=( const domFixed4x3 &cpy ) { (void)cpy; return *this; } 6522 6523 public: // STATIC METHODS 6524 /** 6525 * Creates an instance of this class and returns a daeElementRef referencing it. 6526 * @return a daeElementRef referencing an instance of this object. 6527 */ 6528 static DLLSPEC daeElementRef create(DAE& dae); 6529 /** 6530 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6531 * If a daeMetaElement already exists it will return that instead of creating a new one. 6532 * @return A daeMetaElement describing this COLLADA element. 6533 */ 6534 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6535 }; 6536 6537 class domFixed4x4; 6538 6539 typedef daeSmartRef<domFixed4x4> domFixed4x4Ref; 6540 typedef daeTArray<domFixed4x4Ref> domFixed4x4_Array; 6541 6542 class domFixed4x4 : public daeElement 6543 { 6544 public: 6545 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FIXED4X4; } 6546 static daeInt ID() { return 485; } 6547 virtual daeInt typeID() const { return ID(); } 6548 6549 protected: // Value 6550 /** 6551 * The domCg_fixed4x4 value of the text data of this element. 6552 */ 6553 domCg_fixed4x4 _value; 6554 6555 public: //Accessors and Mutators 6556 /** 6557 * Gets the _value array. 6558 * @return Returns a domCg_fixed4x4 reference of the _value array. 6559 */ 6560 domCg_fixed4x4 &getValue() { return _value; } 6561 /** 6562 * Gets the _value array. 6563 * @return Returns a constant domCg_fixed4x4 reference of the _value array. 6564 */ 6565 const domCg_fixed4x4 &getValue() const { return _value; } 6566 /** 6567 * Sets the _value array. 6568 * @param val The new value for the _value array. 6569 */ 6570 void setValue( const domCg_fixed4x4 &val ) { _value = val; } 6571 6572 protected: 6573 /** 6574 * Constructor 6575 */ 6576 domFixed4x4(DAE& dae) : daeElement(dae), _value() {} 6577 /** 6578 * Destructor 6579 */ 6580 virtual ~domFixed4x4() {} 6581 /** 6582 * Overloaded assignment operator 6583 */ 6584 virtual domFixed4x4 &operator=( const domFixed4x4 &cpy ) { (void)cpy; return *this; } 6585 6586 public: // STATIC METHODS 6587 /** 6588 * Creates an instance of this class and returns a daeElementRef referencing it. 6589 * @return a daeElementRef referencing an instance of this object. 6590 */ 6591 static DLLSPEC daeElementRef create(DAE& dae); 6592 /** 6593 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6594 * If a daeMetaElement already exists it will return that instead of creating a new one. 6595 * @return A daeMetaElement describing this COLLADA element. 6596 */ 6597 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6598 }; 6599 6600 class domString; 6601 6602 typedef daeSmartRef<domString> domStringRef; 6603 typedef daeTArray<domStringRef> domString_Array; 6604 6605 class domString : public daeElement 6606 { 6607 public: 6608 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STRING; } 6609 static daeInt ID() { return 486; } 6610 virtual daeInt typeID() const { return ID(); } 6611 6612 protected: // Value 6613 /** 6614 * The ::xsString value of the text data of this element. 6615 */ 6616 ::xsString _value; 6617 6618 public: //Accessors and Mutators 6619 /** 6620 * Gets the value of this element. 6621 * @return Returns a ::xsString of the value. 6622 */ 6623 ::xsString getValue() const { return _value; } 6624 /** 6625 * Sets the _value of this element. 6626 * @param val The new value for this element. 6627 */ 6628 void setValue( ::xsString val ) { *(daeStringRef*)&_value = val; } 6629 6630 protected: 6631 /** 6632 * Constructor 6633 */ 6634 domString(DAE& dae) : daeElement(dae), _value() {} 6635 /** 6636 * Destructor 6637 */ 6638 virtual ~domString() {} 6639 /** 6640 * Overloaded assignment operator 6641 */ 6642 virtual domString &operator=( const domString &cpy ) { (void)cpy; return *this; } 6643 6644 public: // STATIC METHODS 6645 /** 6646 * Creates an instance of this class and returns a daeElementRef referencing it. 6647 * @return a daeElementRef referencing an instance of this object. 6648 */ 6649 static DLLSPEC daeElementRef create(DAE& dae); 6650 /** 6651 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6652 * If a daeMetaElement already exists it will return that instead of creating a new one. 6653 * @return A daeMetaElement describing this COLLADA element. 6654 */ 6655 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6656 }; 6657 6658 class domEnum; 6659 6660 typedef daeSmartRef<domEnum> domEnumRef; 6661 typedef daeTArray<domEnumRef> domEnum_Array; 6662 6663 class domEnum : public daeElement 6664 { 6665 public: 6666 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ENUM; } 6667 static daeInt ID() { return 487; } 6668 virtual daeInt typeID() const { return ID(); } 6669 6670 protected: // Value 6671 /** 6672 * The domGl_enumeration value of the text data of this element. 6673 */ 6674 domGl_enumeration _value; 6675 6676 public: //Accessors and Mutators 6677 /** 6678 * Gets the value of this element. 6679 * @return a domGl_enumeration of the value. 6680 */ 6681 domGl_enumeration getValue() const { return _value; } 6682 /** 6683 * Sets the _value of this element. 6684 * @param val The new value for this element. 6685 */ 6686 void setValue( domGl_enumeration val ) { _value = val; } 6687 6688 protected: 6689 /** 6690 * Constructor 6691 */ 6692 domEnum(DAE& dae) : daeElement(dae), _value() {} 6693 /** 6694 * Destructor 6695 */ 6696 virtual ~domEnum() {} 6697 /** 6698 * Overloaded assignment operator 6699 */ 6700 virtual domEnum &operator=( const domEnum &cpy ) { (void)cpy; return *this; } 6701 6702 public: // STATIC METHODS 6703 /** 6704 * Creates an instance of this class and returns a daeElementRef referencing it. 6705 * @return a daeElementRef referencing an instance of this object. 6706 */ 6707 static DLLSPEC daeElementRef create(DAE& dae); 6708 /** 6709 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6710 * If a daeMetaElement already exists it will return that instead of creating a new one. 6711 * @return A daeMetaElement describing this COLLADA element. 6712 */ 6713 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6714 }; 6715 6716 6717 6718 protected: // Elements 6719 domBoolRef elemBool; 6720 domBool1Ref elemBool1; 6721 domBool2Ref elemBool2; 6722 domBool3Ref elemBool3; 6723 domBool4Ref elemBool4; 6724 domBool1x1Ref elemBool1x1; 6725 domBool1x2Ref elemBool1x2; 6726 domBool1x3Ref elemBool1x3; 6727 domBool1x4Ref elemBool1x4; 6728 domBool2x1Ref elemBool2x1; 6729 domBool2x2Ref elemBool2x2; 6730 domBool2x3Ref elemBool2x3; 6731 domBool2x4Ref elemBool2x4; 6732 domBool3x1Ref elemBool3x1; 6733 domBool3x2Ref elemBool3x2; 6734 domBool3x3Ref elemBool3x3; 6735 domBool3x4Ref elemBool3x4; 6736 domBool4x1Ref elemBool4x1; 6737 domBool4x2Ref elemBool4x2; 6738 domBool4x3Ref elemBool4x3; 6739 domBool4x4Ref elemBool4x4; 6740 domFloatRef elemFloat; 6741 domFloat1Ref elemFloat1; 6742 domFloat2Ref elemFloat2; 6743 domFloat3Ref elemFloat3; 6744 domFloat4Ref elemFloat4; 6745 domFloat1x1Ref elemFloat1x1; 6746 domFloat1x2Ref elemFloat1x2; 6747 domFloat1x3Ref elemFloat1x3; 6748 domFloat1x4Ref elemFloat1x4; 6749 domFloat2x1Ref elemFloat2x1; 6750 domFloat2x2Ref elemFloat2x2; 6751 domFloat2x3Ref elemFloat2x3; 6752 domFloat2x4Ref elemFloat2x4; 6753 domFloat3x1Ref elemFloat3x1; 6754 domFloat3x2Ref elemFloat3x2; 6755 domFloat3x3Ref elemFloat3x3; 6756 domFloat3x4Ref elemFloat3x4; 6757 domFloat4x1Ref elemFloat4x1; 6758 domFloat4x2Ref elemFloat4x2; 6759 domFloat4x3Ref elemFloat4x3; 6760 domFloat4x4Ref elemFloat4x4; 6761 domIntRef elemInt; 6762 domInt1Ref elemInt1; 6763 domInt2Ref elemInt2; 6764 domInt3Ref elemInt3; 6765 domInt4Ref elemInt4; 6766 domInt1x1Ref elemInt1x1; 6767 domInt1x2Ref elemInt1x2; 6768 domInt1x3Ref elemInt1x3; 6769 domInt1x4Ref elemInt1x4; 6770 domInt2x1Ref elemInt2x1; 6771 domInt2x2Ref elemInt2x2; 6772 domInt2x3Ref elemInt2x3; 6773 domInt2x4Ref elemInt2x4; 6774 domInt3x1Ref elemInt3x1; 6775 domInt3x2Ref elemInt3x2; 6776 domInt3x3Ref elemInt3x3; 6777 domInt3x4Ref elemInt3x4; 6778 domInt4x1Ref elemInt4x1; 6779 domInt4x2Ref elemInt4x2; 6780 domInt4x3Ref elemInt4x3; 6781 domInt4x4Ref elemInt4x4; 6782 domHalfRef elemHalf; 6783 domHalf1Ref elemHalf1; 6784 domHalf2Ref elemHalf2; 6785 domHalf3Ref elemHalf3; 6786 domHalf4Ref elemHalf4; 6787 domHalf1x1Ref elemHalf1x1; 6788 domHalf1x2Ref elemHalf1x2; 6789 domHalf1x3Ref elemHalf1x3; 6790 domHalf1x4Ref elemHalf1x4; 6791 domHalf2x1Ref elemHalf2x1; 6792 domHalf2x2Ref elemHalf2x2; 6793 domHalf2x3Ref elemHalf2x3; 6794 domHalf2x4Ref elemHalf2x4; 6795 domHalf3x1Ref elemHalf3x1; 6796 domHalf3x2Ref elemHalf3x2; 6797 domHalf3x3Ref elemHalf3x3; 6798 domHalf3x4Ref elemHalf3x4; 6799 domHalf4x1Ref elemHalf4x1; 6800 domHalf4x2Ref elemHalf4x2; 6801 domHalf4x3Ref elemHalf4x3; 6802 domHalf4x4Ref elemHalf4x4; 6803 domFixedRef elemFixed; 6804 domFixed1Ref elemFixed1; 6805 domFixed2Ref elemFixed2; 6806 domFixed3Ref elemFixed3; 6807 domFixed4Ref elemFixed4; 6808 domFixed1x1Ref elemFixed1x1; 6809 domFixed1x2Ref elemFixed1x2; 6810 domFixed1x3Ref elemFixed1x3; 6811 domFixed1x4Ref elemFixed1x4; 6812 domFixed2x1Ref elemFixed2x1; 6813 domFixed2x2Ref elemFixed2x2; 6814 domFixed2x3Ref elemFixed2x3; 6815 domFixed2x4Ref elemFixed2x4; 6816 domFixed3x1Ref elemFixed3x1; 6817 domFixed3x2Ref elemFixed3x2; 6818 domFixed3x3Ref elemFixed3x3; 6819 domFixed3x4Ref elemFixed3x4; 6820 domFixed4x1Ref elemFixed4x1; 6821 domFixed4x2Ref elemFixed4x2; 6822 domFixed4x3Ref elemFixed4x3; 6823 domFixed4x4Ref elemFixed4x4; 6824 domCg_surface_typeRef elemSurface; 6825 domCg_sampler1DRef elemSampler1D; 6826 domCg_sampler2DRef elemSampler2D; 6827 domCg_sampler3DRef elemSampler3D; 6828 domCg_samplerRECTRef elemSamplerRECT; 6829 domCg_samplerCUBERef elemSamplerCUBE; 6830 domCg_samplerDEPTHRef elemSamplerDEPTH; 6831 domStringRef elemString; 6832 domEnumRef elemEnum; 6833 /** 6834 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 6835 */ 6836 daeElementRefArray _contents; 6837 /** 6838 * Used to preserve order in elements that have a complex content model. 6839 */ 6840 daeUIntArray _contentsOrder; 6841 6842 /** 6843 * Used to store information needed for some content model objects. 6844 */ 6845 daeTArray< daeCharArray * > _CMData; 6846 6847 6848 public: //Accessors and Mutators 6849 /** 6850 * Gets the bool element. 6851 * @return a daeSmartRef to the bool element. 6852 */ 6853 const domBoolRef getBool() const { return elemBool; } 6854 /** 6855 * Gets the bool1 element. 6856 * @return a daeSmartRef to the bool1 element. 6857 */ 6858 const domBool1Ref getBool1() const { return elemBool1; } 6859 /** 6860 * Gets the bool2 element. 6861 * @return a daeSmartRef to the bool2 element. 6862 */ 6863 const domBool2Ref getBool2() const { return elemBool2; } 6864 /** 6865 * Gets the bool3 element. 6866 * @return a daeSmartRef to the bool3 element. 6867 */ 6868 const domBool3Ref getBool3() const { return elemBool3; } 6869 /** 6870 * Gets the bool4 element. 6871 * @return a daeSmartRef to the bool4 element. 6872 */ 6873 const domBool4Ref getBool4() const { return elemBool4; } 6874 /** 6875 * Gets the bool1x1 element. 6876 * @return a daeSmartRef to the bool1x1 element. 6877 */ 6878 const domBool1x1Ref getBool1x1() const { return elemBool1x1; } 6879 /** 6880 * Gets the bool1x2 element. 6881 * @return a daeSmartRef to the bool1x2 element. 6882 */ 6883 const domBool1x2Ref getBool1x2() const { return elemBool1x2; } 6884 /** 6885 * Gets the bool1x3 element. 6886 * @return a daeSmartRef to the bool1x3 element. 6887 */ 6888 const domBool1x3Ref getBool1x3() const { return elemBool1x3; } 6889 /** 6890 * Gets the bool1x4 element. 6891 * @return a daeSmartRef to the bool1x4 element. 6892 */ 6893 const domBool1x4Ref getBool1x4() const { return elemBool1x4; } 6894 /** 6895 * Gets the bool2x1 element. 6896 * @return a daeSmartRef to the bool2x1 element. 6897 */ 6898 const domBool2x1Ref getBool2x1() const { return elemBool2x1; } 6899 /** 6900 * Gets the bool2x2 element. 6901 * @return a daeSmartRef to the bool2x2 element. 6902 */ 6903 const domBool2x2Ref getBool2x2() const { return elemBool2x2; } 6904 /** 6905 * Gets the bool2x3 element. 6906 * @return a daeSmartRef to the bool2x3 element. 6907 */ 6908 const domBool2x3Ref getBool2x3() const { return elemBool2x3; } 6909 /** 6910 * Gets the bool2x4 element. 6911 * @return a daeSmartRef to the bool2x4 element. 6912 */ 6913 const domBool2x4Ref getBool2x4() const { return elemBool2x4; } 6914 /** 6915 * Gets the bool3x1 element. 6916 * @return a daeSmartRef to the bool3x1 element. 6917 */ 6918 const domBool3x1Ref getBool3x1() const { return elemBool3x1; } 6919 /** 6920 * Gets the bool3x2 element. 6921 * @return a daeSmartRef to the bool3x2 element. 6922 */ 6923 const domBool3x2Ref getBool3x2() const { return elemBool3x2; } 6924 /** 6925 * Gets the bool3x3 element. 6926 * @return a daeSmartRef to the bool3x3 element. 6927 */ 6928 const domBool3x3Ref getBool3x3() const { return elemBool3x3; } 6929 /** 6930 * Gets the bool3x4 element. 6931 * @return a daeSmartRef to the bool3x4 element. 6932 */ 6933 const domBool3x4Ref getBool3x4() const { return elemBool3x4; } 6934 /** 6935 * Gets the bool4x1 element. 6936 * @return a daeSmartRef to the bool4x1 element. 6937 */ 6938 const domBool4x1Ref getBool4x1() const { return elemBool4x1; } 6939 /** 6940 * Gets the bool4x2 element. 6941 * @return a daeSmartRef to the bool4x2 element. 6942 */ 6943 const domBool4x2Ref getBool4x2() const { return elemBool4x2; } 6944 /** 6945 * Gets the bool4x3 element. 6946 * @return a daeSmartRef to the bool4x3 element. 6947 */ 6948 const domBool4x3Ref getBool4x3() const { return elemBool4x3; } 6949 /** 6950 * Gets the bool4x4 element. 6951 * @return a daeSmartRef to the bool4x4 element. 6952 */ 6953 const domBool4x4Ref getBool4x4() const { return elemBool4x4; } 6954 /** 6955 * Gets the float element. 6956 * @return a daeSmartRef to the float element. 6957 */ 6958 const domFloatRef getFloat() const { return elemFloat; } 6959 /** 6960 * Gets the float1 element. 6961 * @return a daeSmartRef to the float1 element. 6962 */ 6963 const domFloat1Ref getFloat1() const { return elemFloat1; } 6964 /** 6965 * Gets the float2 element. 6966 * @return a daeSmartRef to the float2 element. 6967 */ 6968 const domFloat2Ref getFloat2() const { return elemFloat2; } 6969 /** 6970 * Gets the float3 element. 6971 * @return a daeSmartRef to the float3 element. 6972 */ 6973 const domFloat3Ref getFloat3() const { return elemFloat3; } 6974 /** 6975 * Gets the float4 element. 6976 * @return a daeSmartRef to the float4 element. 6977 */ 6978 const domFloat4Ref getFloat4() const { return elemFloat4; } 6979 /** 6980 * Gets the float1x1 element. 6981 * @return a daeSmartRef to the float1x1 element. 6982 */ 6983 const domFloat1x1Ref getFloat1x1() const { return elemFloat1x1; } 6984 /** 6985 * Gets the float1x2 element. 6986 * @return a daeSmartRef to the float1x2 element. 6987 */ 6988 const domFloat1x2Ref getFloat1x2() const { return elemFloat1x2; } 6989 /** 6990 * Gets the float1x3 element. 6991 * @return a daeSmartRef to the float1x3 element. 6992 */ 6993 const domFloat1x3Ref getFloat1x3() const { return elemFloat1x3; } 6994 /** 6995 * Gets the float1x4 element. 6996 * @return a daeSmartRef to the float1x4 element. 6997 */ 6998 const domFloat1x4Ref getFloat1x4() const { return elemFloat1x4; } 6999 /** 7000 * Gets the float2x1 element. 7001 * @return a daeSmartRef to the float2x1 element. 7002 */ 7003 const domFloat2x1Ref getFloat2x1() const { return elemFloat2x1; } 7004 /** 7005 * Gets the float2x2 element. 7006 * @return a daeSmartRef to the float2x2 element. 7007 */ 7008 const domFloat2x2Ref getFloat2x2() const { return elemFloat2x2; } 7009 /** 7010 * Gets the float2x3 element. 7011 * @return a daeSmartRef to the float2x3 element. 7012 */ 7013 const domFloat2x3Ref getFloat2x3() const { return elemFloat2x3; } 7014 /** 7015 * Gets the float2x4 element. 7016 * @return a daeSmartRef to the float2x4 element. 7017 */ 7018 const domFloat2x4Ref getFloat2x4() const { return elemFloat2x4; } 7019 /** 7020 * Gets the float3x1 element. 7021 * @return a daeSmartRef to the float3x1 element. 7022 */ 7023 const domFloat3x1Ref getFloat3x1() const { return elemFloat3x1; } 7024 /** 7025 * Gets the float3x2 element. 7026 * @return a daeSmartRef to the float3x2 element. 7027 */ 7028 const domFloat3x2Ref getFloat3x2() const { return elemFloat3x2; } 7029 /** 7030 * Gets the float3x3 element. 7031 * @return a daeSmartRef to the float3x3 element. 7032 */ 7033 const domFloat3x3Ref getFloat3x3() const { return elemFloat3x3; } 7034 /** 7035 * Gets the float3x4 element. 7036 * @return a daeSmartRef to the float3x4 element. 7037 */ 7038 const domFloat3x4Ref getFloat3x4() const { return elemFloat3x4; } 7039 /** 7040 * Gets the float4x1 element. 7041 * @return a daeSmartRef to the float4x1 element. 7042 */ 7043 const domFloat4x1Ref getFloat4x1() const { return elemFloat4x1; } 7044 /** 7045 * Gets the float4x2 element. 7046 * @return a daeSmartRef to the float4x2 element. 7047 */ 7048 const domFloat4x2Ref getFloat4x2() const { return elemFloat4x2; } 7049 /** 7050 * Gets the float4x3 element. 7051 * @return a daeSmartRef to the float4x3 element. 7052 */ 7053 const domFloat4x3Ref getFloat4x3() const { return elemFloat4x3; } 7054 /** 7055 * Gets the float4x4 element. 7056 * @return a daeSmartRef to the float4x4 element. 7057 */ 7058 const domFloat4x4Ref getFloat4x4() const { return elemFloat4x4; } 7059 /** 7060 * Gets the int element. 7061 * @return a daeSmartRef to the int element. 7062 */ 7063 const domIntRef getInt() const { return elemInt; } 7064 /** 7065 * Gets the int1 element. 7066 * @return a daeSmartRef to the int1 element. 7067 */ 7068 const domInt1Ref getInt1() const { return elemInt1; } 7069 /** 7070 * Gets the int2 element. 7071 * @return a daeSmartRef to the int2 element. 7072 */ 7073 const domInt2Ref getInt2() const { return elemInt2; } 7074 /** 7075 * Gets the int3 element. 7076 * @return a daeSmartRef to the int3 element. 7077 */ 7078 const domInt3Ref getInt3() const { return elemInt3; } 7079 /** 7080 * Gets the int4 element. 7081 * @return a daeSmartRef to the int4 element. 7082 */ 7083 const domInt4Ref getInt4() const { return elemInt4; } 7084 /** 7085 * Gets the int1x1 element. 7086 * @return a daeSmartRef to the int1x1 element. 7087 */ 7088 const domInt1x1Ref getInt1x1() const { return elemInt1x1; } 7089 /** 7090 * Gets the int1x2 element. 7091 * @return a daeSmartRef to the int1x2 element. 7092 */ 7093 const domInt1x2Ref getInt1x2() const { return elemInt1x2; } 7094 /** 7095 * Gets the int1x3 element. 7096 * @return a daeSmartRef to the int1x3 element. 7097 */ 7098 const domInt1x3Ref getInt1x3() const { return elemInt1x3; } 7099 /** 7100 * Gets the int1x4 element. 7101 * @return a daeSmartRef to the int1x4 element. 7102 */ 7103 const domInt1x4Ref getInt1x4() const { return elemInt1x4; } 7104 /** 7105 * Gets the int2x1 element. 7106 * @return a daeSmartRef to the int2x1 element. 7107 */ 7108 const domInt2x1Ref getInt2x1() const { return elemInt2x1; } 7109 /** 7110 * Gets the int2x2 element. 7111 * @return a daeSmartRef to the int2x2 element. 7112 */ 7113 const domInt2x2Ref getInt2x2() const { return elemInt2x2; } 7114 /** 7115 * Gets the int2x3 element. 7116 * @return a daeSmartRef to the int2x3 element. 7117 */ 7118 const domInt2x3Ref getInt2x3() const { return elemInt2x3; } 7119 /** 7120 * Gets the int2x4 element. 7121 * @return a daeSmartRef to the int2x4 element. 7122 */ 7123 const domInt2x4Ref getInt2x4() const { return elemInt2x4; } 7124 /** 7125 * Gets the int3x1 element. 7126 * @return a daeSmartRef to the int3x1 element. 7127 */ 7128 const domInt3x1Ref getInt3x1() const { return elemInt3x1; } 7129 /** 7130 * Gets the int3x2 element. 7131 * @return a daeSmartRef to the int3x2 element. 7132 */ 7133 const domInt3x2Ref getInt3x2() const { return elemInt3x2; } 7134 /** 7135 * Gets the int3x3 element. 7136 * @return a daeSmartRef to the int3x3 element. 7137 */ 7138 const domInt3x3Ref getInt3x3() const { return elemInt3x3; } 7139 /** 7140 * Gets the int3x4 element. 7141 * @return a daeSmartRef to the int3x4 element. 7142 */ 7143 const domInt3x4Ref getInt3x4() const { return elemInt3x4; } 7144 /** 7145 * Gets the int4x1 element. 7146 * @return a daeSmartRef to the int4x1 element. 7147 */ 7148 const domInt4x1Ref getInt4x1() const { return elemInt4x1; } 7149 /** 7150 * Gets the int4x2 element. 7151 * @return a daeSmartRef to the int4x2 element. 7152 */ 7153 const domInt4x2Ref getInt4x2() const { return elemInt4x2; } 7154 /** 7155 * Gets the int4x3 element. 7156 * @return a daeSmartRef to the int4x3 element. 7157 */ 7158 const domInt4x3Ref getInt4x3() const { return elemInt4x3; } 7159 /** 7160 * Gets the int4x4 element. 7161 * @return a daeSmartRef to the int4x4 element. 7162 */ 7163 const domInt4x4Ref getInt4x4() const { return elemInt4x4; } 7164 /** 7165 * Gets the half element. 7166 * @return a daeSmartRef to the half element. 7167 */ 7168 const domHalfRef getHalf() const { return elemHalf; } 7169 /** 7170 * Gets the half1 element. 7171 * @return a daeSmartRef to the half1 element. 7172 */ 7173 const domHalf1Ref getHalf1() const { return elemHalf1; } 7174 /** 7175 * Gets the half2 element. 7176 * @return a daeSmartRef to the half2 element. 7177 */ 7178 const domHalf2Ref getHalf2() const { return elemHalf2; } 7179 /** 7180 * Gets the half3 element. 7181 * @return a daeSmartRef to the half3 element. 7182 */ 7183 const domHalf3Ref getHalf3() const { return elemHalf3; } 7184 /** 7185 * Gets the half4 element. 7186 * @return a daeSmartRef to the half4 element. 7187 */ 7188 const domHalf4Ref getHalf4() const { return elemHalf4; } 7189 /** 7190 * Gets the half1x1 element. 7191 * @return a daeSmartRef to the half1x1 element. 7192 */ 7193 const domHalf1x1Ref getHalf1x1() const { return elemHalf1x1; } 7194 /** 7195 * Gets the half1x2 element. 7196 * @return a daeSmartRef to the half1x2 element. 7197 */ 7198 const domHalf1x2Ref getHalf1x2() const { return elemHalf1x2; } 7199 /** 7200 * Gets the half1x3 element. 7201 * @return a daeSmartRef to the half1x3 element. 7202 */ 7203 const domHalf1x3Ref getHalf1x3() const { return elemHalf1x3; } 7204 /** 7205 * Gets the half1x4 element. 7206 * @return a daeSmartRef to the half1x4 element. 7207 */ 7208 const domHalf1x4Ref getHalf1x4() const { return elemHalf1x4; } 7209 /** 7210 * Gets the half2x1 element. 7211 * @return a daeSmartRef to the half2x1 element. 7212 */ 7213 const domHalf2x1Ref getHalf2x1() const { return elemHalf2x1; } 7214 /** 7215 * Gets the half2x2 element. 7216 * @return a daeSmartRef to the half2x2 element. 7217 */ 7218 const domHalf2x2Ref getHalf2x2() const { return elemHalf2x2; } 7219 /** 7220 * Gets the half2x3 element. 7221 * @return a daeSmartRef to the half2x3 element. 7222 */ 7223 const domHalf2x3Ref getHalf2x3() const { return elemHalf2x3; } 7224 /** 7225 * Gets the half2x4 element. 7226 * @return a daeSmartRef to the half2x4 element. 7227 */ 7228 const domHalf2x4Ref getHalf2x4() const { return elemHalf2x4; } 7229 /** 7230 * Gets the half3x1 element. 7231 * @return a daeSmartRef to the half3x1 element. 7232 */ 7233 const domHalf3x1Ref getHalf3x1() const { return elemHalf3x1; } 7234 /** 7235 * Gets the half3x2 element. 7236 * @return a daeSmartRef to the half3x2 element. 7237 */ 7238 const domHalf3x2Ref getHalf3x2() const { return elemHalf3x2; } 7239 /** 7240 * Gets the half3x3 element. 7241 * @return a daeSmartRef to the half3x3 element. 7242 */ 7243 const domHalf3x3Ref getHalf3x3() const { return elemHalf3x3; } 7244 /** 7245 * Gets the half3x4 element. 7246 * @return a daeSmartRef to the half3x4 element. 7247 */ 7248 const domHalf3x4Ref getHalf3x4() const { return elemHalf3x4; } 7249 /** 7250 * Gets the half4x1 element. 7251 * @return a daeSmartRef to the half4x1 element. 7252 */ 7253 const domHalf4x1Ref getHalf4x1() const { return elemHalf4x1; } 7254 /** 7255 * Gets the half4x2 element. 7256 * @return a daeSmartRef to the half4x2 element. 7257 */ 7258 const domHalf4x2Ref getHalf4x2() const { return elemHalf4x2; } 7259 /** 7260 * Gets the half4x3 element. 7261 * @return a daeSmartRef to the half4x3 element. 7262 */ 7263 const domHalf4x3Ref getHalf4x3() const { return elemHalf4x3; } 7264 /** 7265 * Gets the half4x4 element. 7266 * @return a daeSmartRef to the half4x4 element. 7267 */ 7268 const domHalf4x4Ref getHalf4x4() const { return elemHalf4x4; } 7269 /** 7270 * Gets the fixed element. 7271 * @return a daeSmartRef to the fixed element. 7272 */ 7273 const domFixedRef getFixed() const { return elemFixed; } 7274 /** 7275 * Gets the fixed1 element. 7276 * @return a daeSmartRef to the fixed1 element. 7277 */ 7278 const domFixed1Ref getFixed1() const { return elemFixed1; } 7279 /** 7280 * Gets the fixed2 element. 7281 * @return a daeSmartRef to the fixed2 element. 7282 */ 7283 const domFixed2Ref getFixed2() const { return elemFixed2; } 7284 /** 7285 * Gets the fixed3 element. 7286 * @return a daeSmartRef to the fixed3 element. 7287 */ 7288 const domFixed3Ref getFixed3() const { return elemFixed3; } 7289 /** 7290 * Gets the fixed4 element. 7291 * @return a daeSmartRef to the fixed4 element. 7292 */ 7293 const domFixed4Ref getFixed4() const { return elemFixed4; } 7294 /** 7295 * Gets the fixed1x1 element. 7296 * @return a daeSmartRef to the fixed1x1 element. 7297 */ 7298 const domFixed1x1Ref getFixed1x1() const { return elemFixed1x1; } 7299 /** 7300 * Gets the fixed1x2 element. 7301 * @return a daeSmartRef to the fixed1x2 element. 7302 */ 7303 const domFixed1x2Ref getFixed1x2() const { return elemFixed1x2; } 7304 /** 7305 * Gets the fixed1x3 element. 7306 * @return a daeSmartRef to the fixed1x3 element. 7307 */ 7308 const domFixed1x3Ref getFixed1x3() const { return elemFixed1x3; } 7309 /** 7310 * Gets the fixed1x4 element. 7311 * @return a daeSmartRef to the fixed1x4 element. 7312 */ 7313 const domFixed1x4Ref getFixed1x4() const { return elemFixed1x4; } 7314 /** 7315 * Gets the fixed2x1 element. 7316 * @return a daeSmartRef to the fixed2x1 element. 7317 */ 7318 const domFixed2x1Ref getFixed2x1() const { return elemFixed2x1; } 7319 /** 7320 * Gets the fixed2x2 element. 7321 * @return a daeSmartRef to the fixed2x2 element. 7322 */ 7323 const domFixed2x2Ref getFixed2x2() const { return elemFixed2x2; } 7324 /** 7325 * Gets the fixed2x3 element. 7326 * @return a daeSmartRef to the fixed2x3 element. 7327 */ 7328 const domFixed2x3Ref getFixed2x3() const { return elemFixed2x3; } 7329 /** 7330 * Gets the fixed2x4 element. 7331 * @return a daeSmartRef to the fixed2x4 element. 7332 */ 7333 const domFixed2x4Ref getFixed2x4() const { return elemFixed2x4; } 7334 /** 7335 * Gets the fixed3x1 element. 7336 * @return a daeSmartRef to the fixed3x1 element. 7337 */ 7338 const domFixed3x1Ref getFixed3x1() const { return elemFixed3x1; } 7339 /** 7340 * Gets the fixed3x2 element. 7341 * @return a daeSmartRef to the fixed3x2 element. 7342 */ 7343 const domFixed3x2Ref getFixed3x2() const { return elemFixed3x2; } 7344 /** 7345 * Gets the fixed3x3 element. 7346 * @return a daeSmartRef to the fixed3x3 element. 7347 */ 7348 const domFixed3x3Ref getFixed3x3() const { return elemFixed3x3; } 7349 /** 7350 * Gets the fixed3x4 element. 7351 * @return a daeSmartRef to the fixed3x4 element. 7352 */ 7353 const domFixed3x4Ref getFixed3x4() const { return elemFixed3x4; } 7354 /** 7355 * Gets the fixed4x1 element. 7356 * @return a daeSmartRef to the fixed4x1 element. 7357 */ 7358 const domFixed4x1Ref getFixed4x1() const { return elemFixed4x1; } 7359 /** 7360 * Gets the fixed4x2 element. 7361 * @return a daeSmartRef to the fixed4x2 element. 7362 */ 7363 const domFixed4x2Ref getFixed4x2() const { return elemFixed4x2; } 7364 /** 7365 * Gets the fixed4x3 element. 7366 * @return a daeSmartRef to the fixed4x3 element. 7367 */ 7368 const domFixed4x3Ref getFixed4x3() const { return elemFixed4x3; } 7369 /** 7370 * Gets the fixed4x4 element. 7371 * @return a daeSmartRef to the fixed4x4 element. 7372 */ 7373 const domFixed4x4Ref getFixed4x4() const { return elemFixed4x4; } 7374 /** 7375 * Gets the surface element. 7376 * @return a daeSmartRef to the surface element. 7377 */ 7378 const domCg_surface_typeRef getSurface() const { return elemSurface; } 7379 /** 7380 * Gets the sampler1D element. 7381 * @return a daeSmartRef to the sampler1D element. 7382 */ 7383 const domCg_sampler1DRef getSampler1D() const { return elemSampler1D; } 7384 /** 7385 * Gets the sampler2D element. 7386 * @return a daeSmartRef to the sampler2D element. 7387 */ 7388 const domCg_sampler2DRef getSampler2D() const { return elemSampler2D; } 7389 /** 7390 * Gets the sampler3D element. 7391 * @return a daeSmartRef to the sampler3D element. 7392 */ 7393 const domCg_sampler3DRef getSampler3D() const { return elemSampler3D; } 7394 /** 7395 * Gets the samplerRECT element. 7396 * @return a daeSmartRef to the samplerRECT element. 7397 */ 7398 const domCg_samplerRECTRef getSamplerRECT() const { return elemSamplerRECT; } 7399 /** 7400 * Gets the samplerCUBE element. 7401 * @return a daeSmartRef to the samplerCUBE element. 7402 */ 7403 const domCg_samplerCUBERef getSamplerCUBE() const { return elemSamplerCUBE; } 7404 /** 7405 * Gets the samplerDEPTH element. 7406 * @return a daeSmartRef to the samplerDEPTH element. 7407 */ 7408 const domCg_samplerDEPTHRef getSamplerDEPTH() const { return elemSamplerDEPTH; } 7409 /** 7410 * Gets the string element. 7411 * @return a daeSmartRef to the string element. 7412 */ 7413 const domStringRef getString() const { return elemString; } 7414 /** 7415 * Gets the enum element. 7416 * @return a daeSmartRef to the enum element. 7417 */ 7418 const domEnumRef getEnum() const { return elemEnum; } 7419 /** 7420 * Gets the _contents array. 7421 * @return Returns a reference to the _contents element array. 7422 */ 7423 daeElementRefArray &getContents() { return _contents; } 7424 /** 7425 * Gets the _contents array. 7426 * @return Returns a constant reference to the _contents element array. 7427 */ 7428 const daeElementRefArray &getContents() const { return _contents; } 7429 7430 protected: 7431 /** 7432 * Constructor 7433 */ 7434 domCg_param_type(DAE& dae) : daeElement(dae), elemBool(), elemBool1(), elemBool2(), elemBool3(), elemBool4(), elemBool1x1(), elemBool1x2(), elemBool1x3(), elemBool1x4(), elemBool2x1(), elemBool2x2(), elemBool2x3(), elemBool2x4(), elemBool3x1(), elemBool3x2(), elemBool3x3(), elemBool3x4(), elemBool4x1(), elemBool4x2(), elemBool4x3(), elemBool4x4(), elemFloat(), elemFloat1(), elemFloat2(), elemFloat3(), elemFloat4(), elemFloat1x1(), elemFloat1x2(), elemFloat1x3(), elemFloat1x4(), elemFloat2x1(), elemFloat2x2(), elemFloat2x3(), elemFloat2x4(), elemFloat3x1(), elemFloat3x2(), elemFloat3x3(), elemFloat3x4(), elemFloat4x1(), elemFloat4x2(), elemFloat4x3(), elemFloat4x4(), elemInt(), elemInt1(), elemInt2(), elemInt3(), elemInt4(), elemInt1x1(), elemInt1x2(), elemInt1x3(), elemInt1x4(), elemInt2x1(), elemInt2x2(), elemInt2x3(), elemInt2x4(), elemInt3x1(), elemInt3x2(), elemInt3x3(), elemInt3x4(), elemInt4x1(), elemInt4x2(), elemInt4x3(), elemInt4x4(), elemHalf(), elemHalf1(), elemHalf2(), elemHalf3(), elemHalf4(), elemHalf1x1(), elemHalf1x2(), elemHalf1x3(), elemHalf1x4(), elemHalf2x1(), elemHalf2x2(), elemHalf2x3(), elemHalf2x4(), elemHalf3x1(), elemHalf3x2(), elemHalf3x3(), elemHalf3x4(), elemHalf4x1(), elemHalf4x2(), elemHalf4x3(), elemHalf4x4(), elemFixed(), elemFixed1(), elemFixed2(), elemFixed3(), elemFixed4(), elemFixed1x1(), elemFixed1x2(), elemFixed1x3(), elemFixed1x4(), elemFixed2x1(), elemFixed2x2(), elemFixed2x3(), elemFixed2x4(), elemFixed3x1(), elemFixed3x2(), elemFixed3x3(), elemFixed3x4(), elemFixed4x1(), elemFixed4x2(), elemFixed4x3(), elemFixed4x4(), elemSurface(), elemSampler1D(), elemSampler2D(), elemSampler3D(), elemSamplerRECT(), elemSamplerCUBE(), elemSamplerDEPTH(), elemString(), elemEnum() {} 7435 /** 7436 * Destructor 7437 */ 7438 virtual ~domCg_param_type() { daeElement::deleteCMDataArray(_CMData); } 7439 /** 7440 * Overloaded assignment operator 7441 */ 7442 virtual domCg_param_type &operator=( const domCg_param_type &cpy ) { (void)cpy; return *this; } 7443 7444 public: // STATIC METHODS 7445 /** 7446 * Creates an instance of this class and returns a daeElementRef referencing it. 7447 * @return a daeElementRef referencing an instance of this object. 7448 */ 7449 static DLLSPEC daeElementRef create(DAE& dae); 7450 /** 7451 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7452 * If a daeMetaElement already exists it will return that instead of creating a new one. 7453 * @return A daeMetaElement describing this COLLADA element. 7454 */ 7455 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7456 }; 7457 7458 7459 #endif 7460