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