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 __domGl_pipeline_settings_h__ 10 #define __domGl_pipeline_settings_h__ 11 12 #include <dae/daeDocument.h> 13 #include <dom/domTypes.h> 14 #include <dom/domElements.h> 15 16 #include <dom/domGl_hook_abstract.h> 17 #include <dom/domGl_sampler1D.h> 18 #include <dom/domGl_sampler2D.h> 19 #include <dom/domGl_sampler3D.h> 20 #include <dom/domGl_samplerCUBE.h> 21 #include <dom/domGl_samplerRECT.h> 22 #include <dom/domGl_samplerDEPTH.h> 23 class DAE; 24 25 /** 26 * A group that defines all of the renderstates used for the CG and GLSL profiles. 27 */ 28 class domGl_pipeline_settings : public daeElement 29 { 30 public: 31 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::GL_PIPELINE_SETTINGS; } 32 static daeInt ID() { return 218; } 33 virtual daeInt typeID() const { return ID(); } 34 public: 35 class domAlpha_func; 36 37 typedef daeSmartRef<domAlpha_func> domAlpha_funcRef; 38 typedef daeTArray<domAlpha_funcRef> domAlpha_func_Array; 39 40 class domAlpha_func : public daeElement 41 { 42 public: 43 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ALPHA_FUNC; } 44 static daeInt ID() { return 219; } 45 virtual daeInt typeID() const { return ID(); } 46 public: 47 class domFunc; 48 49 typedef daeSmartRef<domFunc> domFuncRef; 50 typedef daeTArray<domFuncRef> domFunc_Array; 51 52 class domFunc : public daeElement 53 { 54 public: 55 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FUNC; } 56 static daeInt ID() { return 220; } 57 virtual daeInt typeID() const { return ID(); } 58 protected: // Attributes 59 domGl_func_type attrValue; 60 xsNCName attrParam; 61 62 63 public: //Accessors and Mutators 64 /** 65 * Gets the value attribute. 66 * @return Returns a domGl_func_type of the value attribute. 67 */ 68 domGl_func_type getValue() const { return attrValue; } 69 /** 70 * Sets the value attribute. 71 * @param atValue The new value for the value attribute. 72 */ 73 void setValue( domGl_func_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 74 75 /** 76 * Gets the param attribute. 77 * @return Returns a xsNCName of the param attribute. 78 */ 79 xsNCName getParam() const { return attrParam; } 80 /** 81 * Sets the param attribute. 82 * @param atParam The new value for the param attribute. 83 */ 84 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 85 86 protected: 87 /** 88 * Constructor 89 */ 90 domFunc(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 91 /** 92 * Destructor 93 */ 94 virtual ~domFunc() {} 95 /** 96 * Overloaded assignment operator 97 */ 98 virtual domFunc &operator=( const domFunc &cpy ) { (void)cpy; return *this; } 99 100 public: // STATIC METHODS 101 /** 102 * Creates an instance of this class and returns a daeElementRef referencing it. 103 * @return a daeElementRef referencing an instance of this object. 104 */ 105 static DLLSPEC daeElementRef create(DAE& dae); 106 /** 107 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 108 * If a daeMetaElement already exists it will return that instead of creating a new one. 109 * @return A daeMetaElement describing this COLLADA element. 110 */ 111 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 112 }; 113 114 class domValue; 115 116 typedef daeSmartRef<domValue> domValueRef; 117 typedef daeTArray<domValueRef> domValue_Array; 118 119 class domValue : public daeElement 120 { 121 public: 122 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::VALUE; } 123 static daeInt ID() { return 221; } 124 virtual daeInt typeID() const { return ID(); } 125 protected: // Attributes 126 domGl_alpha_value_type attrValue; 127 xsNCName attrParam; 128 129 130 public: //Accessors and Mutators 131 /** 132 * Gets the value attribute. 133 * @return Returns a domGl_alpha_value_type of the value attribute. 134 */ 135 domGl_alpha_value_type getValue() const { return attrValue; } 136 /** 137 * Sets the value attribute. 138 * @param atValue The new value for the value attribute. 139 */ 140 void setValue( domGl_alpha_value_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 141 142 /** 143 * Gets the param attribute. 144 * @return Returns a xsNCName of the param attribute. 145 */ 146 xsNCName getParam() const { return attrParam; } 147 /** 148 * Sets the param attribute. 149 * @param atParam The new value for the param attribute. 150 */ 151 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 152 153 protected: 154 /** 155 * Constructor 156 */ 157 domValue(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 158 /** 159 * Destructor 160 */ 161 virtual ~domValue() {} 162 /** 163 * Overloaded assignment operator 164 */ 165 virtual domValue &operator=( const domValue &cpy ) { (void)cpy; return *this; } 166 167 public: // STATIC METHODS 168 /** 169 * Creates an instance of this class and returns a daeElementRef referencing it. 170 * @return a daeElementRef referencing an instance of this object. 171 */ 172 static DLLSPEC daeElementRef create(DAE& dae); 173 /** 174 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 175 * If a daeMetaElement already exists it will return that instead of creating a new one. 176 * @return A daeMetaElement describing this COLLADA element. 177 */ 178 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 179 }; 180 181 182 183 protected: // Elements 184 domFuncRef elemFunc; 185 domValueRef elemValue; 186 187 public: //Accessors and Mutators 188 /** 189 * Gets the func element. 190 * @return a daeSmartRef to the func element. 191 */ 192 const domFuncRef getFunc() const { return elemFunc; } 193 /** 194 * Gets the value element. 195 * @return a daeSmartRef to the value element. 196 */ 197 const domValueRef getValue() const { return elemValue; } 198 protected: 199 /** 200 * Constructor 201 */ 202 domAlpha_func(DAE& dae) : daeElement(dae), elemFunc(), elemValue() {} 203 /** 204 * Destructor 205 */ 206 virtual ~domAlpha_func() {} 207 /** 208 * Overloaded assignment operator 209 */ 210 virtual domAlpha_func &operator=( const domAlpha_func &cpy ) { (void)cpy; return *this; } 211 212 public: // STATIC METHODS 213 /** 214 * Creates an instance of this class and returns a daeElementRef referencing it. 215 * @return a daeElementRef referencing an instance of this object. 216 */ 217 static DLLSPEC daeElementRef create(DAE& dae); 218 /** 219 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 220 * If a daeMetaElement already exists it will return that instead of creating a new one. 221 * @return A daeMetaElement describing this COLLADA element. 222 */ 223 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 224 }; 225 226 class domBlend_func; 227 228 typedef daeSmartRef<domBlend_func> domBlend_funcRef; 229 typedef daeTArray<domBlend_funcRef> domBlend_func_Array; 230 231 class domBlend_func : public daeElement 232 { 233 public: 234 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BLEND_FUNC; } 235 static daeInt ID() { return 222; } 236 virtual daeInt typeID() const { return ID(); } 237 public: 238 class domSrc; 239 240 typedef daeSmartRef<domSrc> domSrcRef; 241 typedef daeTArray<domSrcRef> domSrc_Array; 242 243 class domSrc : public daeElement 244 { 245 public: 246 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SRC; } 247 static daeInt ID() { return 223; } 248 virtual daeInt typeID() const { return ID(); } 249 protected: // Attributes 250 domGl_blend_type attrValue; 251 xsNCName attrParam; 252 253 254 public: //Accessors and Mutators 255 /** 256 * Gets the value attribute. 257 * @return Returns a domGl_blend_type of the value attribute. 258 */ 259 domGl_blend_type getValue() const { return attrValue; } 260 /** 261 * Sets the value attribute. 262 * @param atValue The new value for the value attribute. 263 */ 264 void setValue( domGl_blend_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 265 266 /** 267 * Gets the param attribute. 268 * @return Returns a xsNCName of the param attribute. 269 */ 270 xsNCName getParam() const { return attrParam; } 271 /** 272 * Sets the param attribute. 273 * @param atParam The new value for the param attribute. 274 */ 275 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 276 277 protected: 278 /** 279 * Constructor 280 */ 281 domSrc(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 282 /** 283 * Destructor 284 */ 285 virtual ~domSrc() {} 286 /** 287 * Overloaded assignment operator 288 */ 289 virtual domSrc &operator=( const domSrc &cpy ) { (void)cpy; return *this; } 290 291 public: // STATIC METHODS 292 /** 293 * Creates an instance of this class and returns a daeElementRef referencing it. 294 * @return a daeElementRef referencing an instance of this object. 295 */ 296 static DLLSPEC daeElementRef create(DAE& dae); 297 /** 298 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 299 * If a daeMetaElement already exists it will return that instead of creating a new one. 300 * @return A daeMetaElement describing this COLLADA element. 301 */ 302 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 303 }; 304 305 class domDest; 306 307 typedef daeSmartRef<domDest> domDestRef; 308 typedef daeTArray<domDestRef> domDest_Array; 309 310 class domDest : public daeElement 311 { 312 public: 313 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEST; } 314 static daeInt ID() { return 224; } 315 virtual daeInt typeID() const { return ID(); } 316 protected: // Attributes 317 domGl_blend_type attrValue; 318 xsNCName attrParam; 319 320 321 public: //Accessors and Mutators 322 /** 323 * Gets the value attribute. 324 * @return Returns a domGl_blend_type of the value attribute. 325 */ 326 domGl_blend_type getValue() const { return attrValue; } 327 /** 328 * Sets the value attribute. 329 * @param atValue The new value for the value attribute. 330 */ 331 void setValue( domGl_blend_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 332 333 /** 334 * Gets the param attribute. 335 * @return Returns a xsNCName of the param attribute. 336 */ 337 xsNCName getParam() const { return attrParam; } 338 /** 339 * Sets the param attribute. 340 * @param atParam The new value for the param attribute. 341 */ 342 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 343 344 protected: 345 /** 346 * Constructor 347 */ 348 domDest(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 349 /** 350 * Destructor 351 */ 352 virtual ~domDest() {} 353 /** 354 * Overloaded assignment operator 355 */ 356 virtual domDest &operator=( const domDest &cpy ) { (void)cpy; return *this; } 357 358 public: // STATIC METHODS 359 /** 360 * Creates an instance of this class and returns a daeElementRef referencing it. 361 * @return a daeElementRef referencing an instance of this object. 362 */ 363 static DLLSPEC daeElementRef create(DAE& dae); 364 /** 365 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 366 * If a daeMetaElement already exists it will return that instead of creating a new one. 367 * @return A daeMetaElement describing this COLLADA element. 368 */ 369 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 370 }; 371 372 373 374 protected: // Elements 375 domSrcRef elemSrc; 376 domDestRef elemDest; 377 378 public: //Accessors and Mutators 379 /** 380 * Gets the src element. 381 * @return a daeSmartRef to the src element. 382 */ 383 const domSrcRef getSrc() const { return elemSrc; } 384 /** 385 * Gets the dest element. 386 * @return a daeSmartRef to the dest element. 387 */ 388 const domDestRef getDest() const { return elemDest; } 389 protected: 390 /** 391 * Constructor 392 */ 393 domBlend_func(DAE& dae) : daeElement(dae), elemSrc(), elemDest() {} 394 /** 395 * Destructor 396 */ 397 virtual ~domBlend_func() {} 398 /** 399 * Overloaded assignment operator 400 */ 401 virtual domBlend_func &operator=( const domBlend_func &cpy ) { (void)cpy; return *this; } 402 403 public: // STATIC METHODS 404 /** 405 * Creates an instance of this class and returns a daeElementRef referencing it. 406 * @return a daeElementRef referencing an instance of this object. 407 */ 408 static DLLSPEC daeElementRef create(DAE& dae); 409 /** 410 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 411 * If a daeMetaElement already exists it will return that instead of creating a new one. 412 * @return A daeMetaElement describing this COLLADA element. 413 */ 414 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 415 }; 416 417 class domBlend_func_separate; 418 419 typedef daeSmartRef<domBlend_func_separate> domBlend_func_separateRef; 420 typedef daeTArray<domBlend_func_separateRef> domBlend_func_separate_Array; 421 422 class domBlend_func_separate : public daeElement 423 { 424 public: 425 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BLEND_FUNC_SEPARATE; } 426 static daeInt ID() { return 225; } 427 virtual daeInt typeID() const { return ID(); } 428 public: 429 class domSrc_rgb; 430 431 typedef daeSmartRef<domSrc_rgb> domSrc_rgbRef; 432 typedef daeTArray<domSrc_rgbRef> domSrc_rgb_Array; 433 434 class domSrc_rgb : public daeElement 435 { 436 public: 437 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SRC_RGB; } 438 static daeInt ID() { return 226; } 439 virtual daeInt typeID() const { return ID(); } 440 protected: // Attributes 441 domGl_blend_type attrValue; 442 xsNCName attrParam; 443 444 445 public: //Accessors and Mutators 446 /** 447 * Gets the value attribute. 448 * @return Returns a domGl_blend_type of the value attribute. 449 */ 450 domGl_blend_type getValue() const { return attrValue; } 451 /** 452 * Sets the value attribute. 453 * @param atValue The new value for the value attribute. 454 */ 455 void setValue( domGl_blend_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 456 457 /** 458 * Gets the param attribute. 459 * @return Returns a xsNCName of the param attribute. 460 */ 461 xsNCName getParam() const { return attrParam; } 462 /** 463 * Sets the param attribute. 464 * @param atParam The new value for the param attribute. 465 */ 466 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 467 468 protected: 469 /** 470 * Constructor 471 */ 472 domSrc_rgb(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 473 /** 474 * Destructor 475 */ 476 virtual ~domSrc_rgb() {} 477 /** 478 * Overloaded assignment operator 479 */ 480 virtual domSrc_rgb &operator=( const domSrc_rgb &cpy ) { (void)cpy; return *this; } 481 482 public: // STATIC METHODS 483 /** 484 * Creates an instance of this class and returns a daeElementRef referencing it. 485 * @return a daeElementRef referencing an instance of this object. 486 */ 487 static DLLSPEC daeElementRef create(DAE& dae); 488 /** 489 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 490 * If a daeMetaElement already exists it will return that instead of creating a new one. 491 * @return A daeMetaElement describing this COLLADA element. 492 */ 493 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 494 }; 495 496 class domDest_rgb; 497 498 typedef daeSmartRef<domDest_rgb> domDest_rgbRef; 499 typedef daeTArray<domDest_rgbRef> domDest_rgb_Array; 500 501 class domDest_rgb : public daeElement 502 { 503 public: 504 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEST_RGB; } 505 static daeInt ID() { return 227; } 506 virtual daeInt typeID() const { return ID(); } 507 protected: // Attributes 508 domGl_blend_type attrValue; 509 xsNCName attrParam; 510 511 512 public: //Accessors and Mutators 513 /** 514 * Gets the value attribute. 515 * @return Returns a domGl_blend_type of the value attribute. 516 */ 517 domGl_blend_type getValue() const { return attrValue; } 518 /** 519 * Sets the value attribute. 520 * @param atValue The new value for the value attribute. 521 */ 522 void setValue( domGl_blend_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 523 524 /** 525 * Gets the param attribute. 526 * @return Returns a xsNCName of the param attribute. 527 */ 528 xsNCName getParam() const { return attrParam; } 529 /** 530 * Sets the param attribute. 531 * @param atParam The new value for the param attribute. 532 */ 533 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 534 535 protected: 536 /** 537 * Constructor 538 */ 539 domDest_rgb(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 540 /** 541 * Destructor 542 */ 543 virtual ~domDest_rgb() {} 544 /** 545 * Overloaded assignment operator 546 */ 547 virtual domDest_rgb &operator=( const domDest_rgb &cpy ) { (void)cpy; return *this; } 548 549 public: // STATIC METHODS 550 /** 551 * Creates an instance of this class and returns a daeElementRef referencing it. 552 * @return a daeElementRef referencing an instance of this object. 553 */ 554 static DLLSPEC daeElementRef create(DAE& dae); 555 /** 556 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 557 * If a daeMetaElement already exists it will return that instead of creating a new one. 558 * @return A daeMetaElement describing this COLLADA element. 559 */ 560 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 561 }; 562 563 class domSrc_alpha; 564 565 typedef daeSmartRef<domSrc_alpha> domSrc_alphaRef; 566 typedef daeTArray<domSrc_alphaRef> domSrc_alpha_Array; 567 568 class domSrc_alpha : public daeElement 569 { 570 public: 571 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SRC_ALPHA; } 572 static daeInt ID() { return 228; } 573 virtual daeInt typeID() const { return ID(); } 574 protected: // Attributes 575 domGl_blend_type attrValue; 576 xsNCName attrParam; 577 578 579 public: //Accessors and Mutators 580 /** 581 * Gets the value attribute. 582 * @return Returns a domGl_blend_type of the value attribute. 583 */ 584 domGl_blend_type getValue() const { return attrValue; } 585 /** 586 * Sets the value attribute. 587 * @param atValue The new value for the value attribute. 588 */ 589 void setValue( domGl_blend_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 590 591 /** 592 * Gets the param attribute. 593 * @return Returns a xsNCName of the param attribute. 594 */ 595 xsNCName getParam() const { return attrParam; } 596 /** 597 * Sets the param attribute. 598 * @param atParam The new value for the param attribute. 599 */ 600 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 601 602 protected: 603 /** 604 * Constructor 605 */ 606 domSrc_alpha(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 607 /** 608 * Destructor 609 */ 610 virtual ~domSrc_alpha() {} 611 /** 612 * Overloaded assignment operator 613 */ 614 virtual domSrc_alpha &operator=( const domSrc_alpha &cpy ) { (void)cpy; return *this; } 615 616 public: // STATIC METHODS 617 /** 618 * Creates an instance of this class and returns a daeElementRef referencing it. 619 * @return a daeElementRef referencing an instance of this object. 620 */ 621 static DLLSPEC daeElementRef create(DAE& dae); 622 /** 623 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 624 * If a daeMetaElement already exists it will return that instead of creating a new one. 625 * @return A daeMetaElement describing this COLLADA element. 626 */ 627 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 628 }; 629 630 class domDest_alpha; 631 632 typedef daeSmartRef<domDest_alpha> domDest_alphaRef; 633 typedef daeTArray<domDest_alphaRef> domDest_alpha_Array; 634 635 class domDest_alpha : public daeElement 636 { 637 public: 638 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEST_ALPHA; } 639 static daeInt ID() { return 229; } 640 virtual daeInt typeID() const { return ID(); } 641 protected: // Attributes 642 domGl_blend_type attrValue; 643 xsNCName attrParam; 644 645 646 public: //Accessors and Mutators 647 /** 648 * Gets the value attribute. 649 * @return Returns a domGl_blend_type of the value attribute. 650 */ 651 domGl_blend_type getValue() const { return attrValue; } 652 /** 653 * Sets the value attribute. 654 * @param atValue The new value for the value attribute. 655 */ 656 void setValue( domGl_blend_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 657 658 /** 659 * Gets the param attribute. 660 * @return Returns a xsNCName of the param attribute. 661 */ 662 xsNCName getParam() const { return attrParam; } 663 /** 664 * Sets the param attribute. 665 * @param atParam The new value for the param attribute. 666 */ 667 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 668 669 protected: 670 /** 671 * Constructor 672 */ 673 domDest_alpha(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 674 /** 675 * Destructor 676 */ 677 virtual ~domDest_alpha() {} 678 /** 679 * Overloaded assignment operator 680 */ 681 virtual domDest_alpha &operator=( const domDest_alpha &cpy ) { (void)cpy; return *this; } 682 683 public: // STATIC METHODS 684 /** 685 * Creates an instance of this class and returns a daeElementRef referencing it. 686 * @return a daeElementRef referencing an instance of this object. 687 */ 688 static DLLSPEC daeElementRef create(DAE& dae); 689 /** 690 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 691 * If a daeMetaElement already exists it will return that instead of creating a new one. 692 * @return A daeMetaElement describing this COLLADA element. 693 */ 694 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 695 }; 696 697 698 699 protected: // Elements 700 domSrc_rgbRef elemSrc_rgb; 701 domDest_rgbRef elemDest_rgb; 702 domSrc_alphaRef elemSrc_alpha; 703 domDest_alphaRef elemDest_alpha; 704 705 public: //Accessors and Mutators 706 /** 707 * Gets the src_rgb element. 708 * @return a daeSmartRef to the src_rgb element. 709 */ 710 const domSrc_rgbRef getSrc_rgb() const { return elemSrc_rgb; } 711 /** 712 * Gets the dest_rgb element. 713 * @return a daeSmartRef to the dest_rgb element. 714 */ 715 const domDest_rgbRef getDest_rgb() const { return elemDest_rgb; } 716 /** 717 * Gets the src_alpha element. 718 * @return a daeSmartRef to the src_alpha element. 719 */ 720 const domSrc_alphaRef getSrc_alpha() const { return elemSrc_alpha; } 721 /** 722 * Gets the dest_alpha element. 723 * @return a daeSmartRef to the dest_alpha element. 724 */ 725 const domDest_alphaRef getDest_alpha() const { return elemDest_alpha; } 726 protected: 727 /** 728 * Constructor 729 */ 730 domBlend_func_separate(DAE& dae) : daeElement(dae), elemSrc_rgb(), elemDest_rgb(), elemSrc_alpha(), elemDest_alpha() {} 731 /** 732 * Destructor 733 */ 734 virtual ~domBlend_func_separate() {} 735 /** 736 * Overloaded assignment operator 737 */ 738 virtual domBlend_func_separate &operator=( const domBlend_func_separate &cpy ) { (void)cpy; return *this; } 739 740 public: // STATIC METHODS 741 /** 742 * Creates an instance of this class and returns a daeElementRef referencing it. 743 * @return a daeElementRef referencing an instance of this object. 744 */ 745 static DLLSPEC daeElementRef create(DAE& dae); 746 /** 747 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 748 * If a daeMetaElement already exists it will return that instead of creating a new one. 749 * @return A daeMetaElement describing this COLLADA element. 750 */ 751 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 752 }; 753 754 class domBlend_equation; 755 756 typedef daeSmartRef<domBlend_equation> domBlend_equationRef; 757 typedef daeTArray<domBlend_equationRef> domBlend_equation_Array; 758 759 class domBlend_equation : public daeElement 760 { 761 public: 762 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BLEND_EQUATION; } 763 static daeInt ID() { return 230; } 764 virtual daeInt typeID() const { return ID(); } 765 protected: // Attributes 766 domGl_blend_equation_type attrValue; 767 xsNCName attrParam; 768 769 770 public: //Accessors and Mutators 771 /** 772 * Gets the value attribute. 773 * @return Returns a domGl_blend_equation_type of the value attribute. 774 */ 775 domGl_blend_equation_type getValue() const { return attrValue; } 776 /** 777 * Sets the value attribute. 778 * @param atValue The new value for the value attribute. 779 */ 780 void setValue( domGl_blend_equation_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 781 782 /** 783 * Gets the param attribute. 784 * @return Returns a xsNCName of the param attribute. 785 */ 786 xsNCName getParam() const { return attrParam; } 787 /** 788 * Sets the param attribute. 789 * @param atParam The new value for the param attribute. 790 */ 791 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 792 793 protected: 794 /** 795 * Constructor 796 */ 797 domBlend_equation(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 798 /** 799 * Destructor 800 */ 801 virtual ~domBlend_equation() {} 802 /** 803 * Overloaded assignment operator 804 */ 805 virtual domBlend_equation &operator=( const domBlend_equation &cpy ) { (void)cpy; return *this; } 806 807 public: // STATIC METHODS 808 /** 809 * Creates an instance of this class and returns a daeElementRef referencing it. 810 * @return a daeElementRef referencing an instance of this object. 811 */ 812 static DLLSPEC daeElementRef create(DAE& dae); 813 /** 814 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 815 * If a daeMetaElement already exists it will return that instead of creating a new one. 816 * @return A daeMetaElement describing this COLLADA element. 817 */ 818 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 819 }; 820 821 class domBlend_equation_separate; 822 823 typedef daeSmartRef<domBlend_equation_separate> domBlend_equation_separateRef; 824 typedef daeTArray<domBlend_equation_separateRef> domBlend_equation_separate_Array; 825 826 class domBlend_equation_separate : public daeElement 827 { 828 public: 829 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BLEND_EQUATION_SEPARATE; } 830 static daeInt ID() { return 231; } 831 virtual daeInt typeID() const { return ID(); } 832 public: 833 class domRgb; 834 835 typedef daeSmartRef<domRgb> domRgbRef; 836 typedef daeTArray<domRgbRef> domRgb_Array; 837 838 class domRgb : public daeElement 839 { 840 public: 841 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::RGB; } 842 static daeInt ID() { return 232; } 843 virtual daeInt typeID() const { return ID(); } 844 protected: // Attributes 845 domGl_blend_equation_type attrValue; 846 xsNCName attrParam; 847 848 849 public: //Accessors and Mutators 850 /** 851 * Gets the value attribute. 852 * @return Returns a domGl_blend_equation_type of the value attribute. 853 */ 854 domGl_blend_equation_type getValue() const { return attrValue; } 855 /** 856 * Sets the value attribute. 857 * @param atValue The new value for the value attribute. 858 */ 859 void setValue( domGl_blend_equation_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 860 861 /** 862 * Gets the param attribute. 863 * @return Returns a xsNCName of the param attribute. 864 */ 865 xsNCName getParam() const { return attrParam; } 866 /** 867 * Sets the param attribute. 868 * @param atParam The new value for the param attribute. 869 */ 870 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 871 872 protected: 873 /** 874 * Constructor 875 */ 876 domRgb(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 877 /** 878 * Destructor 879 */ 880 virtual ~domRgb() {} 881 /** 882 * Overloaded assignment operator 883 */ 884 virtual domRgb &operator=( const domRgb &cpy ) { (void)cpy; return *this; } 885 886 public: // STATIC METHODS 887 /** 888 * Creates an instance of this class and returns a daeElementRef referencing it. 889 * @return a daeElementRef referencing an instance of this object. 890 */ 891 static DLLSPEC daeElementRef create(DAE& dae); 892 /** 893 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 894 * If a daeMetaElement already exists it will return that instead of creating a new one. 895 * @return A daeMetaElement describing this COLLADA element. 896 */ 897 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 898 }; 899 900 class domAlpha; 901 902 typedef daeSmartRef<domAlpha> domAlphaRef; 903 typedef daeTArray<domAlphaRef> domAlpha_Array; 904 905 class domAlpha : public daeElement 906 { 907 public: 908 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ALPHA; } 909 static daeInt ID() { return 233; } 910 virtual daeInt typeID() const { return ID(); } 911 protected: // Attributes 912 domGl_blend_equation_type attrValue; 913 xsNCName attrParam; 914 915 916 public: //Accessors and Mutators 917 /** 918 * Gets the value attribute. 919 * @return Returns a domGl_blend_equation_type of the value attribute. 920 */ 921 domGl_blend_equation_type getValue() const { return attrValue; } 922 /** 923 * Sets the value attribute. 924 * @param atValue The new value for the value attribute. 925 */ 926 void setValue( domGl_blend_equation_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 927 928 /** 929 * Gets the param attribute. 930 * @return Returns a xsNCName of the param attribute. 931 */ 932 xsNCName getParam() const { return attrParam; } 933 /** 934 * Sets the param attribute. 935 * @param atParam The new value for the param attribute. 936 */ 937 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 938 939 protected: 940 /** 941 * Constructor 942 */ 943 domAlpha(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 944 /** 945 * Destructor 946 */ 947 virtual ~domAlpha() {} 948 /** 949 * Overloaded assignment operator 950 */ 951 virtual domAlpha &operator=( const domAlpha &cpy ) { (void)cpy; return *this; } 952 953 public: // STATIC METHODS 954 /** 955 * Creates an instance of this class and returns a daeElementRef referencing it. 956 * @return a daeElementRef referencing an instance of this object. 957 */ 958 static DLLSPEC daeElementRef create(DAE& dae); 959 /** 960 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 961 * If a daeMetaElement already exists it will return that instead of creating a new one. 962 * @return A daeMetaElement describing this COLLADA element. 963 */ 964 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 965 }; 966 967 968 969 protected: // Elements 970 domRgbRef elemRgb; 971 domAlphaRef elemAlpha; 972 973 public: //Accessors and Mutators 974 /** 975 * Gets the rgb element. 976 * @return a daeSmartRef to the rgb element. 977 */ 978 const domRgbRef getRgb() const { return elemRgb; } 979 /** 980 * Gets the alpha element. 981 * @return a daeSmartRef to the alpha element. 982 */ 983 const domAlphaRef getAlpha() const { return elemAlpha; } 984 protected: 985 /** 986 * Constructor 987 */ 988 domBlend_equation_separate(DAE& dae) : daeElement(dae), elemRgb(), elemAlpha() {} 989 /** 990 * Destructor 991 */ 992 virtual ~domBlend_equation_separate() {} 993 /** 994 * Overloaded assignment operator 995 */ 996 virtual domBlend_equation_separate &operator=( const domBlend_equation_separate &cpy ) { (void)cpy; return *this; } 997 998 public: // STATIC METHODS 999 /** 1000 * Creates an instance of this class and returns a daeElementRef referencing it. 1001 * @return a daeElementRef referencing an instance of this object. 1002 */ 1003 static DLLSPEC daeElementRef create(DAE& dae); 1004 /** 1005 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1006 * If a daeMetaElement already exists it will return that instead of creating a new one. 1007 * @return A daeMetaElement describing this COLLADA element. 1008 */ 1009 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1010 }; 1011 1012 class domColor_material; 1013 1014 typedef daeSmartRef<domColor_material> domColor_materialRef; 1015 typedef daeTArray<domColor_materialRef> domColor_material_Array; 1016 1017 class domColor_material : public daeElement 1018 { 1019 public: 1020 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::COLOR_MATERIAL; } 1021 static daeInt ID() { return 234; } 1022 virtual daeInt typeID() const { return ID(); } 1023 public: 1024 class domFace; 1025 1026 typedef daeSmartRef<domFace> domFaceRef; 1027 typedef daeTArray<domFaceRef> domFace_Array; 1028 1029 class domFace : public daeElement 1030 { 1031 public: 1032 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FACE; } 1033 static daeInt ID() { return 235; } 1034 virtual daeInt typeID() const { return ID(); } 1035 protected: // Attributes 1036 domGl_face_type attrValue; 1037 xsNCName attrParam; 1038 1039 1040 public: //Accessors and Mutators 1041 /** 1042 * Gets the value attribute. 1043 * @return Returns a domGl_face_type of the value attribute. 1044 */ 1045 domGl_face_type getValue() const { return attrValue; } 1046 /** 1047 * Sets the value attribute. 1048 * @param atValue The new value for the value attribute. 1049 */ 1050 void setValue( domGl_face_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1051 1052 /** 1053 * Gets the param attribute. 1054 * @return Returns a xsNCName of the param attribute. 1055 */ 1056 xsNCName getParam() const { return attrParam; } 1057 /** 1058 * Sets the param attribute. 1059 * @param atParam The new value for the param attribute. 1060 */ 1061 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1062 1063 protected: 1064 /** 1065 * Constructor 1066 */ 1067 domFace(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1068 /** 1069 * Destructor 1070 */ 1071 virtual ~domFace() {} 1072 /** 1073 * Overloaded assignment operator 1074 */ 1075 virtual domFace &operator=( const domFace &cpy ) { (void)cpy; return *this; } 1076 1077 public: // STATIC METHODS 1078 /** 1079 * Creates an instance of this class and returns a daeElementRef referencing it. 1080 * @return a daeElementRef referencing an instance of this object. 1081 */ 1082 static DLLSPEC daeElementRef create(DAE& dae); 1083 /** 1084 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1085 * If a daeMetaElement already exists it will return that instead of creating a new one. 1086 * @return A daeMetaElement describing this COLLADA element. 1087 */ 1088 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1089 }; 1090 1091 class domMode; 1092 1093 typedef daeSmartRef<domMode> domModeRef; 1094 typedef daeTArray<domModeRef> domMode_Array; 1095 1096 class domMode : public daeElement 1097 { 1098 public: 1099 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MODE; } 1100 static daeInt ID() { return 236; } 1101 virtual daeInt typeID() const { return ID(); } 1102 protected: // Attributes 1103 domGl_material_type attrValue; 1104 xsNCName attrParam; 1105 1106 1107 public: //Accessors and Mutators 1108 /** 1109 * Gets the value attribute. 1110 * @return Returns a domGl_material_type of the value attribute. 1111 */ 1112 domGl_material_type getValue() const { return attrValue; } 1113 /** 1114 * Sets the value attribute. 1115 * @param atValue The new value for the value attribute. 1116 */ 1117 void setValue( domGl_material_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1118 1119 /** 1120 * Gets the param attribute. 1121 * @return Returns a xsNCName of the param attribute. 1122 */ 1123 xsNCName getParam() const { return attrParam; } 1124 /** 1125 * Sets the param attribute. 1126 * @param atParam The new value for the param attribute. 1127 */ 1128 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1129 1130 protected: 1131 /** 1132 * Constructor 1133 */ 1134 domMode(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1135 /** 1136 * Destructor 1137 */ 1138 virtual ~domMode() {} 1139 /** 1140 * Overloaded assignment operator 1141 */ 1142 virtual domMode &operator=( const domMode &cpy ) { (void)cpy; return *this; } 1143 1144 public: // STATIC METHODS 1145 /** 1146 * Creates an instance of this class and returns a daeElementRef referencing it. 1147 * @return a daeElementRef referencing an instance of this object. 1148 */ 1149 static DLLSPEC daeElementRef create(DAE& dae); 1150 /** 1151 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1152 * If a daeMetaElement already exists it will return that instead of creating a new one. 1153 * @return A daeMetaElement describing this COLLADA element. 1154 */ 1155 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1156 }; 1157 1158 1159 1160 protected: // Elements 1161 domFaceRef elemFace; 1162 domModeRef elemMode; 1163 1164 public: //Accessors and Mutators 1165 /** 1166 * Gets the face element. 1167 * @return a daeSmartRef to the face element. 1168 */ 1169 const domFaceRef getFace() const { return elemFace; } 1170 /** 1171 * Gets the mode element. 1172 * @return a daeSmartRef to the mode element. 1173 */ 1174 const domModeRef getMode() const { return elemMode; } 1175 protected: 1176 /** 1177 * Constructor 1178 */ 1179 domColor_material(DAE& dae) : daeElement(dae), elemFace(), elemMode() {} 1180 /** 1181 * Destructor 1182 */ 1183 virtual ~domColor_material() {} 1184 /** 1185 * Overloaded assignment operator 1186 */ 1187 virtual domColor_material &operator=( const domColor_material &cpy ) { (void)cpy; return *this; } 1188 1189 public: // STATIC METHODS 1190 /** 1191 * Creates an instance of this class and returns a daeElementRef referencing it. 1192 * @return a daeElementRef referencing an instance of this object. 1193 */ 1194 static DLLSPEC daeElementRef create(DAE& dae); 1195 /** 1196 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1197 * If a daeMetaElement already exists it will return that instead of creating a new one. 1198 * @return A daeMetaElement describing this COLLADA element. 1199 */ 1200 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1201 }; 1202 1203 class domCull_face; 1204 1205 typedef daeSmartRef<domCull_face> domCull_faceRef; 1206 typedef daeTArray<domCull_faceRef> domCull_face_Array; 1207 1208 class domCull_face : public daeElement 1209 { 1210 public: 1211 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CULL_FACE; } 1212 static daeInt ID() { return 237; } 1213 virtual daeInt typeID() const { return ID(); } 1214 protected: // Attributes 1215 domGl_face_type attrValue; 1216 xsNCName attrParam; 1217 1218 1219 public: //Accessors and Mutators 1220 /** 1221 * Gets the value attribute. 1222 * @return Returns a domGl_face_type of the value attribute. 1223 */ 1224 domGl_face_type getValue() const { return attrValue; } 1225 /** 1226 * Sets the value attribute. 1227 * @param atValue The new value for the value attribute. 1228 */ 1229 void setValue( domGl_face_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1230 1231 /** 1232 * Gets the param attribute. 1233 * @return Returns a xsNCName of the param attribute. 1234 */ 1235 xsNCName getParam() const { return attrParam; } 1236 /** 1237 * Sets the param attribute. 1238 * @param atParam The new value for the param attribute. 1239 */ 1240 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1241 1242 protected: 1243 /** 1244 * Constructor 1245 */ 1246 domCull_face(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1247 /** 1248 * Destructor 1249 */ 1250 virtual ~domCull_face() {} 1251 /** 1252 * Overloaded assignment operator 1253 */ 1254 virtual domCull_face &operator=( const domCull_face &cpy ) { (void)cpy; return *this; } 1255 1256 public: // STATIC METHODS 1257 /** 1258 * Creates an instance of this class and returns a daeElementRef referencing it. 1259 * @return a daeElementRef referencing an instance of this object. 1260 */ 1261 static DLLSPEC daeElementRef create(DAE& dae); 1262 /** 1263 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1264 * If a daeMetaElement already exists it will return that instead of creating a new one. 1265 * @return A daeMetaElement describing this COLLADA element. 1266 */ 1267 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1268 }; 1269 1270 class domDepth_func; 1271 1272 typedef daeSmartRef<domDepth_func> domDepth_funcRef; 1273 typedef daeTArray<domDepth_funcRef> domDepth_func_Array; 1274 1275 class domDepth_func : public daeElement 1276 { 1277 public: 1278 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_FUNC; } 1279 static daeInt ID() { return 238; } 1280 virtual daeInt typeID() const { return ID(); } 1281 protected: // Attributes 1282 domGl_func_type attrValue; 1283 xsNCName attrParam; 1284 1285 1286 public: //Accessors and Mutators 1287 /** 1288 * Gets the value attribute. 1289 * @return Returns a domGl_func_type of the value attribute. 1290 */ 1291 domGl_func_type getValue() const { return attrValue; } 1292 /** 1293 * Sets the value attribute. 1294 * @param atValue The new value for the value attribute. 1295 */ 1296 void setValue( domGl_func_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1297 1298 /** 1299 * Gets the param attribute. 1300 * @return Returns a xsNCName of the param attribute. 1301 */ 1302 xsNCName getParam() const { return attrParam; } 1303 /** 1304 * Sets the param attribute. 1305 * @param atParam The new value for the param attribute. 1306 */ 1307 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1308 1309 protected: 1310 /** 1311 * Constructor 1312 */ 1313 domDepth_func(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1314 /** 1315 * Destructor 1316 */ 1317 virtual ~domDepth_func() {} 1318 /** 1319 * Overloaded assignment operator 1320 */ 1321 virtual domDepth_func &operator=( const domDepth_func &cpy ) { (void)cpy; return *this; } 1322 1323 public: // STATIC METHODS 1324 /** 1325 * Creates an instance of this class and returns a daeElementRef referencing it. 1326 * @return a daeElementRef referencing an instance of this object. 1327 */ 1328 static DLLSPEC daeElementRef create(DAE& dae); 1329 /** 1330 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1331 * If a daeMetaElement already exists it will return that instead of creating a new one. 1332 * @return A daeMetaElement describing this COLLADA element. 1333 */ 1334 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1335 }; 1336 1337 class domFog_mode; 1338 1339 typedef daeSmartRef<domFog_mode> domFog_modeRef; 1340 typedef daeTArray<domFog_modeRef> domFog_mode_Array; 1341 1342 class domFog_mode : public daeElement 1343 { 1344 public: 1345 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_MODE; } 1346 static daeInt ID() { return 239; } 1347 virtual daeInt typeID() const { return ID(); } 1348 protected: // Attributes 1349 domGl_fog_type attrValue; 1350 xsNCName attrParam; 1351 1352 1353 public: //Accessors and Mutators 1354 /** 1355 * Gets the value attribute. 1356 * @return Returns a domGl_fog_type of the value attribute. 1357 */ 1358 domGl_fog_type getValue() const { return attrValue; } 1359 /** 1360 * Sets the value attribute. 1361 * @param atValue The new value for the value attribute. 1362 */ 1363 void setValue( domGl_fog_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1364 1365 /** 1366 * Gets the param attribute. 1367 * @return Returns a xsNCName of the param attribute. 1368 */ 1369 xsNCName getParam() const { return attrParam; } 1370 /** 1371 * Sets the param attribute. 1372 * @param atParam The new value for the param attribute. 1373 */ 1374 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1375 1376 protected: 1377 /** 1378 * Constructor 1379 */ 1380 domFog_mode(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1381 /** 1382 * Destructor 1383 */ 1384 virtual ~domFog_mode() {} 1385 /** 1386 * Overloaded assignment operator 1387 */ 1388 virtual domFog_mode &operator=( const domFog_mode &cpy ) { (void)cpy; return *this; } 1389 1390 public: // STATIC METHODS 1391 /** 1392 * Creates an instance of this class and returns a daeElementRef referencing it. 1393 * @return a daeElementRef referencing an instance of this object. 1394 */ 1395 static DLLSPEC daeElementRef create(DAE& dae); 1396 /** 1397 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1398 * If a daeMetaElement already exists it will return that instead of creating a new one. 1399 * @return A daeMetaElement describing this COLLADA element. 1400 */ 1401 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1402 }; 1403 1404 class domFog_coord_src; 1405 1406 typedef daeSmartRef<domFog_coord_src> domFog_coord_srcRef; 1407 typedef daeTArray<domFog_coord_srcRef> domFog_coord_src_Array; 1408 1409 class domFog_coord_src : public daeElement 1410 { 1411 public: 1412 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_COORD_SRC; } 1413 static daeInt ID() { return 240; } 1414 virtual daeInt typeID() const { return ID(); } 1415 protected: // Attributes 1416 domGl_fog_coord_src_type attrValue; 1417 xsNCName attrParam; 1418 1419 1420 public: //Accessors and Mutators 1421 /** 1422 * Gets the value attribute. 1423 * @return Returns a domGl_fog_coord_src_type of the value attribute. 1424 */ 1425 domGl_fog_coord_src_type getValue() const { return attrValue; } 1426 /** 1427 * Sets the value attribute. 1428 * @param atValue The new value for the value attribute. 1429 */ 1430 void setValue( domGl_fog_coord_src_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1431 1432 /** 1433 * Gets the param attribute. 1434 * @return Returns a xsNCName of the param attribute. 1435 */ 1436 xsNCName getParam() const { return attrParam; } 1437 /** 1438 * Sets the param attribute. 1439 * @param atParam The new value for the param attribute. 1440 */ 1441 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1442 1443 protected: 1444 /** 1445 * Constructor 1446 */ 1447 domFog_coord_src(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1448 /** 1449 * Destructor 1450 */ 1451 virtual ~domFog_coord_src() {} 1452 /** 1453 * Overloaded assignment operator 1454 */ 1455 virtual domFog_coord_src &operator=( const domFog_coord_src &cpy ) { (void)cpy; return *this; } 1456 1457 public: // STATIC METHODS 1458 /** 1459 * Creates an instance of this class and returns a daeElementRef referencing it. 1460 * @return a daeElementRef referencing an instance of this object. 1461 */ 1462 static DLLSPEC daeElementRef create(DAE& dae); 1463 /** 1464 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1465 * If a daeMetaElement already exists it will return that instead of creating a new one. 1466 * @return A daeMetaElement describing this COLLADA element. 1467 */ 1468 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1469 }; 1470 1471 class domFront_face; 1472 1473 typedef daeSmartRef<domFront_face> domFront_faceRef; 1474 typedef daeTArray<domFront_faceRef> domFront_face_Array; 1475 1476 class domFront_face : public daeElement 1477 { 1478 public: 1479 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FRONT_FACE; } 1480 static daeInt ID() { return 241; } 1481 virtual daeInt typeID() const { return ID(); } 1482 protected: // Attributes 1483 domGl_front_face_type attrValue; 1484 xsNCName attrParam; 1485 1486 1487 public: //Accessors and Mutators 1488 /** 1489 * Gets the value attribute. 1490 * @return Returns a domGl_front_face_type of the value attribute. 1491 */ 1492 domGl_front_face_type getValue() const { return attrValue; } 1493 /** 1494 * Sets the value attribute. 1495 * @param atValue The new value for the value attribute. 1496 */ 1497 void setValue( domGl_front_face_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1498 1499 /** 1500 * Gets the param attribute. 1501 * @return Returns a xsNCName of the param attribute. 1502 */ 1503 xsNCName getParam() const { return attrParam; } 1504 /** 1505 * Sets the param attribute. 1506 * @param atParam The new value for the param attribute. 1507 */ 1508 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1509 1510 protected: 1511 /** 1512 * Constructor 1513 */ 1514 domFront_face(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1515 /** 1516 * Destructor 1517 */ 1518 virtual ~domFront_face() {} 1519 /** 1520 * Overloaded assignment operator 1521 */ 1522 virtual domFront_face &operator=( const domFront_face &cpy ) { (void)cpy; return *this; } 1523 1524 public: // STATIC METHODS 1525 /** 1526 * Creates an instance of this class and returns a daeElementRef referencing it. 1527 * @return a daeElementRef referencing an instance of this object. 1528 */ 1529 static DLLSPEC daeElementRef create(DAE& dae); 1530 /** 1531 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1532 * If a daeMetaElement already exists it will return that instead of creating a new one. 1533 * @return A daeMetaElement describing this COLLADA element. 1534 */ 1535 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1536 }; 1537 1538 class domLight_model_color_control; 1539 1540 typedef daeSmartRef<domLight_model_color_control> domLight_model_color_controlRef; 1541 typedef daeTArray<domLight_model_color_controlRef> domLight_model_color_control_Array; 1542 1543 class domLight_model_color_control : public daeElement 1544 { 1545 public: 1546 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_MODEL_COLOR_CONTROL; } 1547 static daeInt ID() { return 242; } 1548 virtual daeInt typeID() const { return ID(); } 1549 protected: // Attributes 1550 domGl_light_model_color_control_type attrValue; 1551 xsNCName attrParam; 1552 1553 1554 public: //Accessors and Mutators 1555 /** 1556 * Gets the value attribute. 1557 * @return Returns a domGl_light_model_color_control_type of the value attribute. 1558 */ 1559 domGl_light_model_color_control_type getValue() const { return attrValue; } 1560 /** 1561 * Sets the value attribute. 1562 * @param atValue The new value for the value attribute. 1563 */ 1564 void setValue( domGl_light_model_color_control_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1565 1566 /** 1567 * Gets the param attribute. 1568 * @return Returns a xsNCName of the param attribute. 1569 */ 1570 xsNCName getParam() const { return attrParam; } 1571 /** 1572 * Sets the param attribute. 1573 * @param atParam The new value for the param attribute. 1574 */ 1575 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1576 1577 protected: 1578 /** 1579 * Constructor 1580 */ 1581 domLight_model_color_control(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1582 /** 1583 * Destructor 1584 */ 1585 virtual ~domLight_model_color_control() {} 1586 /** 1587 * Overloaded assignment operator 1588 */ 1589 virtual domLight_model_color_control &operator=( const domLight_model_color_control &cpy ) { (void)cpy; return *this; } 1590 1591 public: // STATIC METHODS 1592 /** 1593 * Creates an instance of this class and returns a daeElementRef referencing it. 1594 * @return a daeElementRef referencing an instance of this object. 1595 */ 1596 static DLLSPEC daeElementRef create(DAE& dae); 1597 /** 1598 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1599 * If a daeMetaElement already exists it will return that instead of creating a new one. 1600 * @return A daeMetaElement describing this COLLADA element. 1601 */ 1602 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1603 }; 1604 1605 class domLogic_op; 1606 1607 typedef daeSmartRef<domLogic_op> domLogic_opRef; 1608 typedef daeTArray<domLogic_opRef> domLogic_op_Array; 1609 1610 class domLogic_op : public daeElement 1611 { 1612 public: 1613 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LOGIC_OP; } 1614 static daeInt ID() { return 243; } 1615 virtual daeInt typeID() const { return ID(); } 1616 protected: // Attributes 1617 domGl_logic_op_type attrValue; 1618 xsNCName attrParam; 1619 1620 1621 public: //Accessors and Mutators 1622 /** 1623 * Gets the value attribute. 1624 * @return Returns a domGl_logic_op_type of the value attribute. 1625 */ 1626 domGl_logic_op_type getValue() const { return attrValue; } 1627 /** 1628 * Sets the value attribute. 1629 * @param atValue The new value for the value attribute. 1630 */ 1631 void setValue( domGl_logic_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1632 1633 /** 1634 * Gets the param attribute. 1635 * @return Returns a xsNCName of the param attribute. 1636 */ 1637 xsNCName getParam() const { return attrParam; } 1638 /** 1639 * Sets the param attribute. 1640 * @param atParam The new value for the param attribute. 1641 */ 1642 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1643 1644 protected: 1645 /** 1646 * Constructor 1647 */ 1648 domLogic_op(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1649 /** 1650 * Destructor 1651 */ 1652 virtual ~domLogic_op() {} 1653 /** 1654 * Overloaded assignment operator 1655 */ 1656 virtual domLogic_op &operator=( const domLogic_op &cpy ) { (void)cpy; return *this; } 1657 1658 public: // STATIC METHODS 1659 /** 1660 * Creates an instance of this class and returns a daeElementRef referencing it. 1661 * @return a daeElementRef referencing an instance of this object. 1662 */ 1663 static DLLSPEC daeElementRef create(DAE& dae); 1664 /** 1665 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1666 * If a daeMetaElement already exists it will return that instead of creating a new one. 1667 * @return A daeMetaElement describing this COLLADA element. 1668 */ 1669 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1670 }; 1671 1672 class domPolygon_mode; 1673 1674 typedef daeSmartRef<domPolygon_mode> domPolygon_modeRef; 1675 typedef daeTArray<domPolygon_modeRef> domPolygon_mode_Array; 1676 1677 class domPolygon_mode : public daeElement 1678 { 1679 public: 1680 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_MODE; } 1681 static daeInt ID() { return 244; } 1682 virtual daeInt typeID() const { return ID(); } 1683 public: 1684 class domFace; 1685 1686 typedef daeSmartRef<domFace> domFaceRef; 1687 typedef daeTArray<domFaceRef> domFace_Array; 1688 1689 class domFace : public daeElement 1690 { 1691 public: 1692 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FACE; } 1693 static daeInt ID() { return 245; } 1694 virtual daeInt typeID() const { return ID(); } 1695 protected: // Attributes 1696 domGl_face_type attrValue; 1697 xsNCName attrParam; 1698 1699 1700 public: //Accessors and Mutators 1701 /** 1702 * Gets the value attribute. 1703 * @return Returns a domGl_face_type of the value attribute. 1704 */ 1705 domGl_face_type getValue() const { return attrValue; } 1706 /** 1707 * Sets the value attribute. 1708 * @param atValue The new value for the value attribute. 1709 */ 1710 void setValue( domGl_face_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1711 1712 /** 1713 * Gets the param attribute. 1714 * @return Returns a xsNCName of the param attribute. 1715 */ 1716 xsNCName getParam() const { return attrParam; } 1717 /** 1718 * Sets the param attribute. 1719 * @param atParam The new value for the param attribute. 1720 */ 1721 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1722 1723 protected: 1724 /** 1725 * Constructor 1726 */ 1727 domFace(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1728 /** 1729 * Destructor 1730 */ 1731 virtual ~domFace() {} 1732 /** 1733 * Overloaded assignment operator 1734 */ 1735 virtual domFace &operator=( const domFace &cpy ) { (void)cpy; return *this; } 1736 1737 public: // STATIC METHODS 1738 /** 1739 * Creates an instance of this class and returns a daeElementRef referencing it. 1740 * @return a daeElementRef referencing an instance of this object. 1741 */ 1742 static DLLSPEC daeElementRef create(DAE& dae); 1743 /** 1744 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1745 * If a daeMetaElement already exists it will return that instead of creating a new one. 1746 * @return A daeMetaElement describing this COLLADA element. 1747 */ 1748 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1749 }; 1750 1751 class domMode; 1752 1753 typedef daeSmartRef<domMode> domModeRef; 1754 typedef daeTArray<domModeRef> domMode_Array; 1755 1756 class domMode : public daeElement 1757 { 1758 public: 1759 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MODE; } 1760 static daeInt ID() { return 246; } 1761 virtual daeInt typeID() const { return ID(); } 1762 protected: // Attributes 1763 domGl_polygon_mode_type attrValue; 1764 xsNCName attrParam; 1765 1766 1767 public: //Accessors and Mutators 1768 /** 1769 * Gets the value attribute. 1770 * @return Returns a domGl_polygon_mode_type of the value attribute. 1771 */ 1772 domGl_polygon_mode_type getValue() const { return attrValue; } 1773 /** 1774 * Sets the value attribute. 1775 * @param atValue The new value for the value attribute. 1776 */ 1777 void setValue( domGl_polygon_mode_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1778 1779 /** 1780 * Gets the param attribute. 1781 * @return Returns a xsNCName of the param attribute. 1782 */ 1783 xsNCName getParam() const { return attrParam; } 1784 /** 1785 * Sets the param attribute. 1786 * @param atParam The new value for the param attribute. 1787 */ 1788 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1789 1790 protected: 1791 /** 1792 * Constructor 1793 */ 1794 domMode(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1795 /** 1796 * Destructor 1797 */ 1798 virtual ~domMode() {} 1799 /** 1800 * Overloaded assignment operator 1801 */ 1802 virtual domMode &operator=( const domMode &cpy ) { (void)cpy; return *this; } 1803 1804 public: // STATIC METHODS 1805 /** 1806 * Creates an instance of this class and returns a daeElementRef referencing it. 1807 * @return a daeElementRef referencing an instance of this object. 1808 */ 1809 static DLLSPEC daeElementRef create(DAE& dae); 1810 /** 1811 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1812 * If a daeMetaElement already exists it will return that instead of creating a new one. 1813 * @return A daeMetaElement describing this COLLADA element. 1814 */ 1815 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1816 }; 1817 1818 1819 1820 protected: // Elements 1821 domFaceRef elemFace; 1822 domModeRef elemMode; 1823 1824 public: //Accessors and Mutators 1825 /** 1826 * Gets the face element. 1827 * @return a daeSmartRef to the face element. 1828 */ 1829 const domFaceRef getFace() const { return elemFace; } 1830 /** 1831 * Gets the mode element. 1832 * @return a daeSmartRef to the mode element. 1833 */ 1834 const domModeRef getMode() const { return elemMode; } 1835 protected: 1836 /** 1837 * Constructor 1838 */ 1839 domPolygon_mode(DAE& dae) : daeElement(dae), elemFace(), elemMode() {} 1840 /** 1841 * Destructor 1842 */ 1843 virtual ~domPolygon_mode() {} 1844 /** 1845 * Overloaded assignment operator 1846 */ 1847 virtual domPolygon_mode &operator=( const domPolygon_mode &cpy ) { (void)cpy; return *this; } 1848 1849 public: // STATIC METHODS 1850 /** 1851 * Creates an instance of this class and returns a daeElementRef referencing it. 1852 * @return a daeElementRef referencing an instance of this object. 1853 */ 1854 static DLLSPEC daeElementRef create(DAE& dae); 1855 /** 1856 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1857 * If a daeMetaElement already exists it will return that instead of creating a new one. 1858 * @return A daeMetaElement describing this COLLADA element. 1859 */ 1860 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1861 }; 1862 1863 class domShade_model; 1864 1865 typedef daeSmartRef<domShade_model> domShade_modelRef; 1866 typedef daeTArray<domShade_modelRef> domShade_model_Array; 1867 1868 class domShade_model : public daeElement 1869 { 1870 public: 1871 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SHADE_MODEL; } 1872 static daeInt ID() { return 247; } 1873 virtual daeInt typeID() const { return ID(); } 1874 protected: // Attributes 1875 domGl_shade_model_type attrValue; 1876 xsNCName attrParam; 1877 1878 1879 public: //Accessors and Mutators 1880 /** 1881 * Gets the value attribute. 1882 * @return Returns a domGl_shade_model_type of the value attribute. 1883 */ 1884 domGl_shade_model_type getValue() const { return attrValue; } 1885 /** 1886 * Sets the value attribute. 1887 * @param atValue The new value for the value attribute. 1888 */ 1889 void setValue( domGl_shade_model_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1890 1891 /** 1892 * Gets the param attribute. 1893 * @return Returns a xsNCName of the param attribute. 1894 */ 1895 xsNCName getParam() const { return attrParam; } 1896 /** 1897 * Sets the param attribute. 1898 * @param atParam The new value for the param attribute. 1899 */ 1900 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1901 1902 protected: 1903 /** 1904 * Constructor 1905 */ 1906 domShade_model(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1907 /** 1908 * Destructor 1909 */ 1910 virtual ~domShade_model() {} 1911 /** 1912 * Overloaded assignment operator 1913 */ 1914 virtual domShade_model &operator=( const domShade_model &cpy ) { (void)cpy; return *this; } 1915 1916 public: // STATIC METHODS 1917 /** 1918 * Creates an instance of this class and returns a daeElementRef referencing it. 1919 * @return a daeElementRef referencing an instance of this object. 1920 */ 1921 static DLLSPEC daeElementRef create(DAE& dae); 1922 /** 1923 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 1924 * If a daeMetaElement already exists it will return that instead of creating a new one. 1925 * @return A daeMetaElement describing this COLLADA element. 1926 */ 1927 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 1928 }; 1929 1930 class domStencil_func; 1931 1932 typedef daeSmartRef<domStencil_func> domStencil_funcRef; 1933 typedef daeTArray<domStencil_funcRef> domStencil_func_Array; 1934 1935 class domStencil_func : public daeElement 1936 { 1937 public: 1938 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_FUNC; } 1939 static daeInt ID() { return 248; } 1940 virtual daeInt typeID() const { return ID(); } 1941 public: 1942 class domFunc; 1943 1944 typedef daeSmartRef<domFunc> domFuncRef; 1945 typedef daeTArray<domFuncRef> domFunc_Array; 1946 1947 class domFunc : public daeElement 1948 { 1949 public: 1950 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FUNC; } 1951 static daeInt ID() { return 249; } 1952 virtual daeInt typeID() const { return ID(); } 1953 protected: // Attributes 1954 domGl_func_type attrValue; 1955 xsNCName attrParam; 1956 1957 1958 public: //Accessors and Mutators 1959 /** 1960 * Gets the value attribute. 1961 * @return Returns a domGl_func_type of the value attribute. 1962 */ 1963 domGl_func_type getValue() const { return attrValue; } 1964 /** 1965 * Sets the value attribute. 1966 * @param atValue The new value for the value attribute. 1967 */ 1968 void setValue( domGl_func_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 1969 1970 /** 1971 * Gets the param attribute. 1972 * @return Returns a xsNCName of the param attribute. 1973 */ 1974 xsNCName getParam() const { return attrParam; } 1975 /** 1976 * Sets the param attribute. 1977 * @param atParam The new value for the param attribute. 1978 */ 1979 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 1980 1981 protected: 1982 /** 1983 * Constructor 1984 */ 1985 domFunc(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 1986 /** 1987 * Destructor 1988 */ 1989 virtual ~domFunc() {} 1990 /** 1991 * Overloaded assignment operator 1992 */ 1993 virtual domFunc &operator=( const domFunc &cpy ) { (void)cpy; return *this; } 1994 1995 public: // STATIC METHODS 1996 /** 1997 * Creates an instance of this class and returns a daeElementRef referencing it. 1998 * @return a daeElementRef referencing an instance of this object. 1999 */ 2000 static DLLSPEC daeElementRef create(DAE& dae); 2001 /** 2002 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2003 * If a daeMetaElement already exists it will return that instead of creating a new one. 2004 * @return A daeMetaElement describing this COLLADA element. 2005 */ 2006 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2007 }; 2008 2009 class domRef; 2010 2011 typedef daeSmartRef<domRef> domRefRef; 2012 typedef daeTArray<domRefRef> domRef_Array; 2013 2014 class domRef : public daeElement 2015 { 2016 public: 2017 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::REF; } 2018 static daeInt ID() { return 250; } 2019 virtual daeInt typeID() const { return ID(); } 2020 protected: // Attributes 2021 xsUnsignedByte attrValue; 2022 xsNCName attrParam; 2023 2024 2025 public: //Accessors and Mutators 2026 /** 2027 * Gets the value attribute. 2028 * @return Returns a xsUnsignedByte of the value attribute. 2029 */ 2030 xsUnsignedByte getValue() const { return attrValue; } 2031 /** 2032 * Sets the value attribute. 2033 * @param atValue The new value for the value attribute. 2034 */ 2035 void setValue( xsUnsignedByte atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2036 2037 /** 2038 * Gets the param attribute. 2039 * @return Returns a xsNCName of the param attribute. 2040 */ 2041 xsNCName getParam() const { return attrParam; } 2042 /** 2043 * Sets the param attribute. 2044 * @param atParam The new value for the param attribute. 2045 */ 2046 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2047 2048 protected: 2049 /** 2050 * Constructor 2051 */ 2052 domRef(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2053 /** 2054 * Destructor 2055 */ 2056 virtual ~domRef() {} 2057 /** 2058 * Overloaded assignment operator 2059 */ 2060 virtual domRef &operator=( const domRef &cpy ) { (void)cpy; return *this; } 2061 2062 public: // STATIC METHODS 2063 /** 2064 * Creates an instance of this class and returns a daeElementRef referencing it. 2065 * @return a daeElementRef referencing an instance of this object. 2066 */ 2067 static DLLSPEC daeElementRef create(DAE& dae); 2068 /** 2069 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2070 * If a daeMetaElement already exists it will return that instead of creating a new one. 2071 * @return A daeMetaElement describing this COLLADA element. 2072 */ 2073 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2074 }; 2075 2076 class domMask; 2077 2078 typedef daeSmartRef<domMask> domMaskRef; 2079 typedef daeTArray<domMaskRef> domMask_Array; 2080 2081 class domMask : public daeElement 2082 { 2083 public: 2084 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MASK; } 2085 static daeInt ID() { return 251; } 2086 virtual daeInt typeID() const { return ID(); } 2087 protected: // Attributes 2088 xsUnsignedByte attrValue; 2089 xsNCName attrParam; 2090 2091 2092 public: //Accessors and Mutators 2093 /** 2094 * Gets the value attribute. 2095 * @return Returns a xsUnsignedByte of the value attribute. 2096 */ 2097 xsUnsignedByte getValue() const { return attrValue; } 2098 /** 2099 * Sets the value attribute. 2100 * @param atValue The new value for the value attribute. 2101 */ 2102 void setValue( xsUnsignedByte atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2103 2104 /** 2105 * Gets the param attribute. 2106 * @return Returns a xsNCName of the param attribute. 2107 */ 2108 xsNCName getParam() const { return attrParam; } 2109 /** 2110 * Sets the param attribute. 2111 * @param atParam The new value for the param attribute. 2112 */ 2113 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2114 2115 protected: 2116 /** 2117 * Constructor 2118 */ 2119 domMask(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2120 /** 2121 * Destructor 2122 */ 2123 virtual ~domMask() {} 2124 /** 2125 * Overloaded assignment operator 2126 */ 2127 virtual domMask &operator=( const domMask &cpy ) { (void)cpy; return *this; } 2128 2129 public: // STATIC METHODS 2130 /** 2131 * Creates an instance of this class and returns a daeElementRef referencing it. 2132 * @return a daeElementRef referencing an instance of this object. 2133 */ 2134 static DLLSPEC daeElementRef create(DAE& dae); 2135 /** 2136 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2137 * If a daeMetaElement already exists it will return that instead of creating a new one. 2138 * @return A daeMetaElement describing this COLLADA element. 2139 */ 2140 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2141 }; 2142 2143 2144 2145 protected: // Elements 2146 domFuncRef elemFunc; 2147 domRefRef elemRef; 2148 domMaskRef elemMask; 2149 2150 public: //Accessors and Mutators 2151 /** 2152 * Gets the func element. 2153 * @return a daeSmartRef to the func element. 2154 */ 2155 const domFuncRef getFunc() const { return elemFunc; } 2156 /** 2157 * Gets the ref element. 2158 * @return a daeSmartRef to the ref element. 2159 */ 2160 const domRefRef getRef() const { return elemRef; } 2161 /** 2162 * Gets the mask element. 2163 * @return a daeSmartRef to the mask element. 2164 */ 2165 const domMaskRef getMask() const { return elemMask; } 2166 protected: 2167 /** 2168 * Constructor 2169 */ 2170 domStencil_func(DAE& dae) : daeElement(dae), elemFunc(), elemRef(), elemMask() {} 2171 /** 2172 * Destructor 2173 */ 2174 virtual ~domStencil_func() {} 2175 /** 2176 * Overloaded assignment operator 2177 */ 2178 virtual domStencil_func &operator=( const domStencil_func &cpy ) { (void)cpy; return *this; } 2179 2180 public: // STATIC METHODS 2181 /** 2182 * Creates an instance of this class and returns a daeElementRef referencing it. 2183 * @return a daeElementRef referencing an instance of this object. 2184 */ 2185 static DLLSPEC daeElementRef create(DAE& dae); 2186 /** 2187 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2188 * If a daeMetaElement already exists it will return that instead of creating a new one. 2189 * @return A daeMetaElement describing this COLLADA element. 2190 */ 2191 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2192 }; 2193 2194 class domStencil_op; 2195 2196 typedef daeSmartRef<domStencil_op> domStencil_opRef; 2197 typedef daeTArray<domStencil_opRef> domStencil_op_Array; 2198 2199 class domStencil_op : public daeElement 2200 { 2201 public: 2202 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_OP; } 2203 static daeInt ID() { return 252; } 2204 virtual daeInt typeID() const { return ID(); } 2205 public: 2206 class domFail; 2207 2208 typedef daeSmartRef<domFail> domFailRef; 2209 typedef daeTArray<domFailRef> domFail_Array; 2210 2211 class domFail : public daeElement 2212 { 2213 public: 2214 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FAIL; } 2215 static daeInt ID() { return 253; } 2216 virtual daeInt typeID() const { return ID(); } 2217 protected: // Attributes 2218 domGl_stencil_op_type attrValue; 2219 xsNCName attrParam; 2220 2221 2222 public: //Accessors and Mutators 2223 /** 2224 * Gets the value attribute. 2225 * @return Returns a domGl_stencil_op_type of the value attribute. 2226 */ 2227 domGl_stencil_op_type getValue() const { return attrValue; } 2228 /** 2229 * Sets the value attribute. 2230 * @param atValue The new value for the value attribute. 2231 */ 2232 void setValue( domGl_stencil_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2233 2234 /** 2235 * Gets the param attribute. 2236 * @return Returns a xsNCName of the param attribute. 2237 */ 2238 xsNCName getParam() const { return attrParam; } 2239 /** 2240 * Sets the param attribute. 2241 * @param atParam The new value for the param attribute. 2242 */ 2243 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2244 2245 protected: 2246 /** 2247 * Constructor 2248 */ 2249 domFail(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2250 /** 2251 * Destructor 2252 */ 2253 virtual ~domFail() {} 2254 /** 2255 * Overloaded assignment operator 2256 */ 2257 virtual domFail &operator=( const domFail &cpy ) { (void)cpy; return *this; } 2258 2259 public: // STATIC METHODS 2260 /** 2261 * Creates an instance of this class and returns a daeElementRef referencing it. 2262 * @return a daeElementRef referencing an instance of this object. 2263 */ 2264 static DLLSPEC daeElementRef create(DAE& dae); 2265 /** 2266 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2267 * If a daeMetaElement already exists it will return that instead of creating a new one. 2268 * @return A daeMetaElement describing this COLLADA element. 2269 */ 2270 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2271 }; 2272 2273 class domZfail; 2274 2275 typedef daeSmartRef<domZfail> domZfailRef; 2276 typedef daeTArray<domZfailRef> domZfail_Array; 2277 2278 class domZfail : public daeElement 2279 { 2280 public: 2281 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ZFAIL; } 2282 static daeInt ID() { return 254; } 2283 virtual daeInt typeID() const { return ID(); } 2284 protected: // Attributes 2285 domGl_stencil_op_type attrValue; 2286 xsNCName attrParam; 2287 2288 2289 public: //Accessors and Mutators 2290 /** 2291 * Gets the value attribute. 2292 * @return Returns a domGl_stencil_op_type of the value attribute. 2293 */ 2294 domGl_stencil_op_type getValue() const { return attrValue; } 2295 /** 2296 * Sets the value attribute. 2297 * @param atValue The new value for the value attribute. 2298 */ 2299 void setValue( domGl_stencil_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2300 2301 /** 2302 * Gets the param attribute. 2303 * @return Returns a xsNCName of the param attribute. 2304 */ 2305 xsNCName getParam() const { return attrParam; } 2306 /** 2307 * Sets the param attribute. 2308 * @param atParam The new value for the param attribute. 2309 */ 2310 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2311 2312 protected: 2313 /** 2314 * Constructor 2315 */ 2316 domZfail(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2317 /** 2318 * Destructor 2319 */ 2320 virtual ~domZfail() {} 2321 /** 2322 * Overloaded assignment operator 2323 */ 2324 virtual domZfail &operator=( const domZfail &cpy ) { (void)cpy; return *this; } 2325 2326 public: // STATIC METHODS 2327 /** 2328 * Creates an instance of this class and returns a daeElementRef referencing it. 2329 * @return a daeElementRef referencing an instance of this object. 2330 */ 2331 static DLLSPEC daeElementRef create(DAE& dae); 2332 /** 2333 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2334 * If a daeMetaElement already exists it will return that instead of creating a new one. 2335 * @return A daeMetaElement describing this COLLADA element. 2336 */ 2337 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2338 }; 2339 2340 class domZpass; 2341 2342 typedef daeSmartRef<domZpass> domZpassRef; 2343 typedef daeTArray<domZpassRef> domZpass_Array; 2344 2345 class domZpass : public daeElement 2346 { 2347 public: 2348 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ZPASS; } 2349 static daeInt ID() { return 255; } 2350 virtual daeInt typeID() const { return ID(); } 2351 protected: // Attributes 2352 domGl_stencil_op_type attrValue; 2353 xsNCName attrParam; 2354 2355 2356 public: //Accessors and Mutators 2357 /** 2358 * Gets the value attribute. 2359 * @return Returns a domGl_stencil_op_type of the value attribute. 2360 */ 2361 domGl_stencil_op_type getValue() const { return attrValue; } 2362 /** 2363 * Sets the value attribute. 2364 * @param atValue The new value for the value attribute. 2365 */ 2366 void setValue( domGl_stencil_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2367 2368 /** 2369 * Gets the param attribute. 2370 * @return Returns a xsNCName of the param attribute. 2371 */ 2372 xsNCName getParam() const { return attrParam; } 2373 /** 2374 * Sets the param attribute. 2375 * @param atParam The new value for the param attribute. 2376 */ 2377 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2378 2379 protected: 2380 /** 2381 * Constructor 2382 */ 2383 domZpass(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2384 /** 2385 * Destructor 2386 */ 2387 virtual ~domZpass() {} 2388 /** 2389 * Overloaded assignment operator 2390 */ 2391 virtual domZpass &operator=( const domZpass &cpy ) { (void)cpy; return *this; } 2392 2393 public: // STATIC METHODS 2394 /** 2395 * Creates an instance of this class and returns a daeElementRef referencing it. 2396 * @return a daeElementRef referencing an instance of this object. 2397 */ 2398 static DLLSPEC daeElementRef create(DAE& dae); 2399 /** 2400 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2401 * If a daeMetaElement already exists it will return that instead of creating a new one. 2402 * @return A daeMetaElement describing this COLLADA element. 2403 */ 2404 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2405 }; 2406 2407 2408 2409 protected: // Elements 2410 domFailRef elemFail; 2411 domZfailRef elemZfail; 2412 domZpassRef elemZpass; 2413 2414 public: //Accessors and Mutators 2415 /** 2416 * Gets the fail element. 2417 * @return a daeSmartRef to the fail element. 2418 */ 2419 const domFailRef getFail() const { return elemFail; } 2420 /** 2421 * Gets the zfail element. 2422 * @return a daeSmartRef to the zfail element. 2423 */ 2424 const domZfailRef getZfail() const { return elemZfail; } 2425 /** 2426 * Gets the zpass element. 2427 * @return a daeSmartRef to the zpass element. 2428 */ 2429 const domZpassRef getZpass() const { return elemZpass; } 2430 protected: 2431 /** 2432 * Constructor 2433 */ 2434 domStencil_op(DAE& dae) : daeElement(dae), elemFail(), elemZfail(), elemZpass() {} 2435 /** 2436 * Destructor 2437 */ 2438 virtual ~domStencil_op() {} 2439 /** 2440 * Overloaded assignment operator 2441 */ 2442 virtual domStencil_op &operator=( const domStencil_op &cpy ) { (void)cpy; return *this; } 2443 2444 public: // STATIC METHODS 2445 /** 2446 * Creates an instance of this class and returns a daeElementRef referencing it. 2447 * @return a daeElementRef referencing an instance of this object. 2448 */ 2449 static DLLSPEC daeElementRef create(DAE& dae); 2450 /** 2451 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2452 * If a daeMetaElement already exists it will return that instead of creating a new one. 2453 * @return A daeMetaElement describing this COLLADA element. 2454 */ 2455 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2456 }; 2457 2458 class domStencil_func_separate; 2459 2460 typedef daeSmartRef<domStencil_func_separate> domStencil_func_separateRef; 2461 typedef daeTArray<domStencil_func_separateRef> domStencil_func_separate_Array; 2462 2463 class domStencil_func_separate : public daeElement 2464 { 2465 public: 2466 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_FUNC_SEPARATE; } 2467 static daeInt ID() { return 256; } 2468 virtual daeInt typeID() const { return ID(); } 2469 public: 2470 class domFront; 2471 2472 typedef daeSmartRef<domFront> domFrontRef; 2473 typedef daeTArray<domFrontRef> domFront_Array; 2474 2475 class domFront : public daeElement 2476 { 2477 public: 2478 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FRONT; } 2479 static daeInt ID() { return 257; } 2480 virtual daeInt typeID() const { return ID(); } 2481 protected: // Attributes 2482 domGl_func_type attrValue; 2483 xsNCName attrParam; 2484 2485 2486 public: //Accessors and Mutators 2487 /** 2488 * Gets the value attribute. 2489 * @return Returns a domGl_func_type of the value attribute. 2490 */ 2491 domGl_func_type getValue() const { return attrValue; } 2492 /** 2493 * Sets the value attribute. 2494 * @param atValue The new value for the value attribute. 2495 */ 2496 void setValue( domGl_func_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2497 2498 /** 2499 * Gets the param attribute. 2500 * @return Returns a xsNCName of the param attribute. 2501 */ 2502 xsNCName getParam() const { return attrParam; } 2503 /** 2504 * Sets the param attribute. 2505 * @param atParam The new value for the param attribute. 2506 */ 2507 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2508 2509 protected: 2510 /** 2511 * Constructor 2512 */ 2513 domFront(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2514 /** 2515 * Destructor 2516 */ 2517 virtual ~domFront() {} 2518 /** 2519 * Overloaded assignment operator 2520 */ 2521 virtual domFront &operator=( const domFront &cpy ) { (void)cpy; return *this; } 2522 2523 public: // STATIC METHODS 2524 /** 2525 * Creates an instance of this class and returns a daeElementRef referencing it. 2526 * @return a daeElementRef referencing an instance of this object. 2527 */ 2528 static DLLSPEC daeElementRef create(DAE& dae); 2529 /** 2530 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2531 * If a daeMetaElement already exists it will return that instead of creating a new one. 2532 * @return A daeMetaElement describing this COLLADA element. 2533 */ 2534 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2535 }; 2536 2537 class domBack; 2538 2539 typedef daeSmartRef<domBack> domBackRef; 2540 typedef daeTArray<domBackRef> domBack_Array; 2541 2542 class domBack : public daeElement 2543 { 2544 public: 2545 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BACK; } 2546 static daeInt ID() { return 258; } 2547 virtual daeInt typeID() const { return ID(); } 2548 protected: // Attributes 2549 domGl_func_type attrValue; 2550 xsNCName attrParam; 2551 2552 2553 public: //Accessors and Mutators 2554 /** 2555 * Gets the value attribute. 2556 * @return Returns a domGl_func_type of the value attribute. 2557 */ 2558 domGl_func_type getValue() const { return attrValue; } 2559 /** 2560 * Sets the value attribute. 2561 * @param atValue The new value for the value attribute. 2562 */ 2563 void setValue( domGl_func_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2564 2565 /** 2566 * Gets the param attribute. 2567 * @return Returns a xsNCName of the param attribute. 2568 */ 2569 xsNCName getParam() const { return attrParam; } 2570 /** 2571 * Sets the param attribute. 2572 * @param atParam The new value for the param attribute. 2573 */ 2574 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2575 2576 protected: 2577 /** 2578 * Constructor 2579 */ 2580 domBack(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2581 /** 2582 * Destructor 2583 */ 2584 virtual ~domBack() {} 2585 /** 2586 * Overloaded assignment operator 2587 */ 2588 virtual domBack &operator=( const domBack &cpy ) { (void)cpy; return *this; } 2589 2590 public: // STATIC METHODS 2591 /** 2592 * Creates an instance of this class and returns a daeElementRef referencing it. 2593 * @return a daeElementRef referencing an instance of this object. 2594 */ 2595 static DLLSPEC daeElementRef create(DAE& dae); 2596 /** 2597 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2598 * If a daeMetaElement already exists it will return that instead of creating a new one. 2599 * @return A daeMetaElement describing this COLLADA element. 2600 */ 2601 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2602 }; 2603 2604 class domRef; 2605 2606 typedef daeSmartRef<domRef> domRefRef; 2607 typedef daeTArray<domRefRef> domRef_Array; 2608 2609 class domRef : public daeElement 2610 { 2611 public: 2612 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::REF; } 2613 static daeInt ID() { return 259; } 2614 virtual daeInt typeID() const { return ID(); } 2615 protected: // Attributes 2616 xsUnsignedByte attrValue; 2617 xsNCName attrParam; 2618 2619 2620 public: //Accessors and Mutators 2621 /** 2622 * Gets the value attribute. 2623 * @return Returns a xsUnsignedByte of the value attribute. 2624 */ 2625 xsUnsignedByte getValue() const { return attrValue; } 2626 /** 2627 * Sets the value attribute. 2628 * @param atValue The new value for the value attribute. 2629 */ 2630 void setValue( xsUnsignedByte atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2631 2632 /** 2633 * Gets the param attribute. 2634 * @return Returns a xsNCName of the param attribute. 2635 */ 2636 xsNCName getParam() const { return attrParam; } 2637 /** 2638 * Sets the param attribute. 2639 * @param atParam The new value for the param attribute. 2640 */ 2641 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2642 2643 protected: 2644 /** 2645 * Constructor 2646 */ 2647 domRef(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2648 /** 2649 * Destructor 2650 */ 2651 virtual ~domRef() {} 2652 /** 2653 * Overloaded assignment operator 2654 */ 2655 virtual domRef &operator=( const domRef &cpy ) { (void)cpy; return *this; } 2656 2657 public: // STATIC METHODS 2658 /** 2659 * Creates an instance of this class and returns a daeElementRef referencing it. 2660 * @return a daeElementRef referencing an instance of this object. 2661 */ 2662 static DLLSPEC daeElementRef create(DAE& dae); 2663 /** 2664 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2665 * If a daeMetaElement already exists it will return that instead of creating a new one. 2666 * @return A daeMetaElement describing this COLLADA element. 2667 */ 2668 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2669 }; 2670 2671 class domMask; 2672 2673 typedef daeSmartRef<domMask> domMaskRef; 2674 typedef daeTArray<domMaskRef> domMask_Array; 2675 2676 class domMask : public daeElement 2677 { 2678 public: 2679 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MASK; } 2680 static daeInt ID() { return 260; } 2681 virtual daeInt typeID() const { return ID(); } 2682 protected: // Attributes 2683 xsUnsignedByte attrValue; 2684 xsNCName attrParam; 2685 2686 2687 public: //Accessors and Mutators 2688 /** 2689 * Gets the value attribute. 2690 * @return Returns a xsUnsignedByte of the value attribute. 2691 */ 2692 xsUnsignedByte getValue() const { return attrValue; } 2693 /** 2694 * Sets the value attribute. 2695 * @param atValue The new value for the value attribute. 2696 */ 2697 void setValue( xsUnsignedByte atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2698 2699 /** 2700 * Gets the param attribute. 2701 * @return Returns a xsNCName of the param attribute. 2702 */ 2703 xsNCName getParam() const { return attrParam; } 2704 /** 2705 * Sets the param attribute. 2706 * @param atParam The new value for the param attribute. 2707 */ 2708 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2709 2710 protected: 2711 /** 2712 * Constructor 2713 */ 2714 domMask(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2715 /** 2716 * Destructor 2717 */ 2718 virtual ~domMask() {} 2719 /** 2720 * Overloaded assignment operator 2721 */ 2722 virtual domMask &operator=( const domMask &cpy ) { (void)cpy; return *this; } 2723 2724 public: // STATIC METHODS 2725 /** 2726 * Creates an instance of this class and returns a daeElementRef referencing it. 2727 * @return a daeElementRef referencing an instance of this object. 2728 */ 2729 static DLLSPEC daeElementRef create(DAE& dae); 2730 /** 2731 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2732 * If a daeMetaElement already exists it will return that instead of creating a new one. 2733 * @return A daeMetaElement describing this COLLADA element. 2734 */ 2735 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2736 }; 2737 2738 2739 2740 protected: // Elements 2741 domFrontRef elemFront; 2742 domBackRef elemBack; 2743 domRefRef elemRef; 2744 domMaskRef elemMask; 2745 2746 public: //Accessors and Mutators 2747 /** 2748 * Gets the front element. 2749 * @return a daeSmartRef to the front element. 2750 */ 2751 const domFrontRef getFront() const { return elemFront; } 2752 /** 2753 * Gets the back element. 2754 * @return a daeSmartRef to the back element. 2755 */ 2756 const domBackRef getBack() const { return elemBack; } 2757 /** 2758 * Gets the ref element. 2759 * @return a daeSmartRef to the ref element. 2760 */ 2761 const domRefRef getRef() const { return elemRef; } 2762 /** 2763 * Gets the mask element. 2764 * @return a daeSmartRef to the mask element. 2765 */ 2766 const domMaskRef getMask() const { return elemMask; } 2767 protected: 2768 /** 2769 * Constructor 2770 */ 2771 domStencil_func_separate(DAE& dae) : daeElement(dae), elemFront(), elemBack(), elemRef(), elemMask() {} 2772 /** 2773 * Destructor 2774 */ 2775 virtual ~domStencil_func_separate() {} 2776 /** 2777 * Overloaded assignment operator 2778 */ 2779 virtual domStencil_func_separate &operator=( const domStencil_func_separate &cpy ) { (void)cpy; return *this; } 2780 2781 public: // STATIC METHODS 2782 /** 2783 * Creates an instance of this class and returns a daeElementRef referencing it. 2784 * @return a daeElementRef referencing an instance of this object. 2785 */ 2786 static DLLSPEC daeElementRef create(DAE& dae); 2787 /** 2788 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2789 * If a daeMetaElement already exists it will return that instead of creating a new one. 2790 * @return A daeMetaElement describing this COLLADA element. 2791 */ 2792 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2793 }; 2794 2795 class domStencil_op_separate; 2796 2797 typedef daeSmartRef<domStencil_op_separate> domStencil_op_separateRef; 2798 typedef daeTArray<domStencil_op_separateRef> domStencil_op_separate_Array; 2799 2800 class domStencil_op_separate : public daeElement 2801 { 2802 public: 2803 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_OP_SEPARATE; } 2804 static daeInt ID() { return 261; } 2805 virtual daeInt typeID() const { return ID(); } 2806 public: 2807 class domFace; 2808 2809 typedef daeSmartRef<domFace> domFaceRef; 2810 typedef daeTArray<domFaceRef> domFace_Array; 2811 2812 class domFace : public daeElement 2813 { 2814 public: 2815 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FACE; } 2816 static daeInt ID() { return 262; } 2817 virtual daeInt typeID() const { return ID(); } 2818 protected: // Attributes 2819 domGl_face_type attrValue; 2820 xsNCName attrParam; 2821 2822 2823 public: //Accessors and Mutators 2824 /** 2825 * Gets the value attribute. 2826 * @return Returns a domGl_face_type of the value attribute. 2827 */ 2828 domGl_face_type getValue() const { return attrValue; } 2829 /** 2830 * Sets the value attribute. 2831 * @param atValue The new value for the value attribute. 2832 */ 2833 void setValue( domGl_face_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2834 2835 /** 2836 * Gets the param attribute. 2837 * @return Returns a xsNCName of the param attribute. 2838 */ 2839 xsNCName getParam() const { return attrParam; } 2840 /** 2841 * Sets the param attribute. 2842 * @param atParam The new value for the param attribute. 2843 */ 2844 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2845 2846 protected: 2847 /** 2848 * Constructor 2849 */ 2850 domFace(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2851 /** 2852 * Destructor 2853 */ 2854 virtual ~domFace() {} 2855 /** 2856 * Overloaded assignment operator 2857 */ 2858 virtual domFace &operator=( const domFace &cpy ) { (void)cpy; return *this; } 2859 2860 public: // STATIC METHODS 2861 /** 2862 * Creates an instance of this class and returns a daeElementRef referencing it. 2863 * @return a daeElementRef referencing an instance of this object. 2864 */ 2865 static DLLSPEC daeElementRef create(DAE& dae); 2866 /** 2867 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2868 * If a daeMetaElement already exists it will return that instead of creating a new one. 2869 * @return A daeMetaElement describing this COLLADA element. 2870 */ 2871 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2872 }; 2873 2874 class domFail; 2875 2876 typedef daeSmartRef<domFail> domFailRef; 2877 typedef daeTArray<domFailRef> domFail_Array; 2878 2879 class domFail : public daeElement 2880 { 2881 public: 2882 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FAIL; } 2883 static daeInt ID() { return 263; } 2884 virtual daeInt typeID() const { return ID(); } 2885 protected: // Attributes 2886 domGl_stencil_op_type attrValue; 2887 xsNCName attrParam; 2888 2889 2890 public: //Accessors and Mutators 2891 /** 2892 * Gets the value attribute. 2893 * @return Returns a domGl_stencil_op_type of the value attribute. 2894 */ 2895 domGl_stencil_op_type getValue() const { return attrValue; } 2896 /** 2897 * Sets the value attribute. 2898 * @param atValue The new value for the value attribute. 2899 */ 2900 void setValue( domGl_stencil_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2901 2902 /** 2903 * Gets the param attribute. 2904 * @return Returns a xsNCName of the param attribute. 2905 */ 2906 xsNCName getParam() const { return attrParam; } 2907 /** 2908 * Sets the param attribute. 2909 * @param atParam The new value for the param attribute. 2910 */ 2911 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2912 2913 protected: 2914 /** 2915 * Constructor 2916 */ 2917 domFail(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2918 /** 2919 * Destructor 2920 */ 2921 virtual ~domFail() {} 2922 /** 2923 * Overloaded assignment operator 2924 */ 2925 virtual domFail &operator=( const domFail &cpy ) { (void)cpy; return *this; } 2926 2927 public: // STATIC METHODS 2928 /** 2929 * Creates an instance of this class and returns a daeElementRef referencing it. 2930 * @return a daeElementRef referencing an instance of this object. 2931 */ 2932 static DLLSPEC daeElementRef create(DAE& dae); 2933 /** 2934 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 2935 * If a daeMetaElement already exists it will return that instead of creating a new one. 2936 * @return A daeMetaElement describing this COLLADA element. 2937 */ 2938 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 2939 }; 2940 2941 class domZfail; 2942 2943 typedef daeSmartRef<domZfail> domZfailRef; 2944 typedef daeTArray<domZfailRef> domZfail_Array; 2945 2946 class domZfail : public daeElement 2947 { 2948 public: 2949 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ZFAIL; } 2950 static daeInt ID() { return 264; } 2951 virtual daeInt typeID() const { return ID(); } 2952 protected: // Attributes 2953 domGl_stencil_op_type attrValue; 2954 xsNCName attrParam; 2955 2956 2957 public: //Accessors and Mutators 2958 /** 2959 * Gets the value attribute. 2960 * @return Returns a domGl_stencil_op_type of the value attribute. 2961 */ 2962 domGl_stencil_op_type getValue() const { return attrValue; } 2963 /** 2964 * Sets the value attribute. 2965 * @param atValue The new value for the value attribute. 2966 */ 2967 void setValue( domGl_stencil_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 2968 2969 /** 2970 * Gets the param attribute. 2971 * @return Returns a xsNCName of the param attribute. 2972 */ 2973 xsNCName getParam() const { return attrParam; } 2974 /** 2975 * Sets the param attribute. 2976 * @param atParam The new value for the param attribute. 2977 */ 2978 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 2979 2980 protected: 2981 /** 2982 * Constructor 2983 */ 2984 domZfail(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 2985 /** 2986 * Destructor 2987 */ 2988 virtual ~domZfail() {} 2989 /** 2990 * Overloaded assignment operator 2991 */ 2992 virtual domZfail &operator=( const domZfail &cpy ) { (void)cpy; return *this; } 2993 2994 public: // STATIC METHODS 2995 /** 2996 * Creates an instance of this class and returns a daeElementRef referencing it. 2997 * @return a daeElementRef referencing an instance of this object. 2998 */ 2999 static DLLSPEC daeElementRef create(DAE& dae); 3000 /** 3001 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3002 * If a daeMetaElement already exists it will return that instead of creating a new one. 3003 * @return A daeMetaElement describing this COLLADA element. 3004 */ 3005 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3006 }; 3007 3008 class domZpass; 3009 3010 typedef daeSmartRef<domZpass> domZpassRef; 3011 typedef daeTArray<domZpassRef> domZpass_Array; 3012 3013 class domZpass : public daeElement 3014 { 3015 public: 3016 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ZPASS; } 3017 static daeInt ID() { return 265; } 3018 virtual daeInt typeID() const { return ID(); } 3019 protected: // Attributes 3020 domGl_stencil_op_type attrValue; 3021 xsNCName attrParam; 3022 3023 3024 public: //Accessors and Mutators 3025 /** 3026 * Gets the value attribute. 3027 * @return Returns a domGl_stencil_op_type of the value attribute. 3028 */ 3029 domGl_stencil_op_type getValue() const { return attrValue; } 3030 /** 3031 * Sets the value attribute. 3032 * @param atValue The new value for the value attribute. 3033 */ 3034 void setValue( domGl_stencil_op_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3035 3036 /** 3037 * Gets the param attribute. 3038 * @return Returns a xsNCName of the param attribute. 3039 */ 3040 xsNCName getParam() const { return attrParam; } 3041 /** 3042 * Sets the param attribute. 3043 * @param atParam The new value for the param attribute. 3044 */ 3045 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3046 3047 protected: 3048 /** 3049 * Constructor 3050 */ 3051 domZpass(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 3052 /** 3053 * Destructor 3054 */ 3055 virtual ~domZpass() {} 3056 /** 3057 * Overloaded assignment operator 3058 */ 3059 virtual domZpass &operator=( const domZpass &cpy ) { (void)cpy; return *this; } 3060 3061 public: // STATIC METHODS 3062 /** 3063 * Creates an instance of this class and returns a daeElementRef referencing it. 3064 * @return a daeElementRef referencing an instance of this object. 3065 */ 3066 static DLLSPEC daeElementRef create(DAE& dae); 3067 /** 3068 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3069 * If a daeMetaElement already exists it will return that instead of creating a new one. 3070 * @return A daeMetaElement describing this COLLADA element. 3071 */ 3072 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3073 }; 3074 3075 3076 3077 protected: // Elements 3078 domFaceRef elemFace; 3079 domFailRef elemFail; 3080 domZfailRef elemZfail; 3081 domZpassRef elemZpass; 3082 3083 public: //Accessors and Mutators 3084 /** 3085 * Gets the face element. 3086 * @return a daeSmartRef to the face element. 3087 */ 3088 const domFaceRef getFace() const { return elemFace; } 3089 /** 3090 * Gets the fail element. 3091 * @return a daeSmartRef to the fail element. 3092 */ 3093 const domFailRef getFail() const { return elemFail; } 3094 /** 3095 * Gets the zfail element. 3096 * @return a daeSmartRef to the zfail element. 3097 */ 3098 const domZfailRef getZfail() const { return elemZfail; } 3099 /** 3100 * Gets the zpass element. 3101 * @return a daeSmartRef to the zpass element. 3102 */ 3103 const domZpassRef getZpass() const { return elemZpass; } 3104 protected: 3105 /** 3106 * Constructor 3107 */ 3108 domStencil_op_separate(DAE& dae) : daeElement(dae), elemFace(), elemFail(), elemZfail(), elemZpass() {} 3109 /** 3110 * Destructor 3111 */ 3112 virtual ~domStencil_op_separate() {} 3113 /** 3114 * Overloaded assignment operator 3115 */ 3116 virtual domStencil_op_separate &operator=( const domStencil_op_separate &cpy ) { (void)cpy; return *this; } 3117 3118 public: // STATIC METHODS 3119 /** 3120 * Creates an instance of this class and returns a daeElementRef referencing it. 3121 * @return a daeElementRef referencing an instance of this object. 3122 */ 3123 static DLLSPEC daeElementRef create(DAE& dae); 3124 /** 3125 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3126 * If a daeMetaElement already exists it will return that instead of creating a new one. 3127 * @return A daeMetaElement describing this COLLADA element. 3128 */ 3129 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3130 }; 3131 3132 class domStencil_mask_separate; 3133 3134 typedef daeSmartRef<domStencil_mask_separate> domStencil_mask_separateRef; 3135 typedef daeTArray<domStencil_mask_separateRef> domStencil_mask_separate_Array; 3136 3137 class domStencil_mask_separate : public daeElement 3138 { 3139 public: 3140 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_MASK_SEPARATE; } 3141 static daeInt ID() { return 266; } 3142 virtual daeInt typeID() const { return ID(); } 3143 public: 3144 class domFace; 3145 3146 typedef daeSmartRef<domFace> domFaceRef; 3147 typedef daeTArray<domFaceRef> domFace_Array; 3148 3149 class domFace : public daeElement 3150 { 3151 public: 3152 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FACE; } 3153 static daeInt ID() { return 267; } 3154 virtual daeInt typeID() const { return ID(); } 3155 protected: // Attributes 3156 domGl_face_type attrValue; 3157 xsNCName attrParam; 3158 3159 3160 public: //Accessors and Mutators 3161 /** 3162 * Gets the value attribute. 3163 * @return Returns a domGl_face_type of the value attribute. 3164 */ 3165 domGl_face_type getValue() const { return attrValue; } 3166 /** 3167 * Sets the value attribute. 3168 * @param atValue The new value for the value attribute. 3169 */ 3170 void setValue( domGl_face_type atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3171 3172 /** 3173 * Gets the param attribute. 3174 * @return Returns a xsNCName of the param attribute. 3175 */ 3176 xsNCName getParam() const { return attrParam; } 3177 /** 3178 * Sets the param attribute. 3179 * @param atParam The new value for the param attribute. 3180 */ 3181 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3182 3183 protected: 3184 /** 3185 * Constructor 3186 */ 3187 domFace(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 3188 /** 3189 * Destructor 3190 */ 3191 virtual ~domFace() {} 3192 /** 3193 * Overloaded assignment operator 3194 */ 3195 virtual domFace &operator=( const domFace &cpy ) { (void)cpy; return *this; } 3196 3197 public: // STATIC METHODS 3198 /** 3199 * Creates an instance of this class and returns a daeElementRef referencing it. 3200 * @return a daeElementRef referencing an instance of this object. 3201 */ 3202 static DLLSPEC daeElementRef create(DAE& dae); 3203 /** 3204 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3205 * If a daeMetaElement already exists it will return that instead of creating a new one. 3206 * @return A daeMetaElement describing this COLLADA element. 3207 */ 3208 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3209 }; 3210 3211 class domMask; 3212 3213 typedef daeSmartRef<domMask> domMaskRef; 3214 typedef daeTArray<domMaskRef> domMask_Array; 3215 3216 class domMask : public daeElement 3217 { 3218 public: 3219 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MASK; } 3220 static daeInt ID() { return 268; } 3221 virtual daeInt typeID() const { return ID(); } 3222 protected: // Attributes 3223 xsUnsignedByte attrValue; 3224 xsNCName attrParam; 3225 3226 3227 public: //Accessors and Mutators 3228 /** 3229 * Gets the value attribute. 3230 * @return Returns a xsUnsignedByte of the value attribute. 3231 */ 3232 xsUnsignedByte getValue() const { return attrValue; } 3233 /** 3234 * Sets the value attribute. 3235 * @param atValue The new value for the value attribute. 3236 */ 3237 void setValue( xsUnsignedByte atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3238 3239 /** 3240 * Gets the param attribute. 3241 * @return Returns a xsNCName of the param attribute. 3242 */ 3243 xsNCName getParam() const { return attrParam; } 3244 /** 3245 * Sets the param attribute. 3246 * @param atParam The new value for the param attribute. 3247 */ 3248 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3249 3250 protected: 3251 /** 3252 * Constructor 3253 */ 3254 domMask(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 3255 /** 3256 * Destructor 3257 */ 3258 virtual ~domMask() {} 3259 /** 3260 * Overloaded assignment operator 3261 */ 3262 virtual domMask &operator=( const domMask &cpy ) { (void)cpy; return *this; } 3263 3264 public: // STATIC METHODS 3265 /** 3266 * Creates an instance of this class and returns a daeElementRef referencing it. 3267 * @return a daeElementRef referencing an instance of this object. 3268 */ 3269 static DLLSPEC daeElementRef create(DAE& dae); 3270 /** 3271 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3272 * If a daeMetaElement already exists it will return that instead of creating a new one. 3273 * @return A daeMetaElement describing this COLLADA element. 3274 */ 3275 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3276 }; 3277 3278 3279 3280 protected: // Elements 3281 domFaceRef elemFace; 3282 domMaskRef elemMask; 3283 3284 public: //Accessors and Mutators 3285 /** 3286 * Gets the face element. 3287 * @return a daeSmartRef to the face element. 3288 */ 3289 const domFaceRef getFace() const { return elemFace; } 3290 /** 3291 * Gets the mask element. 3292 * @return a daeSmartRef to the mask element. 3293 */ 3294 const domMaskRef getMask() const { return elemMask; } 3295 protected: 3296 /** 3297 * Constructor 3298 */ 3299 domStencil_mask_separate(DAE& dae) : daeElement(dae), elemFace(), elemMask() {} 3300 /** 3301 * Destructor 3302 */ 3303 virtual ~domStencil_mask_separate() {} 3304 /** 3305 * Overloaded assignment operator 3306 */ 3307 virtual domStencil_mask_separate &operator=( const domStencil_mask_separate &cpy ) { (void)cpy; return *this; } 3308 3309 public: // STATIC METHODS 3310 /** 3311 * Creates an instance of this class and returns a daeElementRef referencing it. 3312 * @return a daeElementRef referencing an instance of this object. 3313 */ 3314 static DLLSPEC daeElementRef create(DAE& dae); 3315 /** 3316 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3317 * If a daeMetaElement already exists it will return that instead of creating a new one. 3318 * @return A daeMetaElement describing this COLLADA element. 3319 */ 3320 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3321 }; 3322 3323 class domLight_enable; 3324 3325 typedef daeSmartRef<domLight_enable> domLight_enableRef; 3326 typedef daeTArray<domLight_enableRef> domLight_enable_Array; 3327 3328 class domLight_enable : public daeElement 3329 { 3330 public: 3331 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_ENABLE; } 3332 static daeInt ID() { return 269; } 3333 virtual daeInt typeID() const { return ID(); } 3334 protected: // Attributes 3335 domBool attrValue; 3336 xsNCName attrParam; 3337 domGL_MAX_LIGHTS_index attrIndex; 3338 3339 3340 public: //Accessors and Mutators 3341 /** 3342 * Gets the value attribute. 3343 * @return Returns a domBool of the value attribute. 3344 */ 3345 domBool getValue() const { return attrValue; } 3346 /** 3347 * Sets the value attribute. 3348 * @param atValue The new value for the value attribute. 3349 */ 3350 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3351 3352 /** 3353 * Gets the param attribute. 3354 * @return Returns a xsNCName of the param attribute. 3355 */ 3356 xsNCName getParam() const { return attrParam; } 3357 /** 3358 * Sets the param attribute. 3359 * @param atParam The new value for the param attribute. 3360 */ 3361 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3362 3363 /** 3364 * Gets the index attribute. 3365 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3366 */ 3367 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3368 /** 3369 * Sets the index attribute. 3370 * @param atIndex The new value for the index attribute. 3371 */ 3372 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3373 3374 protected: 3375 /** 3376 * Constructor 3377 */ 3378 domLight_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3379 /** 3380 * Destructor 3381 */ 3382 virtual ~domLight_enable() {} 3383 /** 3384 * Overloaded assignment operator 3385 */ 3386 virtual domLight_enable &operator=( const domLight_enable &cpy ) { (void)cpy; return *this; } 3387 3388 public: // STATIC METHODS 3389 /** 3390 * Creates an instance of this class and returns a daeElementRef referencing it. 3391 * @return a daeElementRef referencing an instance of this object. 3392 */ 3393 static DLLSPEC daeElementRef create(DAE& dae); 3394 /** 3395 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3396 * If a daeMetaElement already exists it will return that instead of creating a new one. 3397 * @return A daeMetaElement describing this COLLADA element. 3398 */ 3399 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3400 }; 3401 3402 class domLight_ambient; 3403 3404 typedef daeSmartRef<domLight_ambient> domLight_ambientRef; 3405 typedef daeTArray<domLight_ambientRef> domLight_ambient_Array; 3406 3407 class domLight_ambient : public daeElement 3408 { 3409 public: 3410 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_AMBIENT; } 3411 static daeInt ID() { return 270; } 3412 virtual daeInt typeID() const { return ID(); } 3413 protected: // Attributes 3414 domFloat4 attrValue; 3415 xsNCName attrParam; 3416 domGL_MAX_LIGHTS_index attrIndex; 3417 3418 3419 public: //Accessors and Mutators 3420 /** 3421 * Gets the value array attribute. 3422 * @return Returns a domFloat4 reference of the value array attribute. 3423 */ 3424 domFloat4 &getValue() { return attrValue; } 3425 /** 3426 * Gets the value array attribute. 3427 * @return Returns a constant domFloat4 reference of the value array attribute. 3428 */ 3429 const domFloat4 &getValue() const { return attrValue; } 3430 /** 3431 * Sets the value array attribute. 3432 * @param atValue The new value for the value array attribute. 3433 */ 3434 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3435 3436 /** 3437 * Gets the param attribute. 3438 * @return Returns a xsNCName of the param attribute. 3439 */ 3440 xsNCName getParam() const { return attrParam; } 3441 /** 3442 * Sets the param attribute. 3443 * @param atParam The new value for the param attribute. 3444 */ 3445 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3446 3447 /** 3448 * Gets the index attribute. 3449 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3450 */ 3451 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3452 /** 3453 * Sets the index attribute. 3454 * @param atIndex The new value for the index attribute. 3455 */ 3456 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3457 3458 protected: 3459 /** 3460 * Constructor 3461 */ 3462 domLight_ambient(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3463 /** 3464 * Destructor 3465 */ 3466 virtual ~domLight_ambient() {} 3467 /** 3468 * Overloaded assignment operator 3469 */ 3470 virtual domLight_ambient &operator=( const domLight_ambient &cpy ) { (void)cpy; return *this; } 3471 3472 public: // STATIC METHODS 3473 /** 3474 * Creates an instance of this class and returns a daeElementRef referencing it. 3475 * @return a daeElementRef referencing an instance of this object. 3476 */ 3477 static DLLSPEC daeElementRef create(DAE& dae); 3478 /** 3479 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3480 * If a daeMetaElement already exists it will return that instead of creating a new one. 3481 * @return A daeMetaElement describing this COLLADA element. 3482 */ 3483 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3484 }; 3485 3486 class domLight_diffuse; 3487 3488 typedef daeSmartRef<domLight_diffuse> domLight_diffuseRef; 3489 typedef daeTArray<domLight_diffuseRef> domLight_diffuse_Array; 3490 3491 class domLight_diffuse : public daeElement 3492 { 3493 public: 3494 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_DIFFUSE; } 3495 static daeInt ID() { return 271; } 3496 virtual daeInt typeID() const { return ID(); } 3497 protected: // Attributes 3498 domFloat4 attrValue; 3499 xsNCName attrParam; 3500 domGL_MAX_LIGHTS_index attrIndex; 3501 3502 3503 public: //Accessors and Mutators 3504 /** 3505 * Gets the value array attribute. 3506 * @return Returns a domFloat4 reference of the value array attribute. 3507 */ 3508 domFloat4 &getValue() { return attrValue; } 3509 /** 3510 * Gets the value array attribute. 3511 * @return Returns a constant domFloat4 reference of the value array attribute. 3512 */ 3513 const domFloat4 &getValue() const { return attrValue; } 3514 /** 3515 * Sets the value array attribute. 3516 * @param atValue The new value for the value array attribute. 3517 */ 3518 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3519 3520 /** 3521 * Gets the param attribute. 3522 * @return Returns a xsNCName of the param attribute. 3523 */ 3524 xsNCName getParam() const { return attrParam; } 3525 /** 3526 * Sets the param attribute. 3527 * @param atParam The new value for the param attribute. 3528 */ 3529 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3530 3531 /** 3532 * Gets the index attribute. 3533 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3534 */ 3535 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3536 /** 3537 * Sets the index attribute. 3538 * @param atIndex The new value for the index attribute. 3539 */ 3540 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3541 3542 protected: 3543 /** 3544 * Constructor 3545 */ 3546 domLight_diffuse(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3547 /** 3548 * Destructor 3549 */ 3550 virtual ~domLight_diffuse() {} 3551 /** 3552 * Overloaded assignment operator 3553 */ 3554 virtual domLight_diffuse &operator=( const domLight_diffuse &cpy ) { (void)cpy; return *this; } 3555 3556 public: // STATIC METHODS 3557 /** 3558 * Creates an instance of this class and returns a daeElementRef referencing it. 3559 * @return a daeElementRef referencing an instance of this object. 3560 */ 3561 static DLLSPEC daeElementRef create(DAE& dae); 3562 /** 3563 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3564 * If a daeMetaElement already exists it will return that instead of creating a new one. 3565 * @return A daeMetaElement describing this COLLADA element. 3566 */ 3567 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3568 }; 3569 3570 class domLight_specular; 3571 3572 typedef daeSmartRef<domLight_specular> domLight_specularRef; 3573 typedef daeTArray<domLight_specularRef> domLight_specular_Array; 3574 3575 class domLight_specular : public daeElement 3576 { 3577 public: 3578 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_SPECULAR; } 3579 static daeInt ID() { return 272; } 3580 virtual daeInt typeID() const { return ID(); } 3581 protected: // Attributes 3582 domFloat4 attrValue; 3583 xsNCName attrParam; 3584 domGL_MAX_LIGHTS_index attrIndex; 3585 3586 3587 public: //Accessors and Mutators 3588 /** 3589 * Gets the value array attribute. 3590 * @return Returns a domFloat4 reference of the value array attribute. 3591 */ 3592 domFloat4 &getValue() { return attrValue; } 3593 /** 3594 * Gets the value array attribute. 3595 * @return Returns a constant domFloat4 reference of the value array attribute. 3596 */ 3597 const domFloat4 &getValue() const { return attrValue; } 3598 /** 3599 * Sets the value array attribute. 3600 * @param atValue The new value for the value array attribute. 3601 */ 3602 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3603 3604 /** 3605 * Gets the param attribute. 3606 * @return Returns a xsNCName of the param attribute. 3607 */ 3608 xsNCName getParam() const { return attrParam; } 3609 /** 3610 * Sets the param attribute. 3611 * @param atParam The new value for the param attribute. 3612 */ 3613 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3614 3615 /** 3616 * Gets the index attribute. 3617 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3618 */ 3619 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3620 /** 3621 * Sets the index attribute. 3622 * @param atIndex The new value for the index attribute. 3623 */ 3624 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3625 3626 protected: 3627 /** 3628 * Constructor 3629 */ 3630 domLight_specular(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3631 /** 3632 * Destructor 3633 */ 3634 virtual ~domLight_specular() {} 3635 /** 3636 * Overloaded assignment operator 3637 */ 3638 virtual domLight_specular &operator=( const domLight_specular &cpy ) { (void)cpy; return *this; } 3639 3640 public: // STATIC METHODS 3641 /** 3642 * Creates an instance of this class and returns a daeElementRef referencing it. 3643 * @return a daeElementRef referencing an instance of this object. 3644 */ 3645 static DLLSPEC daeElementRef create(DAE& dae); 3646 /** 3647 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3648 * If a daeMetaElement already exists it will return that instead of creating a new one. 3649 * @return A daeMetaElement describing this COLLADA element. 3650 */ 3651 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3652 }; 3653 3654 class domLight_position; 3655 3656 typedef daeSmartRef<domLight_position> domLight_positionRef; 3657 typedef daeTArray<domLight_positionRef> domLight_position_Array; 3658 3659 class domLight_position : public daeElement 3660 { 3661 public: 3662 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_POSITION; } 3663 static daeInt ID() { return 273; } 3664 virtual daeInt typeID() const { return ID(); } 3665 protected: // Attributes 3666 domFloat4 attrValue; 3667 xsNCName attrParam; 3668 domGL_MAX_LIGHTS_index attrIndex; 3669 3670 3671 public: //Accessors and Mutators 3672 /** 3673 * Gets the value array attribute. 3674 * @return Returns a domFloat4 reference of the value array attribute. 3675 */ 3676 domFloat4 &getValue() { return attrValue; } 3677 /** 3678 * Gets the value array attribute. 3679 * @return Returns a constant domFloat4 reference of the value array attribute. 3680 */ 3681 const domFloat4 &getValue() const { return attrValue; } 3682 /** 3683 * Sets the value array attribute. 3684 * @param atValue The new value for the value array attribute. 3685 */ 3686 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3687 3688 /** 3689 * Gets the param attribute. 3690 * @return Returns a xsNCName of the param attribute. 3691 */ 3692 xsNCName getParam() const { return attrParam; } 3693 /** 3694 * Sets the param attribute. 3695 * @param atParam The new value for the param attribute. 3696 */ 3697 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3698 3699 /** 3700 * Gets the index attribute. 3701 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3702 */ 3703 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3704 /** 3705 * Sets the index attribute. 3706 * @param atIndex The new value for the index attribute. 3707 */ 3708 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3709 3710 protected: 3711 /** 3712 * Constructor 3713 */ 3714 domLight_position(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3715 /** 3716 * Destructor 3717 */ 3718 virtual ~domLight_position() {} 3719 /** 3720 * Overloaded assignment operator 3721 */ 3722 virtual domLight_position &operator=( const domLight_position &cpy ) { (void)cpy; return *this; } 3723 3724 public: // STATIC METHODS 3725 /** 3726 * Creates an instance of this class and returns a daeElementRef referencing it. 3727 * @return a daeElementRef referencing an instance of this object. 3728 */ 3729 static DLLSPEC daeElementRef create(DAE& dae); 3730 /** 3731 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3732 * If a daeMetaElement already exists it will return that instead of creating a new one. 3733 * @return A daeMetaElement describing this COLLADA element. 3734 */ 3735 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3736 }; 3737 3738 class domLight_constant_attenuation; 3739 3740 typedef daeSmartRef<domLight_constant_attenuation> domLight_constant_attenuationRef; 3741 typedef daeTArray<domLight_constant_attenuationRef> domLight_constant_attenuation_Array; 3742 3743 class domLight_constant_attenuation : public daeElement 3744 { 3745 public: 3746 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_CONSTANT_ATTENUATION; } 3747 static daeInt ID() { return 274; } 3748 virtual daeInt typeID() const { return ID(); } 3749 protected: // Attributes 3750 domFloat attrValue; 3751 xsNCName attrParam; 3752 domGL_MAX_LIGHTS_index attrIndex; 3753 3754 3755 public: //Accessors and Mutators 3756 /** 3757 * Gets the value attribute. 3758 * @return Returns a domFloat of the value attribute. 3759 */ 3760 domFloat getValue() const { return attrValue; } 3761 /** 3762 * Sets the value attribute. 3763 * @param atValue The new value for the value attribute. 3764 */ 3765 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3766 3767 /** 3768 * Gets the param attribute. 3769 * @return Returns a xsNCName of the param attribute. 3770 */ 3771 xsNCName getParam() const { return attrParam; } 3772 /** 3773 * Sets the param attribute. 3774 * @param atParam The new value for the param attribute. 3775 */ 3776 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3777 3778 /** 3779 * Gets the index attribute. 3780 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3781 */ 3782 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3783 /** 3784 * Sets the index attribute. 3785 * @param atIndex The new value for the index attribute. 3786 */ 3787 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3788 3789 protected: 3790 /** 3791 * Constructor 3792 */ 3793 domLight_constant_attenuation(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3794 /** 3795 * Destructor 3796 */ 3797 virtual ~domLight_constant_attenuation() {} 3798 /** 3799 * Overloaded assignment operator 3800 */ 3801 virtual domLight_constant_attenuation &operator=( const domLight_constant_attenuation &cpy ) { (void)cpy; return *this; } 3802 3803 public: // STATIC METHODS 3804 /** 3805 * Creates an instance of this class and returns a daeElementRef referencing it. 3806 * @return a daeElementRef referencing an instance of this object. 3807 */ 3808 static DLLSPEC daeElementRef create(DAE& dae); 3809 /** 3810 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3811 * If a daeMetaElement already exists it will return that instead of creating a new one. 3812 * @return A daeMetaElement describing this COLLADA element. 3813 */ 3814 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3815 }; 3816 3817 class domLight_linear_attenuation; 3818 3819 typedef daeSmartRef<domLight_linear_attenuation> domLight_linear_attenuationRef; 3820 typedef daeTArray<domLight_linear_attenuationRef> domLight_linear_attenuation_Array; 3821 3822 class domLight_linear_attenuation : public daeElement 3823 { 3824 public: 3825 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_LINEAR_ATTENUATION; } 3826 static daeInt ID() { return 275; } 3827 virtual daeInt typeID() const { return ID(); } 3828 protected: // Attributes 3829 domFloat attrValue; 3830 xsNCName attrParam; 3831 domGL_MAX_LIGHTS_index attrIndex; 3832 3833 3834 public: //Accessors and Mutators 3835 /** 3836 * Gets the value attribute. 3837 * @return Returns a domFloat of the value attribute. 3838 */ 3839 domFloat getValue() const { return attrValue; } 3840 /** 3841 * Sets the value attribute. 3842 * @param atValue The new value for the value attribute. 3843 */ 3844 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3845 3846 /** 3847 * Gets the param attribute. 3848 * @return Returns a xsNCName of the param attribute. 3849 */ 3850 xsNCName getParam() const { return attrParam; } 3851 /** 3852 * Sets the param attribute. 3853 * @param atParam The new value for the param attribute. 3854 */ 3855 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3856 3857 /** 3858 * Gets the index attribute. 3859 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3860 */ 3861 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3862 /** 3863 * Sets the index attribute. 3864 * @param atIndex The new value for the index attribute. 3865 */ 3866 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3867 3868 protected: 3869 /** 3870 * Constructor 3871 */ 3872 domLight_linear_attenuation(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3873 /** 3874 * Destructor 3875 */ 3876 virtual ~domLight_linear_attenuation() {} 3877 /** 3878 * Overloaded assignment operator 3879 */ 3880 virtual domLight_linear_attenuation &operator=( const domLight_linear_attenuation &cpy ) { (void)cpy; return *this; } 3881 3882 public: // STATIC METHODS 3883 /** 3884 * Creates an instance of this class and returns a daeElementRef referencing it. 3885 * @return a daeElementRef referencing an instance of this object. 3886 */ 3887 static DLLSPEC daeElementRef create(DAE& dae); 3888 /** 3889 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3890 * If a daeMetaElement already exists it will return that instead of creating a new one. 3891 * @return A daeMetaElement describing this COLLADA element. 3892 */ 3893 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3894 }; 3895 3896 class domLight_quadratic_attenuation; 3897 3898 typedef daeSmartRef<domLight_quadratic_attenuation> domLight_quadratic_attenuationRef; 3899 typedef daeTArray<domLight_quadratic_attenuationRef> domLight_quadratic_attenuation_Array; 3900 3901 class domLight_quadratic_attenuation : public daeElement 3902 { 3903 public: 3904 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_QUADRATIC_ATTENUATION; } 3905 static daeInt ID() { return 276; } 3906 virtual daeInt typeID() const { return ID(); } 3907 protected: // Attributes 3908 domFloat attrValue; 3909 xsNCName attrParam; 3910 domGL_MAX_LIGHTS_index attrIndex; 3911 3912 3913 public: //Accessors and Mutators 3914 /** 3915 * Gets the value attribute. 3916 * @return Returns a domFloat of the value attribute. 3917 */ 3918 domFloat getValue() const { return attrValue; } 3919 /** 3920 * Sets the value attribute. 3921 * @param atValue The new value for the value attribute. 3922 */ 3923 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 3924 3925 /** 3926 * Gets the param attribute. 3927 * @return Returns a xsNCName of the param attribute. 3928 */ 3929 xsNCName getParam() const { return attrParam; } 3930 /** 3931 * Sets the param attribute. 3932 * @param atParam The new value for the param attribute. 3933 */ 3934 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 3935 3936 /** 3937 * Gets the index attribute. 3938 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 3939 */ 3940 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 3941 /** 3942 * Sets the index attribute. 3943 * @param atIndex The new value for the index attribute. 3944 */ 3945 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 3946 3947 protected: 3948 /** 3949 * Constructor 3950 */ 3951 domLight_quadratic_attenuation(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 3952 /** 3953 * Destructor 3954 */ 3955 virtual ~domLight_quadratic_attenuation() {} 3956 /** 3957 * Overloaded assignment operator 3958 */ 3959 virtual domLight_quadratic_attenuation &operator=( const domLight_quadratic_attenuation &cpy ) { (void)cpy; return *this; } 3960 3961 public: // STATIC METHODS 3962 /** 3963 * Creates an instance of this class and returns a daeElementRef referencing it. 3964 * @return a daeElementRef referencing an instance of this object. 3965 */ 3966 static DLLSPEC daeElementRef create(DAE& dae); 3967 /** 3968 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 3969 * If a daeMetaElement already exists it will return that instead of creating a new one. 3970 * @return A daeMetaElement describing this COLLADA element. 3971 */ 3972 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 3973 }; 3974 3975 class domLight_spot_cutoff; 3976 3977 typedef daeSmartRef<domLight_spot_cutoff> domLight_spot_cutoffRef; 3978 typedef daeTArray<domLight_spot_cutoffRef> domLight_spot_cutoff_Array; 3979 3980 class domLight_spot_cutoff : public daeElement 3981 { 3982 public: 3983 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_SPOT_CUTOFF; } 3984 static daeInt ID() { return 277; } 3985 virtual daeInt typeID() const { return ID(); } 3986 protected: // Attributes 3987 domFloat attrValue; 3988 xsNCName attrParam; 3989 domGL_MAX_LIGHTS_index attrIndex; 3990 3991 3992 public: //Accessors and Mutators 3993 /** 3994 * Gets the value attribute. 3995 * @return Returns a domFloat of the value attribute. 3996 */ 3997 domFloat getValue() const { return attrValue; } 3998 /** 3999 * Sets the value attribute. 4000 * @param atValue The new value for the value attribute. 4001 */ 4002 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 4003 4004 /** 4005 * Gets the param attribute. 4006 * @return Returns a xsNCName of the param attribute. 4007 */ 4008 xsNCName getParam() const { return attrParam; } 4009 /** 4010 * Sets the param attribute. 4011 * @param atParam The new value for the param attribute. 4012 */ 4013 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 4014 4015 /** 4016 * Gets the index attribute. 4017 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 4018 */ 4019 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 4020 /** 4021 * Sets the index attribute. 4022 * @param atIndex The new value for the index attribute. 4023 */ 4024 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 4025 4026 protected: 4027 /** 4028 * Constructor 4029 */ 4030 domLight_spot_cutoff(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 4031 /** 4032 * Destructor 4033 */ 4034 virtual ~domLight_spot_cutoff() {} 4035 /** 4036 * Overloaded assignment operator 4037 */ 4038 virtual domLight_spot_cutoff &operator=( const domLight_spot_cutoff &cpy ) { (void)cpy; return *this; } 4039 4040 public: // STATIC METHODS 4041 /** 4042 * Creates an instance of this class and returns a daeElementRef referencing it. 4043 * @return a daeElementRef referencing an instance of this object. 4044 */ 4045 static DLLSPEC daeElementRef create(DAE& dae); 4046 /** 4047 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4048 * If a daeMetaElement already exists it will return that instead of creating a new one. 4049 * @return A daeMetaElement describing this COLLADA element. 4050 */ 4051 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4052 }; 4053 4054 class domLight_spot_direction; 4055 4056 typedef daeSmartRef<domLight_spot_direction> domLight_spot_directionRef; 4057 typedef daeTArray<domLight_spot_directionRef> domLight_spot_direction_Array; 4058 4059 class domLight_spot_direction : public daeElement 4060 { 4061 public: 4062 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_SPOT_DIRECTION; } 4063 static daeInt ID() { return 278; } 4064 virtual daeInt typeID() const { return ID(); } 4065 protected: // Attributes 4066 domFloat3 attrValue; 4067 xsNCName attrParam; 4068 domGL_MAX_LIGHTS_index attrIndex; 4069 4070 4071 public: //Accessors and Mutators 4072 /** 4073 * Gets the value array attribute. 4074 * @return Returns a domFloat3 reference of the value array attribute. 4075 */ 4076 domFloat3 &getValue() { return attrValue; } 4077 /** 4078 * Gets the value array attribute. 4079 * @return Returns a constant domFloat3 reference of the value array attribute. 4080 */ 4081 const domFloat3 &getValue() const { return attrValue; } 4082 /** 4083 * Sets the value array attribute. 4084 * @param atValue The new value for the value array attribute. 4085 */ 4086 void setValue( const domFloat3 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 4087 4088 /** 4089 * Gets the param attribute. 4090 * @return Returns a xsNCName of the param attribute. 4091 */ 4092 xsNCName getParam() const { return attrParam; } 4093 /** 4094 * Sets the param attribute. 4095 * @param atParam The new value for the param attribute. 4096 */ 4097 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 4098 4099 /** 4100 * Gets the index attribute. 4101 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 4102 */ 4103 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 4104 /** 4105 * Sets the index attribute. 4106 * @param atIndex The new value for the index attribute. 4107 */ 4108 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 4109 4110 protected: 4111 /** 4112 * Constructor 4113 */ 4114 domLight_spot_direction(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 4115 /** 4116 * Destructor 4117 */ 4118 virtual ~domLight_spot_direction() {} 4119 /** 4120 * Overloaded assignment operator 4121 */ 4122 virtual domLight_spot_direction &operator=( const domLight_spot_direction &cpy ) { (void)cpy; return *this; } 4123 4124 public: // STATIC METHODS 4125 /** 4126 * Creates an instance of this class and returns a daeElementRef referencing it. 4127 * @return a daeElementRef referencing an instance of this object. 4128 */ 4129 static DLLSPEC daeElementRef create(DAE& dae); 4130 /** 4131 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4132 * If a daeMetaElement already exists it will return that instead of creating a new one. 4133 * @return A daeMetaElement describing this COLLADA element. 4134 */ 4135 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4136 }; 4137 4138 class domLight_spot_exponent; 4139 4140 typedef daeSmartRef<domLight_spot_exponent> domLight_spot_exponentRef; 4141 typedef daeTArray<domLight_spot_exponentRef> domLight_spot_exponent_Array; 4142 4143 class domLight_spot_exponent : public daeElement 4144 { 4145 public: 4146 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_SPOT_EXPONENT; } 4147 static daeInt ID() { return 279; } 4148 virtual daeInt typeID() const { return ID(); } 4149 protected: // Attributes 4150 domFloat attrValue; 4151 xsNCName attrParam; 4152 domGL_MAX_LIGHTS_index attrIndex; 4153 4154 4155 public: //Accessors and Mutators 4156 /** 4157 * Gets the value attribute. 4158 * @return Returns a domFloat of the value attribute. 4159 */ 4160 domFloat getValue() const { return attrValue; } 4161 /** 4162 * Sets the value attribute. 4163 * @param atValue The new value for the value attribute. 4164 */ 4165 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 4166 4167 /** 4168 * Gets the param attribute. 4169 * @return Returns a xsNCName of the param attribute. 4170 */ 4171 xsNCName getParam() const { return attrParam; } 4172 /** 4173 * Sets the param attribute. 4174 * @param atParam The new value for the param attribute. 4175 */ 4176 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 4177 4178 /** 4179 * Gets the index attribute. 4180 * @return Returns a domGL_MAX_LIGHTS_index of the index attribute. 4181 */ 4182 domGL_MAX_LIGHTS_index getIndex() const { return attrIndex; } 4183 /** 4184 * Sets the index attribute. 4185 * @param atIndex The new value for the index attribute. 4186 */ 4187 void setIndex( domGL_MAX_LIGHTS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 4188 4189 protected: 4190 /** 4191 * Constructor 4192 */ 4193 domLight_spot_exponent(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 4194 /** 4195 * Destructor 4196 */ 4197 virtual ~domLight_spot_exponent() {} 4198 /** 4199 * Overloaded assignment operator 4200 */ 4201 virtual domLight_spot_exponent &operator=( const domLight_spot_exponent &cpy ) { (void)cpy; return *this; } 4202 4203 public: // STATIC METHODS 4204 /** 4205 * Creates an instance of this class and returns a daeElementRef referencing it. 4206 * @return a daeElementRef referencing an instance of this object. 4207 */ 4208 static DLLSPEC daeElementRef create(DAE& dae); 4209 /** 4210 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4211 * If a daeMetaElement already exists it will return that instead of creating a new one. 4212 * @return A daeMetaElement describing this COLLADA element. 4213 */ 4214 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4215 }; 4216 4217 class domTexture1D; 4218 4219 typedef daeSmartRef<domTexture1D> domTexture1DRef; 4220 typedef daeTArray<domTexture1DRef> domTexture1D_Array; 4221 4222 class domTexture1D : public daeElement 4223 { 4224 public: 4225 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE1D; } 4226 static daeInt ID() { return 280; } 4227 virtual daeInt typeID() const { return ID(); } 4228 public: 4229 class domParam; 4230 4231 typedef daeSmartRef<domParam> domParamRef; 4232 typedef daeTArray<domParamRef> domParam_Array; 4233 4234 class domParam : public daeElement 4235 { 4236 public: 4237 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PARAM; } 4238 static daeInt ID() { return 281; } 4239 virtual daeInt typeID() const { return ID(); } 4240 4241 protected: // Value 4242 /** 4243 * The xsNCName value of the text data of this element. 4244 */ 4245 xsNCName _value; 4246 4247 public: //Accessors and Mutators 4248 /** 4249 * Gets the value of this element. 4250 * @return Returns a xsNCName of the value. 4251 */ 4252 xsNCName getValue() const { return _value; } 4253 /** 4254 * Sets the _value of this element. 4255 * @param val The new value for this element. 4256 */ 4257 void setValue( xsNCName val ) { *(daeStringRef*)&_value = val; } 4258 4259 protected: 4260 /** 4261 * Constructor 4262 */ 4263 domParam(DAE& dae) : daeElement(dae), _value() {} 4264 /** 4265 * Destructor 4266 */ 4267 virtual ~domParam() {} 4268 /** 4269 * Overloaded assignment operator 4270 */ 4271 virtual domParam &operator=( const domParam &cpy ) { (void)cpy; return *this; } 4272 4273 public: // STATIC METHODS 4274 /** 4275 * Creates an instance of this class and returns a daeElementRef referencing it. 4276 * @return a daeElementRef referencing an instance of this object. 4277 */ 4278 static DLLSPEC daeElementRef create(DAE& dae); 4279 /** 4280 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4281 * If a daeMetaElement already exists it will return that instead of creating a new one. 4282 * @return A daeMetaElement describing this COLLADA element. 4283 */ 4284 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4285 }; 4286 4287 4288 protected: // Attribute 4289 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 4290 4291 protected: // Elements 4292 domGl_sampler1DRef elemValue; 4293 domParamRef elemParam; 4294 /** 4295 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 4296 */ 4297 daeElementRefArray _contents; 4298 /** 4299 * Used to preserve order in elements that have a complex content model. 4300 */ 4301 daeUIntArray _contentsOrder; 4302 4303 /** 4304 * Used to store information needed for some content model objects. 4305 */ 4306 daeTArray< daeCharArray * > _CMData; 4307 4308 4309 public: //Accessors and Mutators 4310 /** 4311 * Gets the index attribute. 4312 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 4313 */ 4314 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 4315 /** 4316 * Sets the index attribute. 4317 * @param atIndex The new value for the index attribute. 4318 */ 4319 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[0] = true; } 4320 4321 /** 4322 * Gets the value element. 4323 * @return a daeSmartRef to the value element. 4324 */ 4325 const domGl_sampler1DRef getValue() const { return elemValue; } 4326 /** 4327 * Gets the param element. 4328 * @return a daeSmartRef to the param element. 4329 */ 4330 const domParamRef getParam() const { return elemParam; } 4331 /** 4332 * Gets the _contents array. 4333 * @return Returns a reference to the _contents element array. 4334 */ 4335 daeElementRefArray &getContents() { return _contents; } 4336 /** 4337 * Gets the _contents array. 4338 * @return Returns a constant reference to the _contents element array. 4339 */ 4340 const daeElementRefArray &getContents() const { return _contents; } 4341 4342 protected: 4343 /** 4344 * Constructor 4345 */ 4346 domTexture1D(DAE& dae) : daeElement(dae), attrIndex(), elemValue(), elemParam() {} 4347 /** 4348 * Destructor 4349 */ 4350 virtual ~domTexture1D() { daeElement::deleteCMDataArray(_CMData); } 4351 /** 4352 * Overloaded assignment operator 4353 */ 4354 virtual domTexture1D &operator=( const domTexture1D &cpy ) { (void)cpy; return *this; } 4355 4356 public: // STATIC METHODS 4357 /** 4358 * Creates an instance of this class and returns a daeElementRef referencing it. 4359 * @return a daeElementRef referencing an instance of this object. 4360 */ 4361 static DLLSPEC daeElementRef create(DAE& dae); 4362 /** 4363 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4364 * If a daeMetaElement already exists it will return that instead of creating a new one. 4365 * @return A daeMetaElement describing this COLLADA element. 4366 */ 4367 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4368 }; 4369 4370 class domTexture2D; 4371 4372 typedef daeSmartRef<domTexture2D> domTexture2DRef; 4373 typedef daeTArray<domTexture2DRef> domTexture2D_Array; 4374 4375 class domTexture2D : public daeElement 4376 { 4377 public: 4378 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE2D; } 4379 static daeInt ID() { return 282; } 4380 virtual daeInt typeID() const { return ID(); } 4381 public: 4382 class domParam; 4383 4384 typedef daeSmartRef<domParam> domParamRef; 4385 typedef daeTArray<domParamRef> domParam_Array; 4386 4387 class domParam : public daeElement 4388 { 4389 public: 4390 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PARAM; } 4391 static daeInt ID() { return 283; } 4392 virtual daeInt typeID() const { return ID(); } 4393 4394 protected: // Value 4395 /** 4396 * The xsNCName value of the text data of this element. 4397 */ 4398 xsNCName _value; 4399 4400 public: //Accessors and Mutators 4401 /** 4402 * Gets the value of this element. 4403 * @return Returns a xsNCName of the value. 4404 */ 4405 xsNCName getValue() const { return _value; } 4406 /** 4407 * Sets the _value of this element. 4408 * @param val The new value for this element. 4409 */ 4410 void setValue( xsNCName val ) { *(daeStringRef*)&_value = val; } 4411 4412 protected: 4413 /** 4414 * Constructor 4415 */ 4416 domParam(DAE& dae) : daeElement(dae), _value() {} 4417 /** 4418 * Destructor 4419 */ 4420 virtual ~domParam() {} 4421 /** 4422 * Overloaded assignment operator 4423 */ 4424 virtual domParam &operator=( const domParam &cpy ) { (void)cpy; return *this; } 4425 4426 public: // STATIC METHODS 4427 /** 4428 * Creates an instance of this class and returns a daeElementRef referencing it. 4429 * @return a daeElementRef referencing an instance of this object. 4430 */ 4431 static DLLSPEC daeElementRef create(DAE& dae); 4432 /** 4433 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4434 * If a daeMetaElement already exists it will return that instead of creating a new one. 4435 * @return A daeMetaElement describing this COLLADA element. 4436 */ 4437 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4438 }; 4439 4440 4441 protected: // Attribute 4442 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 4443 4444 protected: // Elements 4445 domGl_sampler2DRef elemValue; 4446 domParamRef elemParam; 4447 /** 4448 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 4449 */ 4450 daeElementRefArray _contents; 4451 /** 4452 * Used to preserve order in elements that have a complex content model. 4453 */ 4454 daeUIntArray _contentsOrder; 4455 4456 /** 4457 * Used to store information needed for some content model objects. 4458 */ 4459 daeTArray< daeCharArray * > _CMData; 4460 4461 4462 public: //Accessors and Mutators 4463 /** 4464 * Gets the index attribute. 4465 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 4466 */ 4467 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 4468 /** 4469 * Sets the index attribute. 4470 * @param atIndex The new value for the index attribute. 4471 */ 4472 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[0] = true; } 4473 4474 /** 4475 * Gets the value element. 4476 * @return a daeSmartRef to the value element. 4477 */ 4478 const domGl_sampler2DRef getValue() const { return elemValue; } 4479 /** 4480 * Gets the param element. 4481 * @return a daeSmartRef to the param element. 4482 */ 4483 const domParamRef getParam() const { return elemParam; } 4484 /** 4485 * Gets the _contents array. 4486 * @return Returns a reference to the _contents element array. 4487 */ 4488 daeElementRefArray &getContents() { return _contents; } 4489 /** 4490 * Gets the _contents array. 4491 * @return Returns a constant reference to the _contents element array. 4492 */ 4493 const daeElementRefArray &getContents() const { return _contents; } 4494 4495 protected: 4496 /** 4497 * Constructor 4498 */ 4499 domTexture2D(DAE& dae) : daeElement(dae), attrIndex(), elemValue(), elemParam() {} 4500 /** 4501 * Destructor 4502 */ 4503 virtual ~domTexture2D() { daeElement::deleteCMDataArray(_CMData); } 4504 /** 4505 * Overloaded assignment operator 4506 */ 4507 virtual domTexture2D &operator=( const domTexture2D &cpy ) { (void)cpy; return *this; } 4508 4509 public: // STATIC METHODS 4510 /** 4511 * Creates an instance of this class and returns a daeElementRef referencing it. 4512 * @return a daeElementRef referencing an instance of this object. 4513 */ 4514 static DLLSPEC daeElementRef create(DAE& dae); 4515 /** 4516 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4517 * If a daeMetaElement already exists it will return that instead of creating a new one. 4518 * @return A daeMetaElement describing this COLLADA element. 4519 */ 4520 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4521 }; 4522 4523 class domTexture3D; 4524 4525 typedef daeSmartRef<domTexture3D> domTexture3DRef; 4526 typedef daeTArray<domTexture3DRef> domTexture3D_Array; 4527 4528 class domTexture3D : public daeElement 4529 { 4530 public: 4531 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE3D; } 4532 static daeInt ID() { return 284; } 4533 virtual daeInt typeID() const { return ID(); } 4534 public: 4535 class domParam; 4536 4537 typedef daeSmartRef<domParam> domParamRef; 4538 typedef daeTArray<domParamRef> domParam_Array; 4539 4540 class domParam : public daeElement 4541 { 4542 public: 4543 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PARAM; } 4544 static daeInt ID() { return 285; } 4545 virtual daeInt typeID() const { return ID(); } 4546 4547 protected: // Value 4548 /** 4549 * The xsNCName value of the text data of this element. 4550 */ 4551 xsNCName _value; 4552 4553 public: //Accessors and Mutators 4554 /** 4555 * Gets the value of this element. 4556 * @return Returns a xsNCName of the value. 4557 */ 4558 xsNCName getValue() const { return _value; } 4559 /** 4560 * Sets the _value of this element. 4561 * @param val The new value for this element. 4562 */ 4563 void setValue( xsNCName val ) { *(daeStringRef*)&_value = val; } 4564 4565 protected: 4566 /** 4567 * Constructor 4568 */ 4569 domParam(DAE& dae) : daeElement(dae), _value() {} 4570 /** 4571 * Destructor 4572 */ 4573 virtual ~domParam() {} 4574 /** 4575 * Overloaded assignment operator 4576 */ 4577 virtual domParam &operator=( const domParam &cpy ) { (void)cpy; return *this; } 4578 4579 public: // STATIC METHODS 4580 /** 4581 * Creates an instance of this class and returns a daeElementRef referencing it. 4582 * @return a daeElementRef referencing an instance of this object. 4583 */ 4584 static DLLSPEC daeElementRef create(DAE& dae); 4585 /** 4586 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4587 * If a daeMetaElement already exists it will return that instead of creating a new one. 4588 * @return A daeMetaElement describing this COLLADA element. 4589 */ 4590 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4591 }; 4592 4593 4594 protected: // Attribute 4595 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 4596 4597 protected: // Elements 4598 domGl_sampler3DRef elemValue; 4599 domParamRef elemParam; 4600 /** 4601 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 4602 */ 4603 daeElementRefArray _contents; 4604 /** 4605 * Used to preserve order in elements that have a complex content model. 4606 */ 4607 daeUIntArray _contentsOrder; 4608 4609 /** 4610 * Used to store information needed for some content model objects. 4611 */ 4612 daeTArray< daeCharArray * > _CMData; 4613 4614 4615 public: //Accessors and Mutators 4616 /** 4617 * Gets the index attribute. 4618 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 4619 */ 4620 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 4621 /** 4622 * Sets the index attribute. 4623 * @param atIndex The new value for the index attribute. 4624 */ 4625 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[0] = true; } 4626 4627 /** 4628 * Gets the value element. 4629 * @return a daeSmartRef to the value element. 4630 */ 4631 const domGl_sampler3DRef getValue() const { return elemValue; } 4632 /** 4633 * Gets the param element. 4634 * @return a daeSmartRef to the param element. 4635 */ 4636 const domParamRef getParam() const { return elemParam; } 4637 /** 4638 * Gets the _contents array. 4639 * @return Returns a reference to the _contents element array. 4640 */ 4641 daeElementRefArray &getContents() { return _contents; } 4642 /** 4643 * Gets the _contents array. 4644 * @return Returns a constant reference to the _contents element array. 4645 */ 4646 const daeElementRefArray &getContents() const { return _contents; } 4647 4648 protected: 4649 /** 4650 * Constructor 4651 */ 4652 domTexture3D(DAE& dae) : daeElement(dae), attrIndex(), elemValue(), elemParam() {} 4653 /** 4654 * Destructor 4655 */ 4656 virtual ~domTexture3D() { daeElement::deleteCMDataArray(_CMData); } 4657 /** 4658 * Overloaded assignment operator 4659 */ 4660 virtual domTexture3D &operator=( const domTexture3D &cpy ) { (void)cpy; return *this; } 4661 4662 public: // STATIC METHODS 4663 /** 4664 * Creates an instance of this class and returns a daeElementRef referencing it. 4665 * @return a daeElementRef referencing an instance of this object. 4666 */ 4667 static DLLSPEC daeElementRef create(DAE& dae); 4668 /** 4669 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4670 * If a daeMetaElement already exists it will return that instead of creating a new one. 4671 * @return A daeMetaElement describing this COLLADA element. 4672 */ 4673 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4674 }; 4675 4676 class domTextureCUBE; 4677 4678 typedef daeSmartRef<domTextureCUBE> domTextureCUBERef; 4679 typedef daeTArray<domTextureCUBERef> domTextureCUBE_Array; 4680 4681 class domTextureCUBE : public daeElement 4682 { 4683 public: 4684 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURECUBE; } 4685 static daeInt ID() { return 286; } 4686 virtual daeInt typeID() const { return ID(); } 4687 public: 4688 class domParam; 4689 4690 typedef daeSmartRef<domParam> domParamRef; 4691 typedef daeTArray<domParamRef> domParam_Array; 4692 4693 class domParam : public daeElement 4694 { 4695 public: 4696 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PARAM; } 4697 static daeInt ID() { return 287; } 4698 virtual daeInt typeID() const { return ID(); } 4699 4700 protected: // Value 4701 /** 4702 * The xsNCName value of the text data of this element. 4703 */ 4704 xsNCName _value; 4705 4706 public: //Accessors and Mutators 4707 /** 4708 * Gets the value of this element. 4709 * @return Returns a xsNCName of the value. 4710 */ 4711 xsNCName getValue() const { return _value; } 4712 /** 4713 * Sets the _value of this element. 4714 * @param val The new value for this element. 4715 */ 4716 void setValue( xsNCName val ) { *(daeStringRef*)&_value = val; } 4717 4718 protected: 4719 /** 4720 * Constructor 4721 */ 4722 domParam(DAE& dae) : daeElement(dae), _value() {} 4723 /** 4724 * Destructor 4725 */ 4726 virtual ~domParam() {} 4727 /** 4728 * Overloaded assignment operator 4729 */ 4730 virtual domParam &operator=( const domParam &cpy ) { (void)cpy; return *this; } 4731 4732 public: // STATIC METHODS 4733 /** 4734 * Creates an instance of this class and returns a daeElementRef referencing it. 4735 * @return a daeElementRef referencing an instance of this object. 4736 */ 4737 static DLLSPEC daeElementRef create(DAE& dae); 4738 /** 4739 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4740 * If a daeMetaElement already exists it will return that instead of creating a new one. 4741 * @return A daeMetaElement describing this COLLADA element. 4742 */ 4743 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4744 }; 4745 4746 4747 protected: // Attribute 4748 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 4749 4750 protected: // Elements 4751 domGl_samplerCUBERef elemValue; 4752 domParamRef elemParam; 4753 /** 4754 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 4755 */ 4756 daeElementRefArray _contents; 4757 /** 4758 * Used to preserve order in elements that have a complex content model. 4759 */ 4760 daeUIntArray _contentsOrder; 4761 4762 /** 4763 * Used to store information needed for some content model objects. 4764 */ 4765 daeTArray< daeCharArray * > _CMData; 4766 4767 4768 public: //Accessors and Mutators 4769 /** 4770 * Gets the index attribute. 4771 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 4772 */ 4773 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 4774 /** 4775 * Sets the index attribute. 4776 * @param atIndex The new value for the index attribute. 4777 */ 4778 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[0] = true; } 4779 4780 /** 4781 * Gets the value element. 4782 * @return a daeSmartRef to the value element. 4783 */ 4784 const domGl_samplerCUBERef getValue() const { return elemValue; } 4785 /** 4786 * Gets the param element. 4787 * @return a daeSmartRef to the param element. 4788 */ 4789 const domParamRef getParam() const { return elemParam; } 4790 /** 4791 * Gets the _contents array. 4792 * @return Returns a reference to the _contents element array. 4793 */ 4794 daeElementRefArray &getContents() { return _contents; } 4795 /** 4796 * Gets the _contents array. 4797 * @return Returns a constant reference to the _contents element array. 4798 */ 4799 const daeElementRefArray &getContents() const { return _contents; } 4800 4801 protected: 4802 /** 4803 * Constructor 4804 */ 4805 domTextureCUBE(DAE& dae) : daeElement(dae), attrIndex(), elemValue(), elemParam() {} 4806 /** 4807 * Destructor 4808 */ 4809 virtual ~domTextureCUBE() { daeElement::deleteCMDataArray(_CMData); } 4810 /** 4811 * Overloaded assignment operator 4812 */ 4813 virtual domTextureCUBE &operator=( const domTextureCUBE &cpy ) { (void)cpy; return *this; } 4814 4815 public: // STATIC METHODS 4816 /** 4817 * Creates an instance of this class and returns a daeElementRef referencing it. 4818 * @return a daeElementRef referencing an instance of this object. 4819 */ 4820 static DLLSPEC daeElementRef create(DAE& dae); 4821 /** 4822 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4823 * If a daeMetaElement already exists it will return that instead of creating a new one. 4824 * @return A daeMetaElement describing this COLLADA element. 4825 */ 4826 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4827 }; 4828 4829 class domTextureRECT; 4830 4831 typedef daeSmartRef<domTextureRECT> domTextureRECTRef; 4832 typedef daeTArray<domTextureRECTRef> domTextureRECT_Array; 4833 4834 class domTextureRECT : public daeElement 4835 { 4836 public: 4837 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURERECT; } 4838 static daeInt ID() { return 288; } 4839 virtual daeInt typeID() const { return ID(); } 4840 public: 4841 class domParam; 4842 4843 typedef daeSmartRef<domParam> domParamRef; 4844 typedef daeTArray<domParamRef> domParam_Array; 4845 4846 class domParam : public daeElement 4847 { 4848 public: 4849 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PARAM; } 4850 static daeInt ID() { return 289; } 4851 virtual daeInt typeID() const { return ID(); } 4852 4853 protected: // Value 4854 /** 4855 * The xsNCName value of the text data of this element. 4856 */ 4857 xsNCName _value; 4858 4859 public: //Accessors and Mutators 4860 /** 4861 * Gets the value of this element. 4862 * @return Returns a xsNCName of the value. 4863 */ 4864 xsNCName getValue() const { return _value; } 4865 /** 4866 * Sets the _value of this element. 4867 * @param val The new value for this element. 4868 */ 4869 void setValue( xsNCName val ) { *(daeStringRef*)&_value = val; } 4870 4871 protected: 4872 /** 4873 * Constructor 4874 */ 4875 domParam(DAE& dae) : daeElement(dae), _value() {} 4876 /** 4877 * Destructor 4878 */ 4879 virtual ~domParam() {} 4880 /** 4881 * Overloaded assignment operator 4882 */ 4883 virtual domParam &operator=( const domParam &cpy ) { (void)cpy; return *this; } 4884 4885 public: // STATIC METHODS 4886 /** 4887 * Creates an instance of this class and returns a daeElementRef referencing it. 4888 * @return a daeElementRef referencing an instance of this object. 4889 */ 4890 static DLLSPEC daeElementRef create(DAE& dae); 4891 /** 4892 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4893 * If a daeMetaElement already exists it will return that instead of creating a new one. 4894 * @return A daeMetaElement describing this COLLADA element. 4895 */ 4896 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4897 }; 4898 4899 4900 protected: // Attribute 4901 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 4902 4903 protected: // Elements 4904 domGl_samplerRECTRef elemValue; 4905 domParamRef elemParam; 4906 /** 4907 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 4908 */ 4909 daeElementRefArray _contents; 4910 /** 4911 * Used to preserve order in elements that have a complex content model. 4912 */ 4913 daeUIntArray _contentsOrder; 4914 4915 /** 4916 * Used to store information needed for some content model objects. 4917 */ 4918 daeTArray< daeCharArray * > _CMData; 4919 4920 4921 public: //Accessors and Mutators 4922 /** 4923 * Gets the index attribute. 4924 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 4925 */ 4926 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 4927 /** 4928 * Sets the index attribute. 4929 * @param atIndex The new value for the index attribute. 4930 */ 4931 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[0] = true; } 4932 4933 /** 4934 * Gets the value element. 4935 * @return a daeSmartRef to the value element. 4936 */ 4937 const domGl_samplerRECTRef getValue() const { return elemValue; } 4938 /** 4939 * Gets the param element. 4940 * @return a daeSmartRef to the param element. 4941 */ 4942 const domParamRef getParam() const { return elemParam; } 4943 /** 4944 * Gets the _contents array. 4945 * @return Returns a reference to the _contents element array. 4946 */ 4947 daeElementRefArray &getContents() { return _contents; } 4948 /** 4949 * Gets the _contents array. 4950 * @return Returns a constant reference to the _contents element array. 4951 */ 4952 const daeElementRefArray &getContents() const { return _contents; } 4953 4954 protected: 4955 /** 4956 * Constructor 4957 */ 4958 domTextureRECT(DAE& dae) : daeElement(dae), attrIndex(), elemValue(), elemParam() {} 4959 /** 4960 * Destructor 4961 */ 4962 virtual ~domTextureRECT() { daeElement::deleteCMDataArray(_CMData); } 4963 /** 4964 * Overloaded assignment operator 4965 */ 4966 virtual domTextureRECT &operator=( const domTextureRECT &cpy ) { (void)cpy; return *this; } 4967 4968 public: // STATIC METHODS 4969 /** 4970 * Creates an instance of this class and returns a daeElementRef referencing it. 4971 * @return a daeElementRef referencing an instance of this object. 4972 */ 4973 static DLLSPEC daeElementRef create(DAE& dae); 4974 /** 4975 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 4976 * If a daeMetaElement already exists it will return that instead of creating a new one. 4977 * @return A daeMetaElement describing this COLLADA element. 4978 */ 4979 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 4980 }; 4981 4982 class domTextureDEPTH; 4983 4984 typedef daeSmartRef<domTextureDEPTH> domTextureDEPTHRef; 4985 typedef daeTArray<domTextureDEPTHRef> domTextureDEPTH_Array; 4986 4987 class domTextureDEPTH : public daeElement 4988 { 4989 public: 4990 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTUREDEPTH; } 4991 static daeInt ID() { return 290; } 4992 virtual daeInt typeID() const { return ID(); } 4993 public: 4994 class domParam; 4995 4996 typedef daeSmartRef<domParam> domParamRef; 4997 typedef daeTArray<domParamRef> domParam_Array; 4998 4999 class domParam : public daeElement 5000 { 5001 public: 5002 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PARAM; } 5003 static daeInt ID() { return 291; } 5004 virtual daeInt typeID() const { return ID(); } 5005 5006 protected: // Value 5007 /** 5008 * The xsNCName value of the text data of this element. 5009 */ 5010 xsNCName _value; 5011 5012 public: //Accessors and Mutators 5013 /** 5014 * Gets the value of this element. 5015 * @return Returns a xsNCName of the value. 5016 */ 5017 xsNCName getValue() const { return _value; } 5018 /** 5019 * Sets the _value of this element. 5020 * @param val The new value for this element. 5021 */ 5022 void setValue( xsNCName val ) { *(daeStringRef*)&_value = val; } 5023 5024 protected: 5025 /** 5026 * Constructor 5027 */ 5028 domParam(DAE& dae) : daeElement(dae), _value() {} 5029 /** 5030 * Destructor 5031 */ 5032 virtual ~domParam() {} 5033 /** 5034 * Overloaded assignment operator 5035 */ 5036 virtual domParam &operator=( const domParam &cpy ) { (void)cpy; return *this; } 5037 5038 public: // STATIC METHODS 5039 /** 5040 * Creates an instance of this class and returns a daeElementRef referencing it. 5041 * @return a daeElementRef referencing an instance of this object. 5042 */ 5043 static DLLSPEC daeElementRef create(DAE& dae); 5044 /** 5045 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5046 * If a daeMetaElement already exists it will return that instead of creating a new one. 5047 * @return A daeMetaElement describing this COLLADA element. 5048 */ 5049 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5050 }; 5051 5052 5053 protected: // Attribute 5054 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5055 5056 protected: // Elements 5057 domGl_samplerDEPTHRef elemValue; 5058 domParamRef elemParam; 5059 /** 5060 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 5061 */ 5062 daeElementRefArray _contents; 5063 /** 5064 * Used to preserve order in elements that have a complex content model. 5065 */ 5066 daeUIntArray _contentsOrder; 5067 5068 /** 5069 * Used to store information needed for some content model objects. 5070 */ 5071 daeTArray< daeCharArray * > _CMData; 5072 5073 5074 public: //Accessors and Mutators 5075 /** 5076 * Gets the index attribute. 5077 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5078 */ 5079 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5080 /** 5081 * Sets the index attribute. 5082 * @param atIndex The new value for the index attribute. 5083 */ 5084 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[0] = true; } 5085 5086 /** 5087 * Gets the value element. 5088 * @return a daeSmartRef to the value element. 5089 */ 5090 const domGl_samplerDEPTHRef getValue() const { return elemValue; } 5091 /** 5092 * Gets the param element. 5093 * @return a daeSmartRef to the param element. 5094 */ 5095 const domParamRef getParam() const { return elemParam; } 5096 /** 5097 * Gets the _contents array. 5098 * @return Returns a reference to the _contents element array. 5099 */ 5100 daeElementRefArray &getContents() { return _contents; } 5101 /** 5102 * Gets the _contents array. 5103 * @return Returns a constant reference to the _contents element array. 5104 */ 5105 const daeElementRefArray &getContents() const { return _contents; } 5106 5107 protected: 5108 /** 5109 * Constructor 5110 */ 5111 domTextureDEPTH(DAE& dae) : daeElement(dae), attrIndex(), elemValue(), elemParam() {} 5112 /** 5113 * Destructor 5114 */ 5115 virtual ~domTextureDEPTH() { daeElement::deleteCMDataArray(_CMData); } 5116 /** 5117 * Overloaded assignment operator 5118 */ 5119 virtual domTextureDEPTH &operator=( const domTextureDEPTH &cpy ) { (void)cpy; return *this; } 5120 5121 public: // STATIC METHODS 5122 /** 5123 * Creates an instance of this class and returns a daeElementRef referencing it. 5124 * @return a daeElementRef referencing an instance of this object. 5125 */ 5126 static DLLSPEC daeElementRef create(DAE& dae); 5127 /** 5128 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5129 * If a daeMetaElement already exists it will return that instead of creating a new one. 5130 * @return A daeMetaElement describing this COLLADA element. 5131 */ 5132 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5133 }; 5134 5135 class domTexture1D_enable; 5136 5137 typedef daeSmartRef<domTexture1D_enable> domTexture1D_enableRef; 5138 typedef daeTArray<domTexture1D_enableRef> domTexture1D_enable_Array; 5139 5140 class domTexture1D_enable : public daeElement 5141 { 5142 public: 5143 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE1D_ENABLE; } 5144 static daeInt ID() { return 292; } 5145 virtual daeInt typeID() const { return ID(); } 5146 protected: // Attributes 5147 domBool attrValue; 5148 xsNCName attrParam; 5149 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5150 5151 5152 public: //Accessors and Mutators 5153 /** 5154 * Gets the value attribute. 5155 * @return Returns a domBool of the value attribute. 5156 */ 5157 domBool getValue() const { return attrValue; } 5158 /** 5159 * Sets the value attribute. 5160 * @param atValue The new value for the value attribute. 5161 */ 5162 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5163 5164 /** 5165 * Gets the param attribute. 5166 * @return Returns a xsNCName of the param attribute. 5167 */ 5168 xsNCName getParam() const { return attrParam; } 5169 /** 5170 * Sets the param attribute. 5171 * @param atParam The new value for the param attribute. 5172 */ 5173 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5174 5175 /** 5176 * Gets the index attribute. 5177 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5178 */ 5179 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5180 /** 5181 * Sets the index attribute. 5182 * @param atIndex The new value for the index attribute. 5183 */ 5184 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5185 5186 protected: 5187 /** 5188 * Constructor 5189 */ 5190 domTexture1D_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5191 /** 5192 * Destructor 5193 */ 5194 virtual ~domTexture1D_enable() {} 5195 /** 5196 * Overloaded assignment operator 5197 */ 5198 virtual domTexture1D_enable &operator=( const domTexture1D_enable &cpy ) { (void)cpy; return *this; } 5199 5200 public: // STATIC METHODS 5201 /** 5202 * Creates an instance of this class and returns a daeElementRef referencing it. 5203 * @return a daeElementRef referencing an instance of this object. 5204 */ 5205 static DLLSPEC daeElementRef create(DAE& dae); 5206 /** 5207 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5208 * If a daeMetaElement already exists it will return that instead of creating a new one. 5209 * @return A daeMetaElement describing this COLLADA element. 5210 */ 5211 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5212 }; 5213 5214 class domTexture2D_enable; 5215 5216 typedef daeSmartRef<domTexture2D_enable> domTexture2D_enableRef; 5217 typedef daeTArray<domTexture2D_enableRef> domTexture2D_enable_Array; 5218 5219 class domTexture2D_enable : public daeElement 5220 { 5221 public: 5222 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE2D_ENABLE; } 5223 static daeInt ID() { return 293; } 5224 virtual daeInt typeID() const { return ID(); } 5225 protected: // Attributes 5226 domBool attrValue; 5227 xsNCName attrParam; 5228 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5229 5230 5231 public: //Accessors and Mutators 5232 /** 5233 * Gets the value attribute. 5234 * @return Returns a domBool of the value attribute. 5235 */ 5236 domBool getValue() const { return attrValue; } 5237 /** 5238 * Sets the value attribute. 5239 * @param atValue The new value for the value attribute. 5240 */ 5241 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5242 5243 /** 5244 * Gets the param attribute. 5245 * @return Returns a xsNCName of the param attribute. 5246 */ 5247 xsNCName getParam() const { return attrParam; } 5248 /** 5249 * Sets the param attribute. 5250 * @param atParam The new value for the param attribute. 5251 */ 5252 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5253 5254 /** 5255 * Gets the index attribute. 5256 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5257 */ 5258 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5259 /** 5260 * Sets the index attribute. 5261 * @param atIndex The new value for the index attribute. 5262 */ 5263 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5264 5265 protected: 5266 /** 5267 * Constructor 5268 */ 5269 domTexture2D_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5270 /** 5271 * Destructor 5272 */ 5273 virtual ~domTexture2D_enable() {} 5274 /** 5275 * Overloaded assignment operator 5276 */ 5277 virtual domTexture2D_enable &operator=( const domTexture2D_enable &cpy ) { (void)cpy; return *this; } 5278 5279 public: // STATIC METHODS 5280 /** 5281 * Creates an instance of this class and returns a daeElementRef referencing it. 5282 * @return a daeElementRef referencing an instance of this object. 5283 */ 5284 static DLLSPEC daeElementRef create(DAE& dae); 5285 /** 5286 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5287 * If a daeMetaElement already exists it will return that instead of creating a new one. 5288 * @return A daeMetaElement describing this COLLADA element. 5289 */ 5290 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5291 }; 5292 5293 class domTexture3D_enable; 5294 5295 typedef daeSmartRef<domTexture3D_enable> domTexture3D_enableRef; 5296 typedef daeTArray<domTexture3D_enableRef> domTexture3D_enable_Array; 5297 5298 class domTexture3D_enable : public daeElement 5299 { 5300 public: 5301 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE3D_ENABLE; } 5302 static daeInt ID() { return 294; } 5303 virtual daeInt typeID() const { return ID(); } 5304 protected: // Attributes 5305 domBool attrValue; 5306 xsNCName attrParam; 5307 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5308 5309 5310 public: //Accessors and Mutators 5311 /** 5312 * Gets the value attribute. 5313 * @return Returns a domBool of the value attribute. 5314 */ 5315 domBool getValue() const { return attrValue; } 5316 /** 5317 * Sets the value attribute. 5318 * @param atValue The new value for the value attribute. 5319 */ 5320 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5321 5322 /** 5323 * Gets the param attribute. 5324 * @return Returns a xsNCName of the param attribute. 5325 */ 5326 xsNCName getParam() const { return attrParam; } 5327 /** 5328 * Sets the param attribute. 5329 * @param atParam The new value for the param attribute. 5330 */ 5331 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5332 5333 /** 5334 * Gets the index attribute. 5335 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5336 */ 5337 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5338 /** 5339 * Sets the index attribute. 5340 * @param atIndex The new value for the index attribute. 5341 */ 5342 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5343 5344 protected: 5345 /** 5346 * Constructor 5347 */ 5348 domTexture3D_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5349 /** 5350 * Destructor 5351 */ 5352 virtual ~domTexture3D_enable() {} 5353 /** 5354 * Overloaded assignment operator 5355 */ 5356 virtual domTexture3D_enable &operator=( const domTexture3D_enable &cpy ) { (void)cpy; return *this; } 5357 5358 public: // STATIC METHODS 5359 /** 5360 * Creates an instance of this class and returns a daeElementRef referencing it. 5361 * @return a daeElementRef referencing an instance of this object. 5362 */ 5363 static DLLSPEC daeElementRef create(DAE& dae); 5364 /** 5365 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5366 * If a daeMetaElement already exists it will return that instead of creating a new one. 5367 * @return A daeMetaElement describing this COLLADA element. 5368 */ 5369 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5370 }; 5371 5372 class domTextureCUBE_enable; 5373 5374 typedef daeSmartRef<domTextureCUBE_enable> domTextureCUBE_enableRef; 5375 typedef daeTArray<domTextureCUBE_enableRef> domTextureCUBE_enable_Array; 5376 5377 class domTextureCUBE_enable : public daeElement 5378 { 5379 public: 5380 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURECUBE_ENABLE; } 5381 static daeInt ID() { return 295; } 5382 virtual daeInt typeID() const { return ID(); } 5383 protected: // Attributes 5384 domBool attrValue; 5385 xsNCName attrParam; 5386 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5387 5388 5389 public: //Accessors and Mutators 5390 /** 5391 * Gets the value attribute. 5392 * @return Returns a domBool of the value attribute. 5393 */ 5394 domBool getValue() const { return attrValue; } 5395 /** 5396 * Sets the value attribute. 5397 * @param atValue The new value for the value attribute. 5398 */ 5399 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5400 5401 /** 5402 * Gets the param attribute. 5403 * @return Returns a xsNCName of the param attribute. 5404 */ 5405 xsNCName getParam() const { return attrParam; } 5406 /** 5407 * Sets the param attribute. 5408 * @param atParam The new value for the param attribute. 5409 */ 5410 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5411 5412 /** 5413 * Gets the index attribute. 5414 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5415 */ 5416 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5417 /** 5418 * Sets the index attribute. 5419 * @param atIndex The new value for the index attribute. 5420 */ 5421 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5422 5423 protected: 5424 /** 5425 * Constructor 5426 */ 5427 domTextureCUBE_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5428 /** 5429 * Destructor 5430 */ 5431 virtual ~domTextureCUBE_enable() {} 5432 /** 5433 * Overloaded assignment operator 5434 */ 5435 virtual domTextureCUBE_enable &operator=( const domTextureCUBE_enable &cpy ) { (void)cpy; return *this; } 5436 5437 public: // STATIC METHODS 5438 /** 5439 * Creates an instance of this class and returns a daeElementRef referencing it. 5440 * @return a daeElementRef referencing an instance of this object. 5441 */ 5442 static DLLSPEC daeElementRef create(DAE& dae); 5443 /** 5444 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5445 * If a daeMetaElement already exists it will return that instead of creating a new one. 5446 * @return A daeMetaElement describing this COLLADA element. 5447 */ 5448 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5449 }; 5450 5451 class domTextureRECT_enable; 5452 5453 typedef daeSmartRef<domTextureRECT_enable> domTextureRECT_enableRef; 5454 typedef daeTArray<domTextureRECT_enableRef> domTextureRECT_enable_Array; 5455 5456 class domTextureRECT_enable : public daeElement 5457 { 5458 public: 5459 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURERECT_ENABLE; } 5460 static daeInt ID() { return 296; } 5461 virtual daeInt typeID() const { return ID(); } 5462 protected: // Attributes 5463 domBool attrValue; 5464 xsNCName attrParam; 5465 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5466 5467 5468 public: //Accessors and Mutators 5469 /** 5470 * Gets the value attribute. 5471 * @return Returns a domBool of the value attribute. 5472 */ 5473 domBool getValue() const { return attrValue; } 5474 /** 5475 * Sets the value attribute. 5476 * @param atValue The new value for the value attribute. 5477 */ 5478 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5479 5480 /** 5481 * Gets the param attribute. 5482 * @return Returns a xsNCName of the param attribute. 5483 */ 5484 xsNCName getParam() const { return attrParam; } 5485 /** 5486 * Sets the param attribute. 5487 * @param atParam The new value for the param attribute. 5488 */ 5489 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5490 5491 /** 5492 * Gets the index attribute. 5493 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5494 */ 5495 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5496 /** 5497 * Sets the index attribute. 5498 * @param atIndex The new value for the index attribute. 5499 */ 5500 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5501 5502 protected: 5503 /** 5504 * Constructor 5505 */ 5506 domTextureRECT_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5507 /** 5508 * Destructor 5509 */ 5510 virtual ~domTextureRECT_enable() {} 5511 /** 5512 * Overloaded assignment operator 5513 */ 5514 virtual domTextureRECT_enable &operator=( const domTextureRECT_enable &cpy ) { (void)cpy; return *this; } 5515 5516 public: // STATIC METHODS 5517 /** 5518 * Creates an instance of this class and returns a daeElementRef referencing it. 5519 * @return a daeElementRef referencing an instance of this object. 5520 */ 5521 static DLLSPEC daeElementRef create(DAE& dae); 5522 /** 5523 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5524 * If a daeMetaElement already exists it will return that instead of creating a new one. 5525 * @return A daeMetaElement describing this COLLADA element. 5526 */ 5527 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5528 }; 5529 5530 class domTextureDEPTH_enable; 5531 5532 typedef daeSmartRef<domTextureDEPTH_enable> domTextureDEPTH_enableRef; 5533 typedef daeTArray<domTextureDEPTH_enableRef> domTextureDEPTH_enable_Array; 5534 5535 class domTextureDEPTH_enable : public daeElement 5536 { 5537 public: 5538 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTUREDEPTH_ENABLE; } 5539 static daeInt ID() { return 297; } 5540 virtual daeInt typeID() const { return ID(); } 5541 protected: // Attributes 5542 domBool attrValue; 5543 xsNCName attrParam; 5544 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5545 5546 5547 public: //Accessors and Mutators 5548 /** 5549 * Gets the value attribute. 5550 * @return Returns a domBool of the value attribute. 5551 */ 5552 domBool getValue() const { return attrValue; } 5553 /** 5554 * Sets the value attribute. 5555 * @param atValue The new value for the value attribute. 5556 */ 5557 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5558 5559 /** 5560 * Gets the param attribute. 5561 * @return Returns a xsNCName of the param attribute. 5562 */ 5563 xsNCName getParam() const { return attrParam; } 5564 /** 5565 * Sets the param attribute. 5566 * @param atParam The new value for the param attribute. 5567 */ 5568 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5569 5570 /** 5571 * Gets the index attribute. 5572 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5573 */ 5574 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5575 /** 5576 * Sets the index attribute. 5577 * @param atIndex The new value for the index attribute. 5578 */ 5579 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5580 5581 protected: 5582 /** 5583 * Constructor 5584 */ 5585 domTextureDEPTH_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5586 /** 5587 * Destructor 5588 */ 5589 virtual ~domTextureDEPTH_enable() {} 5590 /** 5591 * Overloaded assignment operator 5592 */ 5593 virtual domTextureDEPTH_enable &operator=( const domTextureDEPTH_enable &cpy ) { (void)cpy; return *this; } 5594 5595 public: // STATIC METHODS 5596 /** 5597 * Creates an instance of this class and returns a daeElementRef referencing it. 5598 * @return a daeElementRef referencing an instance of this object. 5599 */ 5600 static DLLSPEC daeElementRef create(DAE& dae); 5601 /** 5602 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5603 * If a daeMetaElement already exists it will return that instead of creating a new one. 5604 * @return A daeMetaElement describing this COLLADA element. 5605 */ 5606 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5607 }; 5608 5609 class domTexture_env_color; 5610 5611 typedef daeSmartRef<domTexture_env_color> domTexture_env_colorRef; 5612 typedef daeTArray<domTexture_env_colorRef> domTexture_env_color_Array; 5613 5614 class domTexture_env_color : public daeElement 5615 { 5616 public: 5617 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE_ENV_COLOR; } 5618 static daeInt ID() { return 298; } 5619 virtual daeInt typeID() const { return ID(); } 5620 protected: // Attributes 5621 domFloat4 attrValue; 5622 xsNCName attrParam; 5623 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5624 5625 5626 public: //Accessors and Mutators 5627 /** 5628 * Gets the value array attribute. 5629 * @return Returns a domFloat4 reference of the value array attribute. 5630 */ 5631 domFloat4 &getValue() { return attrValue; } 5632 /** 5633 * Gets the value array attribute. 5634 * @return Returns a constant domFloat4 reference of the value array attribute. 5635 */ 5636 const domFloat4 &getValue() const { return attrValue; } 5637 /** 5638 * Sets the value array attribute. 5639 * @param atValue The new value for the value array attribute. 5640 */ 5641 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5642 5643 /** 5644 * Gets the param attribute. 5645 * @return Returns a xsNCName of the param attribute. 5646 */ 5647 xsNCName getParam() const { return attrParam; } 5648 /** 5649 * Sets the param attribute. 5650 * @param atParam The new value for the param attribute. 5651 */ 5652 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5653 5654 /** 5655 * Gets the index attribute. 5656 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5657 */ 5658 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5659 /** 5660 * Sets the index attribute. 5661 * @param atIndex The new value for the index attribute. 5662 */ 5663 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5664 5665 protected: 5666 /** 5667 * Constructor 5668 */ 5669 domTexture_env_color(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5670 /** 5671 * Destructor 5672 */ 5673 virtual ~domTexture_env_color() {} 5674 /** 5675 * Overloaded assignment operator 5676 */ 5677 virtual domTexture_env_color &operator=( const domTexture_env_color &cpy ) { (void)cpy; return *this; } 5678 5679 public: // STATIC METHODS 5680 /** 5681 * Creates an instance of this class and returns a daeElementRef referencing it. 5682 * @return a daeElementRef referencing an instance of this object. 5683 */ 5684 static DLLSPEC daeElementRef create(DAE& dae); 5685 /** 5686 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5687 * If a daeMetaElement already exists it will return that instead of creating a new one. 5688 * @return A daeMetaElement describing this COLLADA element. 5689 */ 5690 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5691 }; 5692 5693 class domTexture_env_mode; 5694 5695 typedef daeSmartRef<domTexture_env_mode> domTexture_env_modeRef; 5696 typedef daeTArray<domTexture_env_modeRef> domTexture_env_mode_Array; 5697 5698 class domTexture_env_mode : public daeElement 5699 { 5700 public: 5701 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::TEXTURE_ENV_MODE; } 5702 static daeInt ID() { return 299; } 5703 virtual daeInt typeID() const { return ID(); } 5704 protected: // Attributes 5705 domString attrValue; 5706 xsNCName attrParam; 5707 domGL_MAX_TEXTURE_IMAGE_UNITS_index attrIndex; 5708 5709 5710 public: //Accessors and Mutators 5711 /** 5712 * Gets the value attribute. 5713 * @return Returns a domString of the value attribute. 5714 */ 5715 domString getValue() const { return attrValue; } 5716 /** 5717 * Sets the value attribute. 5718 * @param atValue The new value for the value attribute. 5719 */ 5720 void setValue( domString atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5721 5722 /** 5723 * Gets the param attribute. 5724 * @return Returns a xsNCName of the param attribute. 5725 */ 5726 xsNCName getParam() const { return attrParam; } 5727 /** 5728 * Sets the param attribute. 5729 * @param atParam The new value for the param attribute. 5730 */ 5731 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5732 5733 /** 5734 * Gets the index attribute. 5735 * @return Returns a domGL_MAX_TEXTURE_IMAGE_UNITS_index of the index attribute. 5736 */ 5737 domGL_MAX_TEXTURE_IMAGE_UNITS_index getIndex() const { return attrIndex; } 5738 /** 5739 * Sets the index attribute. 5740 * @param atIndex The new value for the index attribute. 5741 */ 5742 void setIndex( domGL_MAX_TEXTURE_IMAGE_UNITS_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5743 5744 protected: 5745 /** 5746 * Constructor 5747 */ 5748 domTexture_env_mode(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5749 /** 5750 * Destructor 5751 */ 5752 virtual ~domTexture_env_mode() {} 5753 /** 5754 * Overloaded assignment operator 5755 */ 5756 virtual domTexture_env_mode &operator=( const domTexture_env_mode &cpy ) { (void)cpy; return *this; } 5757 5758 public: // STATIC METHODS 5759 /** 5760 * Creates an instance of this class and returns a daeElementRef referencing it. 5761 * @return a daeElementRef referencing an instance of this object. 5762 */ 5763 static DLLSPEC daeElementRef create(DAE& dae); 5764 /** 5765 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5766 * If a daeMetaElement already exists it will return that instead of creating a new one. 5767 * @return A daeMetaElement describing this COLLADA element. 5768 */ 5769 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5770 }; 5771 5772 class domClip_plane; 5773 5774 typedef daeSmartRef<domClip_plane> domClip_planeRef; 5775 typedef daeTArray<domClip_planeRef> domClip_plane_Array; 5776 5777 class domClip_plane : public daeElement 5778 { 5779 public: 5780 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CLIP_PLANE; } 5781 static daeInt ID() { return 300; } 5782 virtual daeInt typeID() const { return ID(); } 5783 protected: // Attributes 5784 domFloat4 attrValue; 5785 xsNCName attrParam; 5786 domGL_MAX_CLIP_PLANES_index attrIndex; 5787 5788 5789 public: //Accessors and Mutators 5790 /** 5791 * Gets the value array attribute. 5792 * @return Returns a domFloat4 reference of the value array attribute. 5793 */ 5794 domFloat4 &getValue() { return attrValue; } 5795 /** 5796 * Gets the value array attribute. 5797 * @return Returns a constant domFloat4 reference of the value array attribute. 5798 */ 5799 const domFloat4 &getValue() const { return attrValue; } 5800 /** 5801 * Sets the value array attribute. 5802 * @param atValue The new value for the value array attribute. 5803 */ 5804 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5805 5806 /** 5807 * Gets the param attribute. 5808 * @return Returns a xsNCName of the param attribute. 5809 */ 5810 xsNCName getParam() const { return attrParam; } 5811 /** 5812 * Sets the param attribute. 5813 * @param atParam The new value for the param attribute. 5814 */ 5815 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5816 5817 /** 5818 * Gets the index attribute. 5819 * @return Returns a domGL_MAX_CLIP_PLANES_index of the index attribute. 5820 */ 5821 domGL_MAX_CLIP_PLANES_index getIndex() const { return attrIndex; } 5822 /** 5823 * Sets the index attribute. 5824 * @param atIndex The new value for the index attribute. 5825 */ 5826 void setIndex( domGL_MAX_CLIP_PLANES_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5827 5828 protected: 5829 /** 5830 * Constructor 5831 */ 5832 domClip_plane(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5833 /** 5834 * Destructor 5835 */ 5836 virtual ~domClip_plane() {} 5837 /** 5838 * Overloaded assignment operator 5839 */ 5840 virtual domClip_plane &operator=( const domClip_plane &cpy ) { (void)cpy; return *this; } 5841 5842 public: // STATIC METHODS 5843 /** 5844 * Creates an instance of this class and returns a daeElementRef referencing it. 5845 * @return a daeElementRef referencing an instance of this object. 5846 */ 5847 static DLLSPEC daeElementRef create(DAE& dae); 5848 /** 5849 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5850 * If a daeMetaElement already exists it will return that instead of creating a new one. 5851 * @return A daeMetaElement describing this COLLADA element. 5852 */ 5853 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5854 }; 5855 5856 class domClip_plane_enable; 5857 5858 typedef daeSmartRef<domClip_plane_enable> domClip_plane_enableRef; 5859 typedef daeTArray<domClip_plane_enableRef> domClip_plane_enable_Array; 5860 5861 class domClip_plane_enable : public daeElement 5862 { 5863 public: 5864 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CLIP_PLANE_ENABLE; } 5865 static daeInt ID() { return 301; } 5866 virtual daeInt typeID() const { return ID(); } 5867 protected: // Attributes 5868 domBool attrValue; 5869 xsNCName attrParam; 5870 domGL_MAX_CLIP_PLANES_index attrIndex; 5871 5872 5873 public: //Accessors and Mutators 5874 /** 5875 * Gets the value attribute. 5876 * @return Returns a domBool of the value attribute. 5877 */ 5878 domBool getValue() const { return attrValue; } 5879 /** 5880 * Sets the value attribute. 5881 * @param atValue The new value for the value attribute. 5882 */ 5883 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5884 5885 /** 5886 * Gets the param attribute. 5887 * @return Returns a xsNCName of the param attribute. 5888 */ 5889 xsNCName getParam() const { return attrParam; } 5890 /** 5891 * Sets the param attribute. 5892 * @param atParam The new value for the param attribute. 5893 */ 5894 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5895 5896 /** 5897 * Gets the index attribute. 5898 * @return Returns a domGL_MAX_CLIP_PLANES_index of the index attribute. 5899 */ 5900 domGL_MAX_CLIP_PLANES_index getIndex() const { return attrIndex; } 5901 /** 5902 * Sets the index attribute. 5903 * @param atIndex The new value for the index attribute. 5904 */ 5905 void setIndex( domGL_MAX_CLIP_PLANES_index atIndex ) { attrIndex = atIndex; _validAttributeArray[2] = true; } 5906 5907 protected: 5908 /** 5909 * Constructor 5910 */ 5911 domClip_plane_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam(), attrIndex() {} 5912 /** 5913 * Destructor 5914 */ 5915 virtual ~domClip_plane_enable() {} 5916 /** 5917 * Overloaded assignment operator 5918 */ 5919 virtual domClip_plane_enable &operator=( const domClip_plane_enable &cpy ) { (void)cpy; return *this; } 5920 5921 public: // STATIC METHODS 5922 /** 5923 * Creates an instance of this class and returns a daeElementRef referencing it. 5924 * @return a daeElementRef referencing an instance of this object. 5925 */ 5926 static DLLSPEC daeElementRef create(DAE& dae); 5927 /** 5928 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 5929 * If a daeMetaElement already exists it will return that instead of creating a new one. 5930 * @return A daeMetaElement describing this COLLADA element. 5931 */ 5932 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 5933 }; 5934 5935 class domBlend_color; 5936 5937 typedef daeSmartRef<domBlend_color> domBlend_colorRef; 5938 typedef daeTArray<domBlend_colorRef> domBlend_color_Array; 5939 5940 class domBlend_color : public daeElement 5941 { 5942 public: 5943 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BLEND_COLOR; } 5944 static daeInt ID() { return 302; } 5945 virtual daeInt typeID() const { return ID(); } 5946 protected: // Attributes 5947 domFloat4 attrValue; 5948 xsNCName attrParam; 5949 5950 5951 public: //Accessors and Mutators 5952 /** 5953 * Gets the value array attribute. 5954 * @return Returns a domFloat4 reference of the value array attribute. 5955 */ 5956 domFloat4 &getValue() { return attrValue; } 5957 /** 5958 * Gets the value array attribute. 5959 * @return Returns a constant domFloat4 reference of the value array attribute. 5960 */ 5961 const domFloat4 &getValue() const { return attrValue; } 5962 /** 5963 * Sets the value array attribute. 5964 * @param atValue The new value for the value array attribute. 5965 */ 5966 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 5967 5968 /** 5969 * Gets the param attribute. 5970 * @return Returns a xsNCName of the param attribute. 5971 */ 5972 xsNCName getParam() const { return attrParam; } 5973 /** 5974 * Sets the param attribute. 5975 * @param atParam The new value for the param attribute. 5976 */ 5977 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 5978 5979 protected: 5980 /** 5981 * Constructor 5982 */ 5983 domBlend_color(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 5984 /** 5985 * Destructor 5986 */ 5987 virtual ~domBlend_color() {} 5988 /** 5989 * Overloaded assignment operator 5990 */ 5991 virtual domBlend_color &operator=( const domBlend_color &cpy ) { (void)cpy; return *this; } 5992 5993 public: // STATIC METHODS 5994 /** 5995 * Creates an instance of this class and returns a daeElementRef referencing it. 5996 * @return a daeElementRef referencing an instance of this object. 5997 */ 5998 static DLLSPEC daeElementRef create(DAE& dae); 5999 /** 6000 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6001 * If a daeMetaElement already exists it will return that instead of creating a new one. 6002 * @return A daeMetaElement describing this COLLADA element. 6003 */ 6004 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6005 }; 6006 6007 class domClear_color; 6008 6009 typedef daeSmartRef<domClear_color> domClear_colorRef; 6010 typedef daeTArray<domClear_colorRef> domClear_color_Array; 6011 6012 class domClear_color : public daeElement 6013 { 6014 public: 6015 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CLEAR_COLOR; } 6016 static daeInt ID() { return 303; } 6017 virtual daeInt typeID() const { return ID(); } 6018 protected: // Attributes 6019 domFloat4 attrValue; 6020 xsNCName attrParam; 6021 6022 6023 public: //Accessors and Mutators 6024 /** 6025 * Gets the value array attribute. 6026 * @return Returns a domFloat4 reference of the value array attribute. 6027 */ 6028 domFloat4 &getValue() { return attrValue; } 6029 /** 6030 * Gets the value array attribute. 6031 * @return Returns a constant domFloat4 reference of the value array attribute. 6032 */ 6033 const domFloat4 &getValue() const { return attrValue; } 6034 /** 6035 * Sets the value array attribute. 6036 * @param atValue The new value for the value array attribute. 6037 */ 6038 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6039 6040 /** 6041 * Gets the param attribute. 6042 * @return Returns a xsNCName of the param attribute. 6043 */ 6044 xsNCName getParam() const { return attrParam; } 6045 /** 6046 * Sets the param attribute. 6047 * @param atParam The new value for the param attribute. 6048 */ 6049 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6050 6051 protected: 6052 /** 6053 * Constructor 6054 */ 6055 domClear_color(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6056 /** 6057 * Destructor 6058 */ 6059 virtual ~domClear_color() {} 6060 /** 6061 * Overloaded assignment operator 6062 */ 6063 virtual domClear_color &operator=( const domClear_color &cpy ) { (void)cpy; return *this; } 6064 6065 public: // STATIC METHODS 6066 /** 6067 * Creates an instance of this class and returns a daeElementRef referencing it. 6068 * @return a daeElementRef referencing an instance of this object. 6069 */ 6070 static DLLSPEC daeElementRef create(DAE& dae); 6071 /** 6072 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6073 * If a daeMetaElement already exists it will return that instead of creating a new one. 6074 * @return A daeMetaElement describing this COLLADA element. 6075 */ 6076 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6077 }; 6078 6079 class domClear_stencil; 6080 6081 typedef daeSmartRef<domClear_stencil> domClear_stencilRef; 6082 typedef daeTArray<domClear_stencilRef> domClear_stencil_Array; 6083 6084 class domClear_stencil : public daeElement 6085 { 6086 public: 6087 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CLEAR_STENCIL; } 6088 static daeInt ID() { return 304; } 6089 virtual daeInt typeID() const { return ID(); } 6090 protected: // Attributes 6091 domInt attrValue; 6092 xsNCName attrParam; 6093 6094 6095 public: //Accessors and Mutators 6096 /** 6097 * Gets the value attribute. 6098 * @return Returns a domInt of the value attribute. 6099 */ 6100 domInt getValue() const { return attrValue; } 6101 /** 6102 * Sets the value attribute. 6103 * @param atValue The new value for the value attribute. 6104 */ 6105 void setValue( domInt atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6106 6107 /** 6108 * Gets the param attribute. 6109 * @return Returns a xsNCName of the param attribute. 6110 */ 6111 xsNCName getParam() const { return attrParam; } 6112 /** 6113 * Sets the param attribute. 6114 * @param atParam The new value for the param attribute. 6115 */ 6116 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6117 6118 protected: 6119 /** 6120 * Constructor 6121 */ 6122 domClear_stencil(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6123 /** 6124 * Destructor 6125 */ 6126 virtual ~domClear_stencil() {} 6127 /** 6128 * Overloaded assignment operator 6129 */ 6130 virtual domClear_stencil &operator=( const domClear_stencil &cpy ) { (void)cpy; return *this; } 6131 6132 public: // STATIC METHODS 6133 /** 6134 * Creates an instance of this class and returns a daeElementRef referencing it. 6135 * @return a daeElementRef referencing an instance of this object. 6136 */ 6137 static DLLSPEC daeElementRef create(DAE& dae); 6138 /** 6139 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6140 * If a daeMetaElement already exists it will return that instead of creating a new one. 6141 * @return A daeMetaElement describing this COLLADA element. 6142 */ 6143 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6144 }; 6145 6146 class domClear_depth; 6147 6148 typedef daeSmartRef<domClear_depth> domClear_depthRef; 6149 typedef daeTArray<domClear_depthRef> domClear_depth_Array; 6150 6151 class domClear_depth : public daeElement 6152 { 6153 public: 6154 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CLEAR_DEPTH; } 6155 static daeInt ID() { return 305; } 6156 virtual daeInt typeID() const { return ID(); } 6157 protected: // Attributes 6158 domFloat attrValue; 6159 xsNCName attrParam; 6160 6161 6162 public: //Accessors and Mutators 6163 /** 6164 * Gets the value attribute. 6165 * @return Returns a domFloat of the value attribute. 6166 */ 6167 domFloat getValue() const { return attrValue; } 6168 /** 6169 * Sets the value attribute. 6170 * @param atValue The new value for the value attribute. 6171 */ 6172 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6173 6174 /** 6175 * Gets the param attribute. 6176 * @return Returns a xsNCName of the param attribute. 6177 */ 6178 xsNCName getParam() const { return attrParam; } 6179 /** 6180 * Sets the param attribute. 6181 * @param atParam The new value for the param attribute. 6182 */ 6183 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6184 6185 protected: 6186 /** 6187 * Constructor 6188 */ 6189 domClear_depth(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6190 /** 6191 * Destructor 6192 */ 6193 virtual ~domClear_depth() {} 6194 /** 6195 * Overloaded assignment operator 6196 */ 6197 virtual domClear_depth &operator=( const domClear_depth &cpy ) { (void)cpy; return *this; } 6198 6199 public: // STATIC METHODS 6200 /** 6201 * Creates an instance of this class and returns a daeElementRef referencing it. 6202 * @return a daeElementRef referencing an instance of this object. 6203 */ 6204 static DLLSPEC daeElementRef create(DAE& dae); 6205 /** 6206 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6207 * If a daeMetaElement already exists it will return that instead of creating a new one. 6208 * @return A daeMetaElement describing this COLLADA element. 6209 */ 6210 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6211 }; 6212 6213 class domColor_mask; 6214 6215 typedef daeSmartRef<domColor_mask> domColor_maskRef; 6216 typedef daeTArray<domColor_maskRef> domColor_mask_Array; 6217 6218 class domColor_mask : public daeElement 6219 { 6220 public: 6221 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::COLOR_MASK; } 6222 static daeInt ID() { return 306; } 6223 virtual daeInt typeID() const { return ID(); } 6224 protected: // Attributes 6225 domBool4 attrValue; 6226 xsNCName attrParam; 6227 6228 6229 public: //Accessors and Mutators 6230 /** 6231 * Gets the value array attribute. 6232 * @return Returns a domBool4 reference of the value array attribute. 6233 */ 6234 domBool4 &getValue() { return attrValue; } 6235 /** 6236 * Gets the value array attribute. 6237 * @return Returns a constant domBool4 reference of the value array attribute. 6238 */ 6239 const domBool4 &getValue() const { return attrValue; } 6240 /** 6241 * Sets the value array attribute. 6242 * @param atValue The new value for the value array attribute. 6243 */ 6244 void setValue( const domBool4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6245 6246 /** 6247 * Gets the param attribute. 6248 * @return Returns a xsNCName of the param attribute. 6249 */ 6250 xsNCName getParam() const { return attrParam; } 6251 /** 6252 * Sets the param attribute. 6253 * @param atParam The new value for the param attribute. 6254 */ 6255 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6256 6257 protected: 6258 /** 6259 * Constructor 6260 */ 6261 domColor_mask(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6262 /** 6263 * Destructor 6264 */ 6265 virtual ~domColor_mask() {} 6266 /** 6267 * Overloaded assignment operator 6268 */ 6269 virtual domColor_mask &operator=( const domColor_mask &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 domDepth_bounds; 6286 6287 typedef daeSmartRef<domDepth_bounds> domDepth_boundsRef; 6288 typedef daeTArray<domDepth_boundsRef> domDepth_bounds_Array; 6289 6290 class domDepth_bounds : public daeElement 6291 { 6292 public: 6293 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_BOUNDS; } 6294 static daeInt ID() { return 307; } 6295 virtual daeInt typeID() const { return ID(); } 6296 protected: // Attributes 6297 domFloat2 attrValue; 6298 xsNCName attrParam; 6299 6300 6301 public: //Accessors and Mutators 6302 /** 6303 * Gets the value array attribute. 6304 * @return Returns a domFloat2 reference of the value array attribute. 6305 */ 6306 domFloat2 &getValue() { return attrValue; } 6307 /** 6308 * Gets the value array attribute. 6309 * @return Returns a constant domFloat2 reference of the value array attribute. 6310 */ 6311 const domFloat2 &getValue() const { return attrValue; } 6312 /** 6313 * Sets the value array attribute. 6314 * @param atValue The new value for the value array attribute. 6315 */ 6316 void setValue( const domFloat2 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6317 6318 /** 6319 * Gets the param attribute. 6320 * @return Returns a xsNCName of the param attribute. 6321 */ 6322 xsNCName getParam() const { return attrParam; } 6323 /** 6324 * Sets the param attribute. 6325 * @param atParam The new value for the param attribute. 6326 */ 6327 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6328 6329 protected: 6330 /** 6331 * Constructor 6332 */ 6333 domDepth_bounds(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6334 /** 6335 * Destructor 6336 */ 6337 virtual ~domDepth_bounds() {} 6338 /** 6339 * Overloaded assignment operator 6340 */ 6341 virtual domDepth_bounds &operator=( const domDepth_bounds &cpy ) { (void)cpy; return *this; } 6342 6343 public: // STATIC METHODS 6344 /** 6345 * Creates an instance of this class and returns a daeElementRef referencing it. 6346 * @return a daeElementRef referencing an instance of this object. 6347 */ 6348 static DLLSPEC daeElementRef create(DAE& dae); 6349 /** 6350 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6351 * If a daeMetaElement already exists it will return that instead of creating a new one. 6352 * @return A daeMetaElement describing this COLLADA element. 6353 */ 6354 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6355 }; 6356 6357 class domDepth_mask; 6358 6359 typedef daeSmartRef<domDepth_mask> domDepth_maskRef; 6360 typedef daeTArray<domDepth_maskRef> domDepth_mask_Array; 6361 6362 class domDepth_mask : public daeElement 6363 { 6364 public: 6365 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_MASK; } 6366 static daeInt ID() { return 308; } 6367 virtual daeInt typeID() const { return ID(); } 6368 protected: // Attributes 6369 domBool attrValue; 6370 xsNCName attrParam; 6371 6372 6373 public: //Accessors and Mutators 6374 /** 6375 * Gets the value attribute. 6376 * @return Returns a domBool of the value attribute. 6377 */ 6378 domBool getValue() const { return attrValue; } 6379 /** 6380 * Sets the value attribute. 6381 * @param atValue The new value for the value attribute. 6382 */ 6383 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6384 6385 /** 6386 * Gets the param attribute. 6387 * @return Returns a xsNCName of the param attribute. 6388 */ 6389 xsNCName getParam() const { return attrParam; } 6390 /** 6391 * Sets the param attribute. 6392 * @param atParam The new value for the param attribute. 6393 */ 6394 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6395 6396 protected: 6397 /** 6398 * Constructor 6399 */ 6400 domDepth_mask(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6401 /** 6402 * Destructor 6403 */ 6404 virtual ~domDepth_mask() {} 6405 /** 6406 * Overloaded assignment operator 6407 */ 6408 virtual domDepth_mask &operator=( const domDepth_mask &cpy ) { (void)cpy; return *this; } 6409 6410 public: // STATIC METHODS 6411 /** 6412 * Creates an instance of this class and returns a daeElementRef referencing it. 6413 * @return a daeElementRef referencing an instance of this object. 6414 */ 6415 static DLLSPEC daeElementRef create(DAE& dae); 6416 /** 6417 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6418 * If a daeMetaElement already exists it will return that instead of creating a new one. 6419 * @return A daeMetaElement describing this COLLADA element. 6420 */ 6421 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6422 }; 6423 6424 class domDepth_range; 6425 6426 typedef daeSmartRef<domDepth_range> domDepth_rangeRef; 6427 typedef daeTArray<domDepth_rangeRef> domDepth_range_Array; 6428 6429 class domDepth_range : public daeElement 6430 { 6431 public: 6432 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_RANGE; } 6433 static daeInt ID() { return 309; } 6434 virtual daeInt typeID() const { return ID(); } 6435 protected: // Attributes 6436 domFloat2 attrValue; 6437 xsNCName attrParam; 6438 6439 6440 public: //Accessors and Mutators 6441 /** 6442 * Gets the value array attribute. 6443 * @return Returns a domFloat2 reference of the value array attribute. 6444 */ 6445 domFloat2 &getValue() { return attrValue; } 6446 /** 6447 * Gets the value array attribute. 6448 * @return Returns a constant domFloat2 reference of the value array attribute. 6449 */ 6450 const domFloat2 &getValue() const { return attrValue; } 6451 /** 6452 * Sets the value array attribute. 6453 * @param atValue The new value for the value array attribute. 6454 */ 6455 void setValue( const domFloat2 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6456 6457 /** 6458 * Gets the param attribute. 6459 * @return Returns a xsNCName of the param attribute. 6460 */ 6461 xsNCName getParam() const { return attrParam; } 6462 /** 6463 * Sets the param attribute. 6464 * @param atParam The new value for the param attribute. 6465 */ 6466 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6467 6468 protected: 6469 /** 6470 * Constructor 6471 */ 6472 domDepth_range(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6473 /** 6474 * Destructor 6475 */ 6476 virtual ~domDepth_range() {} 6477 /** 6478 * Overloaded assignment operator 6479 */ 6480 virtual domDepth_range &operator=( const domDepth_range &cpy ) { (void)cpy; return *this; } 6481 6482 public: // STATIC METHODS 6483 /** 6484 * Creates an instance of this class and returns a daeElementRef referencing it. 6485 * @return a daeElementRef referencing an instance of this object. 6486 */ 6487 static DLLSPEC daeElementRef create(DAE& dae); 6488 /** 6489 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6490 * If a daeMetaElement already exists it will return that instead of creating a new one. 6491 * @return A daeMetaElement describing this COLLADA element. 6492 */ 6493 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6494 }; 6495 6496 class domFog_density; 6497 6498 typedef daeSmartRef<domFog_density> domFog_densityRef; 6499 typedef daeTArray<domFog_densityRef> domFog_density_Array; 6500 6501 class domFog_density : public daeElement 6502 { 6503 public: 6504 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_DENSITY; } 6505 static daeInt ID() { return 310; } 6506 virtual daeInt typeID() const { return ID(); } 6507 protected: // Attributes 6508 domFloat attrValue; 6509 xsNCName attrParam; 6510 6511 6512 public: //Accessors and Mutators 6513 /** 6514 * Gets the value attribute. 6515 * @return Returns a domFloat of the value attribute. 6516 */ 6517 domFloat getValue() const { return attrValue; } 6518 /** 6519 * Sets the value attribute. 6520 * @param atValue The new value for the value attribute. 6521 */ 6522 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6523 6524 /** 6525 * Gets the param attribute. 6526 * @return Returns a xsNCName of the param attribute. 6527 */ 6528 xsNCName getParam() const { return attrParam; } 6529 /** 6530 * Sets the param attribute. 6531 * @param atParam The new value for the param attribute. 6532 */ 6533 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6534 6535 protected: 6536 /** 6537 * Constructor 6538 */ 6539 domFog_density(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6540 /** 6541 * Destructor 6542 */ 6543 virtual ~domFog_density() {} 6544 /** 6545 * Overloaded assignment operator 6546 */ 6547 virtual domFog_density &operator=( const domFog_density &cpy ) { (void)cpy; return *this; } 6548 6549 public: // STATIC METHODS 6550 /** 6551 * Creates an instance of this class and returns a daeElementRef referencing it. 6552 * @return a daeElementRef referencing an instance of this object. 6553 */ 6554 static DLLSPEC daeElementRef create(DAE& dae); 6555 /** 6556 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6557 * If a daeMetaElement already exists it will return that instead of creating a new one. 6558 * @return A daeMetaElement describing this COLLADA element. 6559 */ 6560 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6561 }; 6562 6563 class domFog_start; 6564 6565 typedef daeSmartRef<domFog_start> domFog_startRef; 6566 typedef daeTArray<domFog_startRef> domFog_start_Array; 6567 6568 class domFog_start : public daeElement 6569 { 6570 public: 6571 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_START; } 6572 static daeInt ID() { return 311; } 6573 virtual daeInt typeID() const { return ID(); } 6574 protected: // Attributes 6575 domFloat attrValue; 6576 xsNCName attrParam; 6577 6578 6579 public: //Accessors and Mutators 6580 /** 6581 * Gets the value attribute. 6582 * @return Returns a domFloat of the value attribute. 6583 */ 6584 domFloat getValue() const { return attrValue; } 6585 /** 6586 * Sets the value attribute. 6587 * @param atValue The new value for the value attribute. 6588 */ 6589 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6590 6591 /** 6592 * Gets the param attribute. 6593 * @return Returns a xsNCName of the param attribute. 6594 */ 6595 xsNCName getParam() const { return attrParam; } 6596 /** 6597 * Sets the param attribute. 6598 * @param atParam The new value for the param attribute. 6599 */ 6600 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6601 6602 protected: 6603 /** 6604 * Constructor 6605 */ 6606 domFog_start(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6607 /** 6608 * Destructor 6609 */ 6610 virtual ~domFog_start() {} 6611 /** 6612 * Overloaded assignment operator 6613 */ 6614 virtual domFog_start &operator=( const domFog_start &cpy ) { (void)cpy; return *this; } 6615 6616 public: // STATIC METHODS 6617 /** 6618 * Creates an instance of this class and returns a daeElementRef referencing it. 6619 * @return a daeElementRef referencing an instance of this object. 6620 */ 6621 static DLLSPEC daeElementRef create(DAE& dae); 6622 /** 6623 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6624 * If a daeMetaElement already exists it will return that instead of creating a new one. 6625 * @return A daeMetaElement describing this COLLADA element. 6626 */ 6627 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6628 }; 6629 6630 class domFog_end; 6631 6632 typedef daeSmartRef<domFog_end> domFog_endRef; 6633 typedef daeTArray<domFog_endRef> domFog_end_Array; 6634 6635 class domFog_end : public daeElement 6636 { 6637 public: 6638 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_END; } 6639 static daeInt ID() { return 312; } 6640 virtual daeInt typeID() const { return ID(); } 6641 protected: // Attributes 6642 domFloat attrValue; 6643 xsNCName attrParam; 6644 6645 6646 public: //Accessors and Mutators 6647 /** 6648 * Gets the value attribute. 6649 * @return Returns a domFloat of the value attribute. 6650 */ 6651 domFloat getValue() const { return attrValue; } 6652 /** 6653 * Sets the value attribute. 6654 * @param atValue The new value for the value attribute. 6655 */ 6656 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6657 6658 /** 6659 * Gets the param attribute. 6660 * @return Returns a xsNCName of the param attribute. 6661 */ 6662 xsNCName getParam() const { return attrParam; } 6663 /** 6664 * Sets the param attribute. 6665 * @param atParam The new value for the param attribute. 6666 */ 6667 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6668 6669 protected: 6670 /** 6671 * Constructor 6672 */ 6673 domFog_end(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6674 /** 6675 * Destructor 6676 */ 6677 virtual ~domFog_end() {} 6678 /** 6679 * Overloaded assignment operator 6680 */ 6681 virtual domFog_end &operator=( const domFog_end &cpy ) { (void)cpy; return *this; } 6682 6683 public: // STATIC METHODS 6684 /** 6685 * Creates an instance of this class and returns a daeElementRef referencing it. 6686 * @return a daeElementRef referencing an instance of this object. 6687 */ 6688 static DLLSPEC daeElementRef create(DAE& dae); 6689 /** 6690 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6691 * If a daeMetaElement already exists it will return that instead of creating a new one. 6692 * @return A daeMetaElement describing this COLLADA element. 6693 */ 6694 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6695 }; 6696 6697 class domFog_color; 6698 6699 typedef daeSmartRef<domFog_color> domFog_colorRef; 6700 typedef daeTArray<domFog_colorRef> domFog_color_Array; 6701 6702 class domFog_color : public daeElement 6703 { 6704 public: 6705 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_COLOR; } 6706 static daeInt ID() { return 313; } 6707 virtual daeInt typeID() const { return ID(); } 6708 protected: // Attributes 6709 domFloat4 attrValue; 6710 xsNCName attrParam; 6711 6712 6713 public: //Accessors and Mutators 6714 /** 6715 * Gets the value array attribute. 6716 * @return Returns a domFloat4 reference of the value array attribute. 6717 */ 6718 domFloat4 &getValue() { return attrValue; } 6719 /** 6720 * Gets the value array attribute. 6721 * @return Returns a constant domFloat4 reference of the value array attribute. 6722 */ 6723 const domFloat4 &getValue() const { return attrValue; } 6724 /** 6725 * Sets the value array attribute. 6726 * @param atValue The new value for the value array attribute. 6727 */ 6728 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6729 6730 /** 6731 * Gets the param attribute. 6732 * @return Returns a xsNCName of the param attribute. 6733 */ 6734 xsNCName getParam() const { return attrParam; } 6735 /** 6736 * Sets the param attribute. 6737 * @param atParam The new value for the param attribute. 6738 */ 6739 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6740 6741 protected: 6742 /** 6743 * Constructor 6744 */ 6745 domFog_color(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6746 /** 6747 * Destructor 6748 */ 6749 virtual ~domFog_color() {} 6750 /** 6751 * Overloaded assignment operator 6752 */ 6753 virtual domFog_color &operator=( const domFog_color &cpy ) { (void)cpy; return *this; } 6754 6755 public: // STATIC METHODS 6756 /** 6757 * Creates an instance of this class and returns a daeElementRef referencing it. 6758 * @return a daeElementRef referencing an instance of this object. 6759 */ 6760 static DLLSPEC daeElementRef create(DAE& dae); 6761 /** 6762 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6763 * If a daeMetaElement already exists it will return that instead of creating a new one. 6764 * @return A daeMetaElement describing this COLLADA element. 6765 */ 6766 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6767 }; 6768 6769 class domLight_model_ambient; 6770 6771 typedef daeSmartRef<domLight_model_ambient> domLight_model_ambientRef; 6772 typedef daeTArray<domLight_model_ambientRef> domLight_model_ambient_Array; 6773 6774 class domLight_model_ambient : public daeElement 6775 { 6776 public: 6777 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_MODEL_AMBIENT; } 6778 static daeInt ID() { return 314; } 6779 virtual daeInt typeID() const { return ID(); } 6780 protected: // Attributes 6781 domFloat4 attrValue; 6782 xsNCName attrParam; 6783 6784 6785 public: //Accessors and Mutators 6786 /** 6787 * Gets the value array attribute. 6788 * @return Returns a domFloat4 reference of the value array attribute. 6789 */ 6790 domFloat4 &getValue() { return attrValue; } 6791 /** 6792 * Gets the value array attribute. 6793 * @return Returns a constant domFloat4 reference of the value array attribute. 6794 */ 6795 const domFloat4 &getValue() const { return attrValue; } 6796 /** 6797 * Sets the value array attribute. 6798 * @param atValue The new value for the value array attribute. 6799 */ 6800 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6801 6802 /** 6803 * Gets the param attribute. 6804 * @return Returns a xsNCName of the param attribute. 6805 */ 6806 xsNCName getParam() const { return attrParam; } 6807 /** 6808 * Sets the param attribute. 6809 * @param atParam The new value for the param attribute. 6810 */ 6811 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6812 6813 protected: 6814 /** 6815 * Constructor 6816 */ 6817 domLight_model_ambient(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6818 /** 6819 * Destructor 6820 */ 6821 virtual ~domLight_model_ambient() {} 6822 /** 6823 * Overloaded assignment operator 6824 */ 6825 virtual domLight_model_ambient &operator=( const domLight_model_ambient &cpy ) { (void)cpy; return *this; } 6826 6827 public: // STATIC METHODS 6828 /** 6829 * Creates an instance of this class and returns a daeElementRef referencing it. 6830 * @return a daeElementRef referencing an instance of this object. 6831 */ 6832 static DLLSPEC daeElementRef create(DAE& dae); 6833 /** 6834 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6835 * If a daeMetaElement already exists it will return that instead of creating a new one. 6836 * @return A daeMetaElement describing this COLLADA element. 6837 */ 6838 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6839 }; 6840 6841 class domLighting_enable; 6842 6843 typedef daeSmartRef<domLighting_enable> domLighting_enableRef; 6844 typedef daeTArray<domLighting_enableRef> domLighting_enable_Array; 6845 6846 class domLighting_enable : public daeElement 6847 { 6848 public: 6849 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHTING_ENABLE; } 6850 static daeInt ID() { return 315; } 6851 virtual daeInt typeID() const { return ID(); } 6852 protected: // Attributes 6853 domBool attrValue; 6854 xsNCName attrParam; 6855 6856 6857 public: //Accessors and Mutators 6858 /** 6859 * Gets the value attribute. 6860 * @return Returns a domBool of the value attribute. 6861 */ 6862 domBool getValue() const { return attrValue; } 6863 /** 6864 * Sets the value attribute. 6865 * @param atValue The new value for the value attribute. 6866 */ 6867 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6868 6869 /** 6870 * Gets the param attribute. 6871 * @return Returns a xsNCName of the param attribute. 6872 */ 6873 xsNCName getParam() const { return attrParam; } 6874 /** 6875 * Sets the param attribute. 6876 * @param atParam The new value for the param attribute. 6877 */ 6878 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6879 6880 protected: 6881 /** 6882 * Constructor 6883 */ 6884 domLighting_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6885 /** 6886 * Destructor 6887 */ 6888 virtual ~domLighting_enable() {} 6889 /** 6890 * Overloaded assignment operator 6891 */ 6892 virtual domLighting_enable &operator=( const domLighting_enable &cpy ) { (void)cpy; return *this; } 6893 6894 public: // STATIC METHODS 6895 /** 6896 * Creates an instance of this class and returns a daeElementRef referencing it. 6897 * @return a daeElementRef referencing an instance of this object. 6898 */ 6899 static DLLSPEC daeElementRef create(DAE& dae); 6900 /** 6901 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6902 * If a daeMetaElement already exists it will return that instead of creating a new one. 6903 * @return A daeMetaElement describing this COLLADA element. 6904 */ 6905 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6906 }; 6907 6908 class domLine_stipple; 6909 6910 typedef daeSmartRef<domLine_stipple> domLine_stippleRef; 6911 typedef daeTArray<domLine_stippleRef> domLine_stipple_Array; 6912 6913 class domLine_stipple : public daeElement 6914 { 6915 public: 6916 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LINE_STIPPLE; } 6917 static daeInt ID() { return 316; } 6918 virtual daeInt typeID() const { return ID(); } 6919 protected: // Attributes 6920 domInt2 attrValue; 6921 xsNCName attrParam; 6922 6923 6924 public: //Accessors and Mutators 6925 /** 6926 * Gets the value array attribute. 6927 * @return Returns a domInt2 reference of the value array attribute. 6928 */ 6929 domInt2 &getValue() { return attrValue; } 6930 /** 6931 * Gets the value array attribute. 6932 * @return Returns a constant domInt2 reference of the value array attribute. 6933 */ 6934 const domInt2 &getValue() const { return attrValue; } 6935 /** 6936 * Sets the value array attribute. 6937 * @param atValue The new value for the value array attribute. 6938 */ 6939 void setValue( const domInt2 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 6940 6941 /** 6942 * Gets the param attribute. 6943 * @return Returns a xsNCName of the param attribute. 6944 */ 6945 xsNCName getParam() const { return attrParam; } 6946 /** 6947 * Sets the param attribute. 6948 * @param atParam The new value for the param attribute. 6949 */ 6950 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 6951 6952 protected: 6953 /** 6954 * Constructor 6955 */ 6956 domLine_stipple(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 6957 /** 6958 * Destructor 6959 */ 6960 virtual ~domLine_stipple() {} 6961 /** 6962 * Overloaded assignment operator 6963 */ 6964 virtual domLine_stipple &operator=( const domLine_stipple &cpy ) { (void)cpy; return *this; } 6965 6966 public: // STATIC METHODS 6967 /** 6968 * Creates an instance of this class and returns a daeElementRef referencing it. 6969 * @return a daeElementRef referencing an instance of this object. 6970 */ 6971 static DLLSPEC daeElementRef create(DAE& dae); 6972 /** 6973 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 6974 * If a daeMetaElement already exists it will return that instead of creating a new one. 6975 * @return A daeMetaElement describing this COLLADA element. 6976 */ 6977 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 6978 }; 6979 6980 class domLine_width; 6981 6982 typedef daeSmartRef<domLine_width> domLine_widthRef; 6983 typedef daeTArray<domLine_widthRef> domLine_width_Array; 6984 6985 class domLine_width : public daeElement 6986 { 6987 public: 6988 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LINE_WIDTH; } 6989 static daeInt ID() { return 317; } 6990 virtual daeInt typeID() const { return ID(); } 6991 protected: // Attributes 6992 domFloat attrValue; 6993 xsNCName attrParam; 6994 6995 6996 public: //Accessors and Mutators 6997 /** 6998 * Gets the value attribute. 6999 * @return Returns a domFloat of the value attribute. 7000 */ 7001 domFloat getValue() const { return attrValue; } 7002 /** 7003 * Sets the value attribute. 7004 * @param atValue The new value for the value attribute. 7005 */ 7006 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7007 7008 /** 7009 * Gets the param attribute. 7010 * @return Returns a xsNCName of the param attribute. 7011 */ 7012 xsNCName getParam() const { return attrParam; } 7013 /** 7014 * Sets the param attribute. 7015 * @param atParam The new value for the param attribute. 7016 */ 7017 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7018 7019 protected: 7020 /** 7021 * Constructor 7022 */ 7023 domLine_width(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7024 /** 7025 * Destructor 7026 */ 7027 virtual ~domLine_width() {} 7028 /** 7029 * Overloaded assignment operator 7030 */ 7031 virtual domLine_width &operator=( const domLine_width &cpy ) { (void)cpy; return *this; } 7032 7033 public: // STATIC METHODS 7034 /** 7035 * Creates an instance of this class and returns a daeElementRef referencing it. 7036 * @return a daeElementRef referencing an instance of this object. 7037 */ 7038 static DLLSPEC daeElementRef create(DAE& dae); 7039 /** 7040 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7041 * If a daeMetaElement already exists it will return that instead of creating a new one. 7042 * @return A daeMetaElement describing this COLLADA element. 7043 */ 7044 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7045 }; 7046 7047 class domMaterial_ambient; 7048 7049 typedef daeSmartRef<domMaterial_ambient> domMaterial_ambientRef; 7050 typedef daeTArray<domMaterial_ambientRef> domMaterial_ambient_Array; 7051 7052 class domMaterial_ambient : public daeElement 7053 { 7054 public: 7055 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MATERIAL_AMBIENT; } 7056 static daeInt ID() { return 318; } 7057 virtual daeInt typeID() const { return ID(); } 7058 protected: // Attributes 7059 domFloat4 attrValue; 7060 xsNCName attrParam; 7061 7062 7063 public: //Accessors and Mutators 7064 /** 7065 * Gets the value array attribute. 7066 * @return Returns a domFloat4 reference of the value array attribute. 7067 */ 7068 domFloat4 &getValue() { return attrValue; } 7069 /** 7070 * Gets the value array attribute. 7071 * @return Returns a constant domFloat4 reference of the value array attribute. 7072 */ 7073 const domFloat4 &getValue() const { return attrValue; } 7074 /** 7075 * Sets the value array attribute. 7076 * @param atValue The new value for the value array attribute. 7077 */ 7078 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7079 7080 /** 7081 * Gets the param attribute. 7082 * @return Returns a xsNCName of the param attribute. 7083 */ 7084 xsNCName getParam() const { return attrParam; } 7085 /** 7086 * Sets the param attribute. 7087 * @param atParam The new value for the param attribute. 7088 */ 7089 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7090 7091 protected: 7092 /** 7093 * Constructor 7094 */ 7095 domMaterial_ambient(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7096 /** 7097 * Destructor 7098 */ 7099 virtual ~domMaterial_ambient() {} 7100 /** 7101 * Overloaded assignment operator 7102 */ 7103 virtual domMaterial_ambient &operator=( const domMaterial_ambient &cpy ) { (void)cpy; return *this; } 7104 7105 public: // STATIC METHODS 7106 /** 7107 * Creates an instance of this class and returns a daeElementRef referencing it. 7108 * @return a daeElementRef referencing an instance of this object. 7109 */ 7110 static DLLSPEC daeElementRef create(DAE& dae); 7111 /** 7112 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7113 * If a daeMetaElement already exists it will return that instead of creating a new one. 7114 * @return A daeMetaElement describing this COLLADA element. 7115 */ 7116 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7117 }; 7118 7119 class domMaterial_diffuse; 7120 7121 typedef daeSmartRef<domMaterial_diffuse> domMaterial_diffuseRef; 7122 typedef daeTArray<domMaterial_diffuseRef> domMaterial_diffuse_Array; 7123 7124 class domMaterial_diffuse : public daeElement 7125 { 7126 public: 7127 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MATERIAL_DIFFUSE; } 7128 static daeInt ID() { return 319; } 7129 virtual daeInt typeID() const { return ID(); } 7130 protected: // Attributes 7131 domFloat4 attrValue; 7132 xsNCName attrParam; 7133 7134 7135 public: //Accessors and Mutators 7136 /** 7137 * Gets the value array attribute. 7138 * @return Returns a domFloat4 reference of the value array attribute. 7139 */ 7140 domFloat4 &getValue() { return attrValue; } 7141 /** 7142 * Gets the value array attribute. 7143 * @return Returns a constant domFloat4 reference of the value array attribute. 7144 */ 7145 const domFloat4 &getValue() const { return attrValue; } 7146 /** 7147 * Sets the value array attribute. 7148 * @param atValue The new value for the value array attribute. 7149 */ 7150 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7151 7152 /** 7153 * Gets the param attribute. 7154 * @return Returns a xsNCName of the param attribute. 7155 */ 7156 xsNCName getParam() const { return attrParam; } 7157 /** 7158 * Sets the param attribute. 7159 * @param atParam The new value for the param attribute. 7160 */ 7161 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7162 7163 protected: 7164 /** 7165 * Constructor 7166 */ 7167 domMaterial_diffuse(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7168 /** 7169 * Destructor 7170 */ 7171 virtual ~domMaterial_diffuse() {} 7172 /** 7173 * Overloaded assignment operator 7174 */ 7175 virtual domMaterial_diffuse &operator=( const domMaterial_diffuse &cpy ) { (void)cpy; return *this; } 7176 7177 public: // STATIC METHODS 7178 /** 7179 * Creates an instance of this class and returns a daeElementRef referencing it. 7180 * @return a daeElementRef referencing an instance of this object. 7181 */ 7182 static DLLSPEC daeElementRef create(DAE& dae); 7183 /** 7184 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7185 * If a daeMetaElement already exists it will return that instead of creating a new one. 7186 * @return A daeMetaElement describing this COLLADA element. 7187 */ 7188 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7189 }; 7190 7191 class domMaterial_emission; 7192 7193 typedef daeSmartRef<domMaterial_emission> domMaterial_emissionRef; 7194 typedef daeTArray<domMaterial_emissionRef> domMaterial_emission_Array; 7195 7196 class domMaterial_emission : public daeElement 7197 { 7198 public: 7199 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MATERIAL_EMISSION; } 7200 static daeInt ID() { return 320; } 7201 virtual daeInt typeID() const { return ID(); } 7202 protected: // Attributes 7203 domFloat4 attrValue; 7204 xsNCName attrParam; 7205 7206 7207 public: //Accessors and Mutators 7208 /** 7209 * Gets the value array attribute. 7210 * @return Returns a domFloat4 reference of the value array attribute. 7211 */ 7212 domFloat4 &getValue() { return attrValue; } 7213 /** 7214 * Gets the value array attribute. 7215 * @return Returns a constant domFloat4 reference of the value array attribute. 7216 */ 7217 const domFloat4 &getValue() const { return attrValue; } 7218 /** 7219 * Sets the value array attribute. 7220 * @param atValue The new value for the value array attribute. 7221 */ 7222 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7223 7224 /** 7225 * Gets the param attribute. 7226 * @return Returns a xsNCName of the param attribute. 7227 */ 7228 xsNCName getParam() const { return attrParam; } 7229 /** 7230 * Sets the param attribute. 7231 * @param atParam The new value for the param attribute. 7232 */ 7233 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7234 7235 protected: 7236 /** 7237 * Constructor 7238 */ 7239 domMaterial_emission(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7240 /** 7241 * Destructor 7242 */ 7243 virtual ~domMaterial_emission() {} 7244 /** 7245 * Overloaded assignment operator 7246 */ 7247 virtual domMaterial_emission &operator=( const domMaterial_emission &cpy ) { (void)cpy; return *this; } 7248 7249 public: // STATIC METHODS 7250 /** 7251 * Creates an instance of this class and returns a daeElementRef referencing it. 7252 * @return a daeElementRef referencing an instance of this object. 7253 */ 7254 static DLLSPEC daeElementRef create(DAE& dae); 7255 /** 7256 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7257 * If a daeMetaElement already exists it will return that instead of creating a new one. 7258 * @return A daeMetaElement describing this COLLADA element. 7259 */ 7260 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7261 }; 7262 7263 class domMaterial_shininess; 7264 7265 typedef daeSmartRef<domMaterial_shininess> domMaterial_shininessRef; 7266 typedef daeTArray<domMaterial_shininessRef> domMaterial_shininess_Array; 7267 7268 class domMaterial_shininess : public daeElement 7269 { 7270 public: 7271 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MATERIAL_SHININESS; } 7272 static daeInt ID() { return 321; } 7273 virtual daeInt typeID() const { return ID(); } 7274 protected: // Attributes 7275 domFloat attrValue; 7276 xsNCName attrParam; 7277 7278 7279 public: //Accessors and Mutators 7280 /** 7281 * Gets the value attribute. 7282 * @return Returns a domFloat of the value attribute. 7283 */ 7284 domFloat getValue() const { return attrValue; } 7285 /** 7286 * Sets the value attribute. 7287 * @param atValue The new value for the value attribute. 7288 */ 7289 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7290 7291 /** 7292 * Gets the param attribute. 7293 * @return Returns a xsNCName of the param attribute. 7294 */ 7295 xsNCName getParam() const { return attrParam; } 7296 /** 7297 * Sets the param attribute. 7298 * @param atParam The new value for the param attribute. 7299 */ 7300 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7301 7302 protected: 7303 /** 7304 * Constructor 7305 */ 7306 domMaterial_shininess(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7307 /** 7308 * Destructor 7309 */ 7310 virtual ~domMaterial_shininess() {} 7311 /** 7312 * Overloaded assignment operator 7313 */ 7314 virtual domMaterial_shininess &operator=( const domMaterial_shininess &cpy ) { (void)cpy; return *this; } 7315 7316 public: // STATIC METHODS 7317 /** 7318 * Creates an instance of this class and returns a daeElementRef referencing it. 7319 * @return a daeElementRef referencing an instance of this object. 7320 */ 7321 static DLLSPEC daeElementRef create(DAE& dae); 7322 /** 7323 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7324 * If a daeMetaElement already exists it will return that instead of creating a new one. 7325 * @return A daeMetaElement describing this COLLADA element. 7326 */ 7327 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7328 }; 7329 7330 class domMaterial_specular; 7331 7332 typedef daeSmartRef<domMaterial_specular> domMaterial_specularRef; 7333 typedef daeTArray<domMaterial_specularRef> domMaterial_specular_Array; 7334 7335 class domMaterial_specular : public daeElement 7336 { 7337 public: 7338 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MATERIAL_SPECULAR; } 7339 static daeInt ID() { return 322; } 7340 virtual daeInt typeID() const { return ID(); } 7341 protected: // Attributes 7342 domFloat4 attrValue; 7343 xsNCName attrParam; 7344 7345 7346 public: //Accessors and Mutators 7347 /** 7348 * Gets the value array attribute. 7349 * @return Returns a domFloat4 reference of the value array attribute. 7350 */ 7351 domFloat4 &getValue() { return attrValue; } 7352 /** 7353 * Gets the value array attribute. 7354 * @return Returns a constant domFloat4 reference of the value array attribute. 7355 */ 7356 const domFloat4 &getValue() const { return attrValue; } 7357 /** 7358 * Sets the value array attribute. 7359 * @param atValue The new value for the value array attribute. 7360 */ 7361 void setValue( const domFloat4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7362 7363 /** 7364 * Gets the param attribute. 7365 * @return Returns a xsNCName of the param attribute. 7366 */ 7367 xsNCName getParam() const { return attrParam; } 7368 /** 7369 * Sets the param attribute. 7370 * @param atParam The new value for the param attribute. 7371 */ 7372 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7373 7374 protected: 7375 /** 7376 * Constructor 7377 */ 7378 domMaterial_specular(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7379 /** 7380 * Destructor 7381 */ 7382 virtual ~domMaterial_specular() {} 7383 /** 7384 * Overloaded assignment operator 7385 */ 7386 virtual domMaterial_specular &operator=( const domMaterial_specular &cpy ) { (void)cpy; return *this; } 7387 7388 public: // STATIC METHODS 7389 /** 7390 * Creates an instance of this class and returns a daeElementRef referencing it. 7391 * @return a daeElementRef referencing an instance of this object. 7392 */ 7393 static DLLSPEC daeElementRef create(DAE& dae); 7394 /** 7395 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7396 * If a daeMetaElement already exists it will return that instead of creating a new one. 7397 * @return A daeMetaElement describing this COLLADA element. 7398 */ 7399 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7400 }; 7401 7402 class domModel_view_matrix; 7403 7404 typedef daeSmartRef<domModel_view_matrix> domModel_view_matrixRef; 7405 typedef daeTArray<domModel_view_matrixRef> domModel_view_matrix_Array; 7406 7407 class domModel_view_matrix : public daeElement 7408 { 7409 public: 7410 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MODEL_VIEW_MATRIX; } 7411 static daeInt ID() { return 323; } 7412 virtual daeInt typeID() const { return ID(); } 7413 protected: // Attributes 7414 domFloat4x4 attrValue; 7415 xsNCName attrParam; 7416 7417 7418 public: //Accessors and Mutators 7419 /** 7420 * Gets the value array attribute. 7421 * @return Returns a domFloat4x4 reference of the value array attribute. 7422 */ 7423 domFloat4x4 &getValue() { return attrValue; } 7424 /** 7425 * Gets the value array attribute. 7426 * @return Returns a constant domFloat4x4 reference of the value array attribute. 7427 */ 7428 const domFloat4x4 &getValue() const { return attrValue; } 7429 /** 7430 * Sets the value array attribute. 7431 * @param atValue The new value for the value array attribute. 7432 */ 7433 void setValue( const domFloat4x4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7434 7435 /** 7436 * Gets the param attribute. 7437 * @return Returns a xsNCName of the param attribute. 7438 */ 7439 xsNCName getParam() const { return attrParam; } 7440 /** 7441 * Sets the param attribute. 7442 * @param atParam The new value for the param attribute. 7443 */ 7444 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7445 7446 protected: 7447 /** 7448 * Constructor 7449 */ 7450 domModel_view_matrix(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7451 /** 7452 * Destructor 7453 */ 7454 virtual ~domModel_view_matrix() {} 7455 /** 7456 * Overloaded assignment operator 7457 */ 7458 virtual domModel_view_matrix &operator=( const domModel_view_matrix &cpy ) { (void)cpy; return *this; } 7459 7460 public: // STATIC METHODS 7461 /** 7462 * Creates an instance of this class and returns a daeElementRef referencing it. 7463 * @return a daeElementRef referencing an instance of this object. 7464 */ 7465 static DLLSPEC daeElementRef create(DAE& dae); 7466 /** 7467 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7468 * If a daeMetaElement already exists it will return that instead of creating a new one. 7469 * @return A daeMetaElement describing this COLLADA element. 7470 */ 7471 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7472 }; 7473 7474 class domPoint_distance_attenuation; 7475 7476 typedef daeSmartRef<domPoint_distance_attenuation> domPoint_distance_attenuationRef; 7477 typedef daeTArray<domPoint_distance_attenuationRef> domPoint_distance_attenuation_Array; 7478 7479 class domPoint_distance_attenuation : public daeElement 7480 { 7481 public: 7482 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POINT_DISTANCE_ATTENUATION; } 7483 static daeInt ID() { return 324; } 7484 virtual daeInt typeID() const { return ID(); } 7485 protected: // Attributes 7486 domFloat3 attrValue; 7487 xsNCName attrParam; 7488 7489 7490 public: //Accessors and Mutators 7491 /** 7492 * Gets the value array attribute. 7493 * @return Returns a domFloat3 reference of the value array attribute. 7494 */ 7495 domFloat3 &getValue() { return attrValue; } 7496 /** 7497 * Gets the value array attribute. 7498 * @return Returns a constant domFloat3 reference of the value array attribute. 7499 */ 7500 const domFloat3 &getValue() const { return attrValue; } 7501 /** 7502 * Sets the value array attribute. 7503 * @param atValue The new value for the value array attribute. 7504 */ 7505 void setValue( const domFloat3 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7506 7507 /** 7508 * Gets the param attribute. 7509 * @return Returns a xsNCName of the param attribute. 7510 */ 7511 xsNCName getParam() const { return attrParam; } 7512 /** 7513 * Sets the param attribute. 7514 * @param atParam The new value for the param attribute. 7515 */ 7516 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7517 7518 protected: 7519 /** 7520 * Constructor 7521 */ 7522 domPoint_distance_attenuation(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7523 /** 7524 * Destructor 7525 */ 7526 virtual ~domPoint_distance_attenuation() {} 7527 /** 7528 * Overloaded assignment operator 7529 */ 7530 virtual domPoint_distance_attenuation &operator=( const domPoint_distance_attenuation &cpy ) { (void)cpy; return *this; } 7531 7532 public: // STATIC METHODS 7533 /** 7534 * Creates an instance of this class and returns a daeElementRef referencing it. 7535 * @return a daeElementRef referencing an instance of this object. 7536 */ 7537 static DLLSPEC daeElementRef create(DAE& dae); 7538 /** 7539 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7540 * If a daeMetaElement already exists it will return that instead of creating a new one. 7541 * @return A daeMetaElement describing this COLLADA element. 7542 */ 7543 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7544 }; 7545 7546 class domPoint_fade_threshold_size; 7547 7548 typedef daeSmartRef<domPoint_fade_threshold_size> domPoint_fade_threshold_sizeRef; 7549 typedef daeTArray<domPoint_fade_threshold_sizeRef> domPoint_fade_threshold_size_Array; 7550 7551 class domPoint_fade_threshold_size : public daeElement 7552 { 7553 public: 7554 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POINT_FADE_THRESHOLD_SIZE; } 7555 static daeInt ID() { return 325; } 7556 virtual daeInt typeID() const { return ID(); } 7557 protected: // Attributes 7558 domFloat attrValue; 7559 xsNCName attrParam; 7560 7561 7562 public: //Accessors and Mutators 7563 /** 7564 * Gets the value attribute. 7565 * @return Returns a domFloat of the value attribute. 7566 */ 7567 domFloat getValue() const { return attrValue; } 7568 /** 7569 * Sets the value attribute. 7570 * @param atValue The new value for the value attribute. 7571 */ 7572 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7573 7574 /** 7575 * Gets the param attribute. 7576 * @return Returns a xsNCName of the param attribute. 7577 */ 7578 xsNCName getParam() const { return attrParam; } 7579 /** 7580 * Sets the param attribute. 7581 * @param atParam The new value for the param attribute. 7582 */ 7583 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7584 7585 protected: 7586 /** 7587 * Constructor 7588 */ 7589 domPoint_fade_threshold_size(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7590 /** 7591 * Destructor 7592 */ 7593 virtual ~domPoint_fade_threshold_size() {} 7594 /** 7595 * Overloaded assignment operator 7596 */ 7597 virtual domPoint_fade_threshold_size &operator=( const domPoint_fade_threshold_size &cpy ) { (void)cpy; return *this; } 7598 7599 public: // STATIC METHODS 7600 /** 7601 * Creates an instance of this class and returns a daeElementRef referencing it. 7602 * @return a daeElementRef referencing an instance of this object. 7603 */ 7604 static DLLSPEC daeElementRef create(DAE& dae); 7605 /** 7606 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7607 * If a daeMetaElement already exists it will return that instead of creating a new one. 7608 * @return A daeMetaElement describing this COLLADA element. 7609 */ 7610 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7611 }; 7612 7613 class domPoint_size; 7614 7615 typedef daeSmartRef<domPoint_size> domPoint_sizeRef; 7616 typedef daeTArray<domPoint_sizeRef> domPoint_size_Array; 7617 7618 class domPoint_size : public daeElement 7619 { 7620 public: 7621 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POINT_SIZE; } 7622 static daeInt ID() { return 326; } 7623 virtual daeInt typeID() const { return ID(); } 7624 protected: // Attributes 7625 domFloat attrValue; 7626 xsNCName attrParam; 7627 7628 7629 public: //Accessors and Mutators 7630 /** 7631 * Gets the value attribute. 7632 * @return Returns a domFloat of the value attribute. 7633 */ 7634 domFloat getValue() const { return attrValue; } 7635 /** 7636 * Sets the value attribute. 7637 * @param atValue The new value for the value attribute. 7638 */ 7639 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7640 7641 /** 7642 * Gets the param attribute. 7643 * @return Returns a xsNCName of the param attribute. 7644 */ 7645 xsNCName getParam() const { return attrParam; } 7646 /** 7647 * Sets the param attribute. 7648 * @param atParam The new value for the param attribute. 7649 */ 7650 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7651 7652 protected: 7653 /** 7654 * Constructor 7655 */ 7656 domPoint_size(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7657 /** 7658 * Destructor 7659 */ 7660 virtual ~domPoint_size() {} 7661 /** 7662 * Overloaded assignment operator 7663 */ 7664 virtual domPoint_size &operator=( const domPoint_size &cpy ) { (void)cpy; return *this; } 7665 7666 public: // STATIC METHODS 7667 /** 7668 * Creates an instance of this class and returns a daeElementRef referencing it. 7669 * @return a daeElementRef referencing an instance of this object. 7670 */ 7671 static DLLSPEC daeElementRef create(DAE& dae); 7672 /** 7673 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7674 * If a daeMetaElement already exists it will return that instead of creating a new one. 7675 * @return A daeMetaElement describing this COLLADA element. 7676 */ 7677 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7678 }; 7679 7680 class domPoint_size_min; 7681 7682 typedef daeSmartRef<domPoint_size_min> domPoint_size_minRef; 7683 typedef daeTArray<domPoint_size_minRef> domPoint_size_min_Array; 7684 7685 class domPoint_size_min : public daeElement 7686 { 7687 public: 7688 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POINT_SIZE_MIN; } 7689 static daeInt ID() { return 327; } 7690 virtual daeInt typeID() const { return ID(); } 7691 protected: // Attributes 7692 domFloat attrValue; 7693 xsNCName attrParam; 7694 7695 7696 public: //Accessors and Mutators 7697 /** 7698 * Gets the value attribute. 7699 * @return Returns a domFloat of the value attribute. 7700 */ 7701 domFloat getValue() const { return attrValue; } 7702 /** 7703 * Sets the value attribute. 7704 * @param atValue The new value for the value attribute. 7705 */ 7706 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7707 7708 /** 7709 * Gets the param attribute. 7710 * @return Returns a xsNCName of the param attribute. 7711 */ 7712 xsNCName getParam() const { return attrParam; } 7713 /** 7714 * Sets the param attribute. 7715 * @param atParam The new value for the param attribute. 7716 */ 7717 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7718 7719 protected: 7720 /** 7721 * Constructor 7722 */ 7723 domPoint_size_min(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7724 /** 7725 * Destructor 7726 */ 7727 virtual ~domPoint_size_min() {} 7728 /** 7729 * Overloaded assignment operator 7730 */ 7731 virtual domPoint_size_min &operator=( const domPoint_size_min &cpy ) { (void)cpy; return *this; } 7732 7733 public: // STATIC METHODS 7734 /** 7735 * Creates an instance of this class and returns a daeElementRef referencing it. 7736 * @return a daeElementRef referencing an instance of this object. 7737 */ 7738 static DLLSPEC daeElementRef create(DAE& dae); 7739 /** 7740 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7741 * If a daeMetaElement already exists it will return that instead of creating a new one. 7742 * @return A daeMetaElement describing this COLLADA element. 7743 */ 7744 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7745 }; 7746 7747 class domPoint_size_max; 7748 7749 typedef daeSmartRef<domPoint_size_max> domPoint_size_maxRef; 7750 typedef daeTArray<domPoint_size_maxRef> domPoint_size_max_Array; 7751 7752 class domPoint_size_max : public daeElement 7753 { 7754 public: 7755 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POINT_SIZE_MAX; } 7756 static daeInt ID() { return 328; } 7757 virtual daeInt typeID() const { return ID(); } 7758 protected: // Attributes 7759 domFloat attrValue; 7760 xsNCName attrParam; 7761 7762 7763 public: //Accessors and Mutators 7764 /** 7765 * Gets the value attribute. 7766 * @return Returns a domFloat of the value attribute. 7767 */ 7768 domFloat getValue() const { return attrValue; } 7769 /** 7770 * Sets the value attribute. 7771 * @param atValue The new value for the value attribute. 7772 */ 7773 void setValue( domFloat atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7774 7775 /** 7776 * Gets the param attribute. 7777 * @return Returns a xsNCName of the param attribute. 7778 */ 7779 xsNCName getParam() const { return attrParam; } 7780 /** 7781 * Sets the param attribute. 7782 * @param atParam The new value for the param attribute. 7783 */ 7784 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7785 7786 protected: 7787 /** 7788 * Constructor 7789 */ 7790 domPoint_size_max(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7791 /** 7792 * Destructor 7793 */ 7794 virtual ~domPoint_size_max() {} 7795 /** 7796 * Overloaded assignment operator 7797 */ 7798 virtual domPoint_size_max &operator=( const domPoint_size_max &cpy ) { (void)cpy; return *this; } 7799 7800 public: // STATIC METHODS 7801 /** 7802 * Creates an instance of this class and returns a daeElementRef referencing it. 7803 * @return a daeElementRef referencing an instance of this object. 7804 */ 7805 static DLLSPEC daeElementRef create(DAE& dae); 7806 /** 7807 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7808 * If a daeMetaElement already exists it will return that instead of creating a new one. 7809 * @return A daeMetaElement describing this COLLADA element. 7810 */ 7811 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7812 }; 7813 7814 class domPolygon_offset; 7815 7816 typedef daeSmartRef<domPolygon_offset> domPolygon_offsetRef; 7817 typedef daeTArray<domPolygon_offsetRef> domPolygon_offset_Array; 7818 7819 class domPolygon_offset : public daeElement 7820 { 7821 public: 7822 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_OFFSET; } 7823 static daeInt ID() { return 329; } 7824 virtual daeInt typeID() const { return ID(); } 7825 protected: // Attributes 7826 domFloat2 attrValue; 7827 xsNCName attrParam; 7828 7829 7830 public: //Accessors and Mutators 7831 /** 7832 * Gets the value array attribute. 7833 * @return Returns a domFloat2 reference of the value array attribute. 7834 */ 7835 domFloat2 &getValue() { return attrValue; } 7836 /** 7837 * Gets the value array attribute. 7838 * @return Returns a constant domFloat2 reference of the value array attribute. 7839 */ 7840 const domFloat2 &getValue() const { return attrValue; } 7841 /** 7842 * Sets the value array attribute. 7843 * @param atValue The new value for the value array attribute. 7844 */ 7845 void setValue( const domFloat2 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7846 7847 /** 7848 * Gets the param attribute. 7849 * @return Returns a xsNCName of the param attribute. 7850 */ 7851 xsNCName getParam() const { return attrParam; } 7852 /** 7853 * Sets the param attribute. 7854 * @param atParam The new value for the param attribute. 7855 */ 7856 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7857 7858 protected: 7859 /** 7860 * Constructor 7861 */ 7862 domPolygon_offset(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7863 /** 7864 * Destructor 7865 */ 7866 virtual ~domPolygon_offset() {} 7867 /** 7868 * Overloaded assignment operator 7869 */ 7870 virtual domPolygon_offset &operator=( const domPolygon_offset &cpy ) { (void)cpy; return *this; } 7871 7872 public: // STATIC METHODS 7873 /** 7874 * Creates an instance of this class and returns a daeElementRef referencing it. 7875 * @return a daeElementRef referencing an instance of this object. 7876 */ 7877 static DLLSPEC daeElementRef create(DAE& dae); 7878 /** 7879 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7880 * If a daeMetaElement already exists it will return that instead of creating a new one. 7881 * @return A daeMetaElement describing this COLLADA element. 7882 */ 7883 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7884 }; 7885 7886 class domProjection_matrix; 7887 7888 typedef daeSmartRef<domProjection_matrix> domProjection_matrixRef; 7889 typedef daeTArray<domProjection_matrixRef> domProjection_matrix_Array; 7890 7891 class domProjection_matrix : public daeElement 7892 { 7893 public: 7894 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::PROJECTION_MATRIX; } 7895 static daeInt ID() { return 330; } 7896 virtual daeInt typeID() const { return ID(); } 7897 protected: // Attributes 7898 domFloat4x4 attrValue; 7899 xsNCName attrParam; 7900 7901 7902 public: //Accessors and Mutators 7903 /** 7904 * Gets the value array attribute. 7905 * @return Returns a domFloat4x4 reference of the value array attribute. 7906 */ 7907 domFloat4x4 &getValue() { return attrValue; } 7908 /** 7909 * Gets the value array attribute. 7910 * @return Returns a constant domFloat4x4 reference of the value array attribute. 7911 */ 7912 const domFloat4x4 &getValue() const { return attrValue; } 7913 /** 7914 * Sets the value array attribute. 7915 * @param atValue The new value for the value array attribute. 7916 */ 7917 void setValue( const domFloat4x4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7918 7919 /** 7920 * Gets the param attribute. 7921 * @return Returns a xsNCName of the param attribute. 7922 */ 7923 xsNCName getParam() const { return attrParam; } 7924 /** 7925 * Sets the param attribute. 7926 * @param atParam The new value for the param attribute. 7927 */ 7928 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 7929 7930 protected: 7931 /** 7932 * Constructor 7933 */ 7934 domProjection_matrix(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 7935 /** 7936 * Destructor 7937 */ 7938 virtual ~domProjection_matrix() {} 7939 /** 7940 * Overloaded assignment operator 7941 */ 7942 virtual domProjection_matrix &operator=( const domProjection_matrix &cpy ) { (void)cpy; return *this; } 7943 7944 public: // STATIC METHODS 7945 /** 7946 * Creates an instance of this class and returns a daeElementRef referencing it. 7947 * @return a daeElementRef referencing an instance of this object. 7948 */ 7949 static DLLSPEC daeElementRef create(DAE& dae); 7950 /** 7951 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 7952 * If a daeMetaElement already exists it will return that instead of creating a new one. 7953 * @return A daeMetaElement describing this COLLADA element. 7954 */ 7955 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 7956 }; 7957 7958 class domScissor; 7959 7960 typedef daeSmartRef<domScissor> domScissorRef; 7961 typedef daeTArray<domScissorRef> domScissor_Array; 7962 7963 class domScissor : public daeElement 7964 { 7965 public: 7966 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SCISSOR; } 7967 static daeInt ID() { return 331; } 7968 virtual daeInt typeID() const { return ID(); } 7969 protected: // Attributes 7970 domInt4 attrValue; 7971 xsNCName attrParam; 7972 7973 7974 public: //Accessors and Mutators 7975 /** 7976 * Gets the value array attribute. 7977 * @return Returns a domInt4 reference of the value array attribute. 7978 */ 7979 domInt4 &getValue() { return attrValue; } 7980 /** 7981 * Gets the value array attribute. 7982 * @return Returns a constant domInt4 reference of the value array attribute. 7983 */ 7984 const domInt4 &getValue() const { return attrValue; } 7985 /** 7986 * Sets the value array attribute. 7987 * @param atValue The new value for the value array attribute. 7988 */ 7989 void setValue( const domInt4 &atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 7990 7991 /** 7992 * Gets the param attribute. 7993 * @return Returns a xsNCName of the param attribute. 7994 */ 7995 xsNCName getParam() const { return attrParam; } 7996 /** 7997 * Sets the param attribute. 7998 * @param atParam The new value for the param attribute. 7999 */ 8000 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8001 8002 protected: 8003 /** 8004 * Constructor 8005 */ 8006 domScissor(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8007 /** 8008 * Destructor 8009 */ 8010 virtual ~domScissor() {} 8011 /** 8012 * Overloaded assignment operator 8013 */ 8014 virtual domScissor &operator=( const domScissor &cpy ) { (void)cpy; return *this; } 8015 8016 public: // STATIC METHODS 8017 /** 8018 * Creates an instance of this class and returns a daeElementRef referencing it. 8019 * @return a daeElementRef referencing an instance of this object. 8020 */ 8021 static DLLSPEC daeElementRef create(DAE& dae); 8022 /** 8023 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8024 * If a daeMetaElement already exists it will return that instead of creating a new one. 8025 * @return A daeMetaElement describing this COLLADA element. 8026 */ 8027 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8028 }; 8029 8030 class domStencil_mask; 8031 8032 typedef daeSmartRef<domStencil_mask> domStencil_maskRef; 8033 typedef daeTArray<domStencil_maskRef> domStencil_mask_Array; 8034 8035 class domStencil_mask : public daeElement 8036 { 8037 public: 8038 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_MASK; } 8039 static daeInt ID() { return 332; } 8040 virtual daeInt typeID() const { return ID(); } 8041 protected: // Attributes 8042 domInt attrValue; 8043 xsNCName attrParam; 8044 8045 8046 public: //Accessors and Mutators 8047 /** 8048 * Gets the value attribute. 8049 * @return Returns a domInt of the value attribute. 8050 */ 8051 domInt getValue() const { return attrValue; } 8052 /** 8053 * Sets the value attribute. 8054 * @param atValue The new value for the value attribute. 8055 */ 8056 void setValue( domInt atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8057 8058 /** 8059 * Gets the param attribute. 8060 * @return Returns a xsNCName of the param attribute. 8061 */ 8062 xsNCName getParam() const { return attrParam; } 8063 /** 8064 * Sets the param attribute. 8065 * @param atParam The new value for the param attribute. 8066 */ 8067 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8068 8069 protected: 8070 /** 8071 * Constructor 8072 */ 8073 domStencil_mask(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8074 /** 8075 * Destructor 8076 */ 8077 virtual ~domStencil_mask() {} 8078 /** 8079 * Overloaded assignment operator 8080 */ 8081 virtual domStencil_mask &operator=( const domStencil_mask &cpy ) { (void)cpy; return *this; } 8082 8083 public: // STATIC METHODS 8084 /** 8085 * Creates an instance of this class and returns a daeElementRef referencing it. 8086 * @return a daeElementRef referencing an instance of this object. 8087 */ 8088 static DLLSPEC daeElementRef create(DAE& dae); 8089 /** 8090 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8091 * If a daeMetaElement already exists it will return that instead of creating a new one. 8092 * @return A daeMetaElement describing this COLLADA element. 8093 */ 8094 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8095 }; 8096 8097 class domAlpha_test_enable; 8098 8099 typedef daeSmartRef<domAlpha_test_enable> domAlpha_test_enableRef; 8100 typedef daeTArray<domAlpha_test_enableRef> domAlpha_test_enable_Array; 8101 8102 class domAlpha_test_enable : public daeElement 8103 { 8104 public: 8105 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::ALPHA_TEST_ENABLE; } 8106 static daeInt ID() { return 333; } 8107 virtual daeInt typeID() const { return ID(); } 8108 protected: // Attributes 8109 domBool attrValue; 8110 xsNCName attrParam; 8111 8112 8113 public: //Accessors and Mutators 8114 /** 8115 * Gets the value attribute. 8116 * @return Returns a domBool of the value attribute. 8117 */ 8118 domBool getValue() const { return attrValue; } 8119 /** 8120 * Sets the value attribute. 8121 * @param atValue The new value for the value attribute. 8122 */ 8123 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8124 8125 /** 8126 * Gets the param attribute. 8127 * @return Returns a xsNCName of the param attribute. 8128 */ 8129 xsNCName getParam() const { return attrParam; } 8130 /** 8131 * Sets the param attribute. 8132 * @param atParam The new value for the param attribute. 8133 */ 8134 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8135 8136 protected: 8137 /** 8138 * Constructor 8139 */ 8140 domAlpha_test_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8141 /** 8142 * Destructor 8143 */ 8144 virtual ~domAlpha_test_enable() {} 8145 /** 8146 * Overloaded assignment operator 8147 */ 8148 virtual domAlpha_test_enable &operator=( const domAlpha_test_enable &cpy ) { (void)cpy; return *this; } 8149 8150 public: // STATIC METHODS 8151 /** 8152 * Creates an instance of this class and returns a daeElementRef referencing it. 8153 * @return a daeElementRef referencing an instance of this object. 8154 */ 8155 static DLLSPEC daeElementRef create(DAE& dae); 8156 /** 8157 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8158 * If a daeMetaElement already exists it will return that instead of creating a new one. 8159 * @return A daeMetaElement describing this COLLADA element. 8160 */ 8161 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8162 }; 8163 8164 class domAuto_normal_enable; 8165 8166 typedef daeSmartRef<domAuto_normal_enable> domAuto_normal_enableRef; 8167 typedef daeTArray<domAuto_normal_enableRef> domAuto_normal_enable_Array; 8168 8169 class domAuto_normal_enable : public daeElement 8170 { 8171 public: 8172 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::AUTO_NORMAL_ENABLE; } 8173 static daeInt ID() { return 334; } 8174 virtual daeInt typeID() const { return ID(); } 8175 protected: // Attributes 8176 domBool attrValue; 8177 xsNCName attrParam; 8178 8179 8180 public: //Accessors and Mutators 8181 /** 8182 * Gets the value attribute. 8183 * @return Returns a domBool of the value attribute. 8184 */ 8185 domBool getValue() const { return attrValue; } 8186 /** 8187 * Sets the value attribute. 8188 * @param atValue The new value for the value attribute. 8189 */ 8190 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8191 8192 /** 8193 * Gets the param attribute. 8194 * @return Returns a xsNCName of the param attribute. 8195 */ 8196 xsNCName getParam() const { return attrParam; } 8197 /** 8198 * Sets the param attribute. 8199 * @param atParam The new value for the param attribute. 8200 */ 8201 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8202 8203 protected: 8204 /** 8205 * Constructor 8206 */ 8207 domAuto_normal_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8208 /** 8209 * Destructor 8210 */ 8211 virtual ~domAuto_normal_enable() {} 8212 /** 8213 * Overloaded assignment operator 8214 */ 8215 virtual domAuto_normal_enable &operator=( const domAuto_normal_enable &cpy ) { (void)cpy; return *this; } 8216 8217 public: // STATIC METHODS 8218 /** 8219 * Creates an instance of this class and returns a daeElementRef referencing it. 8220 * @return a daeElementRef referencing an instance of this object. 8221 */ 8222 static DLLSPEC daeElementRef create(DAE& dae); 8223 /** 8224 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8225 * If a daeMetaElement already exists it will return that instead of creating a new one. 8226 * @return A daeMetaElement describing this COLLADA element. 8227 */ 8228 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8229 }; 8230 8231 class domBlend_enable; 8232 8233 typedef daeSmartRef<domBlend_enable> domBlend_enableRef; 8234 typedef daeTArray<domBlend_enableRef> domBlend_enable_Array; 8235 8236 class domBlend_enable : public daeElement 8237 { 8238 public: 8239 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::BLEND_ENABLE; } 8240 static daeInt ID() { return 335; } 8241 virtual daeInt typeID() const { return ID(); } 8242 protected: // Attributes 8243 domBool attrValue; 8244 xsNCName attrParam; 8245 8246 8247 public: //Accessors and Mutators 8248 /** 8249 * Gets the value attribute. 8250 * @return Returns a domBool of the value attribute. 8251 */ 8252 domBool getValue() const { return attrValue; } 8253 /** 8254 * Sets the value attribute. 8255 * @param atValue The new value for the value attribute. 8256 */ 8257 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8258 8259 /** 8260 * Gets the param attribute. 8261 * @return Returns a xsNCName of the param attribute. 8262 */ 8263 xsNCName getParam() const { return attrParam; } 8264 /** 8265 * Sets the param attribute. 8266 * @param atParam The new value for the param attribute. 8267 */ 8268 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8269 8270 protected: 8271 /** 8272 * Constructor 8273 */ 8274 domBlend_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8275 /** 8276 * Destructor 8277 */ 8278 virtual ~domBlend_enable() {} 8279 /** 8280 * Overloaded assignment operator 8281 */ 8282 virtual domBlend_enable &operator=( const domBlend_enable &cpy ) { (void)cpy; return *this; } 8283 8284 public: // STATIC METHODS 8285 /** 8286 * Creates an instance of this class and returns a daeElementRef referencing it. 8287 * @return a daeElementRef referencing an instance of this object. 8288 */ 8289 static DLLSPEC daeElementRef create(DAE& dae); 8290 /** 8291 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8292 * If a daeMetaElement already exists it will return that instead of creating a new one. 8293 * @return A daeMetaElement describing this COLLADA element. 8294 */ 8295 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8296 }; 8297 8298 class domColor_logic_op_enable; 8299 8300 typedef daeSmartRef<domColor_logic_op_enable> domColor_logic_op_enableRef; 8301 typedef daeTArray<domColor_logic_op_enableRef> domColor_logic_op_enable_Array; 8302 8303 class domColor_logic_op_enable : public daeElement 8304 { 8305 public: 8306 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::COLOR_LOGIC_OP_ENABLE; } 8307 static daeInt ID() { return 336; } 8308 virtual daeInt typeID() const { return ID(); } 8309 protected: // Attributes 8310 domBool attrValue; 8311 xsNCName attrParam; 8312 8313 8314 public: //Accessors and Mutators 8315 /** 8316 * Gets the value attribute. 8317 * @return Returns a domBool of the value attribute. 8318 */ 8319 domBool getValue() const { return attrValue; } 8320 /** 8321 * Sets the value attribute. 8322 * @param atValue The new value for the value attribute. 8323 */ 8324 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8325 8326 /** 8327 * Gets the param attribute. 8328 * @return Returns a xsNCName of the param attribute. 8329 */ 8330 xsNCName getParam() const { return attrParam; } 8331 /** 8332 * Sets the param attribute. 8333 * @param atParam The new value for the param attribute. 8334 */ 8335 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8336 8337 protected: 8338 /** 8339 * Constructor 8340 */ 8341 domColor_logic_op_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8342 /** 8343 * Destructor 8344 */ 8345 virtual ~domColor_logic_op_enable() {} 8346 /** 8347 * Overloaded assignment operator 8348 */ 8349 virtual domColor_logic_op_enable &operator=( const domColor_logic_op_enable &cpy ) { (void)cpy; return *this; } 8350 8351 public: // STATIC METHODS 8352 /** 8353 * Creates an instance of this class and returns a daeElementRef referencing it. 8354 * @return a daeElementRef referencing an instance of this object. 8355 */ 8356 static DLLSPEC daeElementRef create(DAE& dae); 8357 /** 8358 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8359 * If a daeMetaElement already exists it will return that instead of creating a new one. 8360 * @return A daeMetaElement describing this COLLADA element. 8361 */ 8362 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8363 }; 8364 8365 class domColor_material_enable; 8366 8367 typedef daeSmartRef<domColor_material_enable> domColor_material_enableRef; 8368 typedef daeTArray<domColor_material_enableRef> domColor_material_enable_Array; 8369 8370 class domColor_material_enable : public daeElement 8371 { 8372 public: 8373 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::COLOR_MATERIAL_ENABLE; } 8374 static daeInt ID() { return 337; } 8375 virtual daeInt typeID() const { return ID(); } 8376 protected: // Attributes 8377 domBool attrValue; 8378 xsNCName attrParam; 8379 8380 8381 public: //Accessors and Mutators 8382 /** 8383 * Gets the value attribute. 8384 * @return Returns a domBool of the value attribute. 8385 */ 8386 domBool getValue() const { return attrValue; } 8387 /** 8388 * Sets the value attribute. 8389 * @param atValue The new value for the value attribute. 8390 */ 8391 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8392 8393 /** 8394 * Gets the param attribute. 8395 * @return Returns a xsNCName of the param attribute. 8396 */ 8397 xsNCName getParam() const { return attrParam; } 8398 /** 8399 * Sets the param attribute. 8400 * @param atParam The new value for the param attribute. 8401 */ 8402 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8403 8404 protected: 8405 /** 8406 * Constructor 8407 */ 8408 domColor_material_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8409 /** 8410 * Destructor 8411 */ 8412 virtual ~domColor_material_enable() {} 8413 /** 8414 * Overloaded assignment operator 8415 */ 8416 virtual domColor_material_enable &operator=( const domColor_material_enable &cpy ) { (void)cpy; return *this; } 8417 8418 public: // STATIC METHODS 8419 /** 8420 * Creates an instance of this class and returns a daeElementRef referencing it. 8421 * @return a daeElementRef referencing an instance of this object. 8422 */ 8423 static DLLSPEC daeElementRef create(DAE& dae); 8424 /** 8425 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8426 * If a daeMetaElement already exists it will return that instead of creating a new one. 8427 * @return A daeMetaElement describing this COLLADA element. 8428 */ 8429 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8430 }; 8431 8432 class domCull_face_enable; 8433 8434 typedef daeSmartRef<domCull_face_enable> domCull_face_enableRef; 8435 typedef daeTArray<domCull_face_enableRef> domCull_face_enable_Array; 8436 8437 class domCull_face_enable : public daeElement 8438 { 8439 public: 8440 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::CULL_FACE_ENABLE; } 8441 static daeInt ID() { return 338; } 8442 virtual daeInt typeID() const { return ID(); } 8443 protected: // Attributes 8444 domBool attrValue; 8445 xsNCName attrParam; 8446 8447 8448 public: //Accessors and Mutators 8449 /** 8450 * Gets the value attribute. 8451 * @return Returns a domBool of the value attribute. 8452 */ 8453 domBool getValue() const { return attrValue; } 8454 /** 8455 * Sets the value attribute. 8456 * @param atValue The new value for the value attribute. 8457 */ 8458 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8459 8460 /** 8461 * Gets the param attribute. 8462 * @return Returns a xsNCName of the param attribute. 8463 */ 8464 xsNCName getParam() const { return attrParam; } 8465 /** 8466 * Sets the param attribute. 8467 * @param atParam The new value for the param attribute. 8468 */ 8469 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8470 8471 protected: 8472 /** 8473 * Constructor 8474 */ 8475 domCull_face_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8476 /** 8477 * Destructor 8478 */ 8479 virtual ~domCull_face_enable() {} 8480 /** 8481 * Overloaded assignment operator 8482 */ 8483 virtual domCull_face_enable &operator=( const domCull_face_enable &cpy ) { (void)cpy; return *this; } 8484 8485 public: // STATIC METHODS 8486 /** 8487 * Creates an instance of this class and returns a daeElementRef referencing it. 8488 * @return a daeElementRef referencing an instance of this object. 8489 */ 8490 static DLLSPEC daeElementRef create(DAE& dae); 8491 /** 8492 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8493 * If a daeMetaElement already exists it will return that instead of creating a new one. 8494 * @return A daeMetaElement describing this COLLADA element. 8495 */ 8496 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8497 }; 8498 8499 class domDepth_bounds_enable; 8500 8501 typedef daeSmartRef<domDepth_bounds_enable> domDepth_bounds_enableRef; 8502 typedef daeTArray<domDepth_bounds_enableRef> domDepth_bounds_enable_Array; 8503 8504 class domDepth_bounds_enable : public daeElement 8505 { 8506 public: 8507 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_BOUNDS_ENABLE; } 8508 static daeInt ID() { return 339; } 8509 virtual daeInt typeID() const { return ID(); } 8510 protected: // Attributes 8511 domBool attrValue; 8512 xsNCName attrParam; 8513 8514 8515 public: //Accessors and Mutators 8516 /** 8517 * Gets the value attribute. 8518 * @return Returns a domBool of the value attribute. 8519 */ 8520 domBool getValue() const { return attrValue; } 8521 /** 8522 * Sets the value attribute. 8523 * @param atValue The new value for the value attribute. 8524 */ 8525 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8526 8527 /** 8528 * Gets the param attribute. 8529 * @return Returns a xsNCName of the param attribute. 8530 */ 8531 xsNCName getParam() const { return attrParam; } 8532 /** 8533 * Sets the param attribute. 8534 * @param atParam The new value for the param attribute. 8535 */ 8536 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8537 8538 protected: 8539 /** 8540 * Constructor 8541 */ 8542 domDepth_bounds_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8543 /** 8544 * Destructor 8545 */ 8546 virtual ~domDepth_bounds_enable() {} 8547 /** 8548 * Overloaded assignment operator 8549 */ 8550 virtual domDepth_bounds_enable &operator=( const domDepth_bounds_enable &cpy ) { (void)cpy; return *this; } 8551 8552 public: // STATIC METHODS 8553 /** 8554 * Creates an instance of this class and returns a daeElementRef referencing it. 8555 * @return a daeElementRef referencing an instance of this object. 8556 */ 8557 static DLLSPEC daeElementRef create(DAE& dae); 8558 /** 8559 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8560 * If a daeMetaElement already exists it will return that instead of creating a new one. 8561 * @return A daeMetaElement describing this COLLADA element. 8562 */ 8563 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8564 }; 8565 8566 class domDepth_clamp_enable; 8567 8568 typedef daeSmartRef<domDepth_clamp_enable> domDepth_clamp_enableRef; 8569 typedef daeTArray<domDepth_clamp_enableRef> domDepth_clamp_enable_Array; 8570 8571 class domDepth_clamp_enable : public daeElement 8572 { 8573 public: 8574 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_CLAMP_ENABLE; } 8575 static daeInt ID() { return 340; } 8576 virtual daeInt typeID() const { return ID(); } 8577 protected: // Attributes 8578 domBool attrValue; 8579 xsNCName attrParam; 8580 8581 8582 public: //Accessors and Mutators 8583 /** 8584 * Gets the value attribute. 8585 * @return Returns a domBool of the value attribute. 8586 */ 8587 domBool getValue() const { return attrValue; } 8588 /** 8589 * Sets the value attribute. 8590 * @param atValue The new value for the value attribute. 8591 */ 8592 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8593 8594 /** 8595 * Gets the param attribute. 8596 * @return Returns a xsNCName of the param attribute. 8597 */ 8598 xsNCName getParam() const { return attrParam; } 8599 /** 8600 * Sets the param attribute. 8601 * @param atParam The new value for the param attribute. 8602 */ 8603 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8604 8605 protected: 8606 /** 8607 * Constructor 8608 */ 8609 domDepth_clamp_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8610 /** 8611 * Destructor 8612 */ 8613 virtual ~domDepth_clamp_enable() {} 8614 /** 8615 * Overloaded assignment operator 8616 */ 8617 virtual domDepth_clamp_enable &operator=( const domDepth_clamp_enable &cpy ) { (void)cpy; return *this; } 8618 8619 public: // STATIC METHODS 8620 /** 8621 * Creates an instance of this class and returns a daeElementRef referencing it. 8622 * @return a daeElementRef referencing an instance of this object. 8623 */ 8624 static DLLSPEC daeElementRef create(DAE& dae); 8625 /** 8626 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8627 * If a daeMetaElement already exists it will return that instead of creating a new one. 8628 * @return A daeMetaElement describing this COLLADA element. 8629 */ 8630 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8631 }; 8632 8633 class domDepth_test_enable; 8634 8635 typedef daeSmartRef<domDepth_test_enable> domDepth_test_enableRef; 8636 typedef daeTArray<domDepth_test_enableRef> domDepth_test_enable_Array; 8637 8638 class domDepth_test_enable : public daeElement 8639 { 8640 public: 8641 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DEPTH_TEST_ENABLE; } 8642 static daeInt ID() { return 341; } 8643 virtual daeInt typeID() const { return ID(); } 8644 protected: // Attributes 8645 domBool attrValue; 8646 xsNCName attrParam; 8647 8648 8649 public: //Accessors and Mutators 8650 /** 8651 * Gets the value attribute. 8652 * @return Returns a domBool of the value attribute. 8653 */ 8654 domBool getValue() const { return attrValue; } 8655 /** 8656 * Sets the value attribute. 8657 * @param atValue The new value for the value attribute. 8658 */ 8659 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8660 8661 /** 8662 * Gets the param attribute. 8663 * @return Returns a xsNCName of the param attribute. 8664 */ 8665 xsNCName getParam() const { return attrParam; } 8666 /** 8667 * Sets the param attribute. 8668 * @param atParam The new value for the param attribute. 8669 */ 8670 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8671 8672 protected: 8673 /** 8674 * Constructor 8675 */ 8676 domDepth_test_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8677 /** 8678 * Destructor 8679 */ 8680 virtual ~domDepth_test_enable() {} 8681 /** 8682 * Overloaded assignment operator 8683 */ 8684 virtual domDepth_test_enable &operator=( const domDepth_test_enable &cpy ) { (void)cpy; return *this; } 8685 8686 public: // STATIC METHODS 8687 /** 8688 * Creates an instance of this class and returns a daeElementRef referencing it. 8689 * @return a daeElementRef referencing an instance of this object. 8690 */ 8691 static DLLSPEC daeElementRef create(DAE& dae); 8692 /** 8693 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8694 * If a daeMetaElement already exists it will return that instead of creating a new one. 8695 * @return A daeMetaElement describing this COLLADA element. 8696 */ 8697 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8698 }; 8699 8700 class domDither_enable; 8701 8702 typedef daeSmartRef<domDither_enable> domDither_enableRef; 8703 typedef daeTArray<domDither_enableRef> domDither_enable_Array; 8704 8705 class domDither_enable : public daeElement 8706 { 8707 public: 8708 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::DITHER_ENABLE; } 8709 static daeInt ID() { return 342; } 8710 virtual daeInt typeID() const { return ID(); } 8711 protected: // Attributes 8712 domBool attrValue; 8713 xsNCName attrParam; 8714 8715 8716 public: //Accessors and Mutators 8717 /** 8718 * Gets the value attribute. 8719 * @return Returns a domBool of the value attribute. 8720 */ 8721 domBool getValue() const { return attrValue; } 8722 /** 8723 * Sets the value attribute. 8724 * @param atValue The new value for the value attribute. 8725 */ 8726 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8727 8728 /** 8729 * Gets the param attribute. 8730 * @return Returns a xsNCName of the param attribute. 8731 */ 8732 xsNCName getParam() const { return attrParam; } 8733 /** 8734 * Sets the param attribute. 8735 * @param atParam The new value for the param attribute. 8736 */ 8737 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8738 8739 protected: 8740 /** 8741 * Constructor 8742 */ 8743 domDither_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8744 /** 8745 * Destructor 8746 */ 8747 virtual ~domDither_enable() {} 8748 /** 8749 * Overloaded assignment operator 8750 */ 8751 virtual domDither_enable &operator=( const domDither_enable &cpy ) { (void)cpy; return *this; } 8752 8753 public: // STATIC METHODS 8754 /** 8755 * Creates an instance of this class and returns a daeElementRef referencing it. 8756 * @return a daeElementRef referencing an instance of this object. 8757 */ 8758 static DLLSPEC daeElementRef create(DAE& dae); 8759 /** 8760 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8761 * If a daeMetaElement already exists it will return that instead of creating a new one. 8762 * @return A daeMetaElement describing this COLLADA element. 8763 */ 8764 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8765 }; 8766 8767 class domFog_enable; 8768 8769 typedef daeSmartRef<domFog_enable> domFog_enableRef; 8770 typedef daeTArray<domFog_enableRef> domFog_enable_Array; 8771 8772 class domFog_enable : public daeElement 8773 { 8774 public: 8775 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::FOG_ENABLE; } 8776 static daeInt ID() { return 343; } 8777 virtual daeInt typeID() const { return ID(); } 8778 protected: // Attributes 8779 domBool attrValue; 8780 xsNCName attrParam; 8781 8782 8783 public: //Accessors and Mutators 8784 /** 8785 * Gets the value attribute. 8786 * @return Returns a domBool of the value attribute. 8787 */ 8788 domBool getValue() const { return attrValue; } 8789 /** 8790 * Sets the value attribute. 8791 * @param atValue The new value for the value attribute. 8792 */ 8793 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8794 8795 /** 8796 * Gets the param attribute. 8797 * @return Returns a xsNCName of the param attribute. 8798 */ 8799 xsNCName getParam() const { return attrParam; } 8800 /** 8801 * Sets the param attribute. 8802 * @param atParam The new value for the param attribute. 8803 */ 8804 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8805 8806 protected: 8807 /** 8808 * Constructor 8809 */ 8810 domFog_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8811 /** 8812 * Destructor 8813 */ 8814 virtual ~domFog_enable() {} 8815 /** 8816 * Overloaded assignment operator 8817 */ 8818 virtual domFog_enable &operator=( const domFog_enable &cpy ) { (void)cpy; return *this; } 8819 8820 public: // STATIC METHODS 8821 /** 8822 * Creates an instance of this class and returns a daeElementRef referencing it. 8823 * @return a daeElementRef referencing an instance of this object. 8824 */ 8825 static DLLSPEC daeElementRef create(DAE& dae); 8826 /** 8827 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8828 * If a daeMetaElement already exists it will return that instead of creating a new one. 8829 * @return A daeMetaElement describing this COLLADA element. 8830 */ 8831 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8832 }; 8833 8834 class domLight_model_local_viewer_enable; 8835 8836 typedef daeSmartRef<domLight_model_local_viewer_enable> domLight_model_local_viewer_enableRef; 8837 typedef daeTArray<domLight_model_local_viewer_enableRef> domLight_model_local_viewer_enable_Array; 8838 8839 class domLight_model_local_viewer_enable : public daeElement 8840 { 8841 public: 8842 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_MODEL_LOCAL_VIEWER_ENABLE; } 8843 static daeInt ID() { return 344; } 8844 virtual daeInt typeID() const { return ID(); } 8845 protected: // Attributes 8846 domBool attrValue; 8847 xsNCName attrParam; 8848 8849 8850 public: //Accessors and Mutators 8851 /** 8852 * Gets the value attribute. 8853 * @return Returns a domBool of the value attribute. 8854 */ 8855 domBool getValue() const { return attrValue; } 8856 /** 8857 * Sets the value attribute. 8858 * @param atValue The new value for the value attribute. 8859 */ 8860 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8861 8862 /** 8863 * Gets the param attribute. 8864 * @return Returns a xsNCName of the param attribute. 8865 */ 8866 xsNCName getParam() const { return attrParam; } 8867 /** 8868 * Sets the param attribute. 8869 * @param atParam The new value for the param attribute. 8870 */ 8871 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8872 8873 protected: 8874 /** 8875 * Constructor 8876 */ 8877 domLight_model_local_viewer_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8878 /** 8879 * Destructor 8880 */ 8881 virtual ~domLight_model_local_viewer_enable() {} 8882 /** 8883 * Overloaded assignment operator 8884 */ 8885 virtual domLight_model_local_viewer_enable &operator=( const domLight_model_local_viewer_enable &cpy ) { (void)cpy; return *this; } 8886 8887 public: // STATIC METHODS 8888 /** 8889 * Creates an instance of this class and returns a daeElementRef referencing it. 8890 * @return a daeElementRef referencing an instance of this object. 8891 */ 8892 static DLLSPEC daeElementRef create(DAE& dae); 8893 /** 8894 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8895 * If a daeMetaElement already exists it will return that instead of creating a new one. 8896 * @return A daeMetaElement describing this COLLADA element. 8897 */ 8898 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8899 }; 8900 8901 class domLight_model_two_side_enable; 8902 8903 typedef daeSmartRef<domLight_model_two_side_enable> domLight_model_two_side_enableRef; 8904 typedef daeTArray<domLight_model_two_side_enableRef> domLight_model_two_side_enable_Array; 8905 8906 class domLight_model_two_side_enable : public daeElement 8907 { 8908 public: 8909 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LIGHT_MODEL_TWO_SIDE_ENABLE; } 8910 static daeInt ID() { return 345; } 8911 virtual daeInt typeID() const { return ID(); } 8912 protected: // Attributes 8913 domBool attrValue; 8914 xsNCName attrParam; 8915 8916 8917 public: //Accessors and Mutators 8918 /** 8919 * Gets the value attribute. 8920 * @return Returns a domBool of the value attribute. 8921 */ 8922 domBool getValue() const { return attrValue; } 8923 /** 8924 * Sets the value attribute. 8925 * @param atValue The new value for the value attribute. 8926 */ 8927 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8928 8929 /** 8930 * Gets the param attribute. 8931 * @return Returns a xsNCName of the param attribute. 8932 */ 8933 xsNCName getParam() const { return attrParam; } 8934 /** 8935 * Sets the param attribute. 8936 * @param atParam The new value for the param attribute. 8937 */ 8938 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 8939 8940 protected: 8941 /** 8942 * Constructor 8943 */ 8944 domLight_model_two_side_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 8945 /** 8946 * Destructor 8947 */ 8948 virtual ~domLight_model_two_side_enable() {} 8949 /** 8950 * Overloaded assignment operator 8951 */ 8952 virtual domLight_model_two_side_enable &operator=( const domLight_model_two_side_enable &cpy ) { (void)cpy; return *this; } 8953 8954 public: // STATIC METHODS 8955 /** 8956 * Creates an instance of this class and returns a daeElementRef referencing it. 8957 * @return a daeElementRef referencing an instance of this object. 8958 */ 8959 static DLLSPEC daeElementRef create(DAE& dae); 8960 /** 8961 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 8962 * If a daeMetaElement already exists it will return that instead of creating a new one. 8963 * @return A daeMetaElement describing this COLLADA element. 8964 */ 8965 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 8966 }; 8967 8968 class domLine_smooth_enable; 8969 8970 typedef daeSmartRef<domLine_smooth_enable> domLine_smooth_enableRef; 8971 typedef daeTArray<domLine_smooth_enableRef> domLine_smooth_enable_Array; 8972 8973 class domLine_smooth_enable : public daeElement 8974 { 8975 public: 8976 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LINE_SMOOTH_ENABLE; } 8977 static daeInt ID() { return 346; } 8978 virtual daeInt typeID() const { return ID(); } 8979 protected: // Attributes 8980 domBool attrValue; 8981 xsNCName attrParam; 8982 8983 8984 public: //Accessors and Mutators 8985 /** 8986 * Gets the value attribute. 8987 * @return Returns a domBool of the value attribute. 8988 */ 8989 domBool getValue() const { return attrValue; } 8990 /** 8991 * Sets the value attribute. 8992 * @param atValue The new value for the value attribute. 8993 */ 8994 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 8995 8996 /** 8997 * Gets the param attribute. 8998 * @return Returns a xsNCName of the param attribute. 8999 */ 9000 xsNCName getParam() const { return attrParam; } 9001 /** 9002 * Sets the param attribute. 9003 * @param atParam The new value for the param attribute. 9004 */ 9005 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9006 9007 protected: 9008 /** 9009 * Constructor 9010 */ 9011 domLine_smooth_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9012 /** 9013 * Destructor 9014 */ 9015 virtual ~domLine_smooth_enable() {} 9016 /** 9017 * Overloaded assignment operator 9018 */ 9019 virtual domLine_smooth_enable &operator=( const domLine_smooth_enable &cpy ) { (void)cpy; return *this; } 9020 9021 public: // STATIC METHODS 9022 /** 9023 * Creates an instance of this class and returns a daeElementRef referencing it. 9024 * @return a daeElementRef referencing an instance of this object. 9025 */ 9026 static DLLSPEC daeElementRef create(DAE& dae); 9027 /** 9028 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9029 * If a daeMetaElement already exists it will return that instead of creating a new one. 9030 * @return A daeMetaElement describing this COLLADA element. 9031 */ 9032 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9033 }; 9034 9035 class domLine_stipple_enable; 9036 9037 typedef daeSmartRef<domLine_stipple_enable> domLine_stipple_enableRef; 9038 typedef daeTArray<domLine_stipple_enableRef> domLine_stipple_enable_Array; 9039 9040 class domLine_stipple_enable : public daeElement 9041 { 9042 public: 9043 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LINE_STIPPLE_ENABLE; } 9044 static daeInt ID() { return 347; } 9045 virtual daeInt typeID() const { return ID(); } 9046 protected: // Attributes 9047 domBool attrValue; 9048 xsNCName attrParam; 9049 9050 9051 public: //Accessors and Mutators 9052 /** 9053 * Gets the value attribute. 9054 * @return Returns a domBool of the value attribute. 9055 */ 9056 domBool getValue() const { return attrValue; } 9057 /** 9058 * Sets the value attribute. 9059 * @param atValue The new value for the value attribute. 9060 */ 9061 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9062 9063 /** 9064 * Gets the param attribute. 9065 * @return Returns a xsNCName of the param attribute. 9066 */ 9067 xsNCName getParam() const { return attrParam; } 9068 /** 9069 * Sets the param attribute. 9070 * @param atParam The new value for the param attribute. 9071 */ 9072 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9073 9074 protected: 9075 /** 9076 * Constructor 9077 */ 9078 domLine_stipple_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9079 /** 9080 * Destructor 9081 */ 9082 virtual ~domLine_stipple_enable() {} 9083 /** 9084 * Overloaded assignment operator 9085 */ 9086 virtual domLine_stipple_enable &operator=( const domLine_stipple_enable &cpy ) { (void)cpy; return *this; } 9087 9088 public: // STATIC METHODS 9089 /** 9090 * Creates an instance of this class and returns a daeElementRef referencing it. 9091 * @return a daeElementRef referencing an instance of this object. 9092 */ 9093 static DLLSPEC daeElementRef create(DAE& dae); 9094 /** 9095 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9096 * If a daeMetaElement already exists it will return that instead of creating a new one. 9097 * @return A daeMetaElement describing this COLLADA element. 9098 */ 9099 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9100 }; 9101 9102 class domLogic_op_enable; 9103 9104 typedef daeSmartRef<domLogic_op_enable> domLogic_op_enableRef; 9105 typedef daeTArray<domLogic_op_enableRef> domLogic_op_enable_Array; 9106 9107 class domLogic_op_enable : public daeElement 9108 { 9109 public: 9110 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::LOGIC_OP_ENABLE; } 9111 static daeInt ID() { return 348; } 9112 virtual daeInt typeID() const { return ID(); } 9113 protected: // Attributes 9114 domBool attrValue; 9115 xsNCName attrParam; 9116 9117 9118 public: //Accessors and Mutators 9119 /** 9120 * Gets the value attribute. 9121 * @return Returns a domBool of the value attribute. 9122 */ 9123 domBool getValue() const { return attrValue; } 9124 /** 9125 * Sets the value attribute. 9126 * @param atValue The new value for the value attribute. 9127 */ 9128 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9129 9130 /** 9131 * Gets the param attribute. 9132 * @return Returns a xsNCName of the param attribute. 9133 */ 9134 xsNCName getParam() const { return attrParam; } 9135 /** 9136 * Sets the param attribute. 9137 * @param atParam The new value for the param attribute. 9138 */ 9139 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9140 9141 protected: 9142 /** 9143 * Constructor 9144 */ 9145 domLogic_op_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9146 /** 9147 * Destructor 9148 */ 9149 virtual ~domLogic_op_enable() {} 9150 /** 9151 * Overloaded assignment operator 9152 */ 9153 virtual domLogic_op_enable &operator=( const domLogic_op_enable &cpy ) { (void)cpy; return *this; } 9154 9155 public: // STATIC METHODS 9156 /** 9157 * Creates an instance of this class and returns a daeElementRef referencing it. 9158 * @return a daeElementRef referencing an instance of this object. 9159 */ 9160 static DLLSPEC daeElementRef create(DAE& dae); 9161 /** 9162 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9163 * If a daeMetaElement already exists it will return that instead of creating a new one. 9164 * @return A daeMetaElement describing this COLLADA element. 9165 */ 9166 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9167 }; 9168 9169 class domMultisample_enable; 9170 9171 typedef daeSmartRef<domMultisample_enable> domMultisample_enableRef; 9172 typedef daeTArray<domMultisample_enableRef> domMultisample_enable_Array; 9173 9174 class domMultisample_enable : public daeElement 9175 { 9176 public: 9177 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::MULTISAMPLE_ENABLE; } 9178 static daeInt ID() { return 349; } 9179 virtual daeInt typeID() const { return ID(); } 9180 protected: // Attributes 9181 domBool attrValue; 9182 xsNCName attrParam; 9183 9184 9185 public: //Accessors and Mutators 9186 /** 9187 * Gets the value attribute. 9188 * @return Returns a domBool of the value attribute. 9189 */ 9190 domBool getValue() const { return attrValue; } 9191 /** 9192 * Sets the value attribute. 9193 * @param atValue The new value for the value attribute. 9194 */ 9195 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9196 9197 /** 9198 * Gets the param attribute. 9199 * @return Returns a xsNCName of the param attribute. 9200 */ 9201 xsNCName getParam() const { return attrParam; } 9202 /** 9203 * Sets the param attribute. 9204 * @param atParam The new value for the param attribute. 9205 */ 9206 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9207 9208 protected: 9209 /** 9210 * Constructor 9211 */ 9212 domMultisample_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9213 /** 9214 * Destructor 9215 */ 9216 virtual ~domMultisample_enable() {} 9217 /** 9218 * Overloaded assignment operator 9219 */ 9220 virtual domMultisample_enable &operator=( const domMultisample_enable &cpy ) { (void)cpy; return *this; } 9221 9222 public: // STATIC METHODS 9223 /** 9224 * Creates an instance of this class and returns a daeElementRef referencing it. 9225 * @return a daeElementRef referencing an instance of this object. 9226 */ 9227 static DLLSPEC daeElementRef create(DAE& dae); 9228 /** 9229 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9230 * If a daeMetaElement already exists it will return that instead of creating a new one. 9231 * @return A daeMetaElement describing this COLLADA element. 9232 */ 9233 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9234 }; 9235 9236 class domNormalize_enable; 9237 9238 typedef daeSmartRef<domNormalize_enable> domNormalize_enableRef; 9239 typedef daeTArray<domNormalize_enableRef> domNormalize_enable_Array; 9240 9241 class domNormalize_enable : public daeElement 9242 { 9243 public: 9244 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::NORMALIZE_ENABLE; } 9245 static daeInt ID() { return 350; } 9246 virtual daeInt typeID() const { return ID(); } 9247 protected: // Attributes 9248 domBool attrValue; 9249 xsNCName attrParam; 9250 9251 9252 public: //Accessors and Mutators 9253 /** 9254 * Gets the value attribute. 9255 * @return Returns a domBool of the value attribute. 9256 */ 9257 domBool getValue() const { return attrValue; } 9258 /** 9259 * Sets the value attribute. 9260 * @param atValue The new value for the value attribute. 9261 */ 9262 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9263 9264 /** 9265 * Gets the param attribute. 9266 * @return Returns a xsNCName of the param attribute. 9267 */ 9268 xsNCName getParam() const { return attrParam; } 9269 /** 9270 * Sets the param attribute. 9271 * @param atParam The new value for the param attribute. 9272 */ 9273 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9274 9275 protected: 9276 /** 9277 * Constructor 9278 */ 9279 domNormalize_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9280 /** 9281 * Destructor 9282 */ 9283 virtual ~domNormalize_enable() {} 9284 /** 9285 * Overloaded assignment operator 9286 */ 9287 virtual domNormalize_enable &operator=( const domNormalize_enable &cpy ) { (void)cpy; return *this; } 9288 9289 public: // STATIC METHODS 9290 /** 9291 * Creates an instance of this class and returns a daeElementRef referencing it. 9292 * @return a daeElementRef referencing an instance of this object. 9293 */ 9294 static DLLSPEC daeElementRef create(DAE& dae); 9295 /** 9296 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9297 * If a daeMetaElement already exists it will return that instead of creating a new one. 9298 * @return A daeMetaElement describing this COLLADA element. 9299 */ 9300 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9301 }; 9302 9303 class domPoint_smooth_enable; 9304 9305 typedef daeSmartRef<domPoint_smooth_enable> domPoint_smooth_enableRef; 9306 typedef daeTArray<domPoint_smooth_enableRef> domPoint_smooth_enable_Array; 9307 9308 class domPoint_smooth_enable : public daeElement 9309 { 9310 public: 9311 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POINT_SMOOTH_ENABLE; } 9312 static daeInt ID() { return 351; } 9313 virtual daeInt typeID() const { return ID(); } 9314 protected: // Attributes 9315 domBool attrValue; 9316 xsNCName attrParam; 9317 9318 9319 public: //Accessors and Mutators 9320 /** 9321 * Gets the value attribute. 9322 * @return Returns a domBool of the value attribute. 9323 */ 9324 domBool getValue() const { return attrValue; } 9325 /** 9326 * Sets the value attribute. 9327 * @param atValue The new value for the value attribute. 9328 */ 9329 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9330 9331 /** 9332 * Gets the param attribute. 9333 * @return Returns a xsNCName of the param attribute. 9334 */ 9335 xsNCName getParam() const { return attrParam; } 9336 /** 9337 * Sets the param attribute. 9338 * @param atParam The new value for the param attribute. 9339 */ 9340 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9341 9342 protected: 9343 /** 9344 * Constructor 9345 */ 9346 domPoint_smooth_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9347 /** 9348 * Destructor 9349 */ 9350 virtual ~domPoint_smooth_enable() {} 9351 /** 9352 * Overloaded assignment operator 9353 */ 9354 virtual domPoint_smooth_enable &operator=( const domPoint_smooth_enable &cpy ) { (void)cpy; return *this; } 9355 9356 public: // STATIC METHODS 9357 /** 9358 * Creates an instance of this class and returns a daeElementRef referencing it. 9359 * @return a daeElementRef referencing an instance of this object. 9360 */ 9361 static DLLSPEC daeElementRef create(DAE& dae); 9362 /** 9363 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9364 * If a daeMetaElement already exists it will return that instead of creating a new one. 9365 * @return A daeMetaElement describing this COLLADA element. 9366 */ 9367 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9368 }; 9369 9370 class domPolygon_offset_fill_enable; 9371 9372 typedef daeSmartRef<domPolygon_offset_fill_enable> domPolygon_offset_fill_enableRef; 9373 typedef daeTArray<domPolygon_offset_fill_enableRef> domPolygon_offset_fill_enable_Array; 9374 9375 class domPolygon_offset_fill_enable : public daeElement 9376 { 9377 public: 9378 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_OFFSET_FILL_ENABLE; } 9379 static daeInt ID() { return 352; } 9380 virtual daeInt typeID() const { return ID(); } 9381 protected: // Attributes 9382 domBool attrValue; 9383 xsNCName attrParam; 9384 9385 9386 public: //Accessors and Mutators 9387 /** 9388 * Gets the value attribute. 9389 * @return Returns a domBool of the value attribute. 9390 */ 9391 domBool getValue() const { return attrValue; } 9392 /** 9393 * Sets the value attribute. 9394 * @param atValue The new value for the value attribute. 9395 */ 9396 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9397 9398 /** 9399 * Gets the param attribute. 9400 * @return Returns a xsNCName of the param attribute. 9401 */ 9402 xsNCName getParam() const { return attrParam; } 9403 /** 9404 * Sets the param attribute. 9405 * @param atParam The new value for the param attribute. 9406 */ 9407 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9408 9409 protected: 9410 /** 9411 * Constructor 9412 */ 9413 domPolygon_offset_fill_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9414 /** 9415 * Destructor 9416 */ 9417 virtual ~domPolygon_offset_fill_enable() {} 9418 /** 9419 * Overloaded assignment operator 9420 */ 9421 virtual domPolygon_offset_fill_enable &operator=( const domPolygon_offset_fill_enable &cpy ) { (void)cpy; return *this; } 9422 9423 public: // STATIC METHODS 9424 /** 9425 * Creates an instance of this class and returns a daeElementRef referencing it. 9426 * @return a daeElementRef referencing an instance of this object. 9427 */ 9428 static DLLSPEC daeElementRef create(DAE& dae); 9429 /** 9430 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9431 * If a daeMetaElement already exists it will return that instead of creating a new one. 9432 * @return A daeMetaElement describing this COLLADA element. 9433 */ 9434 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9435 }; 9436 9437 class domPolygon_offset_line_enable; 9438 9439 typedef daeSmartRef<domPolygon_offset_line_enable> domPolygon_offset_line_enableRef; 9440 typedef daeTArray<domPolygon_offset_line_enableRef> domPolygon_offset_line_enable_Array; 9441 9442 class domPolygon_offset_line_enable : public daeElement 9443 { 9444 public: 9445 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_OFFSET_LINE_ENABLE; } 9446 static daeInt ID() { return 353; } 9447 virtual daeInt typeID() const { return ID(); } 9448 protected: // Attributes 9449 domBool attrValue; 9450 xsNCName attrParam; 9451 9452 9453 public: //Accessors and Mutators 9454 /** 9455 * Gets the value attribute. 9456 * @return Returns a domBool of the value attribute. 9457 */ 9458 domBool getValue() const { return attrValue; } 9459 /** 9460 * Sets the value attribute. 9461 * @param atValue The new value for the value attribute. 9462 */ 9463 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9464 9465 /** 9466 * Gets the param attribute. 9467 * @return Returns a xsNCName of the param attribute. 9468 */ 9469 xsNCName getParam() const { return attrParam; } 9470 /** 9471 * Sets the param attribute. 9472 * @param atParam The new value for the param attribute. 9473 */ 9474 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9475 9476 protected: 9477 /** 9478 * Constructor 9479 */ 9480 domPolygon_offset_line_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9481 /** 9482 * Destructor 9483 */ 9484 virtual ~domPolygon_offset_line_enable() {} 9485 /** 9486 * Overloaded assignment operator 9487 */ 9488 virtual domPolygon_offset_line_enable &operator=( const domPolygon_offset_line_enable &cpy ) { (void)cpy; return *this; } 9489 9490 public: // STATIC METHODS 9491 /** 9492 * Creates an instance of this class and returns a daeElementRef referencing it. 9493 * @return a daeElementRef referencing an instance of this object. 9494 */ 9495 static DLLSPEC daeElementRef create(DAE& dae); 9496 /** 9497 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9498 * If a daeMetaElement already exists it will return that instead of creating a new one. 9499 * @return A daeMetaElement describing this COLLADA element. 9500 */ 9501 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9502 }; 9503 9504 class domPolygon_offset_point_enable; 9505 9506 typedef daeSmartRef<domPolygon_offset_point_enable> domPolygon_offset_point_enableRef; 9507 typedef daeTArray<domPolygon_offset_point_enableRef> domPolygon_offset_point_enable_Array; 9508 9509 class domPolygon_offset_point_enable : public daeElement 9510 { 9511 public: 9512 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_OFFSET_POINT_ENABLE; } 9513 static daeInt ID() { return 354; } 9514 virtual daeInt typeID() const { return ID(); } 9515 protected: // Attributes 9516 domBool attrValue; 9517 xsNCName attrParam; 9518 9519 9520 public: //Accessors and Mutators 9521 /** 9522 * Gets the value attribute. 9523 * @return Returns a domBool of the value attribute. 9524 */ 9525 domBool getValue() const { return attrValue; } 9526 /** 9527 * Sets the value attribute. 9528 * @param atValue The new value for the value attribute. 9529 */ 9530 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9531 9532 /** 9533 * Gets the param attribute. 9534 * @return Returns a xsNCName of the param attribute. 9535 */ 9536 xsNCName getParam() const { return attrParam; } 9537 /** 9538 * Sets the param attribute. 9539 * @param atParam The new value for the param attribute. 9540 */ 9541 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9542 9543 protected: 9544 /** 9545 * Constructor 9546 */ 9547 domPolygon_offset_point_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9548 /** 9549 * Destructor 9550 */ 9551 virtual ~domPolygon_offset_point_enable() {} 9552 /** 9553 * Overloaded assignment operator 9554 */ 9555 virtual domPolygon_offset_point_enable &operator=( const domPolygon_offset_point_enable &cpy ) { (void)cpy; return *this; } 9556 9557 public: // STATIC METHODS 9558 /** 9559 * Creates an instance of this class and returns a daeElementRef referencing it. 9560 * @return a daeElementRef referencing an instance of this object. 9561 */ 9562 static DLLSPEC daeElementRef create(DAE& dae); 9563 /** 9564 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9565 * If a daeMetaElement already exists it will return that instead of creating a new one. 9566 * @return A daeMetaElement describing this COLLADA element. 9567 */ 9568 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9569 }; 9570 9571 class domPolygon_smooth_enable; 9572 9573 typedef daeSmartRef<domPolygon_smooth_enable> domPolygon_smooth_enableRef; 9574 typedef daeTArray<domPolygon_smooth_enableRef> domPolygon_smooth_enable_Array; 9575 9576 class domPolygon_smooth_enable : public daeElement 9577 { 9578 public: 9579 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_SMOOTH_ENABLE; } 9580 static daeInt ID() { return 355; } 9581 virtual daeInt typeID() const { return ID(); } 9582 protected: // Attributes 9583 domBool attrValue; 9584 xsNCName attrParam; 9585 9586 9587 public: //Accessors and Mutators 9588 /** 9589 * Gets the value attribute. 9590 * @return Returns a domBool of the value attribute. 9591 */ 9592 domBool getValue() const { return attrValue; } 9593 /** 9594 * Sets the value attribute. 9595 * @param atValue The new value for the value attribute. 9596 */ 9597 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9598 9599 /** 9600 * Gets the param attribute. 9601 * @return Returns a xsNCName of the param attribute. 9602 */ 9603 xsNCName getParam() const { return attrParam; } 9604 /** 9605 * Sets the param attribute. 9606 * @param atParam The new value for the param attribute. 9607 */ 9608 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9609 9610 protected: 9611 /** 9612 * Constructor 9613 */ 9614 domPolygon_smooth_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9615 /** 9616 * Destructor 9617 */ 9618 virtual ~domPolygon_smooth_enable() {} 9619 /** 9620 * Overloaded assignment operator 9621 */ 9622 virtual domPolygon_smooth_enable &operator=( const domPolygon_smooth_enable &cpy ) { (void)cpy; return *this; } 9623 9624 public: // STATIC METHODS 9625 /** 9626 * Creates an instance of this class and returns a daeElementRef referencing it. 9627 * @return a daeElementRef referencing an instance of this object. 9628 */ 9629 static DLLSPEC daeElementRef create(DAE& dae); 9630 /** 9631 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9632 * If a daeMetaElement already exists it will return that instead of creating a new one. 9633 * @return A daeMetaElement describing this COLLADA element. 9634 */ 9635 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9636 }; 9637 9638 class domPolygon_stipple_enable; 9639 9640 typedef daeSmartRef<domPolygon_stipple_enable> domPolygon_stipple_enableRef; 9641 typedef daeTArray<domPolygon_stipple_enableRef> domPolygon_stipple_enable_Array; 9642 9643 class domPolygon_stipple_enable : public daeElement 9644 { 9645 public: 9646 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::POLYGON_STIPPLE_ENABLE; } 9647 static daeInt ID() { return 356; } 9648 virtual daeInt typeID() const { return ID(); } 9649 protected: // Attributes 9650 domBool attrValue; 9651 xsNCName attrParam; 9652 9653 9654 public: //Accessors and Mutators 9655 /** 9656 * Gets the value attribute. 9657 * @return Returns a domBool of the value attribute. 9658 */ 9659 domBool getValue() const { return attrValue; } 9660 /** 9661 * Sets the value attribute. 9662 * @param atValue The new value for the value attribute. 9663 */ 9664 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9665 9666 /** 9667 * Gets the param attribute. 9668 * @return Returns a xsNCName of the param attribute. 9669 */ 9670 xsNCName getParam() const { return attrParam; } 9671 /** 9672 * Sets the param attribute. 9673 * @param atParam The new value for the param attribute. 9674 */ 9675 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9676 9677 protected: 9678 /** 9679 * Constructor 9680 */ 9681 domPolygon_stipple_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9682 /** 9683 * Destructor 9684 */ 9685 virtual ~domPolygon_stipple_enable() {} 9686 /** 9687 * Overloaded assignment operator 9688 */ 9689 virtual domPolygon_stipple_enable &operator=( const domPolygon_stipple_enable &cpy ) { (void)cpy; return *this; } 9690 9691 public: // STATIC METHODS 9692 /** 9693 * Creates an instance of this class and returns a daeElementRef referencing it. 9694 * @return a daeElementRef referencing an instance of this object. 9695 */ 9696 static DLLSPEC daeElementRef create(DAE& dae); 9697 /** 9698 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9699 * If a daeMetaElement already exists it will return that instead of creating a new one. 9700 * @return A daeMetaElement describing this COLLADA element. 9701 */ 9702 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9703 }; 9704 9705 class domRescale_normal_enable; 9706 9707 typedef daeSmartRef<domRescale_normal_enable> domRescale_normal_enableRef; 9708 typedef daeTArray<domRescale_normal_enableRef> domRescale_normal_enable_Array; 9709 9710 class domRescale_normal_enable : public daeElement 9711 { 9712 public: 9713 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::RESCALE_NORMAL_ENABLE; } 9714 static daeInt ID() { return 357; } 9715 virtual daeInt typeID() const { return ID(); } 9716 protected: // Attributes 9717 domBool attrValue; 9718 xsNCName attrParam; 9719 9720 9721 public: //Accessors and Mutators 9722 /** 9723 * Gets the value attribute. 9724 * @return Returns a domBool of the value attribute. 9725 */ 9726 domBool getValue() const { return attrValue; } 9727 /** 9728 * Sets the value attribute. 9729 * @param atValue The new value for the value attribute. 9730 */ 9731 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9732 9733 /** 9734 * Gets the param attribute. 9735 * @return Returns a xsNCName of the param attribute. 9736 */ 9737 xsNCName getParam() const { return attrParam; } 9738 /** 9739 * Sets the param attribute. 9740 * @param atParam The new value for the param attribute. 9741 */ 9742 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9743 9744 protected: 9745 /** 9746 * Constructor 9747 */ 9748 domRescale_normal_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9749 /** 9750 * Destructor 9751 */ 9752 virtual ~domRescale_normal_enable() {} 9753 /** 9754 * Overloaded assignment operator 9755 */ 9756 virtual domRescale_normal_enable &operator=( const domRescale_normal_enable &cpy ) { (void)cpy; return *this; } 9757 9758 public: // STATIC METHODS 9759 /** 9760 * Creates an instance of this class and returns a daeElementRef referencing it. 9761 * @return a daeElementRef referencing an instance of this object. 9762 */ 9763 static DLLSPEC daeElementRef create(DAE& dae); 9764 /** 9765 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9766 * If a daeMetaElement already exists it will return that instead of creating a new one. 9767 * @return A daeMetaElement describing this COLLADA element. 9768 */ 9769 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9770 }; 9771 9772 class domSample_alpha_to_coverage_enable; 9773 9774 typedef daeSmartRef<domSample_alpha_to_coverage_enable> domSample_alpha_to_coverage_enableRef; 9775 typedef daeTArray<domSample_alpha_to_coverage_enableRef> domSample_alpha_to_coverage_enable_Array; 9776 9777 class domSample_alpha_to_coverage_enable : public daeElement 9778 { 9779 public: 9780 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SAMPLE_ALPHA_TO_COVERAGE_ENABLE; } 9781 static daeInt ID() { return 358; } 9782 virtual daeInt typeID() const { return ID(); } 9783 protected: // Attributes 9784 domBool attrValue; 9785 xsNCName attrParam; 9786 9787 9788 public: //Accessors and Mutators 9789 /** 9790 * Gets the value attribute. 9791 * @return Returns a domBool of the value attribute. 9792 */ 9793 domBool getValue() const { return attrValue; } 9794 /** 9795 * Sets the value attribute. 9796 * @param atValue The new value for the value attribute. 9797 */ 9798 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9799 9800 /** 9801 * Gets the param attribute. 9802 * @return Returns a xsNCName of the param attribute. 9803 */ 9804 xsNCName getParam() const { return attrParam; } 9805 /** 9806 * Sets the param attribute. 9807 * @param atParam The new value for the param attribute. 9808 */ 9809 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9810 9811 protected: 9812 /** 9813 * Constructor 9814 */ 9815 domSample_alpha_to_coverage_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9816 /** 9817 * Destructor 9818 */ 9819 virtual ~domSample_alpha_to_coverage_enable() {} 9820 /** 9821 * Overloaded assignment operator 9822 */ 9823 virtual domSample_alpha_to_coverage_enable &operator=( const domSample_alpha_to_coverage_enable &cpy ) { (void)cpy; return *this; } 9824 9825 public: // STATIC METHODS 9826 /** 9827 * Creates an instance of this class and returns a daeElementRef referencing it. 9828 * @return a daeElementRef referencing an instance of this object. 9829 */ 9830 static DLLSPEC daeElementRef create(DAE& dae); 9831 /** 9832 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9833 * If a daeMetaElement already exists it will return that instead of creating a new one. 9834 * @return A daeMetaElement describing this COLLADA element. 9835 */ 9836 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9837 }; 9838 9839 class domSample_alpha_to_one_enable; 9840 9841 typedef daeSmartRef<domSample_alpha_to_one_enable> domSample_alpha_to_one_enableRef; 9842 typedef daeTArray<domSample_alpha_to_one_enableRef> domSample_alpha_to_one_enable_Array; 9843 9844 class domSample_alpha_to_one_enable : public daeElement 9845 { 9846 public: 9847 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SAMPLE_ALPHA_TO_ONE_ENABLE; } 9848 static daeInt ID() { return 359; } 9849 virtual daeInt typeID() const { return ID(); } 9850 protected: // Attributes 9851 domBool attrValue; 9852 xsNCName attrParam; 9853 9854 9855 public: //Accessors and Mutators 9856 /** 9857 * Gets the value attribute. 9858 * @return Returns a domBool of the value attribute. 9859 */ 9860 domBool getValue() const { return attrValue; } 9861 /** 9862 * Sets the value attribute. 9863 * @param atValue The new value for the value attribute. 9864 */ 9865 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9866 9867 /** 9868 * Gets the param attribute. 9869 * @return Returns a xsNCName of the param attribute. 9870 */ 9871 xsNCName getParam() const { return attrParam; } 9872 /** 9873 * Sets the param attribute. 9874 * @param atParam The new value for the param attribute. 9875 */ 9876 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9877 9878 protected: 9879 /** 9880 * Constructor 9881 */ 9882 domSample_alpha_to_one_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9883 /** 9884 * Destructor 9885 */ 9886 virtual ~domSample_alpha_to_one_enable() {} 9887 /** 9888 * Overloaded assignment operator 9889 */ 9890 virtual domSample_alpha_to_one_enable &operator=( const domSample_alpha_to_one_enable &cpy ) { (void)cpy; return *this; } 9891 9892 public: // STATIC METHODS 9893 /** 9894 * Creates an instance of this class and returns a daeElementRef referencing it. 9895 * @return a daeElementRef referencing an instance of this object. 9896 */ 9897 static DLLSPEC daeElementRef create(DAE& dae); 9898 /** 9899 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9900 * If a daeMetaElement already exists it will return that instead of creating a new one. 9901 * @return A daeMetaElement describing this COLLADA element. 9902 */ 9903 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9904 }; 9905 9906 class domSample_coverage_enable; 9907 9908 typedef daeSmartRef<domSample_coverage_enable> domSample_coverage_enableRef; 9909 typedef daeTArray<domSample_coverage_enableRef> domSample_coverage_enable_Array; 9910 9911 class domSample_coverage_enable : public daeElement 9912 { 9913 public: 9914 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SAMPLE_COVERAGE_ENABLE; } 9915 static daeInt ID() { return 360; } 9916 virtual daeInt typeID() const { return ID(); } 9917 protected: // Attributes 9918 domBool attrValue; 9919 xsNCName attrParam; 9920 9921 9922 public: //Accessors and Mutators 9923 /** 9924 * Gets the value attribute. 9925 * @return Returns a domBool of the value attribute. 9926 */ 9927 domBool getValue() const { return attrValue; } 9928 /** 9929 * Sets the value attribute. 9930 * @param atValue The new value for the value attribute. 9931 */ 9932 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 9933 9934 /** 9935 * Gets the param attribute. 9936 * @return Returns a xsNCName of the param attribute. 9937 */ 9938 xsNCName getParam() const { return attrParam; } 9939 /** 9940 * Sets the param attribute. 9941 * @param atParam The new value for the param attribute. 9942 */ 9943 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 9944 9945 protected: 9946 /** 9947 * Constructor 9948 */ 9949 domSample_coverage_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 9950 /** 9951 * Destructor 9952 */ 9953 virtual ~domSample_coverage_enable() {} 9954 /** 9955 * Overloaded assignment operator 9956 */ 9957 virtual domSample_coverage_enable &operator=( const domSample_coverage_enable &cpy ) { (void)cpy; return *this; } 9958 9959 public: // STATIC METHODS 9960 /** 9961 * Creates an instance of this class and returns a daeElementRef referencing it. 9962 * @return a daeElementRef referencing an instance of this object. 9963 */ 9964 static DLLSPEC daeElementRef create(DAE& dae); 9965 /** 9966 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 9967 * If a daeMetaElement already exists it will return that instead of creating a new one. 9968 * @return A daeMetaElement describing this COLLADA element. 9969 */ 9970 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 9971 }; 9972 9973 class domScissor_test_enable; 9974 9975 typedef daeSmartRef<domScissor_test_enable> domScissor_test_enableRef; 9976 typedef daeTArray<domScissor_test_enableRef> domScissor_test_enable_Array; 9977 9978 class domScissor_test_enable : public daeElement 9979 { 9980 public: 9981 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::SCISSOR_TEST_ENABLE; } 9982 static daeInt ID() { return 361; } 9983 virtual daeInt typeID() const { return ID(); } 9984 protected: // Attributes 9985 domBool attrValue; 9986 xsNCName attrParam; 9987 9988 9989 public: //Accessors and Mutators 9990 /** 9991 * Gets the value attribute. 9992 * @return Returns a domBool of the value attribute. 9993 */ 9994 domBool getValue() const { return attrValue; } 9995 /** 9996 * Sets the value attribute. 9997 * @param atValue The new value for the value attribute. 9998 */ 9999 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 10000 10001 /** 10002 * Gets the param attribute. 10003 * @return Returns a xsNCName of the param attribute. 10004 */ 10005 xsNCName getParam() const { return attrParam; } 10006 /** 10007 * Sets the param attribute. 10008 * @param atParam The new value for the param attribute. 10009 */ 10010 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 10011 10012 protected: 10013 /** 10014 * Constructor 10015 */ 10016 domScissor_test_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 10017 /** 10018 * Destructor 10019 */ 10020 virtual ~domScissor_test_enable() {} 10021 /** 10022 * Overloaded assignment operator 10023 */ 10024 virtual domScissor_test_enable &operator=( const domScissor_test_enable &cpy ) { (void)cpy; return *this; } 10025 10026 public: // STATIC METHODS 10027 /** 10028 * Creates an instance of this class and returns a daeElementRef referencing it. 10029 * @return a daeElementRef referencing an instance of this object. 10030 */ 10031 static DLLSPEC daeElementRef create(DAE& dae); 10032 /** 10033 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 10034 * If a daeMetaElement already exists it will return that instead of creating a new one. 10035 * @return A daeMetaElement describing this COLLADA element. 10036 */ 10037 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 10038 }; 10039 10040 class domStencil_test_enable; 10041 10042 typedef daeSmartRef<domStencil_test_enable> domStencil_test_enableRef; 10043 typedef daeTArray<domStencil_test_enableRef> domStencil_test_enable_Array; 10044 10045 class domStencil_test_enable : public daeElement 10046 { 10047 public: 10048 virtual COLLADA_TYPE::TypeEnum getElementType() const { return COLLADA_TYPE::STENCIL_TEST_ENABLE; } 10049 static daeInt ID() { return 362; } 10050 virtual daeInt typeID() const { return ID(); } 10051 protected: // Attributes 10052 domBool attrValue; 10053 xsNCName attrParam; 10054 10055 10056 public: //Accessors and Mutators 10057 /** 10058 * Gets the value attribute. 10059 * @return Returns a domBool of the value attribute. 10060 */ 10061 domBool getValue() const { return attrValue; } 10062 /** 10063 * Sets the value attribute. 10064 * @param atValue The new value for the value attribute. 10065 */ 10066 void setValue( domBool atValue ) { attrValue = atValue; _validAttributeArray[0] = true; } 10067 10068 /** 10069 * Gets the param attribute. 10070 * @return Returns a xsNCName of the param attribute. 10071 */ 10072 xsNCName getParam() const { return attrParam; } 10073 /** 10074 * Sets the param attribute. 10075 * @param atParam The new value for the param attribute. 10076 */ 10077 void setParam( xsNCName atParam ) { *(daeStringRef*)&attrParam = atParam; _validAttributeArray[1] = true; } 10078 10079 protected: 10080 /** 10081 * Constructor 10082 */ 10083 domStencil_test_enable(DAE& dae) : daeElement(dae), attrValue(), attrParam() {} 10084 /** 10085 * Destructor 10086 */ 10087 virtual ~domStencil_test_enable() {} 10088 /** 10089 * Overloaded assignment operator 10090 */ 10091 virtual domStencil_test_enable &operator=( const domStencil_test_enable &cpy ) { (void)cpy; return *this; } 10092 10093 public: // STATIC METHODS 10094 /** 10095 * Creates an instance of this class and returns a daeElementRef referencing it. 10096 * @return a daeElementRef referencing an instance of this object. 10097 */ 10098 static DLLSPEC daeElementRef create(DAE& dae); 10099 /** 10100 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 10101 * If a daeMetaElement already exists it will return that instead of creating a new one. 10102 * @return A daeMetaElement describing this COLLADA element. 10103 */ 10104 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 10105 }; 10106 10107 10108 10109 protected: // Elements 10110 domAlpha_funcRef elemAlpha_func; 10111 domBlend_funcRef elemBlend_func; 10112 domBlend_func_separateRef elemBlend_func_separate; 10113 domBlend_equationRef elemBlend_equation; 10114 domBlend_equation_separateRef elemBlend_equation_separate; 10115 domColor_materialRef elemColor_material; 10116 domCull_faceRef elemCull_face; 10117 domDepth_funcRef elemDepth_func; 10118 domFog_modeRef elemFog_mode; 10119 domFog_coord_srcRef elemFog_coord_src; 10120 domFront_faceRef elemFront_face; 10121 domLight_model_color_controlRef elemLight_model_color_control; 10122 domLogic_opRef elemLogic_op; 10123 domPolygon_modeRef elemPolygon_mode; 10124 domShade_modelRef elemShade_model; 10125 domStencil_funcRef elemStencil_func; 10126 domStencil_opRef elemStencil_op; 10127 domStencil_func_separateRef elemStencil_func_separate; 10128 domStencil_op_separateRef elemStencil_op_separate; 10129 domStencil_mask_separateRef elemStencil_mask_separate; 10130 domLight_enableRef elemLight_enable; 10131 domLight_ambientRef elemLight_ambient; 10132 domLight_diffuseRef elemLight_diffuse; 10133 domLight_specularRef elemLight_specular; 10134 domLight_positionRef elemLight_position; 10135 domLight_constant_attenuationRef elemLight_constant_attenuation; 10136 domLight_linear_attenuationRef elemLight_linear_attenuation; 10137 domLight_quadratic_attenuationRef elemLight_quadratic_attenuation; 10138 domLight_spot_cutoffRef elemLight_spot_cutoff; 10139 domLight_spot_directionRef elemLight_spot_direction; 10140 domLight_spot_exponentRef elemLight_spot_exponent; 10141 domTexture1DRef elemTexture1D; 10142 domTexture2DRef elemTexture2D; 10143 domTexture3DRef elemTexture3D; 10144 domTextureCUBERef elemTextureCUBE; 10145 domTextureRECTRef elemTextureRECT; 10146 domTextureDEPTHRef elemTextureDEPTH; 10147 domTexture1D_enableRef elemTexture1D_enable; 10148 domTexture2D_enableRef elemTexture2D_enable; 10149 domTexture3D_enableRef elemTexture3D_enable; 10150 domTextureCUBE_enableRef elemTextureCUBE_enable; 10151 domTextureRECT_enableRef elemTextureRECT_enable; 10152 domTextureDEPTH_enableRef elemTextureDEPTH_enable; 10153 domTexture_env_colorRef elemTexture_env_color; 10154 domTexture_env_modeRef elemTexture_env_mode; 10155 domClip_planeRef elemClip_plane; 10156 domClip_plane_enableRef elemClip_plane_enable; 10157 domBlend_colorRef elemBlend_color; 10158 domClear_colorRef elemClear_color; 10159 domClear_stencilRef elemClear_stencil; 10160 domClear_depthRef elemClear_depth; 10161 domColor_maskRef elemColor_mask; 10162 domDepth_boundsRef elemDepth_bounds; 10163 domDepth_maskRef elemDepth_mask; 10164 domDepth_rangeRef elemDepth_range; 10165 domFog_densityRef elemFog_density; 10166 domFog_startRef elemFog_start; 10167 domFog_endRef elemFog_end; 10168 domFog_colorRef elemFog_color; 10169 domLight_model_ambientRef elemLight_model_ambient; 10170 domLighting_enableRef elemLighting_enable; 10171 domLine_stippleRef elemLine_stipple; 10172 domLine_widthRef elemLine_width; 10173 domMaterial_ambientRef elemMaterial_ambient; 10174 domMaterial_diffuseRef elemMaterial_diffuse; 10175 domMaterial_emissionRef elemMaterial_emission; 10176 domMaterial_shininessRef elemMaterial_shininess; 10177 domMaterial_specularRef elemMaterial_specular; 10178 domModel_view_matrixRef elemModel_view_matrix; 10179 domPoint_distance_attenuationRef elemPoint_distance_attenuation; 10180 domPoint_fade_threshold_sizeRef elemPoint_fade_threshold_size; 10181 domPoint_sizeRef elemPoint_size; 10182 domPoint_size_minRef elemPoint_size_min; 10183 domPoint_size_maxRef elemPoint_size_max; 10184 domPolygon_offsetRef elemPolygon_offset; 10185 domProjection_matrixRef elemProjection_matrix; 10186 domScissorRef elemScissor; 10187 domStencil_maskRef elemStencil_mask; 10188 domAlpha_test_enableRef elemAlpha_test_enable; 10189 domAuto_normal_enableRef elemAuto_normal_enable; 10190 domBlend_enableRef elemBlend_enable; 10191 domColor_logic_op_enableRef elemColor_logic_op_enable; 10192 domColor_material_enableRef elemColor_material_enable; 10193 domCull_face_enableRef elemCull_face_enable; 10194 domDepth_bounds_enableRef elemDepth_bounds_enable; 10195 domDepth_clamp_enableRef elemDepth_clamp_enable; 10196 domDepth_test_enableRef elemDepth_test_enable; 10197 domDither_enableRef elemDither_enable; 10198 domFog_enableRef elemFog_enable; 10199 domLight_model_local_viewer_enableRef elemLight_model_local_viewer_enable; 10200 domLight_model_two_side_enableRef elemLight_model_two_side_enable; 10201 domLine_smooth_enableRef elemLine_smooth_enable; 10202 domLine_stipple_enableRef elemLine_stipple_enable; 10203 domLogic_op_enableRef elemLogic_op_enable; 10204 domMultisample_enableRef elemMultisample_enable; 10205 domNormalize_enableRef elemNormalize_enable; 10206 domPoint_smooth_enableRef elemPoint_smooth_enable; 10207 domPolygon_offset_fill_enableRef elemPolygon_offset_fill_enable; 10208 domPolygon_offset_line_enableRef elemPolygon_offset_line_enable; 10209 domPolygon_offset_point_enableRef elemPolygon_offset_point_enable; 10210 domPolygon_smooth_enableRef elemPolygon_smooth_enable; 10211 domPolygon_stipple_enableRef elemPolygon_stipple_enable; 10212 domRescale_normal_enableRef elemRescale_normal_enable; 10213 domSample_alpha_to_coverage_enableRef elemSample_alpha_to_coverage_enable; 10214 domSample_alpha_to_one_enableRef elemSample_alpha_to_one_enable; 10215 domSample_coverage_enableRef elemSample_coverage_enable; 10216 domScissor_test_enableRef elemScissor_test_enable; 10217 domStencil_test_enableRef elemStencil_test_enable; 10218 domGl_hook_abstractRef elemGl_hook_abstract; 10219 /** 10220 * Used to preserve order in elements that do not specify strict sequencing of sub-elements. 10221 */ 10222 daeElementRefArray _contents; 10223 /** 10224 * Used to preserve order in elements that have a complex content model. 10225 */ 10226 daeUIntArray _contentsOrder; 10227 10228 /** 10229 * Used to store information needed for some content model objects. 10230 */ 10231 daeTArray< daeCharArray * > _CMData; 10232 10233 10234 public: //Accessors and Mutators 10235 /** 10236 * Gets the alpha_func element. 10237 * @return a daeSmartRef to the alpha_func element. 10238 */ 10239 const domAlpha_funcRef getAlpha_func() const { return elemAlpha_func; } 10240 /** 10241 * Gets the blend_func element. 10242 * @return a daeSmartRef to the blend_func element. 10243 */ 10244 const domBlend_funcRef getBlend_func() const { return elemBlend_func; } 10245 /** 10246 * Gets the blend_func_separate element. 10247 * @return a daeSmartRef to the blend_func_separate element. 10248 */ 10249 const domBlend_func_separateRef getBlend_func_separate() const { return elemBlend_func_separate; } 10250 /** 10251 * Gets the blend_equation element. 10252 * @return a daeSmartRef to the blend_equation element. 10253 */ 10254 const domBlend_equationRef getBlend_equation() const { return elemBlend_equation; } 10255 /** 10256 * Gets the blend_equation_separate element. 10257 * @return a daeSmartRef to the blend_equation_separate element. 10258 */ 10259 const domBlend_equation_separateRef getBlend_equation_separate() const { return elemBlend_equation_separate; } 10260 /** 10261 * Gets the color_material element. 10262 * @return a daeSmartRef to the color_material element. 10263 */ 10264 const domColor_materialRef getColor_material() const { return elemColor_material; } 10265 /** 10266 * Gets the cull_face element. 10267 * @return a daeSmartRef to the cull_face element. 10268 */ 10269 const domCull_faceRef getCull_face() const { return elemCull_face; } 10270 /** 10271 * Gets the depth_func element. 10272 * @return a daeSmartRef to the depth_func element. 10273 */ 10274 const domDepth_funcRef getDepth_func() const { return elemDepth_func; } 10275 /** 10276 * Gets the fog_mode element. 10277 * @return a daeSmartRef to the fog_mode element. 10278 */ 10279 const domFog_modeRef getFog_mode() const { return elemFog_mode; } 10280 /** 10281 * Gets the fog_coord_src element. 10282 * @return a daeSmartRef to the fog_coord_src element. 10283 */ 10284 const domFog_coord_srcRef getFog_coord_src() const { return elemFog_coord_src; } 10285 /** 10286 * Gets the front_face element. 10287 * @return a daeSmartRef to the front_face element. 10288 */ 10289 const domFront_faceRef getFront_face() const { return elemFront_face; } 10290 /** 10291 * Gets the light_model_color_control element. 10292 * @return a daeSmartRef to the light_model_color_control element. 10293 */ 10294 const domLight_model_color_controlRef getLight_model_color_control() const { return elemLight_model_color_control; } 10295 /** 10296 * Gets the logic_op element. 10297 * @return a daeSmartRef to the logic_op element. 10298 */ 10299 const domLogic_opRef getLogic_op() const { return elemLogic_op; } 10300 /** 10301 * Gets the polygon_mode element. 10302 * @return a daeSmartRef to the polygon_mode element. 10303 */ 10304 const domPolygon_modeRef getPolygon_mode() const { return elemPolygon_mode; } 10305 /** 10306 * Gets the shade_model element. 10307 * @return a daeSmartRef to the shade_model element. 10308 */ 10309 const domShade_modelRef getShade_model() const { return elemShade_model; } 10310 /** 10311 * Gets the stencil_func element. 10312 * @return a daeSmartRef to the stencil_func element. 10313 */ 10314 const domStencil_funcRef getStencil_func() const { return elemStencil_func; } 10315 /** 10316 * Gets the stencil_op element. 10317 * @return a daeSmartRef to the stencil_op element. 10318 */ 10319 const domStencil_opRef getStencil_op() const { return elemStencil_op; } 10320 /** 10321 * Gets the stencil_func_separate element. 10322 * @return a daeSmartRef to the stencil_func_separate element. 10323 */ 10324 const domStencil_func_separateRef getStencil_func_separate() const { return elemStencil_func_separate; } 10325 /** 10326 * Gets the stencil_op_separate element. 10327 * @return a daeSmartRef to the stencil_op_separate element. 10328 */ 10329 const domStencil_op_separateRef getStencil_op_separate() const { return elemStencil_op_separate; } 10330 /** 10331 * Gets the stencil_mask_separate element. 10332 * @return a daeSmartRef to the stencil_mask_separate element. 10333 */ 10334 const domStencil_mask_separateRef getStencil_mask_separate() const { return elemStencil_mask_separate; } 10335 /** 10336 * Gets the light_enable element. 10337 * @return a daeSmartRef to the light_enable element. 10338 */ 10339 const domLight_enableRef getLight_enable() const { return elemLight_enable; } 10340 /** 10341 * Gets the light_ambient element. 10342 * @return a daeSmartRef to the light_ambient element. 10343 */ 10344 const domLight_ambientRef getLight_ambient() const { return elemLight_ambient; } 10345 /** 10346 * Gets the light_diffuse element. 10347 * @return a daeSmartRef to the light_diffuse element. 10348 */ 10349 const domLight_diffuseRef getLight_diffuse() const { return elemLight_diffuse; } 10350 /** 10351 * Gets the light_specular element. 10352 * @return a daeSmartRef to the light_specular element. 10353 */ 10354 const domLight_specularRef getLight_specular() const { return elemLight_specular; } 10355 /** 10356 * Gets the light_position element. 10357 * @return a daeSmartRef to the light_position element. 10358 */ 10359 const domLight_positionRef getLight_position() const { return elemLight_position; } 10360 /** 10361 * Gets the light_constant_attenuation element. 10362 * @return a daeSmartRef to the light_constant_attenuation element. 10363 */ 10364 const domLight_constant_attenuationRef getLight_constant_attenuation() const { return elemLight_constant_attenuation; } 10365 /** 10366 * Gets the light_linear_attenuation element. 10367 * @return a daeSmartRef to the light_linear_attenuation element. 10368 */ 10369 const domLight_linear_attenuationRef getLight_linear_attenuation() const { return elemLight_linear_attenuation; } 10370 /** 10371 * Gets the light_quadratic_attenuation element. 10372 * @return a daeSmartRef to the light_quadratic_attenuation element. 10373 */ 10374 const domLight_quadratic_attenuationRef getLight_quadratic_attenuation() const { return elemLight_quadratic_attenuation; } 10375 /** 10376 * Gets the light_spot_cutoff element. 10377 * @return a daeSmartRef to the light_spot_cutoff element. 10378 */ 10379 const domLight_spot_cutoffRef getLight_spot_cutoff() const { return elemLight_spot_cutoff; } 10380 /** 10381 * Gets the light_spot_direction element. 10382 * @return a daeSmartRef to the light_spot_direction element. 10383 */ 10384 const domLight_spot_directionRef getLight_spot_direction() const { return elemLight_spot_direction; } 10385 /** 10386 * Gets the light_spot_exponent element. 10387 * @return a daeSmartRef to the light_spot_exponent element. 10388 */ 10389 const domLight_spot_exponentRef getLight_spot_exponent() const { return elemLight_spot_exponent; } 10390 /** 10391 * Gets the texture1D element. 10392 * @return a daeSmartRef to the texture1D element. 10393 */ 10394 const domTexture1DRef getTexture1D() const { return elemTexture1D; } 10395 /** 10396 * Gets the texture2D element. 10397 * @return a daeSmartRef to the texture2D element. 10398 */ 10399 const domTexture2DRef getTexture2D() const { return elemTexture2D; } 10400 /** 10401 * Gets the texture3D element. 10402 * @return a daeSmartRef to the texture3D element. 10403 */ 10404 const domTexture3DRef getTexture3D() const { return elemTexture3D; } 10405 /** 10406 * Gets the textureCUBE element. 10407 * @return a daeSmartRef to the textureCUBE element. 10408 */ 10409 const domTextureCUBERef getTextureCUBE() const { return elemTextureCUBE; } 10410 /** 10411 * Gets the textureRECT element. 10412 * @return a daeSmartRef to the textureRECT element. 10413 */ 10414 const domTextureRECTRef getTextureRECT() const { return elemTextureRECT; } 10415 /** 10416 * Gets the textureDEPTH element. 10417 * @return a daeSmartRef to the textureDEPTH element. 10418 */ 10419 const domTextureDEPTHRef getTextureDEPTH() const { return elemTextureDEPTH; } 10420 /** 10421 * Gets the texture1D_enable element. 10422 * @return a daeSmartRef to the texture1D_enable element. 10423 */ 10424 const domTexture1D_enableRef getTexture1D_enable() const { return elemTexture1D_enable; } 10425 /** 10426 * Gets the texture2D_enable element. 10427 * @return a daeSmartRef to the texture2D_enable element. 10428 */ 10429 const domTexture2D_enableRef getTexture2D_enable() const { return elemTexture2D_enable; } 10430 /** 10431 * Gets the texture3D_enable element. 10432 * @return a daeSmartRef to the texture3D_enable element. 10433 */ 10434 const domTexture3D_enableRef getTexture3D_enable() const { return elemTexture3D_enable; } 10435 /** 10436 * Gets the textureCUBE_enable element. 10437 * @return a daeSmartRef to the textureCUBE_enable element. 10438 */ 10439 const domTextureCUBE_enableRef getTextureCUBE_enable() const { return elemTextureCUBE_enable; } 10440 /** 10441 * Gets the textureRECT_enable element. 10442 * @return a daeSmartRef to the textureRECT_enable element. 10443 */ 10444 const domTextureRECT_enableRef getTextureRECT_enable() const { return elemTextureRECT_enable; } 10445 /** 10446 * Gets the textureDEPTH_enable element. 10447 * @return a daeSmartRef to the textureDEPTH_enable element. 10448 */ 10449 const domTextureDEPTH_enableRef getTextureDEPTH_enable() const { return elemTextureDEPTH_enable; } 10450 /** 10451 * Gets the texture_env_color element. 10452 * @return a daeSmartRef to the texture_env_color element. 10453 */ 10454 const domTexture_env_colorRef getTexture_env_color() const { return elemTexture_env_color; } 10455 /** 10456 * Gets the texture_env_mode element. 10457 * @return a daeSmartRef to the texture_env_mode element. 10458 */ 10459 const domTexture_env_modeRef getTexture_env_mode() const { return elemTexture_env_mode; } 10460 /** 10461 * Gets the clip_plane element. 10462 * @return a daeSmartRef to the clip_plane element. 10463 */ 10464 const domClip_planeRef getClip_plane() const { return elemClip_plane; } 10465 /** 10466 * Gets the clip_plane_enable element. 10467 * @return a daeSmartRef to the clip_plane_enable element. 10468 */ 10469 const domClip_plane_enableRef getClip_plane_enable() const { return elemClip_plane_enable; } 10470 /** 10471 * Gets the blend_color element. 10472 * @return a daeSmartRef to the blend_color element. 10473 */ 10474 const domBlend_colorRef getBlend_color() const { return elemBlend_color; } 10475 /** 10476 * Gets the clear_color element. 10477 * @return a daeSmartRef to the clear_color element. 10478 */ 10479 const domClear_colorRef getClear_color() const { return elemClear_color; } 10480 /** 10481 * Gets the clear_stencil element. 10482 * @return a daeSmartRef to the clear_stencil element. 10483 */ 10484 const domClear_stencilRef getClear_stencil() const { return elemClear_stencil; } 10485 /** 10486 * Gets the clear_depth element. 10487 * @return a daeSmartRef to the clear_depth element. 10488 */ 10489 const domClear_depthRef getClear_depth() const { return elemClear_depth; } 10490 /** 10491 * Gets the color_mask element. 10492 * @return a daeSmartRef to the color_mask element. 10493 */ 10494 const domColor_maskRef getColor_mask() const { return elemColor_mask; } 10495 /** 10496 * Gets the depth_bounds element. 10497 * @return a daeSmartRef to the depth_bounds element. 10498 */ 10499 const domDepth_boundsRef getDepth_bounds() const { return elemDepth_bounds; } 10500 /** 10501 * Gets the depth_mask element. 10502 * @return a daeSmartRef to the depth_mask element. 10503 */ 10504 const domDepth_maskRef getDepth_mask() const { return elemDepth_mask; } 10505 /** 10506 * Gets the depth_range element. 10507 * @return a daeSmartRef to the depth_range element. 10508 */ 10509 const domDepth_rangeRef getDepth_range() const { return elemDepth_range; } 10510 /** 10511 * Gets the fog_density element. 10512 * @return a daeSmartRef to the fog_density element. 10513 */ 10514 const domFog_densityRef getFog_density() const { return elemFog_density; } 10515 /** 10516 * Gets the fog_start element. 10517 * @return a daeSmartRef to the fog_start element. 10518 */ 10519 const domFog_startRef getFog_start() const { return elemFog_start; } 10520 /** 10521 * Gets the fog_end element. 10522 * @return a daeSmartRef to the fog_end element. 10523 */ 10524 const domFog_endRef getFog_end() const { return elemFog_end; } 10525 /** 10526 * Gets the fog_color element. 10527 * @return a daeSmartRef to the fog_color element. 10528 */ 10529 const domFog_colorRef getFog_color() const { return elemFog_color; } 10530 /** 10531 * Gets the light_model_ambient element. 10532 * @return a daeSmartRef to the light_model_ambient element. 10533 */ 10534 const domLight_model_ambientRef getLight_model_ambient() const { return elemLight_model_ambient; } 10535 /** 10536 * Gets the lighting_enable element. 10537 * @return a daeSmartRef to the lighting_enable element. 10538 */ 10539 const domLighting_enableRef getLighting_enable() const { return elemLighting_enable; } 10540 /** 10541 * Gets the line_stipple element. 10542 * @return a daeSmartRef to the line_stipple element. 10543 */ 10544 const domLine_stippleRef getLine_stipple() const { return elemLine_stipple; } 10545 /** 10546 * Gets the line_width element. 10547 * @return a daeSmartRef to the line_width element. 10548 */ 10549 const domLine_widthRef getLine_width() const { return elemLine_width; } 10550 /** 10551 * Gets the material_ambient element. 10552 * @return a daeSmartRef to the material_ambient element. 10553 */ 10554 const domMaterial_ambientRef getMaterial_ambient() const { return elemMaterial_ambient; } 10555 /** 10556 * Gets the material_diffuse element. 10557 * @return a daeSmartRef to the material_diffuse element. 10558 */ 10559 const domMaterial_diffuseRef getMaterial_diffuse() const { return elemMaterial_diffuse; } 10560 /** 10561 * Gets the material_emission element. 10562 * @return a daeSmartRef to the material_emission element. 10563 */ 10564 const domMaterial_emissionRef getMaterial_emission() const { return elemMaterial_emission; } 10565 /** 10566 * Gets the material_shininess element. 10567 * @return a daeSmartRef to the material_shininess element. 10568 */ 10569 const domMaterial_shininessRef getMaterial_shininess() const { return elemMaterial_shininess; } 10570 /** 10571 * Gets the material_specular element. 10572 * @return a daeSmartRef to the material_specular element. 10573 */ 10574 const domMaterial_specularRef getMaterial_specular() const { return elemMaterial_specular; } 10575 /** 10576 * Gets the model_view_matrix element. 10577 * @return a daeSmartRef to the model_view_matrix element. 10578 */ 10579 const domModel_view_matrixRef getModel_view_matrix() const { return elemModel_view_matrix; } 10580 /** 10581 * Gets the point_distance_attenuation element. 10582 * @return a daeSmartRef to the point_distance_attenuation element. 10583 */ 10584 const domPoint_distance_attenuationRef getPoint_distance_attenuation() const { return elemPoint_distance_attenuation; } 10585 /** 10586 * Gets the point_fade_threshold_size element. 10587 * @return a daeSmartRef to the point_fade_threshold_size element. 10588 */ 10589 const domPoint_fade_threshold_sizeRef getPoint_fade_threshold_size() const { return elemPoint_fade_threshold_size; } 10590 /** 10591 * Gets the point_size element. 10592 * @return a daeSmartRef to the point_size element. 10593 */ 10594 const domPoint_sizeRef getPoint_size() const { return elemPoint_size; } 10595 /** 10596 * Gets the point_size_min element. 10597 * @return a daeSmartRef to the point_size_min element. 10598 */ 10599 const domPoint_size_minRef getPoint_size_min() const { return elemPoint_size_min; } 10600 /** 10601 * Gets the point_size_max element. 10602 * @return a daeSmartRef to the point_size_max element. 10603 */ 10604 const domPoint_size_maxRef getPoint_size_max() const { return elemPoint_size_max; } 10605 /** 10606 * Gets the polygon_offset element. 10607 * @return a daeSmartRef to the polygon_offset element. 10608 */ 10609 const domPolygon_offsetRef getPolygon_offset() const { return elemPolygon_offset; } 10610 /** 10611 * Gets the projection_matrix element. 10612 * @return a daeSmartRef to the projection_matrix element. 10613 */ 10614 const domProjection_matrixRef getProjection_matrix() const { return elemProjection_matrix; } 10615 /** 10616 * Gets the scissor element. 10617 * @return a daeSmartRef to the scissor element. 10618 */ 10619 const domScissorRef getScissor() const { return elemScissor; } 10620 /** 10621 * Gets the stencil_mask element. 10622 * @return a daeSmartRef to the stencil_mask element. 10623 */ 10624 const domStencil_maskRef getStencil_mask() const { return elemStencil_mask; } 10625 /** 10626 * Gets the alpha_test_enable element. 10627 * @return a daeSmartRef to the alpha_test_enable element. 10628 */ 10629 const domAlpha_test_enableRef getAlpha_test_enable() const { return elemAlpha_test_enable; } 10630 /** 10631 * Gets the auto_normal_enable element. 10632 * @return a daeSmartRef to the auto_normal_enable element. 10633 */ 10634 const domAuto_normal_enableRef getAuto_normal_enable() const { return elemAuto_normal_enable; } 10635 /** 10636 * Gets the blend_enable element. 10637 * @return a daeSmartRef to the blend_enable element. 10638 */ 10639 const domBlend_enableRef getBlend_enable() const { return elemBlend_enable; } 10640 /** 10641 * Gets the color_logic_op_enable element. 10642 * @return a daeSmartRef to the color_logic_op_enable element. 10643 */ 10644 const domColor_logic_op_enableRef getColor_logic_op_enable() const { return elemColor_logic_op_enable; } 10645 /** 10646 * Gets the color_material_enable element. 10647 * @return a daeSmartRef to the color_material_enable element. 10648 */ 10649 const domColor_material_enableRef getColor_material_enable() const { return elemColor_material_enable; } 10650 /** 10651 * Gets the cull_face_enable element. 10652 * @return a daeSmartRef to the cull_face_enable element. 10653 */ 10654 const domCull_face_enableRef getCull_face_enable() const { return elemCull_face_enable; } 10655 /** 10656 * Gets the depth_bounds_enable element. 10657 * @return a daeSmartRef to the depth_bounds_enable element. 10658 */ 10659 const domDepth_bounds_enableRef getDepth_bounds_enable() const { return elemDepth_bounds_enable; } 10660 /** 10661 * Gets the depth_clamp_enable element. 10662 * @return a daeSmartRef to the depth_clamp_enable element. 10663 */ 10664 const domDepth_clamp_enableRef getDepth_clamp_enable() const { return elemDepth_clamp_enable; } 10665 /** 10666 * Gets the depth_test_enable element. 10667 * @return a daeSmartRef to the depth_test_enable element. 10668 */ 10669 const domDepth_test_enableRef getDepth_test_enable() const { return elemDepth_test_enable; } 10670 /** 10671 * Gets the dither_enable element. 10672 * @return a daeSmartRef to the dither_enable element. 10673 */ 10674 const domDither_enableRef getDither_enable() const { return elemDither_enable; } 10675 /** 10676 * Gets the fog_enable element. 10677 * @return a daeSmartRef to the fog_enable element. 10678 */ 10679 const domFog_enableRef getFog_enable() const { return elemFog_enable; } 10680 /** 10681 * Gets the light_model_local_viewer_enable element. 10682 * @return a daeSmartRef to the light_model_local_viewer_enable element. 10683 */ 10684 const domLight_model_local_viewer_enableRef getLight_model_local_viewer_enable() const { return elemLight_model_local_viewer_enable; } 10685 /** 10686 * Gets the light_model_two_side_enable element. 10687 * @return a daeSmartRef to the light_model_two_side_enable element. 10688 */ 10689 const domLight_model_two_side_enableRef getLight_model_two_side_enable() const { return elemLight_model_two_side_enable; } 10690 /** 10691 * Gets the line_smooth_enable element. 10692 * @return a daeSmartRef to the line_smooth_enable element. 10693 */ 10694 const domLine_smooth_enableRef getLine_smooth_enable() const { return elemLine_smooth_enable; } 10695 /** 10696 * Gets the line_stipple_enable element. 10697 * @return a daeSmartRef to the line_stipple_enable element. 10698 */ 10699 const domLine_stipple_enableRef getLine_stipple_enable() const { return elemLine_stipple_enable; } 10700 /** 10701 * Gets the logic_op_enable element. 10702 * @return a daeSmartRef to the logic_op_enable element. 10703 */ 10704 const domLogic_op_enableRef getLogic_op_enable() const { return elemLogic_op_enable; } 10705 /** 10706 * Gets the multisample_enable element. 10707 * @return a daeSmartRef to the multisample_enable element. 10708 */ 10709 const domMultisample_enableRef getMultisample_enable() const { return elemMultisample_enable; } 10710 /** 10711 * Gets the normalize_enable element. 10712 * @return a daeSmartRef to the normalize_enable element. 10713 */ 10714 const domNormalize_enableRef getNormalize_enable() const { return elemNormalize_enable; } 10715 /** 10716 * Gets the point_smooth_enable element. 10717 * @return a daeSmartRef to the point_smooth_enable element. 10718 */ 10719 const domPoint_smooth_enableRef getPoint_smooth_enable() const { return elemPoint_smooth_enable; } 10720 /** 10721 * Gets the polygon_offset_fill_enable element. 10722 * @return a daeSmartRef to the polygon_offset_fill_enable element. 10723 */ 10724 const domPolygon_offset_fill_enableRef getPolygon_offset_fill_enable() const { return elemPolygon_offset_fill_enable; } 10725 /** 10726 * Gets the polygon_offset_line_enable element. 10727 * @return a daeSmartRef to the polygon_offset_line_enable element. 10728 */ 10729 const domPolygon_offset_line_enableRef getPolygon_offset_line_enable() const { return elemPolygon_offset_line_enable; } 10730 /** 10731 * Gets the polygon_offset_point_enable element. 10732 * @return a daeSmartRef to the polygon_offset_point_enable element. 10733 */ 10734 const domPolygon_offset_point_enableRef getPolygon_offset_point_enable() const { return elemPolygon_offset_point_enable; } 10735 /** 10736 * Gets the polygon_smooth_enable element. 10737 * @return a daeSmartRef to the polygon_smooth_enable element. 10738 */ 10739 const domPolygon_smooth_enableRef getPolygon_smooth_enable() const { return elemPolygon_smooth_enable; } 10740 /** 10741 * Gets the polygon_stipple_enable element. 10742 * @return a daeSmartRef to the polygon_stipple_enable element. 10743 */ 10744 const domPolygon_stipple_enableRef getPolygon_stipple_enable() const { return elemPolygon_stipple_enable; } 10745 /** 10746 * Gets the rescale_normal_enable element. 10747 * @return a daeSmartRef to the rescale_normal_enable element. 10748 */ 10749 const domRescale_normal_enableRef getRescale_normal_enable() const { return elemRescale_normal_enable; } 10750 /** 10751 * Gets the sample_alpha_to_coverage_enable element. 10752 * @return a daeSmartRef to the sample_alpha_to_coverage_enable element. 10753 */ 10754 const domSample_alpha_to_coverage_enableRef getSample_alpha_to_coverage_enable() const { return elemSample_alpha_to_coverage_enable; } 10755 /** 10756 * Gets the sample_alpha_to_one_enable element. 10757 * @return a daeSmartRef to the sample_alpha_to_one_enable element. 10758 */ 10759 const domSample_alpha_to_one_enableRef getSample_alpha_to_one_enable() const { return elemSample_alpha_to_one_enable; } 10760 /** 10761 * Gets the sample_coverage_enable element. 10762 * @return a daeSmartRef to the sample_coverage_enable element. 10763 */ 10764 const domSample_coverage_enableRef getSample_coverage_enable() const { return elemSample_coverage_enable; } 10765 /** 10766 * Gets the scissor_test_enable element. 10767 * @return a daeSmartRef to the scissor_test_enable element. 10768 */ 10769 const domScissor_test_enableRef getScissor_test_enable() const { return elemScissor_test_enable; } 10770 /** 10771 * Gets the stencil_test_enable element. 10772 * @return a daeSmartRef to the stencil_test_enable element. 10773 */ 10774 const domStencil_test_enableRef getStencil_test_enable() const { return elemStencil_test_enable; } 10775 /** 10776 * Gets the gl_hook_abstract element. 10777 * @return a daeSmartRef to the gl_hook_abstract element. 10778 */ 10779 const domGl_hook_abstractRef getGl_hook_abstract() const { return elemGl_hook_abstract; } 10780 /** 10781 * Gets the _contents array. 10782 * @return Returns a reference to the _contents element array. 10783 */ 10784 daeElementRefArray &getContents() { return _contents; } 10785 /** 10786 * Gets the _contents array. 10787 * @return Returns a constant reference to the _contents element array. 10788 */ 10789 const daeElementRefArray &getContents() const { return _contents; } 10790 10791 protected: 10792 /** 10793 * Constructor 10794 */ 10795 domGl_pipeline_settings(DAE& dae) : daeElement(dae), elemAlpha_func(), elemBlend_func(), elemBlend_func_separate(), elemBlend_equation(), elemBlend_equation_separate(), elemColor_material(), elemCull_face(), elemDepth_func(), elemFog_mode(), elemFog_coord_src(), elemFront_face(), elemLight_model_color_control(), elemLogic_op(), elemPolygon_mode(), elemShade_model(), elemStencil_func(), elemStencil_op(), elemStencil_func_separate(), elemStencil_op_separate(), elemStencil_mask_separate(), elemLight_enable(), elemLight_ambient(), elemLight_diffuse(), elemLight_specular(), elemLight_position(), elemLight_constant_attenuation(), elemLight_linear_attenuation(), elemLight_quadratic_attenuation(), elemLight_spot_cutoff(), elemLight_spot_direction(), elemLight_spot_exponent(), elemTexture1D(), elemTexture2D(), elemTexture3D(), elemTextureCUBE(), elemTextureRECT(), elemTextureDEPTH(), elemTexture1D_enable(), elemTexture2D_enable(), elemTexture3D_enable(), elemTextureCUBE_enable(), elemTextureRECT_enable(), elemTextureDEPTH_enable(), elemTexture_env_color(), elemTexture_env_mode(), elemClip_plane(), elemClip_plane_enable(), elemBlend_color(), elemClear_color(), elemClear_stencil(), elemClear_depth(), elemColor_mask(), elemDepth_bounds(), elemDepth_mask(), elemDepth_range(), elemFog_density(), elemFog_start(), elemFog_end(), elemFog_color(), elemLight_model_ambient(), elemLighting_enable(), elemLine_stipple(), elemLine_width(), elemMaterial_ambient(), elemMaterial_diffuse(), elemMaterial_emission(), elemMaterial_shininess(), elemMaterial_specular(), elemModel_view_matrix(), elemPoint_distance_attenuation(), elemPoint_fade_threshold_size(), elemPoint_size(), elemPoint_size_min(), elemPoint_size_max(), elemPolygon_offset(), elemProjection_matrix(), elemScissor(), elemStencil_mask(), elemAlpha_test_enable(), elemAuto_normal_enable(), elemBlend_enable(), elemColor_logic_op_enable(), elemColor_material_enable(), elemCull_face_enable(), elemDepth_bounds_enable(), elemDepth_clamp_enable(), elemDepth_test_enable(), elemDither_enable(), elemFog_enable(), elemLight_model_local_viewer_enable(), elemLight_model_two_side_enable(), elemLine_smooth_enable(), elemLine_stipple_enable(), elemLogic_op_enable(), elemMultisample_enable(), elemNormalize_enable(), elemPoint_smooth_enable(), elemPolygon_offset_fill_enable(), elemPolygon_offset_line_enable(), elemPolygon_offset_point_enable(), elemPolygon_smooth_enable(), elemPolygon_stipple_enable(), elemRescale_normal_enable(), elemSample_alpha_to_coverage_enable(), elemSample_alpha_to_one_enable(), elemSample_coverage_enable(), elemScissor_test_enable(), elemStencil_test_enable(), elemGl_hook_abstract() {} 10796 /** 10797 * Destructor 10798 */ 10799 virtual ~domGl_pipeline_settings() { daeElement::deleteCMDataArray(_CMData); } 10800 /** 10801 * Overloaded assignment operator 10802 */ 10803 virtual domGl_pipeline_settings &operator=( const domGl_pipeline_settings &cpy ) { (void)cpy; return *this; } 10804 10805 public: // STATIC METHODS 10806 /** 10807 * Creates an instance of this class and returns a daeElementRef referencing it. 10808 * @return a daeElementRef referencing an instance of this object. 10809 */ 10810 static DLLSPEC daeElementRef create(DAE& dae); 10811 /** 10812 * Creates a daeMetaElement object that describes this element in the meta object reflection framework. 10813 * If a daeMetaElement already exists it will return that instead of creating a new one. 10814 * @return A daeMetaElement describing this COLLADA element. 10815 */ 10816 static DLLSPEC daeMetaElement* registerElement(DAE& dae); 10817 }; 10818 10819 10820 #endif 10821